// Copyright (c) 2020, 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.

// @dart = 2.9

// Regression test for https://github.com/dart-lang/sdk/issues/40462
// VMOptions=--deoptimize_every=140 --optimization_level=3 --use-slow-path --old_gen_heap_size=128

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';

Map<int, bool> var0 = {
  33: false,
  6: true,
  -9223372028264841217: true,
  -77: true,
  -6: false,
  2147483649: false
};
MapEntry<String, bool> var1 = MapEntry<String, bool>('&8\u{1f600}Z', true);
Map<int, bool> var2 = {18: true, 16: false, -30: false, -30: true, 41: false};
Endian var3 = (Endian.host);
ByteData var4 = ByteData(9);
Int8List var5 = Int8List(4);
Uint8List var6 = Uint8List.fromList(
    Uint8ClampedList.fromList(Int64List.fromList(Uint8List(45))));
Uint8ClampedList var7 = Uint8ClampedList(4);
Int16List var8 = Int16List.fromList([-11]);
Uint16List var9 = Uint16List.fromList(Uint16List.fromList(Uint8List(45)));
Int32List var10 = Int32List.fromList(Uint16List(14));
Uint32List var11 = Uint32List.fromList(Int64List.fromList([-8, -95]));
Int64List var12 = Int64List.fromList(Uint32List(3));
Uint64List var13 = Uint64List(2);
Int32x4List var14 = Int32x4List(2);
Int32x4 var15 = Int32x4.bool(false, true, true, true);
Deprecated var16 = Deprecated('G');
Provisional var17 = Provisional();
bool var18 = bool.fromEnvironment(' 9');
Duration var19 = new Duration();
Error var20 = Error();
AssertionError var21 = AssertionError(49);
TypeError var22 = TypeError();
CastError var23 = CastError();
NullThrownError var24 = new NullThrownError();
ArgumentError var25 = ArgumentError.value(27, '', 18);
RangeError var26 = RangeError.index(1, 42, '+m', 'JjY', 46);
IndexError var27 = IndexError(38, 29, 'R1Z', 'VnR7', 13);
FallThroughError var28 = new FallThroughError();
AbstractClassInstantiationError var29 = AbstractClassInstantiationError('Sq');
UnsupportedError var30 = UnsupportedError('(OXv');
UnimplementedError var31 = UnimplementedError('Dt)F@\u2665');
StateError var32 = StateError('y');
ConcurrentModificationError var33 = ConcurrentModificationError(18);
OutOfMemoryError var34 = OutOfMemoryError();
StackOverflowError var35 = StackOverflowError();
CyclicInitializationError var36 = CyclicInitializationError('0');
Exception var37 = new Exception(6);
FormatException var38 = FormatException('w8q', 36, 17);
IntegerDivisionByZeroException var39 = IntegerDivisionByZeroException();
int var40 = -97;
Null var41 = null;
num var42 = -64;
RegExp var43 = RegExp('Dr6eaNw');
String var44 = 'Zgm83P\u2665';
Runes var45 = Runes('RJ ');
RuneIterator var46 = RuneIterator.at('\u2665q', 17);
StringBuffer var47 = StringBuffer(40);
Symbol var48 = Symbol('sA8');
Expando<bool> var49 = Expando<bool>('1\u2665&');
Expando<int> var50 = Expando<int>('6lfPf+');
Expando<String> var51 = Expando<String>(')L9b7#');
List<bool> var52 = [false];
List<int> var53 = [
  49,
  -14,
  31,
  -80,
  ...[9223372034707292160, 44, 6, 3, -42]
];
List<String> var54 = [
  'X#',
  'DP',
  'A\u2665-s4mF',
  'l',
  '9',
  'W6\u{1f600}d\u{1f600}'
];
Set<bool> var55 = {false, false};
Set<int> var56 = {-2147483649};
Set<String> var57 = {
  '',
  'shf!r',
  '\u{1f600}XCBW6',
  '\u{1f600}',
  '1\u{1f600}7FS',
  'w@'
};
Map<bool, bool> var58 = {
  false: false,
  false: true,
  true: false,
  true: true,
  false: false,
  false: false
};
Map<bool, int> var59 = {true: -82, true: -23, false: 22};
Map<bool, String> var60 = {false: 'nC\u2665', true: '', true: '8+E2G'};
Map<int, bool> var61 = {22: false, -35: false, 38: false, 2: false};
Map<int, int> var62 = {38: 48, -3: 45, 47: -9223372032559808511, 2: -73};
Map<int, String> var63 = {
  ...{-47: 'Sizqs\u2665', -91: 'd'}
};
Map<String, bool> var64 = {
  '': false,
  '\u{1f600}\u2665UJe!': true,
  'o!n': false,
  'Jw\u{1f600}\u{1f600}L': true,
  'UL\u2665g-E': true,
  'g\u{1f600}Q@': false
};
Map<String, int> var65 = {
  'TnC2(o': -86,
  '': 17,
  '+!\u{1f600}54!6': -62,
  '': 42,
  'm': -54,
  'sk&EU\u{1f600}n': 23
};
Map<String, String> var66 = {'aTVZDv': '6x\u{1f600}w'};
MapEntry<bool, bool> var67 = MapEntry<bool, bool>(false, true);
MapEntry<bool, int> var68 = MapEntry<bool, int>(true, 23);
MapEntry<bool, String> var69 = new MapEntry<bool, String>(true, '');
MapEntry<int, bool> var70 = MapEntry<int, bool>(40, false);
MapEntry<int, int> var71 = MapEntry<int, int>(8, 46);
MapEntry<int, String> var72 = MapEntry<int, String>(49, 'Ke');
MapEntry<String, bool> var73 = MapEntry<String, bool>('7p', false);
MapEntry<String, int> var74 = new MapEntry<String, int>('+&u', 33);
MapEntry<String, String> var75 = MapEntry<String, String>('1(etj', '@##4jr');

