// 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.

// @dart = 2.9

// See https://github.com/dart-lang/sdk/issues/38654 for context.

// The Dart Project Fuzz Tester (1.53).
// Program generated as:
//   dart dartfuzz.dart --seed 194851581 --no-fp --no-ffi

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, String> var0 = {
  39: 'sl2a(',
  29: 'HGYdMd',
  93: '\u2665',
  97: 'hJ',
  38: 'O',
  25: '',
  40: ''
};
int var1 = 56;
int var2 = -9;
bool var3 = false;
int var4 = -77;
double var5 = 0.9130097229882881;
String var6 = '\u2665g';
List<int> var7 = [-4294967280, -46, -51, 13, -77, -20];
Set<int> var8 = {
  -9223372036854775680,
  25,
  -43,
  2,
  -57,
  -9223372030412324865,
  4294967423,
  -39
};
Map<int, String> var9 = {90: 'DXbRR', 8: 's\u2665y', 51: '0wumJ', 33: 'aee'};

String foo0() {
  {
    int loc0 = 79;
    while (--loc0 > 0) {
      for (int loc1 in ((var7 +
              [
                -51,
                Int32x4.wwzy,
                (((var3 ? (--var2) : 21) < -40)
                    ? (var3 ? var2 : var7[var1])
                    : (var1--)),
                ((var3
                        ? Float32x4.wyyy
                        : var7[
                            (false ? var4 : ZLibOption.DEFAULT_WINDOW_BITS)]) <<
                    var7[var7[-32769]]),
                (var3 ? 8 : var7[-9223372036854775680]),
                (Int32x4.xxww ^ Int32x4.zzyy)
              ]) ??
          ((!((var0 !=
                  {
                    96: 'r&\u2665P',
                    94: ('JXX ' + var6),
                    62: '\u26656',
                    35: ListBase.listToString(var7)
                  })))
              ? ((var3 ? var7 : (true ? var7 : var7)) ??
                  [
                    (false ? var2 : -66),
                    -55,
                    (-(var7[loc0])),
                    var7[-12],
                    ((((27 + var1)).isInfinite
                            ? var3
                            : (var3 ? (var9[var7[-88]]).isEmpty : var3))
                        ? -4294934528
                        : var1),
                    -40,
                    var7[var7[var7[Int32x4.wxyw]]],
                    14
                  ])
              : [Float32x4.yxyy]))) {
        /*
         * Multi-line
         * comment.
         */
        {
          int loc2 = 67;
          while (--loc2 > 0) {
            var8 = {loc1, 62, -37, Float32x4.yxwz, -42};
          }
        }
        var9.forEach((loc2, loc3) {
          var7 = var7;
          try {
            loc3 ??= 'tSWbA';
          } catch (exception, stackTrace) {
            for (int loc4 in [
              ((!((((-82 * var7[-28])).toString() == (var0[31] ?? var6))))
                  ? (--var2)
                  : (--var4))
            ]) {
              var7[Int32x4.wxzx] ~/= Int32x4.ywwx;
            }
            var3 ??= var3;
          } finally {
            var0 ??= var9;
          }
        });
      }
    }
  }
  return ((var3 &&
          (((var3 ? true : (var3 || var3)) ? false : false)
              ? true
              : (!((false && false)))))
      ? 'V-5p'
      : (((Float32x4.xwwx > var7[var2])
              ? var6
              : var9[(((--var2)).isEven ? -90 : (++var2))]) ??
          (var3 ? '' : '!5s#rtD')));
}

