text: function _assertThisInitialized(self) {
      if (self === void 0) {
          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return self;
  }
  function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
      }
  }
  function _getPrototypeOf(o) {
      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
          return o.__proto__ || Object.getPrototypeOf(o);
      };
      return _getPrototypeOf(o);
  }
  function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
          throw new TypeError("Super expression must either be null or a function");
      }
      subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
              value: subClass,
              writable: true,
              configurable: true
          }
      });
      if (superClass) _setPrototypeOf(subClass, superClass);
  }
  function _possibleConstructorReturn(self, call) {
      if (call && (_typeof(call) === "object" || typeof call === "function")) {
          return call;
      }
      return _assertThisInitialized(self);
  }
  function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
          o.__proto__ = p;
          return o;
      };
      return _setPrototypeOf(o, p);
  }
  var _typeof = function(obj) {
      return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
  };
  function _isNativeReflectConstruct() {
      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
      if (Reflect.construct.sham) return false;
      if (typeof Proxy === "function") return true;
      try {
          Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
          }));
          return true;
      } catch (e) {
          return false;
      }
  }
  function _createSuper(Derived) {
      var hasNativeReflectConstruct = _isNativeReflectConstruct();
      return function _createSuperInternal() {
          var Super = _getPrototypeOf(Derived), result;
          if (hasNativeReflectConstruct) {
              var NewTarget = _getPrototypeOf(this).constructor;
              result = Reflect.construct(Super, arguments, NewTarget);
          } else {
              result = Super.apply(this, arguments);
          }
          return _possibleConstructorReturn(this, result);
      };
  }
  var Base = function Base() {
      "use strict";
      _classCallCheck(this, Base);
  };
  var D0 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D0, Base);
      var _super = _createSuper(D0);
      function D0() {
          _classCallCheck(this, D0);
          return _super.apply(this, arguments);
      }
      return D0;
  }(Base);
  var DA = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(DA, Base);
      var _super = _createSuper(DA);
      function DA() {
          _classCallCheck(this, DA);
          return _super.apply(this, arguments);
      }
      return DA;
  }(Base);
  var D1 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D1, Base);
      var _super = _createSuper(D1);
      function D1() {
          _classCallCheck(this, D1);
          return _super.apply(this, arguments);
      }
      return D1;
  }(Base);
  var D1A = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D1A, Base);
      var _super = _createSuper(D1A);
      function D1A() {
          _classCallCheck(this, D1A);
          return _super.apply(this, arguments);
      }
      return D1A;
  }(Base);
  var D2 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D2, Base);
      var _super = _createSuper(D2);
      function D2() {
          _classCallCheck(this, D2);
          return _super.apply(this, arguments);
      }
      return D2;
  }(Base);
  var D2A = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D2A, Base);
      var _super = _createSuper(D2A);
      function D2A() {
          _classCallCheck(this, D2A);
          return _super.apply(this, arguments);
      }
      return D2A;
  }(Base);
  var D3 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D3, Base);
      var _super = _createSuper(D3);
      function D3() {
          _classCallCheck(this, D3);
          return _super.apply(this, arguments);
      }
      return D3;
  }(Base);
  var D3A = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D3A, Base);
      var _super = _createSuper(D3A);
      function D3A() {
          _classCallCheck(this, D3A);
          return _super.apply(this, arguments);
      }
      return D3A;
  }(Base);
  var D4 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D4, Base);
      var _super = _createSuper(D4);
      function D4() {
          _classCallCheck(this, D4);
          return _super.apply(this, arguments);
      }
      return D4;
  }(Base);
  var D5 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D5, Base);
      var _super = _createSuper(D5);
      function D5() {
          _classCallCheck(this, D5);
          return _super.apply(this, arguments);
      }
      return D5;
  }(Base);
  var D6 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D6, Base);
      var _super = _createSuper(D6);
      function D6() {
          _classCallCheck(this, D6);
          return _super.apply(this, arguments);
      }
      return D6;
  }(Base);
  var D7 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D7, Base);
      var _super = _createSuper(D7);
      function D7() {
          _classCallCheck(this, D7);
          return _super.apply(this, arguments);
      }
      return D7;
  }(Base);
  var D8 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D8, Base);
      var _super = _createSuper(D8);
      function D8() {
          _classCallCheck(this, D8);
          return _super.apply(this, arguments);
      }
      return D8;
  }(Base);
  var D9 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D9, Base);
      var _super = _createSuper(D9);
      function D9() {
          _classCallCheck(this, D9);
          return _super.apply(this, arguments);
      }
      return D9;
  }(Base);
  var D10 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D10, Base);
      var _super = _createSuper(D10);
      function D10() {
          _classCallCheck(this, D10);
          return _super.apply(this, arguments);
      }
      return D10;
  }(Base);
  var E1;
  (function(E) {
      E[E["A"] = 0] = "A";
  })(E1 || (E1 = {
  }));
  var D11 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D11, Base);
      var _super = _createSuper(D11);
      function D11() {
          _classCallCheck(this, D11);
          return _super.apply(this, arguments);
      }
      return D11;
  }(Base);
  function f1() {
  }
  (function(f) {
      f.bar = 1;
  })(f1 || (f1 = {
  }));
  var D12 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D12, Base);
      var _super = _createSuper(D12);
      function D12() {
          _classCallCheck(this, D12);
          return _super.apply(this, arguments);
      }
      return D12;
  }(Base);
  var c = function c() {
      "use strict";
      _classCallCheck(this, c);
  };
  (function(c) {
      c.bar = 1;
  })(c || (c = {
  }));
  var D13 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D13, Base);
      var _super = _createSuper(D13);
      function D13() {
          _classCallCheck(this, D13);
          return _super.apply(this, arguments);
      }
      return D13;
  }(Base);
  var D14 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D14, Base);
      var _super = _createSuper(D14);
      function D14() {
          _classCallCheck(this, D14);
          return _super.apply(this, arguments);
      }
      return D14;
  }(Base);
  var D15 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D15, Base);
      var _super = _createSuper(D15);
      function D15() {
          _classCallCheck(this, D15);
          return _super.apply(this, arguments);
      }
      return D15;
  }(Base);
  var D16 = //class D15<T, U extends T> extends Base {
  //    foo: U;
  //}
  /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D16, Base);
      var _super = _createSuper(D16);
      function D16() {
          _classCallCheck(this, D16);
          return _super.apply(this, arguments);
      }
      return D16;
  }(Base);
  var D17 = /*#__PURE__*/ function(Base) {
      "use strict";
      _inherits(D17, Base);
      var _super = _createSuper(D17);
      function D17() {
          _classCallCheck(this, D17);
          return _super.apply(this, arguments);
      }
      return D17;
  }(Base);
  