Error foo0(int par1) {
  if (par1 >= 41) {
    return var22;
  }
  var66.forEach((loc0, loc1) {
    var32 ??= var32;
  });
  {
    int loc0 = 2;
    while (--loc0 > 0) {
      break;
    }
  }
  return new RangeError(47);
}

Endian foo1(Runes par1, FallThroughError par2, Uint16List par3) {
  return (Endian.little);
}

Uint32List foo2(Null par1, String par2, int par3) {
  if (par3 >= 30) {
    return (false ? Uint32List.fromList(new Uint32List(30)) : var11);
  }
  ((StringBuffer(18)).clear());
  (RangeError.checkValueInInterval(
      (true ? (--var40) : 42),
      (-58 ?? (Float32x4.wxwy as int)),
      (-((Uint8ClampedList.bytesPerElement as int))),
      ((var63[26]).substring(30, -4)),
      var44));
  return (Uint32List.fromList((List<int>.filled(34, var40))));
}

extension fooE0 on Runes {
  Exception foo0_Extension0(
      Set<String> par1, Expando<int> par2, List<int> par3, int par4) {
    if (par4 >= 44) {
      return Exception(35);
    }
    {
      int loc0 = 0;
      do {
        if (var18) {
          return ((!((var58[true]
                  ? var58[((!(((RegExp('F\u2665R')).isDotAll))) || (!(var18)))]
                  : true)))
              ? ((false ? (var52[(--var40)] ? true : var18) : true)
                  ? FormatException('y5\u{1f600}1XPZ', 45, 39)
                  : Exception(29))
              : fooE0(var45).foo0_Extension0(
                  {
                      ((true ? var18 : (var64['Xpa'] ? false : var52[var40]))
                          ? ''
                          : 'NDjj\u{1f600}w\u{1f600}'),
                      ('mCOwFm' ?? 'v')
                    },
                  var50,
                  (var6 ??
                      (false ? Uint8List.fromList([(-1 ^ var10[36])]) : var13)),
                  par4 + 1));
        }
      } while (++loc0 < 4);
    }

    for (int loc0 = 0; loc0 < 21; loc0++) {
      print(MapEntry<bool, bool>(true, true));
      {
        int loc1 = 4;
        while (--loc1 > 0) {
          var74 ??= MapEntry<String, int>(' ', 35);
        }
      }
    }
    return fooE0(var45).foo0_Extension0({
      (var18
          ? (var64[var54[var7[6]]]
              ? (var61[6442450945]
                  ? '5zKk&\u{1f600}L'
                  : ('\u2665PpeyDs' ?? 'DSwK\u{1f600}'))
              : '\u2665iOel1')
          : 'KF\u{1f600}'),
      '6x!',
      var60[(!((false ?? (!(true)))))]
    }, var50, var9, par4 + 1);
  }
}

extension fooE1 on CyclicInitializationError {
  List<String> foo1_Extension0(
      FormatException par1, Duration par2, num par3, int par4) {
    if (par4 >= 41) {
      return var54;
    }
    throw (((!((false ? false : var49[(++var40)])))
            ? (!(true))
            : (false
                ? var52[(var40--)]
                : (((RegExp('BQ7TD8@')).isCaseSensitive) && true)))
        ? ((true && var18) ? Symbol('mfQ6U') : Symbol('yr@'))
        : Symbol('J1'));
  }