Set<int> foo1(int par1, bool par2) {
  // Single-line comment.
  {
    int loc0 = 68;
    while (--loc0 > 0) {
      {
        List<int> loc1 = [
          var1,
          -13,
          (false ? ((~(19)) - ((!(true)) ? (par1++) : -89)) : (~((var2--)))),
          Float32x4.yzww,
          var7[(~((--par1)))],
          (-99 % par1),
          (true ? (~(var7[par1])) : Int32x4.xyxw)
        ];
        for (int loc2 in var8) {
          var7[16] <<= Float32x4.yyyx;
        }
        for (int loc2 = 0; loc2 < 33; loc2++) {
          if (var3) {
            var0 = (Map.unmodifiable(var9) ??
                (Map.unmodifiable(var9) ??
                    Map.from({6: var9[var1], 28: foo0(), 36: '8+'})));
            var9[((-93 * loc1[loc2]) +
                (((!((!(par2)))) || (!(par2)))
                    ? (var4 ~/ JsonUtf8Encoder.DEFAULT_BUFFER_SIZE)
                    : -9223372032559775745))] ??= var6;
          }
          var3 = ((!((loc1[loc0] != (false ? (--var4) : var1)))) ||
              ('').endsWith('xTYEp\u2665'));
        }
      }
      for (int loc1 in var7) {
        var7[Float32x4.ywzy] >>= var2;
        /*
         * Multi-line
         * comment.
         */
        var8 = (((false ? var8 : {var1, Float32x4.xwyw}) ??
                ({(Int32x4.wxyy & var7[(par1--)])} ??
                    (var3
                        ? {var7[73], 20, var4, (var7[(-20 | loc1)] * 84), 47}
                        : (par2
                            ? {
                                8,
                                -66,
                                (((var7[var7[-56]])
                                            .toRadixString(Int32x4.wyxx) !=
                                        (('j' ?? 'r')).toLowerCase())
                                    ? var7[var7[(var2++)]]
                                    : (-(Duration.microsecondsPerDay))),
                                (~(((!(true))
                                    ? (false
                                        ? (++var2)
                                        : var7[ZLibOption.STRATEGY_FILTERED])
                                    : Float32x4.xxyz))),
                                (var3
                                    ? (true
                                        ? (-95 -
                                            (-25 ??
                                                ((false ? true : var3)
                                                    ? Int32x4.xxww
                                                    : var7[-29])))
                                        : (var2++))
                                    : -34)
                              }
                            : ({(++var4), par1, (-81 % var7[-54])})
                                .toSet())))) ??
            {
              (~((-((loc1++))))),
              (var7[var7[4295032832]] - RawSocketOption.levelIPv4)
            });
      }
    }
  }
  return {
    var7[var2],
    var2,
    (-(((par2 && par2) ? Int32x4.ywzw : Float32x4.wywx))),
    ((!(NetworkInterface.listSupported))
        ? (--var4)
        : (((var6).isEmpty
                ? (-73 * ((var7[var4]).isOdd ? Float32x4.xwww : -63))
                : -4) -
            (~(69)))),
    (((true
                ? (true
                    ? -9223372032559808257
                    : (~((par2 ? (var1--) : (false ? var7[-4] : var1)))))
                : 27) <<
            Float32x4.xyzy) -
        ((~(var7[Float32x4.xyzz])) &
            (((par2 ? true : false) ? par2 : true)
                ? 44
                : ((!(par2)) ? -57 : var7[var2])))),
    (MapBase.mapToString((Map.from({
              77: ((!(false)) ? var6 : var0[var7[var7[var7[-63]]]]),
              87: '9vj',
              50: 'e\u26655-',
              46: var9[-32],
              96: var6
            }) ??
            {
              32: var0[-9223372032559742976],
              4: SetBase.setToString(var8),
              67: var0[Int32x4.yxww],
              53: var9[53],
              91: var6,
              17: '2gtffn'
            })))
        .length
  };
}