  String foo1_Extension1(StringBuffer par1, Int16List par2, int par3) {
    if (par3 >= 14) {
      return var63[var50[
          ((((false ? {var50[-61]} : var56)).add(par3)) ? 8589934591 : 15)]];
    }
    try {
      return fooE1(var36).foo1_Extension1(par1, par2, par3 + 1);
    } on OutOfMemoryError {
      exit(254);
    } catch (exception, stackTrace) {
      switch ((-17 ~/ (true ? (-(var40)) : (-(var42))))) {
        case 3680904311:
          {
            throw (((true || true)
                    ? ([(((var60[var18]).trim()) * 27)] ==
                        ArgumentError.value(37, 'G+cy&', 37))
                    : (!((((var54[(--var40)]).trimRight()) == Provisional()))))
                ? fooE1(var36).foo1_Extension0(
                    FormatException('y', 31, 49), var19, -4294967296, 0)
                : var54);
            break;
          }
        case 3680904315:
          {
            var51 ??= var51;
            break;
          }
        default:
          {
            var66.forEach((loc0, loc1) {
              var52 = ((!((var42 > var40)))
                  ? var52
                  : [
                      (((var18
                              ? Int32x4.bool(false, false, true, false)
                              : (true ? new Int32x4(13, 16, 20, 25) : var15)))
                          .flagW),
                      var18
                    ]);
            });
            break;
          }
      }
    }
    {
      int loc0 = 43;
      while (--loc0 > 0) {
        (((true
                ? (true
                    ? {
                        40: 'nbk',
                        38: fooE1(var36).foo1_Extension1(var47, var8, par3 + 1)
                      }
                    : var63)
                : var63))
            .addAll(var63));
        try {
          var58.forEach((loc1, loc2) {
            /// Single-line documentation comment.
            throw var68;
          });
          {
            int loc1 = 0;
            do {
              var12 = Int64List.fromList(Int8List.fromList(Int64List.fromList(
                  Uint8ClampedList.fromList([var59[true]]))));
            } while (++loc1 < 3);
          }
        } on OutOfMemoryError {
          exit(254);
        } catch (exception, stackTrace) {
          return '3';
        } finally {
          var24 ??= NullThrownError();
        }
      }
    }
    return var63[(Int32x4.xxxz as int)];
  }
}

extension fooE2 on TypeError {
  StateError foo2_Extension0(List<String> par1) {
    var47 = var47;
    if ((!(var49[((false ? var18 : ((Duration() > var19) ? true : false))
        ? -25
        : var40)]))) {
      if (var49[43]) {
        var63 = ((((!(true)) ? (8589934591 >= (6442450945 % -14)) : var18) ^
                (var18
                    ? (((false
                            ? var14[(true ? -9 : var40)]
                            : Int32x4.bool(false, true, true, true)))
                        .flagW)
                    : false))
            ? (var64['1']
                ? {
                    (--var40): 'h\u{1f600}E(S@r',
                    (var40++): var63[var6[36]],
                    (--var40): var60[true]
                  }
                : {
                    ((({((~(var40)) ?? var40): 'dU\u2665nE'}).isNotEmpty)
                            ? -45
                            : var40):
                        var63[(true
                            ? 36
                            : ((var61[var40] ? false : false)
                                ? var40
                                : (~((var40--)))))],
                    (~((Int32x4.zzwz as int))): (true
                        ? var44
                        : (fooE1(var36).foo1_Extension1(var47, var8, 0) +
                            var36.foo1_Extension1(var47, Int16List(18), 0))),
                    (((var6 == Symbol('\u2665uarCSV')) &&
                                (var18 ? var18 : var18))
                            ? (var40++)
                            : 25):
                        (((((!(((RegExp('t')).isMultiLine))) ? var18 : false)
                                ? var8[((true ? -65 : (3 % -99)) ~/ 30)]
                                : var40))
                            .toStringAsExponential((Int32x4.wxxz as int)))
                  })
            : {
                (-9223372032559808513 ~/ (-(4294967297))):
                    var36.foo1_Extension1(StringBuffer(24), var8, 0),
                if ((!((var18 ^ false))))
                  (var0[(var42 ~/ var40)] ? -39 : -96): 'BuzKc'
                else
                  (Int32x4.yxyy as int): (false ? 'Rxpx2T' : '(xEVAx'),
                (Int32x4.xxxw as int): var54[(Float32x4.zyyw as int)],
                (~(-7)): ('' * 8)
              });
      } else {
        var60 = {
          (!(var18)): fooE1(var36).foo1_Extension1(
              StringBuffer(0), Int16List.fromList(Uint64List(6)), 0),
          var18: ('U6o5y' * 31),
          ((((RegExp('')).isCaseSensitive) &&
                  (false ||
                      var58[(({var40}).add(var12[(-9223372030412324863 ??
                          var65[((var18).toString())])]))])) ||
              ((new Duration() * (false ? var40 : var40)) <=
                  (-((var19 ?? var19))))): 'HZIfq',
          var64[var44]: var44,
          var52[(var5[-0] | ((++var40) >> var40))]: ((var18
                  ? false
                  : (true
                      ? var2[-91]
                      : var58[
                          ((((var15).shuffleMix(Int32x4(3, 6, 11, 16), var40)))
                              .flagX)]))
              ? var54[12]
              : var54[(-((var18 ? var40 : var40)))]),
          var2[(~(-87))]: 'LxD'
        };
        var20 ??= ((((var18 ? RegExp('S#lVaW(') : var43)).isUnicode)
            ? FallThroughError()
            : foo0(0));
      }
    }
    return StateError('99');
  }

  Int64List foo2_Extension1(
      Exception par1, Int16List par2, List<String> par3, int par4) {
    if (par4 >= 5) {
      return ((!(((new RegExp('I!'))
              .hasMatch((false ? 'A\u{1f600}\u26656' : ('F4xY' ?? var51[0]))))))
          ? Int64List(30)
          : var12);
    } // Single-line comment.
    if ((((bool.fromEnvironment((((-(var40))).toString()))) & false) ||
        var58[var49[-4294967295]])) {
      try {
        var2 = var2;
      } on OutOfMemoryError {
        exit(254);
      } catch (exception, stackTrace) {
        (({27: '7BxmY'}).clear());
      }
    }
    var13 = var13;
    return (var22).foo2_Extension1(
        var38,
        par2,
        var36.foo1_Extension0(
            (var58[true]
                ? FormatException('2IWwRf', 3, 34)
                : new FormatException('d!B', 4, 28)),
            Duration(),
            45,
            0),
        par4 + 1);
  }

  NullThrownError foo2_Extension2(Exception par1,
      IntegerDivisionByZeroException par2, FormatException par3) {
    var42 = 30;
    var1 = MapEntry<String, bool>('abGhTN', true);
    return var24;
  }
}

extension fooE3 on Null {
  Int32x4 foo3_Extension0(int par1) {
    if (par1 >= 6) {
      return (((Int32x4(12, 1, 48, 9)).withX((22 ?? ((8 | par1) >> 41)))) ^
          var15);
    }
    ((((((var5).sublist(((!((!(false)))) ? -87 : -9223372030412324865),
                    (--var40))) +
                var12) +
            (var8 ?? var8)))
        .fillRange(-9223372036854775807, -2147483649, (Float32x4.xwyw as int)));
    return Int32x4.bool(true, true, false, false);
  }
}

extension fooE4 on Duration {
  MapEntry<int, String> foo4_Extension0(Exception par1, Int32x4 par2) {
    (({
      ...{
        (false ? -22 : (var18 ? var13[var40] : (++var40))),
        var40,
        -9223372030412324864,
        (var64[var44] ? 27 : var40),
        (Float32x4.wyyx as int)
      },
      ...{-94, (var40--)},
      (~(var40)),
      for (int loc0 in {(DateTime.april as int)}) (var40++)
    }).clear());
    return MapEntry<int, String>(15, 'Y3U');
  }

  CyclicInitializationError foo4_Extension1(bool par1, Int32x4List par2) {
    {
      int loc0 = 12;
      while (--loc0 > 0) {
        {
          UnsupportedError loc1 = var31;
          {
            int loc2 = 48;
            while (--loc2 > 0) {
              var50 ??= (false ? new Expando<int>('N') : var50);
            }
          }
        }
        return (true
            ? (false ? CyclicInitializationError('pbsl\u2665B)') : var36)
            : CyclicInitializationError('SY8K'));
      }
    }
    return CyclicInitializationError('x');
  }
}

class X0 {
  Int32x4 fld0_0 = Int32x4(4, 17, 25, 21);
  FallThroughError fld0_1 = new FallThroughError();
  Int16List fld0_2 = Int16List.fromList(Int32List.fromList(Uint32List(21)));
  MapEntry<String, int> fld0_3 = MapEntry<String, int>('Z)i6o', 1);

  List<bool> foo0_0(Map<String, int> par1) {
    (({(~((-(var40)))): 'S'}).addAll({
      for (int loc0 = 0; loc0 < 9; loc0++) -40: var44,
      (Int32x4.ywzy as int): ((var31).message),
      if (var58[(!(false))])
        -45: (String.fromEnvironment(((((true && var49[-9223372036854775807])
                ? CyclicInitializationError('8DdLh-y')
                : var36))
            .toString()))),
      var40: var54[(var40++)]
    }));
    return ([
          true,
          (var64[var63[13]]
              ? (((true
                      ? var15
                      : (var58[var58[false]]
                          ? new Int32x4(18, 23, 13, 30)
                          : Int32x4(49, 44, 37, 37))))
                  .flagW)
              : (!(var52[(Float32x4.yzyw as int)]))),
          var18,
          (!(((var56).add((~(43))))))
        ] ??
        var52);
  }

  NullThrownError foo0_1(int par1) {
    if (par1 >= 20) {
      return var22.foo2_Extension2(var38, IntegerDivisionByZeroException(),
          FormatException('JHGQ-3', 48, 18));
    }
    try {
      var66.forEach((loc0, loc1) {
        {
          int loc2 = 0;
          do {
            for (int loc3 = 0; loc3 < 10; loc3++) {
              throw StackOverflowError();
            }
            var27 ??= var27;
          } while (++loc2 < 20);
        }

        {
          int loc2 = 28;
          while (--loc2 > 0) {
            // Single-line comment.
            return NullThrownError();
          }
        }
      });
    } on OutOfMemoryError {
      exit(254);
    } catch (exception, stackTrace) {
      /// Single-line documentation comment.
      throw var23;
    } finally {
      // Single-line comment.
      try {
        /*
         * Multi-line
         * comment.
         */
        ((((((var41.foo3_Extension0(0)).flagW) |
                    (((true ? true : var49[(Float32x4.yxxy as int)])
                            ? var18
                            : var58[var64['Zmg\u26656']])
                        ? var64[((true ? '' : ('+TZ' + var44)) + var54[-89])]
                        : true))
                ? RuneIterator.at('8zi', 34)
                : (((var52[var40] ? var45 : Runes('M!y'))).iterator)))
            .reset((Float32x4.xzxx as int)));
      } on OutOfMemoryError {
        exit(254);
      } catch (exception, stackTrace) {
        // Single-line comment.
        {
          int loc0 = 0;
          do {
            var31 ??= (var18 ? UnimplementedError('') : var31);
          } while (++loc0 < 19);
        }
      } finally {
        var33 ??= var33;
        print({
          'p',
          '5',
          'nFd',
          ((('\u2665QJhrGu').substring(
                  (var40 ~/
                      ((false ? true : (!(true)))
                          ? (var40 - 15)
                          : -4294967296)),
                  -52)) *
              36),
          ('aA\u{1f600}' +
              (var60[((true
                          ? true
                          : (!(((var14[(-(((var52[27] ? 39 : var40) << -35)))])
                              .flagX)))) ^
                      var18)] *
                  8)),
          ((var64[var44]).toString())
        });
      }
    }
    return var24;
  }