String foo2(Map<int, String> par1, bool par2) {
  try {
    par2 = (false
        ? false
        : (SecurityContext.alpnSupported
            ? false
            : (var3 ? ('aXL').isNotEmpty : (77).isNegative)));
    if ((((++var4) ~/ (var4 & var1))).isEven) {
      /*
       * Multi-line
       * comment.
       */
      var7 ??= (((((-(var7[-2]))).toString() ?? foo0()) ??
              (true
                  ? (par1[(-57 + (var7[52] | -91))] + var9[57])
                  : Uri.decodeFull((false
                      ? '17'
                      : (8).toStringAsExponential(var7[var7[8]]))))))
          .codeUnits;
    }
  } catch (exception, stackTrace) {
    {
      bool loc0 = ({
        61: String.fromEnvironment(('K4\u2665dc0' + var6)),
        85: ((!(true)) ? 'I&P' : par1[(~((-((++var4)))))])
      }).isNotEmpty;
      {
        Map<int, String> loc1 =
            Map.from({55: (true ? '' : 'ZoDx\u{1f600}'), 82: foo0()});

        /// Single-line documentation comment.
        var3 = var3;
      }
      {
        int loc1 = 81;
        while (--loc1 > 0) {
          var3 = (!((List.filled(38, 87) !=
              ((false ? (true ? loc0 : true) : var3) ? var7 : var7))));
          try {
            par2 = var3;
            switch (loc1) {
              case 1947756698:
                {
                  var7 = [
                    [(--var1), -74, (-(Float32x4.ywyw))][((-(38)) | (var2--))],
                    Float32x4.yyzy,
                    (Int32x4.yxzx % Int32x4.ywyx),
                    var4,
                    (loc0 ? (var1--) : Float32x4.xzxy),
                    (-((~(-15))))
                  ];

                  /// Single-line documentation comment.
                  throw {
                    (true ? ((var4++) ~/ (-69 ?? 78)) : (var1--)),
                    (--var1),
                    (-((var2--))),
                    (-82 % (-30).bitLength),
                    14,
                    32768,
                    Int32x4.zxwy
                  };
                }
                break;
              case 1947756704:
                {
                  if (true) {
                    break;
                  }
                }
                break;
            }
          } catch (exception, stackTrace) {
            var6 = 'YgW\u{1f600}';
            if ((!(((true ? loc0 : var3) &&
                ((var3 ? ((var1++)).isFinite : par2) || var3))))) {
              try {
                return foo0();
              } catch (exception, stackTrace) {
                var6 = foo0();
              }
              par1 = ((par2 ? (par1 ?? Map.identity()) : var9) ?? var9);
            } else {
              var7 ??= var7;
              return 'ACaB#Z1';
            }
          }
        }
      }
    }
    for (int loc0 = 0; loc0 < 15; loc0++) {
      var7[(-(((Uint64List.bytesPerElement).isFinite ? -12 : -46)))] ~/= (true
          ? loc0
          : (~((var7[(14 >> (-((var1--))))] ^ (9223372032559808639 ?? loc0)))));
    }
  } finally {
    /*
     * Multi-line
     * comment.
     */
    try {
      {
        int loc0 = 73;
        while (--loc0 > 0) {
          {
            int loc1 = 0;
            do {
              var4 <<= loc0;
              for (int loc2 in var8) {
                par2 = true;
                par2 ??= (foo0()).isEmpty;
              }
            } while (++loc1 < 73);
          }
          var9 = var0;
        }
      }
      for (int loc0 = 0; loc0 < 96; loc0++) {
        /// Single-line documentation comment.
        try {
          par2 ??= ('(b').endsWith('x-f76ee');
          var3 = var3;
        } catch (exception, stackTrace) {
          var8 ??= foo1((var3 ? 51 : (false ? Int32x4.zzxy : (-((~(-84)))))),
              (NetworkInterface.listSupported || true));
        }
      }
    } catch (exception, stackTrace) {
      for (int loc0 in [
        (~((-(((par2 ? Int32x4.zzzw : var2) * (-(89))))))),
        -14,
        -88,
        (var4++),
        (var7[((var7[Float32x4.xxxx] % (~(var7[var4]))) | -16)] |
            (var7[Float32x4.zwwz] ^ -9223372036854775681))
      ]) {
        var7[(par2 ? 60 : (-7 >> -53))] ??= Int32x4.yzxw;
        for (int loc1
            in (var3 ? (((loc0 * var7[16])).toString()).codeUnits : var7)) {
          var0.forEach((loc2, loc3) {
            var3 ??= (foo0()).isNotEmpty;
            throw (var4++);
          });
        }
      }
    } finally {
      try {
        var8 = ((!(true))
            ? {Float32x4.zzwy, 67, -6, 85}
            : foo1(Float32x4.zwxy, var3));
        var8 = foo1(
            (-54).abs(),
            ((var3 ? true : (!(var3)))
                ? (!((Uri.encodeFull('aILQc')).endsWith('+7o0Q6b')))
                : ((true ? ('bEIx').endsWith(par1[var2]) : par2)
                    ? false
                    : ({
                          -77,
                          (false ? -9223372036854775792 : 4294968296),
                          var4,
                          var7[var7[var7[var2]]]
                        } !=
                        {
                          var7[-80],
                          (true ? var7[22] : (-(58))),
                          -77,
                          (var7[Int32x4.wxwz] ~/ 66)
                        }))));
      } catch (exception, stackTrace) {
        try {
          var6 ??= par1[(('R12').isNotEmpty
              ? (par2 ? 4294967396 : var2)
              : (((var0).isEmpty ? true : par2) ? var4 : var2))];
          var8 ??= (var8 ??
              {
                (~(((var7[var2] ?? 86) >>
                    (((-(var7[var1]))).isNaN
                        ? (var3 ? (false ? -4294901760 : (-(var7[32]))) : var1)
                        : var4)))),
                Int32x4.wyzy
              });
        } catch (exception, stackTrace) {
          var9 = (Map.of({
                59: var6,
                3: var0[DateTime.may],
                49: par1[var2],
                71: '6',
                77: ((!(true)) ? ('QB\u2665OU6' ?? 'r-\u2665') : foo0()),
                88: foo0()
              }) ??
              var0);
          var6 ??= ((('').substring(40, (~(Int32x4.yxxx))) ??
                  ((var9[81] ?? '0(G') + ('u-+').toLowerCase())))
              .trimRight();
        }
        var7 = [-9223372032559808512];
      } finally {
        var4 -= var7[(++var2)];
      }
      var0.forEach((loc0, loc1) {
        switch (Int32x4.xyyw) {
          case 2310807338:
            {
              var9[((var7[var7[var1]] % (~(49))) & (~((var7[34]).toInt())))] ??=
                  ('5j' ?? 'jfHUh');
              var8 ??= ((!((!(var3))))
                  ? (par2
                      ? var8
                      : ((var7[(-38 - (var3 ? -38 : -91))]).isNegative
                          ? (true
                              ? (({-83, loc0} ??
                                      {
                                        var1,
                                        27,
                                        -73,
                                        var7[var4],
                                        (-88 +
                                            (~(((var3
                                                    ? ((-(-51)) + -60)
                                                    : var7[-21]) ??
                                                -65))))
                                      }))
                                  .difference({
                                  (-(Float32x4.yxzw)),
                                  (--var2),
                                  Int32x4.wywz,
                                  (-(((true
                                          ? (true
                                              ? (true ? (!(var3)) : true)
                                              : true)
                                          : (var8 != {(~(loc0)), 28, -96}))
                                      ? (par2
                                          ? ((par2
                                                  ? var7[var7[(++var4)]]
                                                  : (var4--)) +
                                              57)
                                          : ((((var3 ? false : true)
                                                      ? par2
                                                      : par2)
                                                  ? (var4 * var7[-74])
                                                  : var2) >>
                                              (false ? 63 : -23)))
                                      : (false ? -6 : (par2 ? 10 : var2))))),
                                  -35,
                                  (-(-92)),
                                  var7[DateTime.saturday]
                                })
                              : Set.identity())
                          : (par2
                              ? {(-((var2 | (-(-57)))))}
                              : ((var4 < 10)
                                  ? foo1(var7[8], par2)
                                  : (var3
                                      ? {96, 82, var7[(++var4)]}
                                      : {var2})))))
                  : foo1(
                      ((false || true)
                          ? loc0
                          : ((var3
                                  ? 49
                                  : ((var2 ?? var7[(-((~(23))))]) >> 97)) <<
                              var7[34])),
                      (!(par2))));
            }
            break;
          case 2310807345:
            {
              var8 ??= ((foo1((false ? var1 : (var4++)), (!(par2))) ??
                      ((var8 ??
                              {
                                var4,
                                -22,
                                (-(var7[((~(Float32x4.zyzx)) | var7[-23])])),
                                -35
                              }) ??
                          {var1, 21, var2, var7[Float32x4.ywyw], loc0})) ??
                  foo1(var7[(~(-75))], (!(false))));
              {
                int loc2 = 64;
                while (--loc2 > 0) {
                  var7 = var7;

                  /// Single-line documentation comment.
                  if (true) {
                    par2 = (var8).add(((var7[var1] + (-(4294967425))) ??
                        var7[((-(-9223372032559775745)) - (--var4))]));
                    if ((Map.from(par1)).isEmpty) {
                      var9 ??= ((Map.unmodifiable(Map.unmodifiable(par1)) ??
                              (((var2).isInfinite ? var9 : par1) ??
                                  Map.unmodifiable((par1 ?? par1)))) ??
                          (Map.unmodifiable({
                                51: par1[(~((~(Uint64List.bytesPerElement))))],
                                14: foo0(),
                                69: var0[var1],
                                56: loc1,
                                41: (false ? var0[Int32x4.yxwy] : loc1),
                                30: ((!(var3)) ? '' : 'L'),
                                80: 'UsR6'
                              }) ??
                              {
                                67: loc1,
                                73: ((var4).isEven
                                    ? ('' ?? (var3 ? foo0() : var6))
                                    : foo0())
                              }));
                    }
                  } else {
                    var7[(SecurityContext.alpnSupported
                        ? (~((true ? Float32x4.ywzw : -97)))
                        : loc2)] = (--var2);
                  }
                }
              }
            }
            break;
        }
        print(true);
      });
    }
    for (int loc0 in [
      (++var1),
      (var7[(~(((false ? (false && par2) : (71).isInfinite)
              ? var7[87]
              : -9223372028264841217)))] -
          var7[var2]),
      ((~((-(((true ? true : false)
              ? var7[-78]
              : (((false || false) ? true : (true && (false && true)))
                  ? var2
                  : (par2 ? -13 : 65))))))) >>
          ((var3 ? false : false) ? (~((~(-97)))) : Uint8List.bytesPerElement))
    ]) {
      // Single-line comment.
      break;
    }
  }
  return 'F+\u2665';
}

main() {
  try {
    foo2(
        ((var3 ? var9 : var0) ??
            {
              30: '',
              58: '\u2665bc',
              45: ' \u{1f600}',
              79: 'zLuiBp',
              2: 'X9\u{1f600}2Lq',
              78: 'PP6NIH',
              77: 'OB',
              80: 'EcL\u{1f600}yp'
            }),
        (!(((47).toString()).isEmpty)));
  } on OutOfMemoryError {
    print('oom');
    exit(254);
  } catch (e, st) {
    print('foo2 throws');
  }
}