  Int8List foo0_2(Symbol par1, MapEntry<bool, bool> par2,
      Map<String, String> par3, int par4) {
    if (par4 >= 40) {
      return Int8List(9);
    }
    var1 ??= MapEntry<String, bool>('B\u{1f600}\u2665v-fx', true);
    if (false) {
      if ((var42 >= -64)) {
        {
          int loc0 = 0;
          do {
            ((var63).addAll({3: ((((var18).toString()) + var44) + 'PIW@')}));
            var41 = null;
          } while (++loc0 < 20);
        }
      }
      switch (((Float32x4.yyxy as int) & var40)) {
        case 2432097039:
          {
            if ((!((var18 |
                ((!((bool.fromEnvironment('Doptl\u{1f600}R'))))
                    ? true
                    : var18))))) {
              return var5;
            } else {
              var63 = {
                (-((true
                    ? var11[fld0_2[(Int32x4.zwzz as int)]]
                    : var11[(var18
                        ? var12[var59[
                            ((Int32x4.bool(true, false, true, false)).flagZ)]]
                        : var40)]))): var44,
                ...{(-(-0)): '@yx+(O'},
                ...{
                  (var40 >> -39):
                      (((var18 ? var52[-9223372036854775807] : false)
                              ? var58[var18]
                              : (!((false || false))))
                          ? '\u{1f600}B4hFc'
                          : '33xC'),
                  if ((var19 >= Duration()))
                    (Float32x4.ywyz as int): var44
                  else
                    var5[var50[(var42 ~/ var42)]]: var51[var40],
                  ...{
                    var62[-12]: '@LYD',
                    ((false ? var42 : var40) ~/ -42):
                        (([''] == var47) ? '' : var44)
                  }
                },
                (Float32x4.yyyx as int): 'eD0\u2665A',
                if ((!(var18)))
                  ((var15).x as int):
                      ((!(var58[(!(var64[')']))])) ? var44 : var44)
                else
                  -88: ((StateError('')).toString()),
                var13[var40]: var44
              };
            }
            break;
          }
        case 2432097049:
          {
            var33 ??= ConcurrentModificationError(18);
            break;
          }
        default:
          {
            var59 = {
              false: (~(((~(var40)) >> var40))),
              (false ? var18 : (!(false))): var40,
              (false ?? (!((((-49).isInfinite) && var58[var58[var18]])))):
                  (var40--),
              (!((var54 == NullThrownError()))): -12
            };
            break;
          }
      }
    } else {
      try {
        if (((34 - 11) >= (-(49)))) {
          var39 = var39;
          var56 = var56;
        }
      } on OutOfMemoryError {
        exit(254);
      } catch (exception, stackTrace) {
        throw StackOverflowError();
      }
      if (var18) {
        print({
          (var58[true] ? (++var40) : var12[(5 | (Int32x4.wwxx as int))]):
              (++var40),
          (Int64List.bytesPerElement as int):
              var6[(~(var50[var62[var65[par3['Zb']]]]))],
          (var18 ? (true ? 10 : (++var40)) : -79): (var64['h\u{1f600}X\u2665(']
              ? (true
                  ? var5[(((((((((33 > (true ? var40 : var42)) ? var43 : var43))
                                      .isMultiLine)
                                  ? ''
                                  : '#'))
                              .endsWith(var51[9223372032559808512]))
                          ? (!(var18))
                          : var49[22])
                      ? var40
                      : var40)]
                  : (33 ~/ 38))
              : (++var40))
        });
      }
    }
    return foo0_2(
        Symbol('y-r3rR'), MapEntry<bool, bool>(true, false), par3, par4 + 1);
  }

  @override
  Int32x4List call(int par1) {
    if (par1 >= 5) {
      return Int32x4List(5);
    }
    if ((true
        ? var61[(Int32x4.zwyx as int)]
        : (((Float32x4.ywyy as int)).isInfinite))) {
      return var14;
    }
  }

  void run() {
    var17 ??= Provisional();
  }
}

extension XE0 on X0 {
  IntegerDivisionByZeroException foo0_Extension0(
      Map<bool, int> par1, RuneIterator par2, Duration par3) {
    var64.forEach((loc0, loc1) {
      {
        int loc2 = 0;
        do {
          fld0_3 ??= MapEntry<String, int>('4T\u2665i', 30);
        } while (++loc2 < 44);
      }
    });
    return (var52[(Uint32List.bytesPerElement as int)]
        ? var39
        : IntegerDivisionByZeroException());
  }

  List<bool> foo0_Extension1(List<int> par1) {
    /**
     ** Multi-line
     ** documentation comment.
     */
    if (false) {
      switch (((var40++) | -57)) {
        case 3773120366:
          {
            for (int loc0 in foo2(
                null,
                (false
                    ? (var36.foo1_Extension1(var47, Int16List(25), 0) ??
                        (Uri.encodeFull(fooE1(var36)
                            .foo1_Extension1(var47, Int16List(8), 0))))
                    : '\u2665Lgd(n'),
                0)) {
              try {
                var6 = Uint8List(12);
              } on OutOfMemoryError {
                exit(254);
              } catch (exception, stackTrace) {
                var20 = foo0(0);
                var1 = MapEntry<String, bool>('X', true);
              } finally {
                try {
                  var41 = (var0[(ZLibOption.strategyHuffmanOnly as int)]
                      ? (provisional)
                      : (((((~(-43)) | (2147483649 ^ var40))).isNaN)
                          ? (var64[(true ? 'TA6\u{1f600}FQT' : 'p\u2665p!-')]
                              ? null
                              : null)
                          : null));
                  var49 ??= var49;
                } on OutOfMemoryError {
                  exit(254);
                } catch (exception, stackTrace) {
                  try {
                    /*
                   * Multi-line
                   * comment.
                   */
                    var64 = var64;
                  } on OutOfMemoryError {
                    exit(254);
                  } catch (exception, stackTrace) {
                    var23 = CastError();
                    for (int loc1 = 0; loc1 < 14; loc1++) {
                      continue;
                    }
                  } finally {
                    var69 = MapEntry<bool, String>(false, 'SemmWM');
                  }
                  var14[(-((~(-54))))] += var14[(--var40)];
                }
                for (int loc1 = 0; loc1 < 1; loc1++) {
                  var5 = Int8List(38);
                  var13 = var13;
                }
              }
            }
            break;
          }
        case 3773120375:
          {
            var25 = var27;
            break;
          }
        case 3773120384:
          {
            try {
              // Single-line comment.
              ((Uint8ClampedList(24)).removeRange(
                  (var62[-9223372032559808513] ^ -29), var7[var40]));
              var4 ??= ByteData(11);
            } on OutOfMemoryError {
              exit(254);
            } catch (exception, stackTrace) {
              var13 = Uint64List.fromList(
                  Uint8List.fromList(Uint8ClampedList.fromList([(35 | -41)])));
              if ((((!(((false ? var0[var40] : var18)
                          ? (false | (SecurityContext.alpnSupported))
                          : true)))
                      ? false
                      : var18)
                  ? true
                  : var18)) {
                var9 = Uint16List(15);
              }
            }
            break;
          }
      }
      for (int loc0 = 0; loc0 < 22; loc0++) {
        var14 = X0()(0);
        throw MapEntry<bool, int>(true, 16);
      }
    } else {
      ((StringBuffer(44)).clear());
      var39 ??= IntegerDivisionByZeroException();
    }
    return [
      false,
      (!(var18)),
      false,
      var64[
          var36.foo1_Extension1(StringBuffer(2), Int16List.fromList([-27]), 0)],
      true,
      false
    ];
  }
}

class X1 extends X0 {
  Map<bool, String> fld1_0 = {true: '\u2665SE)b'};

  Map<int, int> foo1_0(Deprecated par1, int par2) {
    if (par2 >= 22) {
      return {
        (var40++): var7[(--var40)],
        (((-(var59[true])) | ((--var40) ?? var11[var9[-76]])) >> var62[14]):
            (~((par2--)))
      };
    }
    throw UnimplementedError('O');
  }

  @override
  Int32x4List call(int par1) {
    var26 ??= IndexError(27, 18, '+Qy9', '', 6);
    {
      int loc0 = 41;
      while (--loc0 > 0) {
        /// Single-line documentation comment.
        try {
          fld1_0 = {
            var52[var10[par1]]:
                (((var40++)).toStringAsPrecision(var13[(par1--)])),
            var2[44]: var36.foo1_Extension1(var47,
                (Int16List.fromList(Uint16List.fromList(Int64List(34)))), 0),
            ((!(true))
                    ? false
                    : var52[(var18 ? 33 : (true ? var8[var5[par1]] : -27))]):
                (var36.foo1_Extension1(
                        var47,
                        Int16List.fromList(Uint16List.fromList(Int8List(25))),
                        0) +
                    '7'),
            var18: var36.foo1_Extension1(
                var47, ((var8).sublist(var59[var49[par1]], (par1--))), 0)
          };
          var66 = var66;
        } on OutOfMemoryError {
          exit(254);
        } catch (exception, stackTrace) {
          {
            int loc1 = 33;
            while (--loc1 > 0) {
              var52 = (var52 +
                  ((loc0 < (var49[var11[(-((loc1 ?? -57)))]] ? (-(-1)) : par1))
                      ? ((true
                              ? [true, false]
                              : [
                                  true,
                                  var18,
                                  (((((~(37)) << -9223372036854775808) |
                                          ((loc0).modInverse(loc1) as int)))
                                      .isNegative),
                                  ('D\u2665Sp' ==
                                      IndexError(14, 12, 'PDTOXf', '&5e', 13))
                                ]) ??
                          [true, (!(false))])
                      : [true]));
            }
          }
          if (var18) {
            var20 ??= NullThrownError();
            var14[(Float32x4.zyxw as int)] &= (var41).foo3_Extension0(0);
          } else {
            var74 = MapEntry<String, int>('Jwvy&', 9);
          }
        }
      }
    }
    return Int32x4List(11);
  }

  void run() {
    super.run();
    var49 ??= var49;
  }
}

extension XE1 on X1 {
  IndexError foo1_Extension0(
      Runes par1, MapEntry<bool, int> par2, Exception par3, int par4) {
    if (par4 >= 19) {
      return var27;
    }
    for (int loc0 = 0; loc0 < 19; loc0++) {
      if (((((var58[var18] && (var19 > Duration()))
              ? (true ? (~(-43)) : var5[(var40--)])
              : 2147483647))
          .isInfinite)) {
        return var27;
      } else {
        var41 = var41;
        var23 = (var18
            ? ((var18 ? (false ?? var18) : (false ? ((-38).isEven) : var18))
                ? CastError()
                : CastError())
            : CastError());
      }
    }
    return IndexError(15, 17, 'yw', '', 20);
  }

  Expando<String> foo1_Extension1() {
    /// Single-line documentation comment.
    var59.forEach((loc0, loc1) {
      throw var68;
    });
    return var51;
  }

  Expando<int> foo1_Extension2(CyclicInitializationError par1, Null par2) {
    {
      int loc0 = 0;
      do {
        // Single-line comment.
        var67 ??= (((!((var18 && var58[false])))
                ? ((((var30).toString())).endsWith(var63[
                    ((true ? loc0 : (var9[11] >> (-(-34)))) <<
                        (Float32x4.zwww as int))]))
                : var18)
            ? MapEntry<bool, bool>(false, false)
            : MapEntry<bool, bool>(true, true));
      } while (++loc0 < 29);
    }

    {
      int loc0 = 25;
      while (--loc0 > 0) {
        for (int loc1 = 0; loc1 < 40; loc1++) {
          throw new Expando<String>('+huc0\u2665');
        }
        try {
          continue;
        } on OutOfMemoryError {
          exit(254);
        } catch (exception, stackTrace) {
          var66.forEach((loc1, loc2) {
            if (true) {
              var5 = Int8List.fromList(
                  Uint8ClampedList.fromList([var50[(-(loc0))]]));
            }
          });
          if ((NetworkInterface.listSupported)) {
            for (int loc1 = 0; loc1 < 37; loc1++) {
              var74 ??= var74;
              {
                Set<int> loc2 = {
                  1,
                  (var9[(--var40)] ^
                      (-82 ??
                          (true
                              ? var59[var18]
                              : (var58[var58[(!(false))]] ? (~(loc0)) : 0)))),
                  loc0,
                  ((((var47).isNotEmpty) ??
                          (var52[(Float32x4.xyzw as int)] || (var19 < var19)))
                      ? (var40--)
                      : ((Float32x4.zxzz as int) ^ 48)),
                  ((false | ((var18 ? false : var18) ? (!(var18)) : true))
                      ? (((!(false))
                              ? ((true ? false : var18)
                                  ? (!(var18))
                                  : (!(var61[var12[44]])))
                              : var18)
                          ? (var40++)
                          : 10)
                      : (--var40))
                };
                fld1_0 = ((!(var18))
                    ? ((!((!(var18))))
                        ? fld1_0
                        : {
                            false: (Uri.decodeFull(
                                var66[((Deprecated('uvZ6GU')).toString())]))
                          })
                    : {
                        var18: (true
                            ? ((!(true))
                                ? ''
                                : fooE1(par1)
                                    .foo1_Extension1(StringBuffer(49), var8, 0))
                            : ('' + 'qD6Fry')),
                        (((var58[true] ? RegExp('Zp') : RegExp(''))).isDotAll):
                            fooE1(par1)
                                .foo1_Extension1(StringBuffer(38), var8, 0),
                        ((StringBuffer(39)).isEmpty):
                            ((MapEntry<int, String>(41, 'S2lAKd')).toString()),
                        var64[(var18
                                ? (var60[(false
                                        ? false
                                        : (SecurityContext.alpnSupported))] ??
                                    '\u{1f600}lsZ')
                                : 'c4+Ry')]:
                            (Uri.decodeQueryComponent(
                                var63[(var49[(var40--)] ? -66 : (var40++))])),
                        (!(((StringBuffer(41)).isNotEmpty))):
                            ((null).toString())
                      });
                var66 = var66;
              }
            }
            return Expando<int>('eo');
          }
        } finally {
          print(var27);
        }
      }
    }
    return Expando<int>('');
  }
}

main() {
  try {
    foo0(0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('foo0() throws');
  }
  try {
    foo1(
        (var61[(false ? 1 : var40)]
            ? (true ? Runes('\u{1f600}\u{1f600}RK') : var45)
            : ((!(true)) ? ((var63[var40]).runes) : var45)),
        FallThroughError(),
        Uint16List(33));
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('foo1() throws');
  }
  try {
    foo2(((9223372036854775807 < -24) ? (true ? null : var41) : var41), '', 0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('foo2() throws');
  }
  try {
    var45.foo0_Extension0(
        {'udb(R', '\u2665IEp\u{1f600}e', 'DMEbe#g', ''}, var50, var8, 0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('var45.foo0_Extension0() throws');
  }
  try {
    fooE1(var36).foo1_Extension0(
        FormatException('n', 3, 48), var19, ((var40 % var42) * -2), 0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('fooE1(var36).foo1_Extension0() throws');
  }
  try {
    fooE1(var36).foo1_Extension1(
        (false ? StringBuffer(36) : StringBuffer(2)), Int16List(25), 0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('fooE1(var36).foo1_Extension1() throws');
  }
  try {
    var22.foo2_Extension0(
        (var54 + ['\u2665aAaW', 'Wc', '\u2665u- jf\u{1f600}']));
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('var22.foo2_Extension0() throws');
  }
  try {
    (var22).foo2_Extension1(IntegerDivisionByZeroException(), var8, ['OiV'], 0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('(var22).foo2_Extension1() throws');
  }
  try {
    var22.foo2_Extension2(
        (((var66[((('2S2\u{1f600}Y' * 43))
                    .substring((Float32x4.zyyy as int), var9[34]))])
                .endsWith(var44))
            ? ((!(var58[var58[var18]])) ? Exception(9) : var38)
            : var38),
        IntegerDivisionByZeroException(),
        FormatException('T', 23, 36));
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('var22.foo2_Extension2() throws');
  }
  try {
    var41.foo3_Extension0(0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('var41.foo3_Extension0() throws');
  }
  try {
    fooE4(var19).foo4_Extension0(
        var38,
        ((((Int32x4(3, 32, 0, 1) - Int32x4(38, 16, 29, 3))).flagX)
            ? var14[(false ? var40 : (var40++))]
            : var14[var11[-75]]));
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('fooE4(var19).foo4_Extension0() throws');
  }
  try {
    var19.foo4_Extension1((SecurityContext.alpnSupported), var14);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('var19.foo4_Extension1() throws');
  }

  try {
    X0().foo0_0({'i\u2665\u26651': -89, 'YPf': -88, 'k': -62, 'zhny': -65});
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('X0().foo0_0 throws');
  }
  try {
    X0().foo0_1(0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('X0().foo0_1 throws');
  }
  try {
    X0().foo0_2(Symbol('L Cn'), MapEntry<bool, bool>(true, true),
        {' pP': '', '': '2A\u2665B', '': 'm\u2665b'}, 0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('X0().foo0_2 throws');
  }
  try {
    X0()(0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('X0() throws');
  }
  try {
    X0().foo0_Extension0({false: 29, true: 27}, var46, (-((-(var19)))));
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('X0().foo0_Extension0 throws');
  }
  try {
    (X0()).foo0_Extension1((false
        ? ([-0, -12] ?? Uint8ClampedList(4))
        : (List<int>.filled(43, var40))));
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('(X0()).foo0_Extension1 throws');
  }
  try {
    X1().foo1_0(Deprecated('CR4-'), 0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('X1().foo1_0 throws');
  }
  try {
    X1()((Int32x4.xyzz as int));
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('X1() throws');
  }
  try {
    (X1()).foo1_Extension0((('-pjz').runes),
        (true ? var68 : MapEntry<bool, int>(false, 16)), var39, 0);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('(X1()).foo1_Extension0 throws');
  }
  try {
    (X1()).foo1_Extension1();
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('(X1()).foo1_Extension1 throws');
  }
  try {
    (X1()).foo1_Extension2(var36, var41);
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('(X1()).foo1_Extension2 throws');
  }
  try {
    X1().run();
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('X1().run() throws');
  }
  try {
    print(
        '$var0\n$var1\n$var2\n$var3\n$var4\n$var5\n$var6\n$var7\n$var8\n$var9\n$var10\n$var11\n$var12\n$var13\n$var14\n$var15\n$var16\n$var17\n$var18\n$var19\n$var20\n$var21\n$var22\n$var23\n$var24\n$var25\n$var26\n$var27\n$var28\n$var29\n$var30\n$var31\n$var32\n$var33\n$var34\n$var35\n$var36\n$var37\n$var38\n$var39\n$var40\n$var41\n$var42\n$var43\n$var44\n$var45\n$var46\n$var47\n$var48\n$var49\n$var50\n$var51\n$var52\n$var53\n$var54\n$var55\n$var56\n$var57\n$var58\n$var59\n$var60\n$var61\n$var62\n$var63\n$var64\n$var65\n$var66\n$var67\n$var68\n$var69\n$var70\n$var71\n$var72\n$var73\n$var74\n$var75\n');
  } on OutOfMemoryError {
    exit(254);
  } catch (e, st) {
    print('print() throws');
  }
}