"use strict";
(() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __commonJS = (cb, mod) => function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

  // node_modules/vscode-jsonrpc/lib/common/is.js
  var require_is = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/is.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.boolean = boolean;
      exports.string = string;
      exports.number = number;
      exports.error = error;
      exports.func = func;
      exports.array = array;
      exports.stringArray = stringArray;
      function boolean(value) {
        return value === true || value === false;
      }
      function string(value) {
        return typeof value === "string" || value instanceof String;
      }
      function number(value) {
        return typeof value === "number" || value instanceof Number;
      }
      function error(value) {
        return value instanceof Error;
      }
      function func(value) {
        return typeof value === "function";
      }
      function array(value) {
        return Array.isArray(value);
      }
      function stringArray(value) {
        return array(value) && value.every((elem) => string(elem));
      }
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/messages.js
  var require_messages = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/messages.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0;
      var is = __importStar(require_is());
      var ErrorCodes;
      (function(ErrorCodes2) {
        ErrorCodes2.ParseError = -32700;
        ErrorCodes2.InvalidRequest = -32600;
        ErrorCodes2.MethodNotFound = -32601;
        ErrorCodes2.InvalidParams = -32602;
        ErrorCodes2.InternalError = -32603;
        ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
        ErrorCodes2.serverErrorStart = -32099;
        ErrorCodes2.MessageWriteError = -32099;
        ErrorCodes2.MessageReadError = -32098;
        ErrorCodes2.PendingResponseRejected = -32097;
        ErrorCodes2.ConnectionInactive = -32096;
        ErrorCodes2.ServerNotInitialized = -32002;
        ErrorCodes2.UnknownErrorCode = -32001;
        ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
        ErrorCodes2.serverErrorEnd = -32e3;
      })(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));
      var ResponseError = class _ResponseError extends Error {
        code;
        data;
        constructor(code, message, data) {
          super(message);
          this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
          this.data = data;
          Object.setPrototypeOf(this, _ResponseError.prototype);
        }
        toJson() {
          const result = {
            code: this.code,
            message: this.message
          };
          if (this.data !== void 0) {
            result.data = this.data;
          }
          return result;
        }
      };
      exports.ResponseError = ResponseError;
      var ParameterStructures = class _ParameterStructures {
        kind;
        /**
         * The parameter structure is automatically inferred on the number of parameters
         * and the parameter type in case of a single param.
         */
        static auto = new _ParameterStructures("auto");
        /**
         * Forces `byPosition` parameter structure. This is useful if you have a single
         * parameter which has a literal type.
         */
        static byPosition = new _ParameterStructures("byPosition");
        /**
         * Forces `byName` parameter structure. This is only useful when having a single
         * parameter. The library will report errors if used with a different number of
         * parameters.
         */
        static byName = new _ParameterStructures("byName");
        constructor(kind) {
          this.kind = kind;
        }
        static is(value) {
          return value === _ParameterStructures.auto || value === _ParameterStructures.byName || value === _ParameterStructures.byPosition;
        }
        toString() {
          return this.kind;
        }
      };
      exports.ParameterStructures = ParameterStructures;
      var AbstractMessageSignature = class {
        method;
        numberOfParams;
        constructor(method, numberOfParams) {
          this.method = method;
          this.numberOfParams = numberOfParams;
        }
        get parameterStructures() {
          return ParameterStructures.auto;
        }
      };
      exports.AbstractMessageSignature = AbstractMessageSignature;
      var RequestType0 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 0);
        }
      };
      exports.RequestType0 = RequestType0;
      var RequestType = class extends AbstractMessageSignature {
        _parameterStructures;
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method, _parameterStructures = ParameterStructures.auto) {
          super(method, 1);
          this._parameterStructures = _parameterStructures;
        }
        get parameterStructures() {
          return this._parameterStructures;
        }
      };
      exports.RequestType = RequestType;
      var RequestType1 = class extends AbstractMessageSignature {
        _parameterStructures;
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method, _parameterStructures = ParameterStructures.auto) {
          super(method, 1);
          this._parameterStructures = _parameterStructures;
        }
        get parameterStructures() {
          return this._parameterStructures;
        }
      };
      exports.RequestType1 = RequestType1;
      var RequestType2 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 2);
        }
      };
      exports.RequestType2 = RequestType2;
      var RequestType3 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 3);
        }
      };
      exports.RequestType3 = RequestType3;
      var RequestType4 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 4);
        }
      };
      exports.RequestType4 = RequestType4;
      var RequestType5 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 5);
        }
      };
      exports.RequestType5 = RequestType5;
      var RequestType6 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 6);
        }
      };
      exports.RequestType6 = RequestType6;
      var RequestType7 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 7);
        }
      };
      exports.RequestType7 = RequestType7;
      var RequestType8 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 8);
        }
      };
      exports.RequestType8 = RequestType8;
      var RequestType9 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 9);
        }
      };
      exports.RequestType9 = RequestType9;
      var NotificationType = class extends AbstractMessageSignature {
        _parameterStructures;
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method, _parameterStructures = ParameterStructures.auto) {
          super(method, 1);
          this._parameterStructures = _parameterStructures;
        }
        get parameterStructures() {
          return this._parameterStructures;
        }
      };
      exports.NotificationType = NotificationType;
      var NotificationType0 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 0);
        }
      };
      exports.NotificationType0 = NotificationType0;
      var NotificationType1 = class extends AbstractMessageSignature {
        _parameterStructures;
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method, _parameterStructures = ParameterStructures.auto) {
          super(method, 1);
          this._parameterStructures = _parameterStructures;
        }
        get parameterStructures() {
          return this._parameterStructures;
        }
      };
      exports.NotificationType1 = NotificationType1;
      var NotificationType2 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 2);
        }
      };
      exports.NotificationType2 = NotificationType2;
      var NotificationType3 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 3);
        }
      };
      exports.NotificationType3 = NotificationType3;
      var NotificationType4 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 4);
        }
      };
      exports.NotificationType4 = NotificationType4;
      var NotificationType5 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 5);
        }
      };
      exports.NotificationType5 = NotificationType5;
      var NotificationType6 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 6);
        }
      };
      exports.NotificationType6 = NotificationType6;
      var NotificationType7 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 7);
        }
      };
      exports.NotificationType7 = NotificationType7;
      var NotificationType8 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 8);
        }
      };
      exports.NotificationType8 = NotificationType8;
      var NotificationType9 = class extends AbstractMessageSignature {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        _;
        constructor(method) {
          super(method, 9);
        }
      };
      exports.NotificationType9 = NotificationType9;
      var Message;
      (function(Message2) {
        function isRequest(message) {
          const candidate = message;
          return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
        }
        Message2.isRequest = isRequest;
        function isNotification(message) {
          const candidate = message;
          return candidate && is.string(candidate.method) && message.id === void 0;
        }
        Message2.isNotification = isNotification;
        function isResponse(message) {
          const candidate = message;
          return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
        }
        Message2.isResponse = isResponse;
      })(Message || (exports.Message = Message = {}));
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/linkedMap.js
  var require_linkedMap = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/linkedMap.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LRUCache = exports.LinkedMap = exports.Touch = void 0;
      var Touch;
      (function(Touch2) {
        Touch2.None = 0;
        Touch2.First = 1;
        Touch2.AsOld = Touch2.First;
        Touch2.Last = 2;
        Touch2.AsNew = Touch2.Last;
      })(Touch || (exports.Touch = Touch = {}));
      var LinkedMap = class {
        [Symbol.toStringTag] = "LinkedMap";
        _map;
        _head;
        _tail;
        _size;
        _state;
        constructor() {
          this._map = /* @__PURE__ */ new Map();
          this._head = void 0;
          this._tail = void 0;
          this._size = 0;
          this._state = 0;
        }
        clear() {
          this._map.clear();
          this._head = void 0;
          this._tail = void 0;
          this._size = 0;
          this._state++;
        }
        isEmpty() {
          return !this._head && !this._tail;
        }
        get size() {
          return this._size;
        }
        get first() {
          return this._head?.value;
        }
        get last() {
          return this._tail?.value;
        }
        before(key) {
          const item = this._map.get(key);
          return item ? item.previous?.value : void 0;
        }
        after(key) {
          const item = this._map.get(key);
          return item ? item.next?.value : void 0;
        }
        has(key) {
          return this._map.has(key);
        }
        get(key, touch = Touch.None) {
          const item = this._map.get(key);
          if (!item) {
            return void 0;
          }
          if (touch !== Touch.None) {
            this.touch(item, touch);
          }
          return item.value;
        }
        set(key, value, touch = Touch.None) {
          let item = this._map.get(key);
          if (item) {
            item.value = value;
            if (touch !== Touch.None) {
              this.touch(item, touch);
            }
          } else {
            item = { key, value, next: void 0, previous: void 0 };
            switch (touch) {
              case Touch.None:
                this.addItemLast(item);
                break;
              case Touch.First:
                this.addItemFirst(item);
                break;
              case Touch.Last:
                this.addItemLast(item);
                break;
              default:
                this.addItemLast(item);
                break;
            }
            this._map.set(key, item);
            this._size++;
          }
          return this;
        }
        delete(key) {
          return !!this.remove(key);
        }
        remove(key) {
          const item = this._map.get(key);
          if (!item) {
            return void 0;
          }
          this._map.delete(key);
          this.removeItem(item);
          this._size--;
          return item.value;
        }
        shift() {
          if (!this._head && !this._tail) {
            return void 0;
          }
          if (!this._head || !this._tail) {
            throw new Error("Invalid list");
          }
          const item = this._head;
          this._map.delete(item.key);
          this.removeItem(item);
          this._size--;
          return item.value;
        }
        forEach(callbackfn, thisArg) {
          const state = this._state;
          let current = this._head;
          while (current) {
            if (thisArg) {
              callbackfn.bind(thisArg)(current.value, current.key, this);
            } else {
              callbackfn(current.value, current.key, this);
            }
            if (this._state !== state) {
              throw new Error(`LinkedMap got modified during iteration.`);
            }
            current = current.next;
          }
        }
        keys() {
          const state = this._state;
          let current = this._head;
          const iterator = {
            [Symbol.iterator]: () => {
              return iterator;
            },
            next: () => {
              if (this._state !== state) {
                throw new Error(`LinkedMap got modified during iteration.`);
              }
              if (current) {
                const result = { value: current.key, done: false };
                current = current.next;
                return result;
              } else {
                return { value: void 0, done: true };
              }
            }
          };
          return iterator;
        }
        values() {
          const state = this._state;
          let current = this._head;
          const iterator = {
            [Symbol.iterator]: () => {
              return iterator;
            },
            next: () => {
              if (this._state !== state) {
                throw new Error(`LinkedMap got modified during iteration.`);
              }
              if (current) {
                const result = { value: current.value, done: false };
                current = current.next;
                return result;
              } else {
                return { value: void 0, done: true };
              }
            }
          };
          return iterator;
        }
        entries() {
          const state = this._state;
          let current = this._head;
          const iterator = {
            [Symbol.iterator]: () => {
              return iterator;
            },
            next: () => {
              if (this._state !== state) {
                throw new Error(`LinkedMap got modified during iteration.`);
              }
              if (current) {
                const result = { value: [current.key, current.value], done: false };
                current = current.next;
                return result;
              } else {
                return { value: void 0, done: true };
              }
            }
          };
          return iterator;
        }
        [Symbol.iterator]() {
          return this.entries();
        }
        trimOld(newSize) {
          if (newSize >= this.size) {
            return;
          }
          if (newSize === 0) {
            this.clear();
            return;
          }
          let current = this._head;
          let currentSize = this.size;
          while (current && currentSize > newSize) {
            this._map.delete(current.key);
            current = current.next;
            currentSize--;
          }
          this._head = current;
          this._size = currentSize;
          if (current) {
            current.previous = void 0;
          }
          this._state++;
        }
        addItemFirst(item) {
          if (!this._head && !this._tail) {
            this._tail = item;
          } else if (!this._head) {
            throw new Error("Invalid list");
          } else {
            item.next = this._head;
            this._head.previous = item;
          }
          this._head = item;
          this._state++;
        }
        addItemLast(item) {
          if (!this._head && !this._tail) {
            this._head = item;
          } else if (!this._tail) {
            throw new Error("Invalid list");
          } else {
            item.previous = this._tail;
            this._tail.next = item;
          }
          this._tail = item;
          this._state++;
        }
        removeItem(item) {
          if (item === this._head && item === this._tail) {
            this._head = void 0;
            this._tail = void 0;
          } else if (item === this._head) {
            if (!item.next) {
              throw new Error("Invalid list");
            }
            item.next.previous = void 0;
            this._head = item.next;
          } else if (item === this._tail) {
            if (!item.previous) {
              throw new Error("Invalid list");
            }
            item.previous.next = void 0;
            this._tail = item.previous;
          } else {
            const next = item.next;
            const previous = item.previous;
            if (!next || !previous) {
              throw new Error("Invalid list");
            }
            next.previous = previous;
            previous.next = next;
          }
          item.next = void 0;
          item.previous = void 0;
          this._state++;
        }
        touch(item, touch) {
          if (!this._head || !this._tail) {
            throw new Error("Invalid list");
          }
          if (touch !== Touch.First && touch !== Touch.Last) {
            return;
          }
          if (touch === Touch.First) {
            if (item === this._head) {
              return;
            }
            const next = item.next;
            const previous = item.previous;
            if (item === this._tail) {
              previous.next = void 0;
              this._tail = previous;
            } else {
              next.previous = previous;
              previous.next = next;
            }
            item.previous = void 0;
            item.next = this._head;
            this._head.previous = item;
            this._head = item;
            this._state++;
          } else if (touch === Touch.Last) {
            if (item === this._tail) {
              return;
            }
            const next = item.next;
            const previous = item.previous;
            if (item === this._head) {
              next.previous = void 0;
              this._head = next;
            } else {
              next.previous = previous;
              previous.next = next;
            }
            item.next = void 0;
            item.previous = this._tail;
            this._tail.next = item;
            this._tail = item;
            this._state++;
          }
        }
        toJSON() {
          const data = [];
          this.forEach((value, key) => {
            data.push([key, value]);
          });
          return data;
        }
        fromJSON(data) {
          this.clear();
          for (const [key, value] of data) {
            this.set(key, value);
          }
        }
      };
      exports.LinkedMap = LinkedMap;
      var LRUCache = class extends LinkedMap {
        _limit;
        _ratio;
        constructor(limit, ratio = 1) {
          super();
          this._limit = limit;
          this._ratio = Math.min(Math.max(0, ratio), 1);
        }
        get limit() {
          return this._limit;
        }
        set limit(limit) {
          this._limit = limit;
          this.checkTrim();
        }
        get ratio() {
          return this._ratio;
        }
        set ratio(ratio) {
          this._ratio = Math.min(Math.max(0, ratio), 1);
          this.checkTrim();
        }
        get(key, touch = Touch.AsNew) {
          return super.get(key, touch);
        }
        peek(key) {
          return super.get(key, Touch.None);
        }
        set(key, value) {
          super.set(key, value, Touch.Last);
          this.checkTrim();
          return this;
        }
        checkTrim() {
          if (this.size > this._limit) {
            this.trimOld(Math.round(this._limit * this._ratio));
          }
        }
      };
      exports.LRUCache = LRUCache;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/disposable.js
  var require_disposable = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/disposable.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Disposable = void 0;
      var Disposable;
      (function(Disposable2) {
        function create(func) {
          return {
            dispose: func
          };
        }
        Disposable2.create = create;
      })(Disposable || (exports.Disposable = Disposable = {}));
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/ral.js
  var require_ral = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/ral.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      var _ral;
      function RAL() {
        if (_ral === void 0) {
          throw new Error(`No runtime abstraction layer installed`);
        }
        return _ral;
      }
      (function(RAL2) {
        function install(ral) {
          if (ral === void 0) {
            throw new Error(`No runtime abstraction layer provided`);
          }
          _ral = ral;
        }
        RAL2.install = install;
      })(RAL || (RAL = {}));
      exports.default = RAL;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/events.js
  var require_events = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/events.js"(exports) {
      "use strict";
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Emitter = exports.Event = void 0;
      var ral_1 = __importDefault(require_ral());
      var Event;
      (function(Event2) {
        const _disposable = { dispose() {
        } };
        Event2.None = function() {
          return _disposable;
        };
      })(Event || (exports.Event = Event = {}));
      var CallbackList = class {
        _callbacks;
        _contexts;
        add(callback, context = null, bucket) {
          if (!this._callbacks) {
            this._callbacks = [];
            this._contexts = [];
          }
          this._callbacks.push(callback);
          this._contexts.push(context);
          if (Array.isArray(bucket)) {
            bucket.push({ dispose: () => this.remove(callback, context) });
          }
        }
        remove(callback, context = null) {
          if (!this._callbacks) {
            return;
          }
          let foundCallbackWithDifferentContext = false;
          for (let i = 0, len = this._callbacks.length; i < len; i++) {
            if (this._callbacks[i] === callback) {
              if (this._contexts[i] === context) {
                this._callbacks.splice(i, 1);
                this._contexts.splice(i, 1);
                return;
              } else {
                foundCallbackWithDifferentContext = true;
              }
            }
          }
          if (foundCallbackWithDifferentContext) {
            throw new Error("When adding a listener with a context, you should remove it with the same context");
          }
        }
        invoke(...args) {
          if (!this._callbacks) {
            return [];
          }
          const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
          for (let i = 0, len = callbacks.length; i < len; i++) {
            try {
              ret.push(callbacks[i].apply(contexts[i], args));
            } catch (e) {
              (0, ral_1.default)().console.error(e);
            }
          }
          return ret;
        }
        isEmpty() {
          return !this._callbacks || this._callbacks.length === 0;
        }
        dispose() {
          this._callbacks = void 0;
          this._contexts = void 0;
        }
      };
      var Emitter = class _Emitter {
        _options;
        static _noop = function() {
        };
        _event;
        _callbacks;
        constructor(_options) {
          this._options = _options;
        }
        /**
         * For the public to allow to subscribe
         * to events from this Emitter
         */
        get event() {
          if (!this._event) {
            this._event = (listener, thisArgs, disposables) => {
              if (!this._callbacks) {
                this._callbacks = new CallbackList();
              }
              if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
                this._options.onFirstListenerAdd(this);
              }
              this._callbacks.add(listener, thisArgs);
              const result = {
                dispose: () => {
                  if (!this._callbacks) {
                    return;
                  }
                  this._callbacks.remove(listener, thisArgs);
                  result.dispose = _Emitter._noop;
                  if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
                    this._options.onLastListenerRemove(this);
                  }
                }
              };
              if (Array.isArray(disposables)) {
                disposables.push(result);
              }
              return result;
            };
          }
          return this._event;
        }
        /**
         * To be kept private to fire an event to
         * subscribers
         */
        fire(event) {
          if (this._callbacks) {
            this._callbacks.invoke.call(this._callbacks, event);
          }
        }
        dispose() {
          if (this._callbacks) {
            this._callbacks.dispose();
            this._callbacks = void 0;
          }
        }
      };
      exports.Emitter = Emitter;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/cancellation.js
  var require_cancellation = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/cancellation.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CancellationTokenSource = exports.CancellationToken = void 0;
      var ral_1 = __importDefault(require_ral());
      var Is3 = __importStar(require_is());
      var events_1 = require_events();
      var CancellationToken;
      (function(CancellationToken2) {
        CancellationToken2.None = Object.freeze({
          isCancellationRequested: false,
          onCancellationRequested: events_1.Event.None
        });
        CancellationToken2.Cancelled = Object.freeze({
          isCancellationRequested: true,
          onCancellationRequested: events_1.Event.None
        });
        function is(value) {
          const candidate = value;
          return candidate && (candidate === CancellationToken2.None || candidate === CancellationToken2.Cancelled || Is3.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
        }
        CancellationToken2.is = is;
      })(CancellationToken || (exports.CancellationToken = CancellationToken = {}));
      var shortcutEvent = Object.freeze(function(callback, context) {
        const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
        return { dispose() {
          handle.dispose();
        } };
      });
      var MutableToken = class {
        _isCancelled = false;
        _emitter;
        cancel() {
          if (!this._isCancelled) {
            this._isCancelled = true;
            if (this._emitter) {
              this._emitter.fire(void 0);
              this.dispose();
            }
          }
        }
        get isCancellationRequested() {
          return this._isCancelled;
        }
        get onCancellationRequested() {
          if (this._isCancelled) {
            return shortcutEvent;
          }
          if (!this._emitter) {
            this._emitter = new events_1.Emitter();
          }
          return this._emitter.event;
        }
        dispose() {
          if (this._emitter) {
            this._emitter.dispose();
            this._emitter = void 0;
          }
        }
      };
      var CancellationTokenSource = class {
        _token;
        get token() {
          if (!this._token) {
            this._token = new MutableToken();
          }
          return this._token;
        }
        cancel() {
          if (!this._token) {
            this._token = CancellationToken.Cancelled;
          } else {
            this._token.cancel();
          }
        }
        dispose() {
          if (!this._token) {
            this._token = CancellationToken.None;
          } else if (this._token instanceof MutableToken) {
            this._token.dispose();
          }
        }
      };
      exports.CancellationTokenSource = CancellationTokenSource;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js
  var require_sharedArrayCancellation = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = void 0;
      var cancellation_1 = require_cancellation();
      var CancellationState;
      (function(CancellationState2) {
        CancellationState2.Continue = 0;
        CancellationState2.Cancelled = 1;
      })(CancellationState || (CancellationState = {}));
      var SharedArraySenderStrategy = class {
        buffers;
        constructor() {
          this.buffers = /* @__PURE__ */ new Map();
        }
        enableCancellation(request) {
          if (request.id === null) {
            return;
          }
          const buffer = new SharedArrayBuffer(4);
          const data = new Int32Array(buffer, 0, 1);
          data[0] = CancellationState.Continue;
          this.buffers.set(request.id, buffer);
          request.$cancellationData = buffer;
        }
        async sendCancellation(_conn, id) {
          const buffer = this.buffers.get(id);
          if (buffer === void 0) {
            return;
          }
          const data = new Int32Array(buffer, 0, 1);
          Atomics.store(data, 0, CancellationState.Cancelled);
        }
        cleanup(id) {
          this.buffers.delete(id);
        }
        dispose() {
          this.buffers.clear();
        }
      };
      exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
      var SharedArrayBufferCancellationToken = class {
        data;
        constructor(buffer) {
          this.data = new Int32Array(buffer, 0, 1);
        }
        get isCancellationRequested() {
          return Atomics.load(this.data, 0) === CancellationState.Cancelled;
        }
        get onCancellationRequested() {
          throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
        }
      };
      var SharedArrayBufferCancellationTokenSource = class {
        token;
        constructor(buffer) {
          this.token = new SharedArrayBufferCancellationToken(buffer);
        }
        cancel() {
        }
        dispose() {
        }
      };
      var SharedArrayReceiverStrategy = class {
        kind = "request";
        createCancellationTokenSource(request) {
          const buffer = request.$cancellationData;
          if (buffer === void 0) {
            return new cancellation_1.CancellationTokenSource();
          }
          return new SharedArrayBufferCancellationTokenSource(buffer);
        }
      };
      exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/semaphore.js
  var require_semaphore = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/semaphore.js"(exports) {
      "use strict";
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Semaphore = void 0;
      var ral_1 = __importDefault(require_ral());
      var Semaphore = class {
        _capacity;
        _active;
        _waiting;
        constructor(capacity = 1) {
          if (capacity <= 0) {
            throw new Error("Capacity must be greater than 0");
          }
          this._capacity = capacity;
          this._active = 0;
          this._waiting = [];
        }
        lock(thunk) {
          return new Promise((resolve, reject) => {
            this._waiting.push({ thunk, resolve, reject });
            this.runNext();
          });
        }
        get active() {
          return this._active;
        }
        runNext() {
          if (this._waiting.length === 0 || this._active === this._capacity) {
            return;
          }
          (0, ral_1.default)().timer.setImmediate(() => this.doRunNext());
        }
        doRunNext() {
          if (this._waiting.length === 0 || this._active === this._capacity) {
            return;
          }
          const next = this._waiting.shift();
          this._active++;
          if (this._active > this._capacity) {
            throw new Error(`Too many thunks active`);
          }
          try {
            const result = next.thunk();
            if (result instanceof Promise) {
              result.then((value) => {
                this._active--;
                next.resolve(value);
                this.runNext();
              }, (err) => {
                this._active--;
                next.reject(err);
                this.runNext();
              });
            } else {
              this._active--;
              next.resolve(result);
              this.runNext();
            }
          } catch (err) {
            this._active--;
            next.reject(err);
            this.runNext();
          }
        }
      };
      exports.Semaphore = Semaphore;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/messageReader.js
  var require_messageReader = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/messageReader.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0;
      var ral_1 = __importDefault(require_ral());
      var Is3 = __importStar(require_is());
      var events_1 = require_events();
      var semaphore_1 = require_semaphore();
      var MessageReader;
      (function(MessageReader2) {
        function is(value) {
          const candidate = value;
          return candidate && Is3.func(candidate.listen) && Is3.func(candidate.dispose) && Is3.func(candidate.onError) && Is3.func(candidate.onClose) && Is3.func(candidate.onPartialMessage);
        }
        MessageReader2.is = is;
      })(MessageReader || (exports.MessageReader = MessageReader = {}));
      var AbstractMessageReader = class {
        errorEmitter;
        closeEmitter;
        partialMessageEmitter;
        constructor() {
          this.errorEmitter = new events_1.Emitter();
          this.closeEmitter = new events_1.Emitter();
          this.partialMessageEmitter = new events_1.Emitter();
        }
        dispose() {
          this.errorEmitter.dispose();
          this.closeEmitter.dispose();
          this.partialMessageEmitter.dispose();
        }
        get onError() {
          return this.errorEmitter.event;
        }
        fireError(error) {
          this.errorEmitter.fire(this.asError(error));
        }
        get onClose() {
          return this.closeEmitter.event;
        }
        fireClose() {
          this.closeEmitter.fire(void 0);
        }
        get onPartialMessage() {
          return this.partialMessageEmitter.event;
        }
        firePartialMessage(info) {
          this.partialMessageEmitter.fire(info);
        }
        asError(error) {
          if (error instanceof Error) {
            return error;
          } else {
            return new Error(`Reader received error. Reason: ${Is3.string(error.message) ? error.message : "unknown"}`);
          }
        }
      };
      exports.AbstractMessageReader = AbstractMessageReader;
      var ResolvedMessageReaderOptions;
      (function(ResolvedMessageReaderOptions2) {
        function fromOptions(options) {
          let charset;
          let result;
          let contentDecoder;
          const contentDecoders = /* @__PURE__ */ new Map();
          let contentTypeDecoder;
          const contentTypeDecoders = /* @__PURE__ */ new Map();
          if (options === void 0 || typeof options === "string") {
            charset = options ?? "utf-8";
          } else {
            charset = options.charset ?? "utf-8";
            if (options.contentDecoder !== void 0) {
              contentDecoder = options.contentDecoder;
              contentDecoders.set(contentDecoder.name, contentDecoder);
            }
            if (options.contentDecoders !== void 0) {
              for (const decoder of options.contentDecoders) {
                contentDecoders.set(decoder.name, decoder);
              }
            }
            if (options.contentTypeDecoder !== void 0) {
              contentTypeDecoder = options.contentTypeDecoder;
              contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
            }
            if (options.contentTypeDecoders !== void 0) {
              for (const decoder of options.contentTypeDecoders) {
                contentTypeDecoders.set(decoder.name, decoder);
              }
            }
          }
          if (contentTypeDecoder === void 0) {
            contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder;
            contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
          }
          return { charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders };
        }
        ResolvedMessageReaderOptions2.fromOptions = fromOptions;
      })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
      var ReadableStreamMessageReader = class extends AbstractMessageReader {
        readable;
        options;
        callback;
        nextMessageLength;
        messageToken;
        buffer;
        partialMessageTimer;
        _partialMessageTimeout;
        readSemaphore;
        constructor(readable, options) {
          super();
          this.readable = readable;
          this.options = ResolvedMessageReaderOptions.fromOptions(options);
          this.buffer = (0, ral_1.default)().messageBuffer.create(this.options.charset);
          this._partialMessageTimeout = 1e4;
          this.nextMessageLength = -1;
          this.messageToken = 0;
          this.readSemaphore = new semaphore_1.Semaphore(1);
        }
        set partialMessageTimeout(timeout) {
          this._partialMessageTimeout = timeout;
        }
        get partialMessageTimeout() {
          return this._partialMessageTimeout;
        }
        listen(callback) {
          this.nextMessageLength = -1;
          this.messageToken = 0;
          this.partialMessageTimer = void 0;
          this.callback = callback;
          const result = this.readable.onData((data) => {
            this.onData(data);
          });
          this.readable.onError((error) => this.fireError(error));
          this.readable.onClose(() => this.fireClose());
          return result;
        }
        onData(data) {
          try {
            this.buffer.append(data);
            while (true) {
              if (this.nextMessageLength === -1) {
                const headers = this.buffer.tryReadHeaders(true);
                if (!headers) {
                  return;
                }
                const contentLength = headers.get("content-length");
                if (!contentLength) {
                  this.fireError(new Error(`Header must provide a Content-Length property.
${JSON.stringify(Object.fromEntries(headers))}`));
                  return;
                }
                const length = parseInt(contentLength);
                if (isNaN(length)) {
                  this.fireError(new Error(`Content-Length value must be a number. Got ${contentLength}`));
                  return;
                }
                this.nextMessageLength = length;
              }
              const body = this.buffer.tryReadBody(this.nextMessageLength);
              if (body === void 0) {
                this.setPartialMessageTimer();
                return;
              }
              this.clearPartialMessageTimer();
              this.nextMessageLength = -1;
              this.readSemaphore.lock(async () => {
                const bytes = this.options.contentDecoder !== void 0 ? await this.options.contentDecoder.decode(body) : body;
                const message = await this.options.contentTypeDecoder.decode(bytes, this.options);
                this.callback(message);
              }).catch((error) => {
                this.fireError(error);
              });
            }
          } catch (error) {
            this.fireError(error);
          }
        }
        clearPartialMessageTimer() {
          if (this.partialMessageTimer) {
            this.partialMessageTimer.dispose();
            this.partialMessageTimer = void 0;
          }
        }
        setPartialMessageTimer() {
          this.clearPartialMessageTimer();
          if (this._partialMessageTimeout <= 0) {
            return;
          }
          this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout((token, timeout) => {
            this.partialMessageTimer = void 0;
            if (token === this.messageToken) {
              this.firePartialMessage({ messageToken: token, waitingTime: timeout });
              this.setPartialMessageTimer();
            }
          }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
        }
      };
      exports.ReadableStreamMessageReader = ReadableStreamMessageReader;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/messageWriter.js
  var require_messageWriter = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/messageWriter.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0;
      var ral_1 = __importDefault(require_ral());
      var Is3 = __importStar(require_is());
      var semaphore_1 = require_semaphore();
      var events_1 = require_events();
      var ContentLength = "Content-Length: ";
      var CRLF = "\r\n";
      var MessageWriter;
      (function(MessageWriter2) {
        function is(value) {
          const candidate = value;
          return candidate && Is3.func(candidate.dispose) && Is3.func(candidate.onClose) && Is3.func(candidate.onError) && Is3.func(candidate.write);
        }
        MessageWriter2.is = is;
      })(MessageWriter || (exports.MessageWriter = MessageWriter = {}));
      var AbstractMessageWriter = class {
        errorEmitter;
        closeEmitter;
        constructor() {
          this.errorEmitter = new events_1.Emitter();
          this.closeEmitter = new events_1.Emitter();
        }
        dispose() {
          this.errorEmitter.dispose();
          this.closeEmitter.dispose();
        }
        get onError() {
          return this.errorEmitter.event;
        }
        fireError(error, message, count) {
          this.errorEmitter.fire([this.asError(error), message, count]);
        }
        get onClose() {
          return this.closeEmitter.event;
        }
        fireClose() {
          this.closeEmitter.fire(void 0);
        }
        asError(error) {
          if (error instanceof Error) {
            return error;
          } else {
            return new Error(`Writer received error. Reason: ${Is3.string(error.message) ? error.message : "unknown"}`);
          }
        }
      };
      exports.AbstractMessageWriter = AbstractMessageWriter;
      var ResolvedMessageWriterOptions;
      (function(ResolvedMessageWriterOptions2) {
        function fromOptions(options) {
          if (options === void 0 || typeof options === "string") {
            return { charset: options ?? "utf-8", contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder };
          } else {
            return { charset: options.charset ?? "utf-8", contentEncoder: options.contentEncoder, contentTypeEncoder: options.contentTypeEncoder ?? (0, ral_1.default)().applicationJson.encoder };
          }
        }
        ResolvedMessageWriterOptions2.fromOptions = fromOptions;
      })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
      var WriteableStreamMessageWriter = class extends AbstractMessageWriter {
        writable;
        options;
        errorCount;
        writeSemaphore;
        constructor(writable, options) {
          super();
          this.writable = writable;
          this.options = ResolvedMessageWriterOptions.fromOptions(options);
          this.errorCount = 0;
          this.writeSemaphore = new semaphore_1.Semaphore(1);
          this.writable.onError((error) => this.fireError(error));
          this.writable.onClose(() => this.fireClose());
        }
        async write(msg) {
          return this.writeSemaphore.lock(async () => {
            const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
              if (this.options.contentEncoder !== void 0) {
                return this.options.contentEncoder.encode(buffer);
              } else {
                return buffer;
              }
            });
            return payload.then((buffer) => {
              const headers = [];
              headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
              headers.push(CRLF);
              return this.doWrite(msg, headers, buffer);
            }, (error) => {
              this.fireError(error);
              throw error;
            });
          });
        }
        async doWrite(msg, headers, data) {
          try {
            await this.writable.write(headers.join(""), "ascii");
            return this.writable.write(data);
          } catch (error) {
            this.handleError(error, msg);
            return Promise.reject(error);
          }
        }
        handleError(error, msg) {
          this.errorCount++;
          this.fireError(error, msg, this.errorCount);
        }
        end() {
          this.writable.end();
        }
      };
      exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
  var require_messageBuffer = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/messageBuffer.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.AbstractMessageBuffer = void 0;
      var CR = 13;
      var LF = 10;
      var CRLF = "\r\n";
      var AbstractMessageBuffer = class {
        _encoding;
        _chunks;
        _totalLength;
        constructor(encoding = "utf-8") {
          this._encoding = encoding;
          this._chunks = [];
          this._totalLength = 0;
        }
        get encoding() {
          return this._encoding;
        }
        append(chunk) {
          const toAppend = typeof chunk === "string" ? this.fromString(chunk, this._encoding) : chunk;
          this._chunks.push(toAppend);
          this._totalLength += toAppend.byteLength;
        }
        tryReadHeaders(lowerCaseKeys = false) {
          if (this._chunks.length === 0) {
            return void 0;
          }
          let state = 0;
          let chunkIndex = 0;
          let offset = 0;
          let chunkBytesRead = 0;
          row: while (chunkIndex < this._chunks.length) {
            const chunk = this._chunks[chunkIndex];
            offset = 0;
            while (offset < chunk.length) {
              const value = chunk[offset];
              switch (value) {
                case CR:
                  switch (state) {
                    case 0:
                      state = 1;
                      break;
                    case 2:
                      state = 3;
                      break;
                    default:
                      state = 0;
                  }
                  break;
                case LF:
                  switch (state) {
                    case 1:
                      state = 2;
                      break;
                    case 3:
                      state = 4;
                      offset++;
                      break row;
                    default:
                      state = 0;
                  }
                  break;
                default:
                  state = 0;
              }
              offset++;
            }
            chunkBytesRead += chunk.byteLength;
            chunkIndex++;
          }
          if (state !== 4) {
            return void 0;
          }
          const buffer = this._read(chunkBytesRead + offset);
          const result = /* @__PURE__ */ new Map();
          const headers = this.toString(buffer, "ascii").split(CRLF);
          if (headers.length < 2) {
            return result;
          }
          for (let i = 0; i < headers.length - 2; i++) {
            const header = headers[i];
            const index2 = header.indexOf(":");
            if (index2 === -1) {
              throw new Error(`Message header must separate key and value using ':'
${header}`);
            }
            const key = header.substr(0, index2);
            const value = header.substr(index2 + 1).trim();
            result.set(lowerCaseKeys ? key.toLowerCase() : key, value);
          }
          return result;
        }
        tryReadBody(length) {
          if (this._totalLength < length) {
            return void 0;
          }
          return this._read(length);
        }
        get numberOfBytes() {
          return this._totalLength;
        }
        _read(byteCount) {
          if (byteCount === 0) {
            return this.emptyBuffer();
          }
          if (byteCount > this._totalLength) {
            throw new Error(`Cannot read so many bytes!`);
          }
          if (this._chunks[0].byteLength === byteCount) {
            const chunk = this._chunks[0];
            this._chunks.shift();
            this._totalLength -= byteCount;
            return this.asNative(chunk);
          }
          if (this._chunks[0].byteLength > byteCount) {
            const chunk = this._chunks[0];
            const result2 = this.asNative(chunk, byteCount);
            this._chunks[0] = chunk.slice(byteCount);
            this._totalLength -= byteCount;
            return result2;
          }
          const result = this.allocNative(byteCount);
          let resultOffset = 0;
          const chunkIndex = 0;
          while (byteCount > 0) {
            const chunk = this._chunks[chunkIndex];
            if (chunk.byteLength > byteCount) {
              const chunkPart = chunk.slice(0, byteCount);
              result.set(chunkPart, resultOffset);
              resultOffset += byteCount;
              this._chunks[chunkIndex] = chunk.slice(byteCount);
              this._totalLength -= byteCount;
              byteCount -= byteCount;
            } else {
              result.set(chunk, resultOffset);
              resultOffset += chunk.byteLength;
              this._chunks.shift();
              this._totalLength -= chunk.byteLength;
              byteCount -= chunk.byteLength;
            }
          }
          return result;
        }
      };
      exports.AbstractMessageBuffer = AbstractMessageBuffer;
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/connection.js
  var require_connection = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/connection.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.TraceValue = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0;
      exports.createMessageConnection = createMessageConnection;
      var ral_1 = __importDefault(require_ral());
      var Is3 = __importStar(require_is());
      var messages_1 = require_messages();
      var linkedMap_1 = require_linkedMap();
      var events_1 = require_events();
      var cancellation_1 = require_cancellation();
      var CancelNotification;
      (function(CancelNotification2) {
        CancelNotification2.type = new messages_1.NotificationType("$/cancelRequest");
      })(CancelNotification || (CancelNotification = {}));
      var ProgressToken;
      (function(ProgressToken2) {
        function is(value) {
          return typeof value === "string" || typeof value === "number";
        }
        ProgressToken2.is = is;
      })(ProgressToken || (exports.ProgressToken = ProgressToken = {}));
      var ProgressNotification;
      (function(ProgressNotification2) {
        ProgressNotification2.type = new messages_1.NotificationType("$/progress");
      })(ProgressNotification || (ProgressNotification = {}));
      var ProgressType = class {
        /**
         * Clients must not use these properties. They are here to ensure correct typing.
         * in TypeScript
         */
        __;
        _pr;
        constructor() {
        }
      };
      exports.ProgressType = ProgressType;
      var StarRequestHandler;
      (function(StarRequestHandler2) {
        function is(value) {
          return Is3.func(value);
        }
        StarRequestHandler2.is = is;
      })(StarRequestHandler || (StarRequestHandler = {}));
      exports.NullLogger = Object.freeze({
        error: () => {
        },
        warn: () => {
        },
        info: () => {
        },
        log: () => {
        }
      });
      var Trace;
      (function(Trace2) {
        Trace2[Trace2["Off"] = 0] = "Off";
        Trace2[Trace2["Messages"] = 1] = "Messages";
        Trace2[Trace2["Compact"] = 2] = "Compact";
        Trace2[Trace2["Verbose"] = 3] = "Verbose";
      })(Trace || (exports.Trace = Trace = {}));
      var TraceValue;
      (function(TraceValue2) {
        TraceValue2.Off = "off";
        TraceValue2.Messages = "messages";
        TraceValue2.Compact = "compact";
        TraceValue2.Verbose = "verbose";
      })(TraceValue || (exports.TraceValue = TraceValue = {}));
      exports.TraceValues = TraceValue;
      (function(Trace2) {
        function fromString(value) {
          if (!Is3.string(value)) {
            return Trace2.Off;
          }
          value = value.toLowerCase();
          switch (value) {
            case "off":
              return Trace2.Off;
            case "messages":
              return Trace2.Messages;
            case "compact":
              return Trace2.Compact;
            case "verbose":
              return Trace2.Verbose;
            default:
              return Trace2.Off;
          }
        }
        Trace2.fromString = fromString;
        function toString(value) {
          switch (value) {
            case Trace2.Off:
              return "off";
            case Trace2.Messages:
              return "messages";
            case Trace2.Compact:
              return "compact";
            case Trace2.Verbose:
              return "verbose";
            default:
              return "off";
          }
        }
        Trace2.toString = toString;
      })(Trace || (exports.Trace = Trace = {}));
      var TraceFormat;
      (function(TraceFormat2) {
        TraceFormat2["Text"] = "text";
        TraceFormat2["JSON"] = "json";
      })(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
      (function(TraceFormat2) {
        function fromString(value) {
          if (!Is3.string(value)) {
            return TraceFormat2.Text;
          }
          value = value.toLowerCase();
          if (value === "json") {
            return TraceFormat2.JSON;
          } else {
            return TraceFormat2.Text;
          }
        }
        TraceFormat2.fromString = fromString;
      })(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
      var SetTraceNotification;
      (function(SetTraceNotification2) {
        SetTraceNotification2.type = new messages_1.NotificationType("$/setTrace");
      })(SetTraceNotification || (exports.SetTraceNotification = SetTraceNotification = {}));
      var LogTraceNotification;
      (function(LogTraceNotification2) {
        LogTraceNotification2.type = new messages_1.NotificationType("$/logTrace");
      })(LogTraceNotification || (exports.LogTraceNotification = LogTraceNotification = {}));
      var ConnectionErrors;
      (function(ConnectionErrors2) {
        ConnectionErrors2[ConnectionErrors2["Closed"] = 1] = "Closed";
        ConnectionErrors2[ConnectionErrors2["Disposed"] = 2] = "Disposed";
        ConnectionErrors2[ConnectionErrors2["AlreadyListening"] = 3] = "AlreadyListening";
      })(ConnectionErrors || (exports.ConnectionErrors = ConnectionErrors = {}));
      var ConnectionError = class _ConnectionError extends Error {
        code;
        constructor(code, message) {
          super(message);
          this.code = code;
          Object.setPrototypeOf(this, _ConnectionError.prototype);
        }
      };
      exports.ConnectionError = ConnectionError;
      var ConnectionStrategy;
      (function(ConnectionStrategy2) {
        function is(value) {
          const candidate = value;
          return candidate && Is3.func(candidate.cancelUndispatched);
        }
        ConnectionStrategy2.is = is;
      })(ConnectionStrategy || (exports.ConnectionStrategy = ConnectionStrategy = {}));
      var IdCancellationReceiverStrategy;
      (function(IdCancellationReceiverStrategy2) {
        function is(value) {
          const candidate = value;
          return candidate && (candidate.kind === void 0 || candidate.kind === "id") && Is3.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is3.func(candidate.dispose));
        }
        IdCancellationReceiverStrategy2.is = is;
      })(IdCancellationReceiverStrategy || (exports.IdCancellationReceiverStrategy = IdCancellationReceiverStrategy = {}));
      var RequestCancellationReceiverStrategy;
      (function(RequestCancellationReceiverStrategy2) {
        function is(value) {
          const candidate = value;
          return candidate && candidate.kind === "request" && Is3.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is3.func(candidate.dispose));
        }
        RequestCancellationReceiverStrategy2.is = is;
      })(RequestCancellationReceiverStrategy || (exports.RequestCancellationReceiverStrategy = RequestCancellationReceiverStrategy = {}));
      var CancellationReceiverStrategy;
      (function(CancellationReceiverStrategy2) {
        CancellationReceiverStrategy2.Message = Object.freeze({
          createCancellationTokenSource(_) {
            return new cancellation_1.CancellationTokenSource();
          }
        });
        function is(value) {
          return IdCancellationReceiverStrategy.is(value) || RequestCancellationReceiverStrategy.is(value);
        }
        CancellationReceiverStrategy2.is = is;
      })(CancellationReceiverStrategy || (exports.CancellationReceiverStrategy = CancellationReceiverStrategy = {}));
      var CancellationSenderStrategy;
      (function(CancellationSenderStrategy2) {
        CancellationSenderStrategy2.Message = Object.freeze({
          sendCancellation(conn, id) {
            return conn.sendNotification(CancelNotification.type, { id });
          },
          cleanup(_) {
          }
        });
        function is(value) {
          const candidate = value;
          return candidate && Is3.func(candidate.sendCancellation) && Is3.func(candidate.cleanup);
        }
        CancellationSenderStrategy2.is = is;
      })(CancellationSenderStrategy || (exports.CancellationSenderStrategy = CancellationSenderStrategy = {}));
      var CancellationStrategy;
      (function(CancellationStrategy2) {
        CancellationStrategy2.Message = Object.freeze({
          receiver: CancellationReceiverStrategy.Message,
          sender: CancellationSenderStrategy.Message
        });
        function is(value) {
          const candidate = value;
          return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
        }
        CancellationStrategy2.is = is;
      })(CancellationStrategy || (exports.CancellationStrategy = CancellationStrategy = {}));
      var MessageStrategy;
      (function(MessageStrategy2) {
        function is(value) {
          const candidate = value;
          return candidate && Is3.func(candidate.handleMessage);
        }
        MessageStrategy2.is = is;
      })(MessageStrategy || (exports.MessageStrategy = MessageStrategy = {}));
      var ConnectionOptions;
      (function(ConnectionOptions2) {
        function is(value) {
          const candidate = value;
          return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy) || Is3.number(candidate.maxParallelism));
        }
        ConnectionOptions2.is = is;
      })(ConnectionOptions || (exports.ConnectionOptions = ConnectionOptions = {}));
      var ConnectionState;
      (function(ConnectionState2) {
        ConnectionState2[ConnectionState2["New"] = 1] = "New";
        ConnectionState2[ConnectionState2["Listening"] = 2] = "Listening";
        ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
        ConnectionState2[ConnectionState2["Disposed"] = 4] = "Disposed";
      })(ConnectionState || (ConnectionState = {}));
      function createMessageConnection(messageReader, messageWriter, _logger, options) {
        const logger = _logger !== void 0 ? _logger : exports.NullLogger;
        let sequenceNumber = 0;
        let notificationSequenceNumber = 0;
        let unknownResponseSequenceNumber = 0;
        const version = "2.0";
        const maxParallelism = options?.maxParallelism ?? -1;
        let inFlight = 0;
        let starRequestHandler = void 0;
        const requestHandlers = /* @__PURE__ */ new Map();
        let starNotificationHandler = void 0;
        const notificationHandlers = /* @__PURE__ */ new Map();
        const progressHandlers = /* @__PURE__ */ new Map();
        let timer;
        let messageQueue = new linkedMap_1.LinkedMap();
        let responsePromises = /* @__PURE__ */ new Map();
        let knownCanceledRequests = /* @__PURE__ */ new Set();
        let requestTokens = /* @__PURE__ */ new Map();
        let trace = Trace.Off;
        let traceFormat = TraceFormat.Text;
        let tracer;
        let state = ConnectionState.New;
        const errorEmitter = new events_1.Emitter();
        const closeEmitter = new events_1.Emitter();
        const unhandledNotificationEmitter = new events_1.Emitter();
        const unhandledProgressEmitter = new events_1.Emitter();
        const disposeEmitter = new events_1.Emitter();
        const cancellationStrategy = options && options.cancellationStrategy ? options.cancellationStrategy : CancellationStrategy.Message;
        function cancelUndispatched(_message) {
          return void 0;
        }
        function isListening() {
          return state === ConnectionState.Listening;
        }
        function isClosed() {
          return state === ConnectionState.Closed;
        }
        function isDisposed() {
          return state === ConnectionState.Disposed;
        }
        function closeHandler() {
          if (state === ConnectionState.New || state === ConnectionState.Listening) {
            state = ConnectionState.Closed;
            closeEmitter.fire(void 0);
          }
        }
        function readErrorHandler(error) {
          errorEmitter.fire([error, void 0, void 0]);
        }
        function writeErrorHandler(data) {
          errorEmitter.fire(data);
        }
        messageReader.onClose(closeHandler);
        messageReader.onError(readErrorHandler);
        messageWriter.onClose(closeHandler);
        messageWriter.onError(writeErrorHandler);
        function createRequestQueueKey(id) {
          if (id === null) {
            throw new Error(`Can't send requests with id null since the response can't be correlated.`);
          }
          return "req-" + id.toString();
        }
        function createResponseQueueKey(id) {
          if (id === null) {
            return "res-unknown-" + (++unknownResponseSequenceNumber).toString();
          } else {
            return "res-" + id.toString();
          }
        }
        function createNotificationQueueKey() {
          return "not-" + (++notificationSequenceNumber).toString();
        }
        function addMessageToQueue(queue, message) {
          if (messages_1.Message.isRequest(message)) {
            queue.set(createRequestQueueKey(message.id), message);
          } else if (messages_1.Message.isResponse(message)) {
            if (maxParallelism === -1) {
              queue.set(createResponseQueueKey(message.id), message);
            } else {
              handleResponse(message);
            }
          } else {
            queue.set(createNotificationQueueKey(), message);
          }
        }
        function triggerMessageQueue() {
          if (timer || messageQueue.size === 0) {
            return;
          }
          if (maxParallelism !== -1 && inFlight >= maxParallelism) {
            return;
          }
          timer = (0, ral_1.default)().timer.setImmediate(async () => {
            timer = void 0;
            if (messageQueue.size === 0) {
              return;
            }
            if (maxParallelism !== -1 && inFlight >= maxParallelism) {
              return;
            }
            const message = messageQueue.shift();
            let result;
            try {
              inFlight++;
              const messageStrategy = options?.messageStrategy;
              if (MessageStrategy.is(messageStrategy)) {
                result = messageStrategy.handleMessage(message, handleMessage);
              } else {
                result = handleMessage(message);
              }
            } catch (error) {
              logger.error(`Processing message queue failed: ${error.toString()}`);
            } finally {
              if (result instanceof Promise) {
                result.then(() => {
                  inFlight--;
                  triggerMessageQueue();
                }).catch((error) => {
                  logger.error(`Processing message queue failed: ${error.toString()}`);
                });
              } else {
                inFlight--;
              }
              triggerMessageQueue();
            }
          });
        }
        async function handleMessage(message) {
          if (messages_1.Message.isRequest(message)) {
            return handleRequest(message);
          } else if (messages_1.Message.isNotification(message)) {
            return handleNotification(message);
          } else if (messages_1.Message.isResponse(message)) {
            return handleResponse(message);
          } else {
            return handleInvalidMessage(message);
          }
        }
        const callback = (message) => {
          try {
            if (messages_1.Message.isNotification(message) && message.method === CancelNotification.type.method) {
              const cancelId = message.params.id;
              const key = createRequestQueueKey(cancelId);
              const toCancel = messageQueue.get(key);
              if (messages_1.Message.isRequest(toCancel)) {
                const strategy = options?.connectionStrategy;
                const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
                if (response && (response.error !== void 0 || response.result !== void 0)) {
                  messageQueue.delete(key);
                  requestTokens.delete(cancelId);
                  response.id = toCancel.id;
                  traceSendingResponse(response, message.method, Date.now());
                  messageWriter.write(response).catch(() => logger.error(`Sending response for canceled message failed.`));
                  return;
                }
              }
              const cancellationToken = requestTokens.get(cancelId);
              if (cancellationToken !== void 0) {
                cancellationToken.cancel();
                traceReceivedNotification(message);
                return;
              } else {
                knownCanceledRequests.add(cancelId);
              }
            }
            addMessageToQueue(messageQueue, message);
          } finally {
            triggerMessageQueue();
          }
        };
        async function handleRequest(requestMessage) {
          if (isDisposed()) {
            return Promise.resolve();
          }
          function reply(resultOrError, method, startTime2) {
            const message = {
              jsonrpc: version,
              id: requestMessage.id
            };
            if (resultOrError instanceof messages_1.ResponseError) {
              message.error = resultOrError.toJson();
            } else {
              message.result = resultOrError === void 0 ? null : resultOrError;
            }
            traceSendingResponse(message, method, startTime2);
            return messageWriter.write(message);
          }
          function replyError(error, method, startTime2) {
            const message = {
              jsonrpc: version,
              id: requestMessage.id,
              error: error.toJson()
            };
            traceSendingResponse(message, method, startTime2);
            return messageWriter.write(message);
          }
          traceReceivedRequest(requestMessage);
          const element = requestHandlers.get(requestMessage.method);
          let type;
          let requestHandler;
          if (element) {
            type = element.type;
            requestHandler = element.handler;
          }
          const startTime = Date.now();
          if (requestHandler || starRequestHandler) {
            const tokenKey = requestMessage.id ?? String(Date.now());
            const cancellationSource = IdCancellationReceiverStrategy.is(cancellationStrategy.receiver) ? cancellationStrategy.receiver.createCancellationTokenSource(tokenKey) : cancellationStrategy.receiver.createCancellationTokenSource(requestMessage);
            if (requestMessage.id !== null && knownCanceledRequests.has(requestMessage.id)) {
              cancellationSource.cancel();
            }
            if (requestMessage.id !== null) {
              requestTokens.set(tokenKey, cancellationSource);
            }
            try {
              let handlerResult;
              if (requestHandler) {
                if (requestMessage.params === void 0) {
                  if (type !== void 0 && type.numberOfParams !== 0) {
                    return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
                  }
                  handlerResult = requestHandler(cancellationSource.token);
                } else if (Array.isArray(requestMessage.params)) {
                  if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byName) {
                    return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
                  }
                  handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
                } else {
                  if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
                    return replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
                  }
                  handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
                }
              } else if (starRequestHandler) {
                handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
              }
              const resultOrError = await handlerResult;
              await reply(resultOrError, requestMessage.method, startTime);
            } catch (error) {
              if (error instanceof messages_1.ResponseError) {
                await reply(error, requestMessage.method, startTime);
              } else if (error && Is3.string(error.message)) {
                await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
              } else {
                await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
              }
            } finally {
              requestTokens.delete(tokenKey);
            }
          } else {
            await replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
          }
        }
        function handleResponse(responseMessage) {
          if (isDisposed()) {
            return;
          }
          if (responseMessage.id === null) {
            if (responseMessage.error) {
              logger.error(`Received response message without id: Error is: 
${JSON.stringify(responseMessage.error, void 0, 4)}`);
            } else {
              logger.error(`Received response message without id. No further error information provided.`);
            }
          } else {
            const key = responseMessage.id;
            const responsePromise = responsePromises.get(key);
            traceReceivedResponse(responseMessage, responsePromise);
            if (responsePromise !== void 0) {
              responsePromises.delete(key);
              try {
                if (responseMessage.error) {
                  const error = responseMessage.error;
                  responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
                } else if (responseMessage.result !== void 0) {
                  responsePromise.resolve(responseMessage.result);
                } else {
                  throw new Error("Should never happen.");
                }
              } catch (error) {
                if (error.message) {
                  logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
                } else {
                  logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
                }
              }
            }
          }
        }
        async function handleNotification(message) {
          if (isDisposed()) {
            return;
          }
          let type = void 0;
          let notificationHandler;
          if (message.method === CancelNotification.type.method) {
            const cancelId = message.params.id;
            knownCanceledRequests.delete(cancelId);
            traceReceivedNotification(message);
            return;
          } else {
            const element = notificationHandlers.get(message.method);
            if (element) {
              notificationHandler = element.handler;
              type = element.type;
            }
          }
          if (notificationHandler || starNotificationHandler) {
            try {
              traceReceivedNotification(message);
              if (notificationHandler) {
                if (message.params === void 0) {
                  if (type !== void 0) {
                    if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
                      logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
                    }
                  }
                  await notificationHandler();
                } else if (Array.isArray(message.params)) {
                  const params = message.params;
                  if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) {
                    await notificationHandler({ token: params[0], value: params[1] });
                  } else {
                    if (type !== void 0) {
                      if (type.parameterStructures === messages_1.ParameterStructures.byName) {
                        logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
                      }
                      if (type.numberOfParams !== message.params.length) {
                        logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
                      }
                    }
                    await notificationHandler(...params);
                  }
                } else {
                  if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
                    logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
                  }
                  await notificationHandler(message.params);
                }
              } else if (starNotificationHandler) {
                await starNotificationHandler(message.method, message.params);
              }
            } catch (error) {
              if (error.message) {
                logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
              } else {
                logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
              }
            }
          } else {
            unhandledNotificationEmitter.fire(message);
          }
        }
        function handleInvalidMessage(message) {
          if (!message) {
            logger.error("Received empty message.");
            return;
          }
          logger.error(`Received message which is neither a response nor a notification message:
${JSON.stringify(message, null, 4)}`);
          const responseMessage = message;
          if (Is3.string(responseMessage.id) || Is3.number(responseMessage.id)) {
            const key = responseMessage.id;
            const responseHandler = responsePromises.get(key);
            if (responseHandler) {
              responseHandler.reject(new Error("The received response has neither a result nor an error property."));
            }
          }
        }
        function stringifyTrace(params) {
          if (params === void 0 || params === null) {
            return void 0;
          }
          switch (trace) {
            case Trace.Verbose:
              return JSON.stringify(params, null, 4);
            case Trace.Compact:
              return JSON.stringify(params);
            default:
              return void 0;
          }
        }
        function traceSendingRequest(message) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
              data = `Params: ${stringifyTrace(message.params)}`;
            }
            tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
          } else {
            logLSPMessage("send-request", message);
          }
        }
        function traceSendingNotification(message) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if (trace === Trace.Verbose || trace === Trace.Compact) {
              if (message.params) {
                data = `Params: ${stringifyTrace(message.params)}`;
              } else {
                data = "No parameters provided.";
              }
            }
            tracer.log(`Sending notification '${message.method}'.`, data);
          } else {
            logLSPMessage("send-notification", message);
          }
        }
        function traceSendingResponse(message, method, startTime) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if (trace === Trace.Verbose || trace === Trace.Compact) {
              if (message.error && message.error.data) {
                data = `Error data: ${stringifyTrace(message.error.data)}`;
              } else {
                if (message.result) {
                  data = `Result: ${stringifyTrace(message.result)}`;
                } else if (message.error === void 0) {
                  data = "No result returned.";
                }
              }
            }
            tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
          } else {
            logLSPMessage("send-response", message);
          }
        }
        function traceReceivedRequest(message) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
              data = `Params: ${stringifyTrace(message.params)}`;
            }
            tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
          } else {
            logLSPMessage("receive-request", message);
          }
        }
        function traceReceivedNotification(message) {
          if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if (trace === Trace.Verbose || trace === Trace.Compact) {
              if (message.params) {
                data = `Params: ${stringifyTrace(message.params)}`;
              } else {
                data = "No parameters provided.";
              }
            }
            tracer.log(`Received notification '${message.method}'.`, data);
          } else {
            logLSPMessage("receive-notification", message);
          }
        }
        function traceReceivedResponse(message, responsePromise) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if (trace === Trace.Verbose || trace === Trace.Compact) {
              if (message.error && message.error.data) {
                data = `Error data: ${stringifyTrace(message.error.data)}`;
              } else {
                if (message.result) {
                  data = `Result: ${stringifyTrace(message.result)}`;
                } else if (message.error === void 0) {
                  data = "No result returned.";
                }
              }
            }
            if (responsePromise) {
              const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
              tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
            } else {
              tracer.log(`Received response ${message.id} without active response promise.`, data);
            }
          } else {
            logLSPMessage("receive-response", message);
          }
        }
        function logLSPMessage(type, message) {
          if (!tracer || trace === Trace.Off) {
            return;
          }
          const lspMessage = {
            isLSPMessage: true,
            type,
            message,
            timestamp: Date.now()
          };
          tracer.log(lspMessage);
        }
        function throwIfClosedOrDisposed() {
          if (isClosed()) {
            throw new ConnectionError(ConnectionErrors.Closed, "Connection is closed.");
          }
          if (isDisposed()) {
            throw new ConnectionError(ConnectionErrors.Disposed, "Connection is disposed.");
          }
        }
        function throwIfListening() {
          if (isListening()) {
            throw new ConnectionError(ConnectionErrors.AlreadyListening, "Connection is already listening");
          }
        }
        function throwIfNotListening() {
          if (!isListening()) {
            throw new Error("Call listen() first.");
          }
        }
        function undefinedToNull(param) {
          if (param === void 0) {
            return null;
          } else {
            return param;
          }
        }
        function nullToUndefined(param) {
          if (param === null) {
            return void 0;
          } else {
            return param;
          }
        }
        function isNamedParam(param) {
          return param !== void 0 && param !== null && !Array.isArray(param) && typeof param === "object";
        }
        function computeSingleParam(parameterStructures, param) {
          switch (parameterStructures) {
            case messages_1.ParameterStructures.auto:
              if (isNamedParam(param)) {
                return nullToUndefined(param);
              } else {
                return [undefinedToNull(param)];
              }
            case messages_1.ParameterStructures.byName:
              if (!isNamedParam(param)) {
                throw new Error(`Received parameters by name but param is not an object literal.`);
              }
              return nullToUndefined(param);
            case messages_1.ParameterStructures.byPosition:
              return [undefinedToNull(param)];
            default:
              throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
          }
        }
        function computeMessageParams(type, params) {
          let result;
          const numberOfParams = type.numberOfParams;
          switch (numberOfParams) {
            case 0:
              result = void 0;
              break;
            case 1:
              result = computeSingleParam(type.parameterStructures, params[0]);
              break;
            default:
              result = [];
              for (let i = 0; i < params.length && i < numberOfParams; i++) {
                result.push(undefinedToNull(params[i]));
              }
              if (params.length < numberOfParams) {
                for (let i = params.length; i < numberOfParams; i++) {
                  result.push(null);
                }
              }
              break;
          }
          return result;
        }
        const connection2 = {
          sendNotification: (type, ...args) => {
            throwIfClosedOrDisposed();
            let method;
            let messageParams;
            if (Is3.string(type)) {
              method = type;
              const first = args[0];
              let paramStart = 0;
              let parameterStructures = messages_1.ParameterStructures.auto;
              if (messages_1.ParameterStructures.is(first)) {
                paramStart = 1;
                parameterStructures = first;
              }
              const paramEnd = args.length;
              const numberOfParams = paramEnd - paramStart;
              switch (numberOfParams) {
                case 0:
                  messageParams = void 0;
                  break;
                case 1:
                  messageParams = computeSingleParam(parameterStructures, args[paramStart]);
                  break;
                default:
                  if (parameterStructures === messages_1.ParameterStructures.byName) {
                    throw new Error(`Received ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
                  }
                  messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
                  break;
              }
            } else {
              const params = args;
              method = type.method;
              messageParams = computeMessageParams(type, params);
            }
            const notificationMessage = {
              jsonrpc: version,
              method,
              params: messageParams
            };
            traceSendingNotification(notificationMessage);
            return messageWriter.write(notificationMessage).catch((error) => {
              logger.error(`Sending notification failed.`);
              throw error;
            });
          },
          onNotification: (type, handler) => {
            throwIfClosedOrDisposed();
            let method;
            if (Is3.func(type)) {
              starNotificationHandler = type;
            } else if (handler) {
              if (Is3.string(type)) {
                method = type;
                notificationHandlers.set(type, { type: void 0, handler });
              } else {
                method = type.method;
                notificationHandlers.set(type.method, { type, handler });
              }
            }
            return {
              dispose: () => {
                if (method !== void 0) {
                  if (notificationHandlers.get(method)?.handler === handler) {
                    notificationHandlers.delete(method);
                  }
                } else if (starNotificationHandler === type) {
                  starNotificationHandler = void 0;
                }
              }
            };
          },
          onProgress: (_type, token, handler) => {
            if (progressHandlers.has(token)) {
              throw new Error(`Progress handler for token ${token} already registered`);
            }
            progressHandlers.set(token, handler);
            return {
              dispose: () => {
                if (progressHandlers.get(token) === handler) {
                  progressHandlers.delete(token);
                }
              }
            };
          },
          sendProgress: (_type, token, value) => {
            return connection2.sendNotification(ProgressNotification.type, { token, value });
          },
          onUnhandledProgress: unhandledProgressEmitter.event,
          sendRequest: (type, ...args) => {
            throwIfClosedOrDisposed();
            throwIfNotListening();
            function sendCancellation(connection3, id2) {
              const p = cancellationStrategy.sender.sendCancellation(connection3, id2);
              if (p === void 0) {
                logger.log(`Received no promise from cancellation strategy when cancelling id ${id2}`);
              } else {
                p.catch(() => {
                  logger.log(`Sending cancellation messages for id ${id2} failed.`);
                });
              }
            }
            let method;
            let messageParams;
            let token = void 0;
            if (Is3.string(type)) {
              method = type;
              const first = args[0];
              const last = args[args.length - 1];
              let paramStart = 0;
              let parameterStructures = messages_1.ParameterStructures.auto;
              if (messages_1.ParameterStructures.is(first)) {
                paramStart = 1;
                parameterStructures = first;
              }
              let paramEnd = args.length;
              if (cancellation_1.CancellationToken.is(last)) {
                paramEnd = paramEnd - 1;
                token = last;
              }
              const numberOfParams = paramEnd - paramStart;
              switch (numberOfParams) {
                case 0:
                  messageParams = void 0;
                  break;
                case 1:
                  messageParams = computeSingleParam(parameterStructures, args[paramStart]);
                  break;
                default:
                  if (parameterStructures === messages_1.ParameterStructures.byName) {
                    throw new Error(`Received ${numberOfParams} parameters for 'by Name' request parameter structure.`);
                  }
                  messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
                  break;
              }
            } else {
              const params = args;
              method = type.method;
              messageParams = computeMessageParams(type, params);
              const numberOfParams = type.numberOfParams;
              token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : void 0;
            }
            const id = sequenceNumber++;
            let disposable;
            let tokenWasCancelled = false;
            if (token !== void 0) {
              if (token.isCancellationRequested) {
                tokenWasCancelled = true;
              } else {
                disposable = token.onCancellationRequested(() => {
                  sendCancellation(connection2, id);
                });
              }
            }
            const requestMessage = {
              jsonrpc: version,
              id,
              method,
              params: messageParams
            };
            traceSendingRequest(requestMessage);
            if (typeof cancellationStrategy.sender.enableCancellation === "function") {
              cancellationStrategy.sender.enableCancellation(requestMessage);
            }
            return new Promise(async (resolve, reject) => {
              const resolveWithCleanup = (r) => {
                resolve(r);
                cancellationStrategy.sender.cleanup(id);
                disposable?.dispose();
              };
              const rejectWithCleanup = (r) => {
                reject(r);
                cancellationStrategy.sender.cleanup(id);
                disposable?.dispose();
              };
              const responsePromise = { method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup };
              try {
                responsePromises.set(id, responsePromise);
                await messageWriter.write(requestMessage);
                if (tokenWasCancelled) {
                  sendCancellation(connection2, id);
                }
              } catch (error) {
                responsePromises.delete(id);
                responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : "Unknown reason"));
                logger.error(`Sending request failed.`);
                throw error;
              }
            });
          },
          onRequest: (type, handler) => {
            throwIfClosedOrDisposed();
            let method = null;
            if (StarRequestHandler.is(type)) {
              method = void 0;
              starRequestHandler = type;
            } else if (Is3.string(type)) {
              method = null;
              if (handler !== void 0) {
                method = type;
                requestHandlers.set(type, { handler, type: void 0 });
              }
            } else {
              if (handler !== void 0) {
                method = type.method;
                requestHandlers.set(type.method, { type, handler });
              }
            }
            return {
              dispose: () => {
                if (method === null) {
                  return;
                }
                if (method !== void 0) {
                  if (requestHandlers.get(method)?.handler === handler) {
                    requestHandlers.delete(method);
                  }
                } else if (starRequestHandler === type) {
                  starRequestHandler = void 0;
                }
              }
            };
          },
          hasPendingResponse: () => {
            return responsePromises.size > 0;
          },
          trace: async (_value, _tracer, sendNotificationOrTraceOptions) => {
            let _sendNotification = false;
            let _traceFormat = TraceFormat.Text;
            if (sendNotificationOrTraceOptions !== void 0) {
              if (Is3.boolean(sendNotificationOrTraceOptions)) {
                _sendNotification = sendNotificationOrTraceOptions;
              } else {
                _sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
                _traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
              }
            }
            trace = _value;
            traceFormat = _traceFormat;
            if (trace === Trace.Off) {
              tracer = void 0;
            } else {
              tracer = _tracer;
            }
            if (_sendNotification && !isClosed() && !isDisposed()) {
              await connection2.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
            }
          },
          onError: errorEmitter.event,
          onClose: closeEmitter.event,
          onUnhandledNotification: unhandledNotificationEmitter.event,
          onDispose: disposeEmitter.event,
          end: () => {
            messageWriter.end();
          },
          dispose: () => {
            if (isDisposed()) {
              return;
            }
            state = ConnectionState.Disposed;
            disposeEmitter.fire(void 0);
            const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, "Pending response rejected since connection got disposed");
            for (const promise of responsePromises.values()) {
              promise.reject(error);
            }
            responsePromises = /* @__PURE__ */ new Map();
            requestTokens = /* @__PURE__ */ new Map();
            knownCanceledRequests = /* @__PURE__ */ new Set();
            messageQueue = new linkedMap_1.LinkedMap();
            if (Is3.func(messageWriter.dispose)) {
              messageWriter.dispose();
            }
            if (Is3.func(messageReader.dispose)) {
              messageReader.dispose();
            }
          },
          listen: () => {
            throwIfClosedOrDisposed();
            throwIfListening();
            state = ConnectionState.Listening;
            messageReader.listen(callback);
          },
          inspect: () => {
            (0, ral_1.default)().console.log("inspect");
          }
        };
        connection2.onNotification(LogTraceNotification.type, (params) => {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          const verbose = trace === Trace.Verbose || trace === Trace.Compact;
          tracer.log(params.message, verbose ? params.verbose : void 0);
        });
        connection2.onNotification(ProgressNotification.type, async (params) => {
          const handler = progressHandlers.get(params.token);
          if (handler) {
            await handler(params.value);
          } else {
            unhandledProgressEmitter.fire(params);
          }
        });
        return connection2;
      }
    }
  });

  // node_modules/vscode-jsonrpc/lib/common/api.js
  var require_api = __commonJS({
    "node_modules/vscode-jsonrpc/lib/common/api.js"(exports) {
      "use strict";
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.AbstractMessageBuffer = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = exports.LRUCache = exports.Touch = exports.LinkedMap = exports.ParameterStructures = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.ErrorCodes = exports.ResponseError = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType0 = exports.RequestType = exports.Message = exports.RAL = void 0;
      exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.TraceValue = exports.Trace = void 0;
      var messages_1 = require_messages();
      Object.defineProperty(exports, "Message", { enumerable: true, get: function() {
        return messages_1.Message;
      } });
      Object.defineProperty(exports, "RequestType", { enumerable: true, get: function() {
        return messages_1.RequestType;
      } });
      Object.defineProperty(exports, "RequestType0", { enumerable: true, get: function() {
        return messages_1.RequestType0;
      } });
      Object.defineProperty(exports, "RequestType1", { enumerable: true, get: function() {
        return messages_1.RequestType1;
      } });
      Object.defineProperty(exports, "RequestType2", { enumerable: true, get: function() {
        return messages_1.RequestType2;
      } });
      Object.defineProperty(exports, "RequestType3", { enumerable: true, get: function() {
        return messages_1.RequestType3;
      } });
      Object.defineProperty(exports, "RequestType4", { enumerable: true, get: function() {
        return messages_1.RequestType4;
      } });
      Object.defineProperty(exports, "RequestType5", { enumerable: true, get: function() {
        return messages_1.RequestType5;
      } });
      Object.defineProperty(exports, "RequestType6", { enumerable: true, get: function() {
        return messages_1.RequestType6;
      } });
      Object.defineProperty(exports, "RequestType7", { enumerable: true, get: function() {
        return messages_1.RequestType7;
      } });
      Object.defineProperty(exports, "RequestType8", { enumerable: true, get: function() {
        return messages_1.RequestType8;
      } });
      Object.defineProperty(exports, "RequestType9", { enumerable: true, get: function() {
        return messages_1.RequestType9;
      } });
      Object.defineProperty(exports, "ResponseError", { enumerable: true, get: function() {
        return messages_1.ResponseError;
      } });
      Object.defineProperty(exports, "ErrorCodes", { enumerable: true, get: function() {
        return messages_1.ErrorCodes;
      } });
      Object.defineProperty(exports, "NotificationType", { enumerable: true, get: function() {
        return messages_1.NotificationType;
      } });
      Object.defineProperty(exports, "NotificationType0", { enumerable: true, get: function() {
        return messages_1.NotificationType0;
      } });
      Object.defineProperty(exports, "NotificationType1", { enumerable: true, get: function() {
        return messages_1.NotificationType1;
      } });
      Object.defineProperty(exports, "NotificationType2", { enumerable: true, get: function() {
        return messages_1.NotificationType2;
      } });
      Object.defineProperty(exports, "NotificationType3", { enumerable: true, get: function() {
        return messages_1.NotificationType3;
      } });
      Object.defineProperty(exports, "NotificationType4", { enumerable: true, get: function() {
        return messages_1.NotificationType4;
      } });
      Object.defineProperty(exports, "NotificationType5", { enumerable: true, get: function() {
        return messages_1.NotificationType5;
      } });
      Object.defineProperty(exports, "NotificationType6", { enumerable: true, get: function() {
        return messages_1.NotificationType6;
      } });
      Object.defineProperty(exports, "NotificationType7", { enumerable: true, get: function() {
        return messages_1.NotificationType7;
      } });
      Object.defineProperty(exports, "NotificationType8", { enumerable: true, get: function() {
        return messages_1.NotificationType8;
      } });
      Object.defineProperty(exports, "NotificationType9", { enumerable: true, get: function() {
        return messages_1.NotificationType9;
      } });
      Object.defineProperty(exports, "ParameterStructures", { enumerable: true, get: function() {
        return messages_1.ParameterStructures;
      } });
      var linkedMap_1 = require_linkedMap();
      Object.defineProperty(exports, "LinkedMap", { enumerable: true, get: function() {
        return linkedMap_1.LinkedMap;
      } });
      Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function() {
        return linkedMap_1.LRUCache;
      } });
      Object.defineProperty(exports, "Touch", { enumerable: true, get: function() {
        return linkedMap_1.Touch;
      } });
      var disposable_1 = require_disposable();
      Object.defineProperty(exports, "Disposable", { enumerable: true, get: function() {
        return disposable_1.Disposable;
      } });
      var events_1 = require_events();
      Object.defineProperty(exports, "Event", { enumerable: true, get: function() {
        return events_1.Event;
      } });
      Object.defineProperty(exports, "Emitter", { enumerable: true, get: function() {
        return events_1.Emitter;
      } });
      var cancellation_1 = require_cancellation();
      Object.defineProperty(exports, "CancellationTokenSource", { enumerable: true, get: function() {
        return cancellation_1.CancellationTokenSource;
      } });
      Object.defineProperty(exports, "CancellationToken", { enumerable: true, get: function() {
        return cancellation_1.CancellationToken;
      } });
      var sharedArrayCancellation_1 = require_sharedArrayCancellation();
      Object.defineProperty(exports, "SharedArraySenderStrategy", { enumerable: true, get: function() {
        return sharedArrayCancellation_1.SharedArraySenderStrategy;
      } });
      Object.defineProperty(exports, "SharedArrayReceiverStrategy", { enumerable: true, get: function() {
        return sharedArrayCancellation_1.SharedArrayReceiverStrategy;
      } });
      var messageReader_1 = require_messageReader();
      Object.defineProperty(exports, "MessageReader", { enumerable: true, get: function() {
        return messageReader_1.MessageReader;
      } });
      Object.defineProperty(exports, "AbstractMessageReader", { enumerable: true, get: function() {
        return messageReader_1.AbstractMessageReader;
      } });
      Object.defineProperty(exports, "ReadableStreamMessageReader", { enumerable: true, get: function() {
        return messageReader_1.ReadableStreamMessageReader;
      } });
      var messageWriter_1 = require_messageWriter();
      Object.defineProperty(exports, "MessageWriter", { enumerable: true, get: function() {
        return messageWriter_1.MessageWriter;
      } });
      Object.defineProperty(exports, "AbstractMessageWriter", { enumerable: true, get: function() {
        return messageWriter_1.AbstractMessageWriter;
      } });
      Object.defineProperty(exports, "WriteableStreamMessageWriter", { enumerable: true, get: function() {
        return messageWriter_1.WriteableStreamMessageWriter;
      } });
      var messageBuffer_1 = require_messageBuffer();
      Object.defineProperty(exports, "AbstractMessageBuffer", { enumerable: true, get: function() {
        return messageBuffer_1.AbstractMessageBuffer;
      } });
      var connection_1 = require_connection();
      Object.defineProperty(exports, "ConnectionStrategy", { enumerable: true, get: function() {
        return connection_1.ConnectionStrategy;
      } });
      Object.defineProperty(exports, "ConnectionOptions", { enumerable: true, get: function() {
        return connection_1.ConnectionOptions;
      } });
      Object.defineProperty(exports, "NullLogger", { enumerable: true, get: function() {
        return connection_1.NullLogger;
      } });
      Object.defineProperty(exports, "createMessageConnection", { enumerable: true, get: function() {
        return connection_1.createMessageConnection;
      } });
      Object.defineProperty(exports, "ProgressToken", { enumerable: true, get: function() {
        return connection_1.ProgressToken;
      } });
      Object.defineProperty(exports, "ProgressType", { enumerable: true, get: function() {
        return connection_1.ProgressType;
      } });
      Object.defineProperty(exports, "Trace", { enumerable: true, get: function() {
        return connection_1.Trace;
      } });
      Object.defineProperty(exports, "TraceValue", { enumerable: true, get: function() {
        return connection_1.TraceValue;
      } });
      Object.defineProperty(exports, "TraceFormat", { enumerable: true, get: function() {
        return connection_1.TraceFormat;
      } });
      Object.defineProperty(exports, "SetTraceNotification", { enumerable: true, get: function() {
        return connection_1.SetTraceNotification;
      } });
      Object.defineProperty(exports, "LogTraceNotification", { enumerable: true, get: function() {
        return connection_1.LogTraceNotification;
      } });
      Object.defineProperty(exports, "ConnectionErrors", { enumerable: true, get: function() {
        return connection_1.ConnectionErrors;
      } });
      Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function() {
        return connection_1.ConnectionError;
      } });
      Object.defineProperty(exports, "CancellationReceiverStrategy", { enumerable: true, get: function() {
        return connection_1.CancellationReceiverStrategy;
      } });
      Object.defineProperty(exports, "IdCancellationReceiverStrategy", { enumerable: true, get: function() {
        return connection_1.IdCancellationReceiverStrategy;
      } });
      Object.defineProperty(exports, "RequestCancellationReceiverStrategy", { enumerable: true, get: function() {
        return connection_1.RequestCancellationReceiverStrategy;
      } });
      Object.defineProperty(exports, "CancellationSenderStrategy", { enumerable: true, get: function() {
        return connection_1.CancellationSenderStrategy;
      } });
      Object.defineProperty(exports, "CancellationStrategy", { enumerable: true, get: function() {
        return connection_1.CancellationStrategy;
      } });
      Object.defineProperty(exports, "MessageStrategy", { enumerable: true, get: function() {
        return connection_1.MessageStrategy;
      } });
      Object.defineProperty(exports, "TraceValues", { enumerable: true, get: function() {
        return connection_1.TraceValues;
      } });
      var ral_1 = __importDefault(require_ral());
      exports.RAL = ral_1.default;
    }
  });

  // node_modules/vscode-languageserver-types/lib/esm/main.js
  var main_exports = {};
  __export(main_exports, {
    AnnotatedTextEdit: () => AnnotatedTextEdit,
    ApplyKind: () => ApplyKind,
    ChangeAnnotation: () => ChangeAnnotation,
    ChangeAnnotationIdentifier: () => ChangeAnnotationIdentifier,
    CodeAction: () => CodeAction,
    CodeActionContext: () => CodeActionContext,
    CodeActionKind: () => CodeActionKind,
    CodeActionTag: () => CodeActionTag,
    CodeActionTriggerKind: () => CodeActionTriggerKind,
    CodeDescription: () => CodeDescription,
    CodeLens: () => CodeLens,
    Color: () => Color,
    ColorInformation: () => ColorInformation,
    ColorPresentation: () => ColorPresentation,
    Command: () => Command,
    CompletionItem: () => CompletionItem,
    CompletionItemKind: () => CompletionItemKind,
    CompletionItemLabelDetails: () => CompletionItemLabelDetails,
    CompletionItemTag: () => CompletionItemTag,
    CompletionList: () => CompletionList,
    CreateFile: () => CreateFile,
    DeleteFile: () => DeleteFile,
    Diagnostic: () => Diagnostic,
    DiagnosticRelatedInformation: () => DiagnosticRelatedInformation,
    DiagnosticSeverity: () => DiagnosticSeverity,
    DiagnosticTag: () => DiagnosticTag,
    DocumentHighlight: () => DocumentHighlight,
    DocumentHighlightKind: () => DocumentHighlightKind,
    DocumentLink: () => DocumentLink,
    DocumentSymbol: () => DocumentSymbol,
    DocumentUri: () => DocumentUri,
    EOL: () => EOL,
    FoldingRange: () => FoldingRange,
    FoldingRangeKind: () => FoldingRangeKind,
    FormattingOptions: () => FormattingOptions,
    Hover: () => Hover,
    InlayHint: () => InlayHint,
    InlayHintKind: () => InlayHintKind,
    InlayHintLabelPart: () => InlayHintLabelPart,
    InlineCompletionContext: () => InlineCompletionContext,
    InlineCompletionItem: () => InlineCompletionItem,
    InlineCompletionList: () => InlineCompletionList,
    InlineCompletionTriggerKind: () => InlineCompletionTriggerKind,
    InlineValueContext: () => InlineValueContext,
    InlineValueEvaluatableExpression: () => InlineValueEvaluatableExpression,
    InlineValueText: () => InlineValueText,
    InlineValueVariableLookup: () => InlineValueVariableLookup,
    InsertReplaceEdit: () => InsertReplaceEdit,
    InsertTextFormat: () => InsertTextFormat,
    InsertTextMode: () => InsertTextMode,
    LanguageKind: () => LanguageKind,
    Location: () => Location,
    LocationLink: () => LocationLink,
    MarkedString: () => MarkedString,
    MarkupContent: () => MarkupContent,
    MarkupKind: () => MarkupKind,
    OptionalVersionedTextDocumentIdentifier: () => OptionalVersionedTextDocumentIdentifier,
    ParameterInformation: () => ParameterInformation,
    Position: () => Position,
    Range: () => Range,
    RenameFile: () => RenameFile,
    SelectedCompletionInfo: () => SelectedCompletionInfo,
    SelectionRange: () => SelectionRange,
    SemanticTokenModifiers: () => SemanticTokenModifiers,
    SemanticTokenTypes: () => SemanticTokenTypes,
    SemanticTokens: () => SemanticTokens,
    SignatureInformation: () => SignatureInformation,
    SnippetTextEdit: () => SnippetTextEdit,
    StringValue: () => StringValue,
    SymbolInformation: () => SymbolInformation,
    SymbolKind: () => SymbolKind,
    SymbolTag: () => SymbolTag,
    TextDocument: () => TextDocument,
    TextDocumentEdit: () => TextDocumentEdit,
    TextDocumentIdentifier: () => TextDocumentIdentifier,
    TextDocumentItem: () => TextDocumentItem,
    TextEdit: () => TextEdit,
    URI: () => URI,
    VersionedTextDocumentIdentifier: () => VersionedTextDocumentIdentifier,
    WorkspaceChange: () => WorkspaceChange,
    WorkspaceEdit: () => WorkspaceEdit,
    WorkspaceFolder: () => WorkspaceFolder,
    WorkspaceSymbol: () => WorkspaceSymbol,
    integer: () => integer,
    uinteger: () => uinteger
  });
  var DocumentUri, URI, integer, uinteger, Position, Range, Location, LocationLink, Color, ColorInformation, ColorPresentation, FoldingRangeKind, FoldingRange, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag, CodeDescription, Diagnostic, Command, TextEdit, ChangeAnnotation, ChangeAnnotationIdentifier, AnnotatedTextEdit, TextDocumentEdit, CreateFile, RenameFile, DeleteFile, WorkspaceEdit, TextEditChangeImpl, SnippetTextEdit, ChangeAnnotations, WorkspaceChange, TextDocumentIdentifier, VersionedTextDocumentIdentifier, OptionalVersionedTextDocumentIdentifier, LanguageKind, TextDocumentItem, MarkupKind, MarkupContent, CompletionItemKind, InsertTextFormat, CompletionItemTag, InsertReplaceEdit, InsertTextMode, ApplyKind, CompletionItemLabelDetails, CompletionItem, CompletionList, MarkedString, Hover, ParameterInformation, SignatureInformation, DocumentHighlightKind, DocumentHighlight, SymbolKind, SymbolTag, SymbolInformation, WorkspaceSymbol, DocumentSymbol, CodeActionKind, CodeActionTriggerKind, CodeActionContext, CodeActionTag, CodeAction, CodeLens, FormattingOptions, DocumentLink, SelectionRange, SemanticTokenTypes, SemanticTokenModifiers, SemanticTokens, InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression, InlineValueContext, InlayHintKind, InlayHintLabelPart, InlayHint, StringValue, InlineCompletionItem, InlineCompletionList, InlineCompletionTriggerKind, SelectedCompletionInfo, InlineCompletionContext, WorkspaceFolder, EOL, TextDocument, FullTextDocument, Is;
  var init_main = __esm({
    "node_modules/vscode-languageserver-types/lib/esm/main.js"() {
      "use strict";
      (function(DocumentUri3) {
        function is(value) {
          return typeof value === "string";
        }
        DocumentUri3.is = is;
      })(DocumentUri || (DocumentUri = {}));
      (function(URI3) {
        function is(value) {
          return typeof value === "string";
        }
        URI3.is = is;
      })(URI || (URI = {}));
      (function(integer3) {
        integer3.MIN_VALUE = -2147483648;
        integer3.MAX_VALUE = 2147483647;
        function is(value) {
          return typeof value === "number" && integer3.MIN_VALUE <= value && value <= integer3.MAX_VALUE;
        }
        integer3.is = is;
      })(integer || (integer = {}));
      (function(uinteger3) {
        uinteger3.MIN_VALUE = 0;
        uinteger3.MAX_VALUE = 2147483647;
        function is(value) {
          return typeof value === "number" && uinteger3.MIN_VALUE <= value && value <= uinteger3.MAX_VALUE;
        }
        uinteger3.is = is;
      })(uinteger || (uinteger = {}));
      (function(Position4) {
        function create(line, character) {
          if (line === Number.MAX_VALUE) {
            line = uinteger.MAX_VALUE;
          }
          if (character === Number.MAX_VALUE) {
            character = uinteger.MAX_VALUE;
          }
          return { line, character };
        }
        Position4.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
        }
        Position4.is = is;
      })(Position || (Position = {}));
      (function(Range4) {
        function create(one, two, three, four) {
          if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
            return { start: Position.create(one, two), end: Position.create(three, four) };
          } else if (Position.is(one) && Position.is(two)) {
            return { start: one, end: two };
          } else {
            throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
          }
        }
        Range4.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
        }
        Range4.is = is;
      })(Range || (Range = {}));
      (function(Location4) {
        function create(uri, range) {
          return { uri, range };
        }
        Location4.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
        }
        Location4.is = is;
      })(Location || (Location = {}));
      (function(LocationLink3) {
        function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
          return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
        }
        LocationLink3.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && Range.is(candidate.targetSelectionRange) && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
        }
        LocationLink3.is = is;
      })(LocationLink || (LocationLink = {}));
      (function(Color3) {
        function create(red, green, blue, alpha) {
          return {
            red,
            green,
            blue,
            alpha
          };
        }
        Color3.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
        }
        Color3.is = is;
      })(Color || (Color = {}));
      (function(ColorInformation3) {
        function create(range, color) {
          return {
            range,
            color
          };
        }
        ColorInformation3.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);
        }
        ColorInformation3.is = is;
      })(ColorInformation || (ColorInformation = {}));
      (function(ColorPresentation3) {
        function create(label, textEdit, additionalTextEdits) {
          return {
            label,
            textEdit,
            additionalTextEdits
          };
        }
        ColorPresentation3.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
        }
        ColorPresentation3.is = is;
      })(ColorPresentation || (ColorPresentation = {}));
      (function(FoldingRangeKind4) {
        FoldingRangeKind4.Comment = "comment";
        FoldingRangeKind4.Imports = "imports";
        FoldingRangeKind4.Region = "region";
      })(FoldingRangeKind || (FoldingRangeKind = {}));
      (function(FoldingRange5) {
        function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
          const result = {
            startLine,
            endLine
          };
          if (Is.defined(startCharacter)) {
            result.startCharacter = startCharacter;
          }
          if (Is.defined(endCharacter)) {
            result.endCharacter = endCharacter;
          }
          if (Is.defined(kind)) {
            result.kind = kind;
          }
          if (Is.defined(collapsedText)) {
            result.collapsedText = collapsedText;
          }
          return result;
        }
        FoldingRange5.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
        }
        FoldingRange5.is = is;
      })(FoldingRange || (FoldingRange = {}));
      (function(DiagnosticRelatedInformation3) {
        function create(location, message) {
          return {
            location,
            message
          };
        }
        DiagnosticRelatedInformation3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
        }
        DiagnosticRelatedInformation3.is = is;
      })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
      (function(DiagnosticSeverity7) {
        DiagnosticSeverity7.Error = 1;
        DiagnosticSeverity7.Warning = 2;
        DiagnosticSeverity7.Information = 3;
        DiagnosticSeverity7.Hint = 4;
      })(DiagnosticSeverity || (DiagnosticSeverity = {}));
      (function(DiagnosticTag3) {
        DiagnosticTag3.Unnecessary = 1;
        DiagnosticTag3.Deprecated = 2;
      })(DiagnosticTag || (DiagnosticTag = {}));
      (function(CodeDescription3) {
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Is.string(candidate.href);
        }
        CodeDescription3.is = is;
      })(CodeDescription || (CodeDescription = {}));
      (function(Diagnostic7) {
        function create(range, message, severity, code, source, relatedInformation) {
          const result = { range, message };
          if (Is.defined(severity)) {
            result.severity = severity;
          }
          if (Is.defined(code)) {
            result.code = code;
          }
          if (Is.defined(source)) {
            result.source = source;
          }
          if (Is.defined(relatedInformation)) {
            result.relatedInformation = relatedInformation;
          }
          return result;
        }
        Diagnostic7.create = create;
        function is(value) {
          var _a;
          const candidate = value;
          return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.message) || MarkupContent.is(candidate.message)) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
        }
        Diagnostic7.is = is;
        function is3_17(value) {
          return Is.string(value.message);
        }
        Diagnostic7.is3_17 = is3_17;
        function getMessageString(diagnostic) {
          if (Is.string(diagnostic.message)) {
            return diagnostic.message;
          } else if (MarkupContent.is(diagnostic.message)) {
            return diagnostic.message.value;
          } else {
            throw new Error(`Unknown message type ${typeof diagnostic.message}`);
          }
        }
        Diagnostic7.getMessageString = getMessageString;
      })(Diagnostic || (Diagnostic = {}));
      (function(Command3) {
        function create(title, command, ...args) {
          const result = { title, command };
          if (Is.defined(args) && args.length > 0) {
            result.arguments = args;
          }
          return result;
        }
        Command3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Is.string(candidate.title) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip)) && Is.string(candidate.command);
        }
        Command3.is = is;
      })(Command || (Command = {}));
      (function(TextEdit6) {
        function replace(range, newText) {
          return { range, newText };
        }
        TextEdit6.replace = replace;
        function insert(position, newText) {
          return { range: { start: position, end: position }, newText };
        }
        TextEdit6.insert = insert;
        function del(range) {
          return { range, newText: "" };
        }
        TextEdit6.del = del;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range);
        }
        TextEdit6.is = is;
      })(TextEdit || (TextEdit = {}));
      (function(ChangeAnnotation3) {
        function create(label, needsConfirmation, description) {
          const result = { label };
          if (needsConfirmation !== void 0) {
            result.needsConfirmation = needsConfirmation;
          }
          if (description !== void 0) {
            result.description = description;
          }
          return result;
        }
        ChangeAnnotation3.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
        }
        ChangeAnnotation3.is = is;
      })(ChangeAnnotation || (ChangeAnnotation = {}));
      (function(ChangeAnnotationIdentifier3) {
        function is(value) {
          const candidate = value;
          return Is.string(candidate);
        }
        ChangeAnnotationIdentifier3.is = is;
      })(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
      (function(AnnotatedTextEdit3) {
        function replace(range, newText, annotation) {
          return { range, newText, annotationId: annotation };
        }
        AnnotatedTextEdit3.replace = replace;
        function insert(position, newText, annotation) {
          return { range: { start: position, end: position }, newText, annotationId: annotation };
        }
        AnnotatedTextEdit3.insert = insert;
        function del(range, annotation) {
          return { range, newText: "", annotationId: annotation };
        }
        AnnotatedTextEdit3.del = del;
        function is(value) {
          const candidate = value;
          return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
        }
        AnnotatedTextEdit3.is = is;
      })(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
      (function(TextDocumentEdit3) {
        function create(textDocument, edits) {
          return { textDocument, edits };
        }
        TextDocumentEdit3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
        }
        TextDocumentEdit3.is = is;
      })(TextDocumentEdit || (TextDocumentEdit = {}));
      (function(CreateFile3) {
        function create(uri, options, annotation) {
          const result = {
            kind: "create",
            uri
          };
          if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
            result.options = options;
          }
          if (annotation !== void 0) {
            result.annotationId = annotation;
          }
          return result;
        }
        CreateFile3.create = create;
        function is(value) {
          const candidate = value;
          return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
        }
        CreateFile3.is = is;
      })(CreateFile || (CreateFile = {}));
      (function(RenameFile3) {
        function create(oldUri, newUri, options, annotation) {
          const result = {
            kind: "rename",
            oldUri,
            newUri
          };
          if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
            result.options = options;
          }
          if (annotation !== void 0) {
            result.annotationId = annotation;
          }
          return result;
        }
        RenameFile3.create = create;
        function is(value) {
          const candidate = value;
          return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
        }
        RenameFile3.is = is;
      })(RenameFile || (RenameFile = {}));
      (function(DeleteFile3) {
        function create(uri, options, annotation) {
          const result = {
            kind: "delete",
            uri
          };
          if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
            result.options = options;
          }
          if (annotation !== void 0) {
            result.annotationId = annotation;
          }
          return result;
        }
        DeleteFile3.create = create;
        function is(value) {
          const candidate = value;
          return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
        }
        DeleteFile3.is = is;
      })(DeleteFile || (DeleteFile = {}));
      (function(WorkspaceEdit5) {
        function is(value) {
          const candidate = value;
          return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every((change) => {
            if (Is.string(change.kind)) {
              return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
            } else {
              return TextDocumentEdit.is(change);
            }
          }));
        }
        WorkspaceEdit5.is = is;
      })(WorkspaceEdit || (WorkspaceEdit = {}));
      TextEditChangeImpl = class {
        constructor(edits, changeAnnotations) {
          this.edits = edits;
          this.changeAnnotations = changeAnnotations;
        }
        insert(position, newText, annotation) {
          let edit;
          let id;
          if (annotation === void 0) {
            edit = TextEdit.insert(position, newText);
          } else if (ChangeAnnotationIdentifier.is(annotation)) {
            id = annotation;
            edit = AnnotatedTextEdit.insert(position, newText, annotation);
          } else {
            this.assertChangeAnnotations(this.changeAnnotations);
            id = this.changeAnnotations.manage(annotation);
            edit = AnnotatedTextEdit.insert(position, newText, id);
          }
          this.edits.push(edit);
          if (id !== void 0) {
            return id;
          }
        }
        replace(range, newText, annotation) {
          let edit;
          let id;
          if (annotation === void 0) {
            edit = TextEdit.replace(range, newText);
          } else if (ChangeAnnotationIdentifier.is(annotation)) {
            id = annotation;
            edit = AnnotatedTextEdit.replace(range, newText, annotation);
          } else {
            this.assertChangeAnnotations(this.changeAnnotations);
            id = this.changeAnnotations.manage(annotation);
            edit = AnnotatedTextEdit.replace(range, newText, id);
          }
          this.edits.push(edit);
          if (id !== void 0) {
            return id;
          }
        }
        delete(range, annotation) {
          let edit;
          let id;
          if (annotation === void 0) {
            edit = TextEdit.del(range);
          } else if (ChangeAnnotationIdentifier.is(annotation)) {
            id = annotation;
            edit = AnnotatedTextEdit.del(range, annotation);
          } else {
            this.assertChangeAnnotations(this.changeAnnotations);
            id = this.changeAnnotations.manage(annotation);
            edit = AnnotatedTextEdit.del(range, id);
          }
          this.edits.push(edit);
          if (id !== void 0) {
            return id;
          }
        }
        add(edit) {
          this.edits.push(edit);
        }
        all() {
          return this.edits;
        }
        clear() {
          this.edits.splice(0, this.edits.length);
        }
        assertChangeAnnotations(value) {
          if (value === void 0) {
            throw new Error(`Text edit change is not configured to manage change annotations.`);
          }
        }
      };
      (function(SnippetTextEdit2) {
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Range.is(candidate.range) && StringValue.isSnippet(candidate.snippet) && (candidate.annotationId === void 0 || (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId)));
        }
        SnippetTextEdit2.is = is;
      })(SnippetTextEdit || (SnippetTextEdit = {}));
      ChangeAnnotations = class {
        constructor(annotations) {
          this._annotations = annotations === void 0 ? /* @__PURE__ */ Object.create(null) : annotations;
          this._counter = 0;
          this._size = 0;
        }
        all() {
          return this._annotations;
        }
        get size() {
          return this._size;
        }
        manage(idOrAnnotation, annotation) {
          let id;
          if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
            id = idOrAnnotation;
          } else {
            id = this.nextId();
            annotation = idOrAnnotation;
          }
          if (this._annotations[id] !== void 0) {
            throw new Error(`Id ${id} is already in use.`);
          }
          if (annotation === void 0) {
            throw new Error(`No annotation provided for id ${id}`);
          }
          this._annotations[id] = annotation;
          this._size++;
          return id;
        }
        nextId() {
          this._counter++;
          return this._counter.toString();
        }
      };
      WorkspaceChange = class {
        constructor(workspaceEdit) {
          this._textEditChanges = /* @__PURE__ */ Object.create(null);
          if (workspaceEdit !== void 0) {
            this._workspaceEdit = workspaceEdit;
            if (workspaceEdit.documentChanges) {
              this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);
              workspaceEdit.changeAnnotations = this._changeAnnotations.all();
              workspaceEdit.documentChanges.forEach((change) => {
                if (TextDocumentEdit.is(change)) {
                  const textEditChange = new TextEditChangeImpl(change.edits, this._changeAnnotations);
                  this._textEditChanges[change.textDocument.uri] = textEditChange;
                }
              });
            } else if (workspaceEdit.changes) {
              Object.keys(workspaceEdit.changes).forEach((key) => {
                const textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);
                this._textEditChanges[key] = textEditChange;
              });
            }
          } else {
            this._workspaceEdit = {};
          }
        }
        /**
         * Returns the underlying {@link WorkspaceEdit} literal
         * use to be returned from a workspace edit operation like rename.
         */
        get edit() {
          this.initDocumentChanges();
          if (this._changeAnnotations !== void 0) {
            if (this._changeAnnotations.size === 0) {
              this._workspaceEdit.changeAnnotations = void 0;
            } else {
              this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
            }
          }
          return this._workspaceEdit;
        }
        getTextEditChange(key) {
          if (OptionalVersionedTextDocumentIdentifier.is(key)) {
            this.initDocumentChanges();
            if (this._workspaceEdit.documentChanges === void 0) {
              throw new Error("Workspace edit is not configured for document changes.");
            }
            const textDocument = { uri: key.uri, version: key.version };
            let result = this._textEditChanges[textDocument.uri];
            if (!result) {
              const edits = [];
              const textDocumentEdit = {
                textDocument,
                edits
              };
              this._workspaceEdit.documentChanges.push(textDocumentEdit);
              result = new TextEditChangeImpl(edits, this._changeAnnotations);
              this._textEditChanges[textDocument.uri] = result;
            }
            return result;
          } else {
            this.initChanges();
            if (this._workspaceEdit.changes === void 0) {
              throw new Error("Workspace edit is not configured for normal text edit changes.");
            }
            let result = this._textEditChanges[key];
            if (!result) {
              const edits = [];
              this._workspaceEdit.changes[key] = edits;
              result = new TextEditChangeImpl(edits);
              this._textEditChanges[key] = result;
            }
            return result;
          }
        }
        initDocumentChanges() {
          if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
            this._changeAnnotations = new ChangeAnnotations();
            this._workspaceEdit.documentChanges = [];
            this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
          }
        }
        initChanges() {
          if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
            this._workspaceEdit.changes = /* @__PURE__ */ Object.create(null);
          }
        }
        createFile(uri, optionsOrAnnotation, options) {
          this.initDocumentChanges();
          if (this._workspaceEdit.documentChanges === void 0) {
            throw new Error("Workspace edit is not configured for document changes.");
          }
          let annotation;
          if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
            annotation = optionsOrAnnotation;
          } else {
            options = optionsOrAnnotation;
          }
          let operation;
          let id;
          if (annotation === void 0) {
            operation = CreateFile.create(uri, options);
          } else {
            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
            operation = CreateFile.create(uri, options, id);
          }
          this._workspaceEdit.documentChanges.push(operation);
          if (id !== void 0) {
            return id;
          }
        }
        renameFile(oldUri, newUri, optionsOrAnnotation, options) {
          this.initDocumentChanges();
          if (this._workspaceEdit.documentChanges === void 0) {
            throw new Error("Workspace edit is not configured for document changes.");
          }
          let annotation;
          if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
            annotation = optionsOrAnnotation;
          } else {
            options = optionsOrAnnotation;
          }
          let operation;
          let id;
          if (annotation === void 0) {
            operation = RenameFile.create(oldUri, newUri, options);
          } else {
            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
            operation = RenameFile.create(oldUri, newUri, options, id);
          }
          this._workspaceEdit.documentChanges.push(operation);
          if (id !== void 0) {
            return id;
          }
        }
        deleteFile(uri, optionsOrAnnotation, options) {
          this.initDocumentChanges();
          if (this._workspaceEdit.documentChanges === void 0) {
            throw new Error("Workspace edit is not configured for document changes.");
          }
          let annotation;
          if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {
            annotation = optionsOrAnnotation;
          } else {
            options = optionsOrAnnotation;
          }
          let operation;
          let id;
          if (annotation === void 0) {
            operation = DeleteFile.create(uri, options);
          } else {
            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
            operation = DeleteFile.create(uri, options, id);
          }
          this._workspaceEdit.documentChanges.push(operation);
          if (id !== void 0) {
            return id;
          }
        }
      };
      (function(TextDocumentIdentifier3) {
        function create(uri) {
          return { uri };
        }
        TextDocumentIdentifier3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Is.string(candidate.uri);
        }
        TextDocumentIdentifier3.is = is;
      })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
      (function(VersionedTextDocumentIdentifier3) {
        function create(uri, version) {
          return { uri, version };
        }
        VersionedTextDocumentIdentifier3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
        }
        VersionedTextDocumentIdentifier3.is = is;
      })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
      (function(OptionalVersionedTextDocumentIdentifier3) {
        function create(uri, version) {
          return { uri, version };
        }
        OptionalVersionedTextDocumentIdentifier3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
        }
        OptionalVersionedTextDocumentIdentifier3.is = is;
      })(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
      (function(LanguageKind2) {
        LanguageKind2.ABAP = "abap";
        LanguageKind2.WindowsBat = "bat";
        LanguageKind2.BibTeX = "bibtex";
        LanguageKind2.Clojure = "clojure";
        LanguageKind2.Coffeescript = "coffeescript";
        LanguageKind2.C = "c";
        LanguageKind2.CPP = "cpp";
        LanguageKind2.CSharp = "csharp";
        LanguageKind2.CSS = "css";
        LanguageKind2.D = "d";
        LanguageKind2.Delphi = "pascal";
        LanguageKind2.Diff = "diff";
        LanguageKind2.Dart = "dart";
        LanguageKind2.Dockerfile = "dockerfile";
        LanguageKind2.Elixir = "elixir";
        LanguageKind2.Erlang = "erlang";
        LanguageKind2.FSharp = "fsharp";
        LanguageKind2.GitCommit = "git-commit";
        LanguageKind2.GitRebase = "git-rebase";
        LanguageKind2.Go = "go";
        LanguageKind2.Groovy = "groovy";
        LanguageKind2.Handlebars = "handlebars";
        LanguageKind2.Haskell = "haskell";
        LanguageKind2.HTML = "html";
        LanguageKind2.Ini = "ini";
        LanguageKind2.Java = "java";
        LanguageKind2.JavaScript = "javascript";
        LanguageKind2.JavaScriptReact = "javascriptreact";
        LanguageKind2.JSON = "json";
        LanguageKind2.LaTeX = "latex";
        LanguageKind2.Less = "less";
        LanguageKind2.Lua = "lua";
        LanguageKind2.Makefile = "makefile";
        LanguageKind2.Markdown = "markdown";
        LanguageKind2.ObjectiveC = "objective-c";
        LanguageKind2.ObjectiveCPP = "objective-cpp";
        LanguageKind2.Pascal = "pascal";
        LanguageKind2.Perl = "perl";
        LanguageKind2.Perl6 = "perl6";
        LanguageKind2.PHP = "php";
        LanguageKind2.Plaintext = "plaintext";
        LanguageKind2.Powershell = "powershell";
        LanguageKind2.Pug = "jade";
        LanguageKind2.Python = "python";
        LanguageKind2.R = "r";
        LanguageKind2.Razor = "razor";
        LanguageKind2.Ruby = "ruby";
        LanguageKind2.Rust = "rust";
        LanguageKind2.SCSS = "scss";
        LanguageKind2.SASS = "sass";
        LanguageKind2.Scala = "scala";
        LanguageKind2.ShaderLab = "shaderlab";
        LanguageKind2.ShellScript = "shellscript";
        LanguageKind2.SQL = "sql";
        LanguageKind2.Swift = "swift";
        LanguageKind2.TypeScript = "typescript";
        LanguageKind2.TypeScriptReact = "typescriptreact";
        LanguageKind2.TeX = "tex";
        LanguageKind2.VisualBasic = "vb";
        LanguageKind2.XML = "xml";
        LanguageKind2.XSL = "xsl";
        LanguageKind2.YAML = "yaml";
      })(LanguageKind || (LanguageKind = {}));
      (function(TextDocumentItem3) {
        function create(uri, languageId, version, text) {
          return { uri, languageId, version, text };
        }
        TextDocumentItem3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
        }
        TextDocumentItem3.is = is;
      })(TextDocumentItem || (TextDocumentItem = {}));
      (function(MarkupKind4) {
        MarkupKind4.PlainText = "plaintext";
        MarkupKind4.Markdown = "markdown";
        function is(value) {
          const candidate = value;
          return candidate === MarkupKind4.PlainText || candidate === MarkupKind4.Markdown;
        }
        MarkupKind4.is = is;
      })(MarkupKind || (MarkupKind = {}));
      (function(MarkupContent4) {
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
        }
        MarkupContent4.is = is;
      })(MarkupContent || (MarkupContent = {}));
      (function(CompletionItemKind4) {
        CompletionItemKind4.Text = 1;
        CompletionItemKind4.Method = 2;
        CompletionItemKind4.Function = 3;
        CompletionItemKind4.Constructor = 4;
        CompletionItemKind4.Field = 5;
        CompletionItemKind4.Variable = 6;
        CompletionItemKind4.Class = 7;
        CompletionItemKind4.Interface = 8;
        CompletionItemKind4.Module = 9;
        CompletionItemKind4.Property = 10;
        CompletionItemKind4.Unit = 11;
        CompletionItemKind4.Value = 12;
        CompletionItemKind4.Enum = 13;
        CompletionItemKind4.Keyword = 14;
        CompletionItemKind4.Snippet = 15;
        CompletionItemKind4.Color = 16;
        CompletionItemKind4.File = 17;
        CompletionItemKind4.Reference = 18;
        CompletionItemKind4.Folder = 19;
        CompletionItemKind4.EnumMember = 20;
        CompletionItemKind4.Constant = 21;
        CompletionItemKind4.Struct = 22;
        CompletionItemKind4.Event = 23;
        CompletionItemKind4.Operator = 24;
        CompletionItemKind4.TypeParameter = 25;
      })(CompletionItemKind || (CompletionItemKind = {}));
      (function(InsertTextFormat4) {
        InsertTextFormat4.PlainText = 1;
        InsertTextFormat4.Snippet = 2;
      })(InsertTextFormat || (InsertTextFormat = {}));
      (function(CompletionItemTag3) {
        CompletionItemTag3.Deprecated = 1;
      })(CompletionItemTag || (CompletionItemTag = {}));
      (function(InsertReplaceEdit3) {
        function create(newText, insert, replace) {
          return { newText, insert, replace };
        }
        InsertReplaceEdit3.create = create;
        function is(value) {
          const candidate = value;
          return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
        }
        InsertReplaceEdit3.is = is;
      })(InsertReplaceEdit || (InsertReplaceEdit = {}));
      (function(InsertTextMode3) {
        InsertTextMode3.asIs = 1;
        InsertTextMode3.adjustIndentation = 2;
      })(InsertTextMode || (InsertTextMode = {}));
      (function(ApplyKind2) {
        ApplyKind2.Replace = 1;
        ApplyKind2.Merge = 2;
      })(ApplyKind || (ApplyKind = {}));
      (function(CompletionItemLabelDetails3) {
        function is(value) {
          const candidate = value;
          return candidate && (Is.string(candidate.detail) || candidate.detail === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
        }
        CompletionItemLabelDetails3.is = is;
      })(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));
      (function(CompletionItem5) {
        function create(label) {
          return { label };
        }
        CompletionItem5.create = create;
      })(CompletionItem || (CompletionItem = {}));
      (function(CompletionList3) {
        function create(items, isIncomplete) {
          return { items: items ? items : [], isIncomplete: !!isIncomplete };
        }
        CompletionList3.create = create;
      })(CompletionList || (CompletionList = {}));
      (function(MarkedString3) {
        function fromPlainText(plainText) {
          return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
        }
        MarkedString3.fromPlainText = fromPlainText;
        function is(value) {
          const candidate = value;
          return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
        }
        MarkedString3.is = is;
      })(MarkedString || (MarkedString = {}));
      (function(Hover5) {
        function is(value) {
          const candidate = value;
          return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range));
        }
        Hover5.is = is;
      })(Hover || (Hover = {}));
      (function(ParameterInformation3) {
        function create(label, documentation) {
          return documentation ? { label, documentation } : { label };
        }
        ParameterInformation3.create = create;
      })(ParameterInformation || (ParameterInformation = {}));
      (function(SignatureInformation3) {
        function create(label, documentation, ...parameters) {
          const result = { label };
          if (Is.defined(documentation)) {
            result.documentation = documentation;
          }
          if (Is.defined(parameters)) {
            result.parameters = parameters;
          } else {
            result.parameters = [];
          }
          return result;
        }
        SignatureInformation3.create = create;
      })(SignatureInformation || (SignatureInformation = {}));
      (function(DocumentHighlightKind3) {
        DocumentHighlightKind3.Text = 1;
        DocumentHighlightKind3.Read = 2;
        DocumentHighlightKind3.Write = 3;
      })(DocumentHighlightKind || (DocumentHighlightKind = {}));
      (function(DocumentHighlight3) {
        function create(range, kind) {
          const result = { range };
          if (Is.number(kind)) {
            result.kind = kind;
          }
          return result;
        }
        DocumentHighlight3.create = create;
      })(DocumentHighlight || (DocumentHighlight = {}));
      (function(SymbolKind4) {
        SymbolKind4.File = 1;
        SymbolKind4.Module = 2;
        SymbolKind4.Namespace = 3;
        SymbolKind4.Package = 4;
        SymbolKind4.Class = 5;
        SymbolKind4.Method = 6;
        SymbolKind4.Property = 7;
        SymbolKind4.Field = 8;
        SymbolKind4.Constructor = 9;
        SymbolKind4.Enum = 10;
        SymbolKind4.Interface = 11;
        SymbolKind4.Function = 12;
        SymbolKind4.Variable = 13;
        SymbolKind4.Constant = 14;
        SymbolKind4.String = 15;
        SymbolKind4.Number = 16;
        SymbolKind4.Boolean = 17;
        SymbolKind4.Array = 18;
        SymbolKind4.Object = 19;
        SymbolKind4.Key = 20;
        SymbolKind4.Null = 21;
        SymbolKind4.EnumMember = 22;
        SymbolKind4.Struct = 23;
        SymbolKind4.Event = 24;
        SymbolKind4.Operator = 25;
        SymbolKind4.TypeParameter = 26;
      })(SymbolKind || (SymbolKind = {}));
      (function(SymbolTag3) {
        SymbolTag3.Deprecated = 1;
      })(SymbolTag || (SymbolTag = {}));
      (function(SymbolInformation3) {
        function create(name, kind, range, uri, containerName) {
          const result = {
            name,
            kind,
            location: { uri, range }
          };
          if (containerName) {
            result.containerName = containerName;
          }
          return result;
        }
        SymbolInformation3.create = create;
      })(SymbolInformation || (SymbolInformation = {}));
      (function(WorkspaceSymbol3) {
        function create(name, kind, uri, range) {
          return range !== void 0 ? { name, kind, location: { uri, range } } : { name, kind, location: { uri } };
        }
        WorkspaceSymbol3.create = create;
      })(WorkspaceSymbol || (WorkspaceSymbol = {}));
      (function(DocumentSymbol4) {
        function create(name, detail, kind, range, selectionRange, children) {
          const result = {
            name,
            detail,
            kind,
            range,
            selectionRange
          };
          if (children !== void 0) {
            result.children = children;
          }
          return result;
        }
        DocumentSymbol4.create = create;
        function is(value) {
          const candidate = value;
          return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range.is(candidate.range) && Range.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
        }
        DocumentSymbol4.is = is;
      })(DocumentSymbol || (DocumentSymbol = {}));
      (function(CodeActionKind5) {
        CodeActionKind5.Empty = "";
        CodeActionKind5.QuickFix = "quickfix";
        CodeActionKind5.Refactor = "refactor";
        CodeActionKind5.RefactorExtract = "refactor.extract";
        CodeActionKind5.RefactorInline = "refactor.inline";
        CodeActionKind5.RefactorMove = "refactor.move";
        CodeActionKind5.RefactorRewrite = "refactor.rewrite";
        CodeActionKind5.Source = "source";
        CodeActionKind5.SourceOrganizeImports = "source.organizeImports";
        CodeActionKind5.SourceFixAll = "source.fixAll";
        CodeActionKind5.Notebook = "notebook";
      })(CodeActionKind || (CodeActionKind = {}));
      (function(CodeActionTriggerKind3) {
        CodeActionTriggerKind3.Invoked = 1;
        CodeActionTriggerKind3.Automatic = 2;
      })(CodeActionTriggerKind || (CodeActionTriggerKind = {}));
      (function(CodeActionContext3) {
        function create(diagnostics, only, triggerKind) {
          const result = { diagnostics };
          if (only !== void 0 && only !== null) {
            result.only = only;
          }
          if (triggerKind !== void 0 && triggerKind !== null) {
            result.triggerKind = triggerKind;
          }
          return result;
        }
        CodeActionContext3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === void 0 || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
        }
        CodeActionContext3.is = is;
      })(CodeActionContext || (CodeActionContext = {}));
      (function(CodeActionTag2) {
        CodeActionTag2.LLMGenerated = 1;
        function is(value) {
          return Is.defined(value) && value === CodeActionTag2.LLMGenerated;
        }
        CodeActionTag2.is = is;
      })(CodeActionTag || (CodeActionTag = {}));
      (function(CodeAction4) {
        function create(title, kindOrCommandOrEdit, kind) {
          const result = { title };
          let checkKind = true;
          if (typeof kindOrCommandOrEdit === "string") {
            checkKind = false;
            result.kind = kindOrCommandOrEdit;
          } else if (Command.is(kindOrCommandOrEdit)) {
            result.command = kindOrCommandOrEdit;
          } else {
            result.edit = kindOrCommandOrEdit;
          }
          if (checkKind && kind !== void 0) {
            result.kind = kind;
          }
          return result;
        }
        CodeAction4.create = create;
        function is(value) {
          const candidate = value;
          return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit)) && (candidate.tags === void 0 || Is.typedArray(candidate.tags, CodeActionTag.is));
        }
        CodeAction4.is = is;
      })(CodeAction || (CodeAction = {}));
      (function(CodeLens3) {
        function create(range, data) {
          const result = { range };
          if (Is.defined(data)) {
            result.data = data;
          }
          return result;
        }
        CodeLens3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
        }
        CodeLens3.is = is;
      })(CodeLens || (CodeLens = {}));
      (function(FormattingOptions3) {
        function create(tabSize, insertSpaces) {
          return { tabSize, insertSpaces };
        }
        FormattingOptions3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
        }
        FormattingOptions3.is = is;
      })(FormattingOptions || (FormattingOptions = {}));
      (function(DocumentLink3) {
        function create(range, target, data) {
          return { range, target, data };
        }
        DocumentLink3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
        }
        DocumentLink3.is = is;
      })(DocumentLink || (DocumentLink = {}));
      (function(SelectionRange3) {
        function create(range, parent) {
          return { range, parent };
        }
        SelectionRange3.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === void 0 || SelectionRange3.is(candidate.parent));
        }
        SelectionRange3.is = is;
      })(SelectionRange || (SelectionRange = {}));
      (function(SemanticTokenTypes3) {
        SemanticTokenTypes3["namespace"] = "namespace";
        SemanticTokenTypes3["type"] = "type";
        SemanticTokenTypes3["class"] = "class";
        SemanticTokenTypes3["enum"] = "enum";
        SemanticTokenTypes3["interface"] = "interface";
        SemanticTokenTypes3["struct"] = "struct";
        SemanticTokenTypes3["typeParameter"] = "typeParameter";
        SemanticTokenTypes3["parameter"] = "parameter";
        SemanticTokenTypes3["variable"] = "variable";
        SemanticTokenTypes3["property"] = "property";
        SemanticTokenTypes3["enumMember"] = "enumMember";
        SemanticTokenTypes3["event"] = "event";
        SemanticTokenTypes3["function"] = "function";
        SemanticTokenTypes3["method"] = "method";
        SemanticTokenTypes3["macro"] = "macro";
        SemanticTokenTypes3["keyword"] = "keyword";
        SemanticTokenTypes3["modifier"] = "modifier";
        SemanticTokenTypes3["comment"] = "comment";
        SemanticTokenTypes3["string"] = "string";
        SemanticTokenTypes3["number"] = "number";
        SemanticTokenTypes3["regexp"] = "regexp";
        SemanticTokenTypes3["operator"] = "operator";
        SemanticTokenTypes3["decorator"] = "decorator";
        SemanticTokenTypes3["label"] = "label";
      })(SemanticTokenTypes || (SemanticTokenTypes = {}));
      (function(SemanticTokenModifiers3) {
        SemanticTokenModifiers3["declaration"] = "declaration";
        SemanticTokenModifiers3["definition"] = "definition";
        SemanticTokenModifiers3["readonly"] = "readonly";
        SemanticTokenModifiers3["static"] = "static";
        SemanticTokenModifiers3["deprecated"] = "deprecated";
        SemanticTokenModifiers3["abstract"] = "abstract";
        SemanticTokenModifiers3["async"] = "async";
        SemanticTokenModifiers3["modification"] = "modification";
        SemanticTokenModifiers3["documentation"] = "documentation";
        SemanticTokenModifiers3["defaultLibrary"] = "defaultLibrary";
      })(SemanticTokenModifiers || (SemanticTokenModifiers = {}));
      (function(SemanticTokens5) {
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
        }
        SemanticTokens5.is = is;
      })(SemanticTokens || (SemanticTokens = {}));
      (function(InlineValueText3) {
        function create(range, text) {
          return { range, text };
        }
        InlineValueText3.create = create;
        function is(value) {
          const candidate = value;
          return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);
        }
        InlineValueText3.is = is;
      })(InlineValueText || (InlineValueText = {}));
      (function(InlineValueVariableLookup3) {
        function create(range, variableName, caseSensitiveLookup) {
          return { range, variableName, caseSensitiveLookup };
        }
        InlineValueVariableLookup3.create = create;
        function is(value) {
          const candidate = value;
          return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup) && (Is.string(candidate.variableName) || candidate.variableName === void 0);
        }
        InlineValueVariableLookup3.is = is;
      })(InlineValueVariableLookup || (InlineValueVariableLookup = {}));
      (function(InlineValueEvaluatableExpression3) {
        function create(range, expression) {
          return { range, expression };
        }
        InlineValueEvaluatableExpression3.create = create;
        function is(value) {
          const candidate = value;
          return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && (Is.string(candidate.expression) || candidate.expression === void 0);
        }
        InlineValueEvaluatableExpression3.is = is;
      })(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));
      (function(InlineValueContext3) {
        function create(frameId, stoppedLocation) {
          return { frameId, stoppedLocation };
        }
        InlineValueContext3.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Range.is(value.stoppedLocation);
        }
        InlineValueContext3.is = is;
      })(InlineValueContext || (InlineValueContext = {}));
      (function(InlayHintKind3) {
        InlayHintKind3.Type = 1;
        InlayHintKind3.Parameter = 2;
        function is(value) {
          return value === 1 || value === 2;
        }
        InlayHintKind3.is = is;
      })(InlayHintKind || (InlayHintKind = {}));
      (function(InlayHintLabelPart3) {
        function create(value) {
          return { value };
        }
        InlayHintLabelPart3.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.location === void 0 || Location.is(candidate.location)) && (candidate.command === void 0 || Command.is(candidate.command));
        }
        InlayHintLabelPart3.is = is;
      })(InlayHintLabelPart || (InlayHintLabelPart = {}));
      (function(InlayHint3) {
        function create(position, label, kind) {
          const result = { position, label };
          if (kind !== void 0) {
            result.kind = kind;
          }
          return result;
        }
        InlayHint3.create = create;
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && Position.is(candidate.position) && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is)) && (candidate.kind === void 0 || InlayHintKind.is(candidate.kind)) && candidate.textEdits === void 0 || Is.typedArray(candidate.textEdits, TextEdit.is) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.paddingLeft === void 0 || Is.boolean(candidate.paddingLeft)) && (candidate.paddingRight === void 0 || Is.boolean(candidate.paddingRight));
        }
        InlayHint3.is = is;
      })(InlayHint || (InlayHint = {}));
      (function(StringValue3) {
        function createSnippet(value) {
          return { kind: "snippet", value };
        }
        StringValue3.createSnippet = createSnippet;
        function isSnippet(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && candidate.kind === "snippet" && Is.string(candidate.value);
        }
        StringValue3.isSnippet = isSnippet;
      })(StringValue || (StringValue = {}));
      (function(InlineCompletionItem3) {
        function create(insertText, filterText, range, command) {
          return { insertText, filterText, range, command };
        }
        InlineCompletionItem3.create = create;
      })(InlineCompletionItem || (InlineCompletionItem = {}));
      (function(InlineCompletionList3) {
        function create(items) {
          return { items };
        }
        InlineCompletionList3.create = create;
      })(InlineCompletionList || (InlineCompletionList = {}));
      (function(InlineCompletionTriggerKind3) {
        InlineCompletionTriggerKind3.Invoked = 1;
        InlineCompletionTriggerKind3.Automatic = 2;
      })(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));
      (function(SelectedCompletionInfo3) {
        function create(range, text) {
          return { range, text };
        }
        SelectedCompletionInfo3.create = create;
      })(SelectedCompletionInfo || (SelectedCompletionInfo = {}));
      (function(InlineCompletionContext3) {
        function create(triggerKind, selectedCompletionInfo) {
          return { triggerKind, selectedCompletionInfo };
        }
        InlineCompletionContext3.create = create;
      })(InlineCompletionContext || (InlineCompletionContext = {}));
      (function(WorkspaceFolder3) {
        function is(value) {
          const candidate = value;
          return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
        }
        WorkspaceFolder3.is = is;
      })(WorkspaceFolder || (WorkspaceFolder = {}));
      EOL = ["\n", "\r\n", "\r"];
      (function(TextDocument4) {
        function create(uri, languageId, version, content) {
          return new FullTextDocument(uri, languageId, version, content);
        }
        TextDocument4.create = create;
        function is(value) {
          const candidate = value;
          return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
        }
        TextDocument4.is = is;
        function applyEdits(document, edits) {
          let text = document.getText();
          const sortedEdits = mergeSort2(edits, (a, b) => {
            const diff = a.range.start.line - b.range.start.line;
            if (diff === 0) {
              return a.range.start.character - b.range.start.character;
            }
            return diff;
          });
          let lastModifiedOffset = text.length;
          for (let i = sortedEdits.length - 1; i >= 0; i--) {
            const e = sortedEdits[i];
            const startOffset = document.offsetAt(e.range.start);
            const endOffset = document.offsetAt(e.range.end);
            if (endOffset <= lastModifiedOffset) {
              text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
            } else {
              throw new Error("Overlapping edit");
            }
            lastModifiedOffset = startOffset;
          }
          return text;
        }
        TextDocument4.applyEdits = applyEdits;
        function mergeSort2(data, compare) {
          if (data.length <= 1) {
            return data;
          }
          const p = data.length / 2 | 0;
          const left = data.slice(0, p);
          const right = data.slice(p);
          mergeSort2(left, compare);
          mergeSort2(right, compare);
          let leftIdx = 0;
          let rightIdx = 0;
          let i = 0;
          while (leftIdx < left.length && rightIdx < right.length) {
            const ret = compare(left[leftIdx], right[rightIdx]);
            if (ret <= 0) {
              data[i++] = left[leftIdx++];
            } else {
              data[i++] = right[rightIdx++];
            }
          }
          while (leftIdx < left.length) {
            data[i++] = left[leftIdx++];
          }
          while (rightIdx < right.length) {
            data[i++] = right[rightIdx++];
          }
          return data;
        }
      })(TextDocument || (TextDocument = {}));
      FullTextDocument = class {
        constructor(uri, languageId, version, content) {
          this._uri = uri;
          this._languageId = languageId;
          this._version = version;
          this._content = content;
          this._lineOffsets = void 0;
        }
        get uri() {
          return this._uri;
        }
        get languageId() {
          return this._languageId;
        }
        get version() {
          return this._version;
        }
        getText(range) {
          if (range) {
            const start = this.offsetAt(range.start);
            const end = this.offsetAt(range.end);
            return this._content.substring(start, end);
          }
          return this._content;
        }
        update(event, version) {
          this._content = event.text;
          this._version = version;
          this._lineOffsets = void 0;
        }
        getLineOffsets() {
          if (this._lineOffsets === void 0) {
            const lineOffsets = [];
            const text = this._content;
            let isLineStart = true;
            for (let i = 0; i < text.length; i++) {
              if (isLineStart) {
                lineOffsets.push(i);
                isLineStart = false;
              }
              const ch = text.charAt(i);
              isLineStart = ch === "\r" || ch === "\n";
              if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
                i++;
              }
            }
            if (isLineStart && text.length > 0) {
              lineOffsets.push(text.length);
            }
            this._lineOffsets = lineOffsets;
          }
          return this._lineOffsets;
        }
        positionAt(offset) {
          offset = Math.max(Math.min(offset, this._content.length), 0);
          const lineOffsets = this.getLineOffsets();
          let low = 0, high = lineOffsets.length;
          if (high === 0) {
            return Position.create(0, offset);
          }
          while (low < high) {
            const mid = Math.floor((low + high) / 2);
            if (lineOffsets[mid] > offset) {
              high = mid;
            } else {
              low = mid + 1;
            }
          }
          const line = low - 1;
          return Position.create(line, offset - lineOffsets[line]);
        }
        offsetAt(position) {
          const lineOffsets = this.getLineOffsets();
          if (position.line >= lineOffsets.length) {
            return this._content.length;
          } else if (position.line < 0) {
            return 0;
          }
          const lineOffset = lineOffsets[position.line];
          const nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
          return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
        }
        get lineCount() {
          return this.getLineOffsets().length;
        }
      };
      (function(Is3) {
        const toString = Object.prototype.toString;
        function defined(value) {
          return typeof value !== "undefined";
        }
        Is3.defined = defined;
        function undefined2(value) {
          return typeof value === "undefined";
        }
        Is3.undefined = undefined2;
        function boolean(value) {
          return value === true || value === false;
        }
        Is3.boolean = boolean;
        function string(value) {
          return toString.call(value) === "[object String]";
        }
        Is3.string = string;
        function number(value) {
          return toString.call(value) === "[object Number]";
        }
        Is3.number = number;
        function numberRange(value, min, max) {
          return toString.call(value) === "[object Number]" && min <= value && value <= max;
        }
        Is3.numberRange = numberRange;
        function integer3(value) {
          return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
        }
        Is3.integer = integer3;
        function uinteger3(value) {
          return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
        }
        Is3.uinteger = uinteger3;
        function func(value) {
          return toString.call(value) === "[object Function]";
        }
        Is3.func = func;
        function objectLiteral(value) {
          return value !== null && typeof value === "object";
        }
        Is3.objectLiteral = objectLiteral;
        function typedArray(value, check) {
          return Array.isArray(value) && value.every(check);
        }
        Is3.typedArray = typedArray;
      })(Is || (Is = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/messages.js
  var require_messages2 = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/messages.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CM = exports.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = exports.MessageDirection = void 0;
      var vscode_jsonrpc_1 = require_api();
      var MessageDirection;
      (function(MessageDirection2) {
        MessageDirection2["clientToServer"] = "clientToServer";
        MessageDirection2["serverToClient"] = "serverToClient";
        MessageDirection2["both"] = "both";
      })(MessageDirection || (exports.MessageDirection = MessageDirection = {}));
      var RegistrationType = class {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        ____;
        method;
        constructor(method) {
          this.method = method;
        }
      };
      exports.RegistrationType = RegistrationType;
      var ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 {
        /**
         * Clients must not use these properties. They are here to ensure correct typing.
         * in TypeScript
         */
        __;
        ___;
        ____;
        _pr;
        constructor(method) {
          super(method);
        }
      };
      exports.ProtocolRequestType0 = ProtocolRequestType0;
      var ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        __;
        ___;
        ____;
        _pr;
        constructor(method) {
          super(method, vscode_jsonrpc_1.ParameterStructures.byName);
        }
      };
      exports.ProtocolRequestType = ProtocolRequestType;
      var ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        ___;
        ____;
        constructor(method) {
          super(method);
        }
      };
      exports.ProtocolNotificationType0 = ProtocolNotificationType0;
      var ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType {
        /**
         * Clients must not use this property. It is here to ensure correct typing.
         */
        ___;
        ____;
        constructor(method) {
          super(method, vscode_jsonrpc_1.ParameterStructures.byName);
        }
      };
      exports.ProtocolNotificationType = ProtocolNotificationType;
      var CM;
      (function(CM2) {
        function create(client, server) {
          return { client, server };
        }
        CM2.create = create;
      })(CM || (exports.CM = CM = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/utils/is.js
  var require_is2 = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/utils/is.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.boolean = boolean;
      exports.string = string;
      exports.number = number;
      exports.error = error;
      exports.func = func;
      exports.array = array;
      exports.stringArray = stringArray;
      exports.typedArray = typedArray;
      exports.objectLiteral = objectLiteral;
      function boolean(value) {
        return value === true || value === false;
      }
      function string(value) {
        return typeof value === "string" || value instanceof String;
      }
      function number(value) {
        return typeof value === "number" || value instanceof Number;
      }
      function error(value) {
        return value instanceof Error;
      }
      function func(value) {
        return typeof value === "function";
      }
      function array(value) {
        return Array.isArray(value);
      }
      function stringArray(value) {
        return array(value) && value.every((elem) => string(elem));
      }
      function typedArray(value, check) {
        return Array.isArray(value) && value.every(check);
      }
      function objectLiteral(value) {
        return value !== null && typeof value === "object";
      }
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js
  var require_protocol_implementation = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ImplementationRequest = void 0;
      var messages_1 = require_messages2();
      var ImplementationRequest;
      (function(ImplementationRequest2) {
        ImplementationRequest2.method = "textDocument/implementation";
        ImplementationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ImplementationRequest2.type = new messages_1.ProtocolRequestType(ImplementationRequest2.method);
        ImplementationRequest2.capabilities = messages_1.CM.create("textDocument.implementation", "implementationProvider");
      })(ImplementationRequest || (exports.ImplementationRequest = ImplementationRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js
  var require_protocol_typeDefinition = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TypeDefinitionRequest = void 0;
      var messages_1 = require_messages2();
      var TypeDefinitionRequest;
      (function(TypeDefinitionRequest2) {
        TypeDefinitionRequest2.method = "textDocument/typeDefinition";
        TypeDefinitionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TypeDefinitionRequest2.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest2.method);
        TypeDefinitionRequest2.capabilities = messages_1.CM.create("textDocument.typeDefinition", "typeDefinitionProvider");
      })(TypeDefinitionRequest || (exports.TypeDefinitionRequest = TypeDefinitionRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolder.js
  var require_protocol_workspaceFolder = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolder.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = void 0;
      var messages_1 = require_messages2();
      var WorkspaceFoldersRequest;
      (function(WorkspaceFoldersRequest2) {
        WorkspaceFoldersRequest2.method = "workspace/workspaceFolders";
        WorkspaceFoldersRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        WorkspaceFoldersRequest2.type = new messages_1.ProtocolRequestType0(WorkspaceFoldersRequest2.method);
        WorkspaceFoldersRequest2.capabilities = messages_1.CM.create("workspace.workspaceFolders", "workspace.workspaceFolders");
      })(WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = WorkspaceFoldersRequest = {}));
      var DidChangeWorkspaceFoldersNotification;
      (function(DidChangeWorkspaceFoldersNotification2) {
        DidChangeWorkspaceFoldersNotification2.method = "workspace/didChangeWorkspaceFolders";
        DidChangeWorkspaceFoldersNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeWorkspaceFoldersNotification2.type = new messages_1.ProtocolNotificationType(DidChangeWorkspaceFoldersNotification2.method);
        DidChangeWorkspaceFoldersNotification2.capabilities = messages_1.CM.create(void 0, "workspace.workspaceFolders.changeNotifications");
      })(DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = DidChangeWorkspaceFoldersNotification = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js
  var require_protocol_configuration = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ConfigurationRequest = void 0;
      var messages_1 = require_messages2();
      var ConfigurationRequest;
      (function(ConfigurationRequest2) {
        ConfigurationRequest2.method = "workspace/configuration";
        ConfigurationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        ConfigurationRequest2.type = new messages_1.ProtocolRequestType(ConfigurationRequest2.method);
        ConfigurationRequest2.capabilities = messages_1.CM.create("workspace.configuration", void 0);
      })(ConfigurationRequest || (exports.ConfigurationRequest = ConfigurationRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js
  var require_protocol_colorProvider = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ColorPresentationRequest = exports.DocumentColorRequest = void 0;
      var messages_1 = require_messages2();
      var DocumentColorRequest;
      (function(DocumentColorRequest2) {
        DocumentColorRequest2.method = "textDocument/documentColor";
        DocumentColorRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentColorRequest2.type = new messages_1.ProtocolRequestType(DocumentColorRequest2.method);
        DocumentColorRequest2.capabilities = messages_1.CM.create("textDocument.colorProvider", "colorProvider");
      })(DocumentColorRequest || (exports.DocumentColorRequest = DocumentColorRequest = {}));
      var ColorPresentationRequest;
      (function(ColorPresentationRequest2) {
        ColorPresentationRequest2.method = "textDocument/colorPresentation";
        ColorPresentationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ColorPresentationRequest2.type = new messages_1.ProtocolRequestType(ColorPresentationRequest2.method);
        ColorPresentationRequest2.capabilities = messages_1.CM.create("textDocument.colorProvider", "colorProvider");
      })(ColorPresentationRequest || (exports.ColorPresentationRequest = ColorPresentationRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js
  var require_protocol_foldingRange = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.FoldingRangeRefreshRequest = exports.FoldingRangeRequest = void 0;
      var messages_1 = require_messages2();
      var FoldingRangeRequest;
      (function(FoldingRangeRequest2) {
        FoldingRangeRequest2.method = "textDocument/foldingRange";
        FoldingRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        FoldingRangeRequest2.type = new messages_1.ProtocolRequestType(FoldingRangeRequest2.method);
        FoldingRangeRequest2.capabilities = messages_1.CM.create("textDocument.foldingRange", "foldingRangeProvider");
      })(FoldingRangeRequest || (exports.FoldingRangeRequest = FoldingRangeRequest = {}));
      var FoldingRangeRefreshRequest;
      (function(FoldingRangeRefreshRequest2) {
        FoldingRangeRefreshRequest2.method = `workspace/foldingRange/refresh`;
        FoldingRangeRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        FoldingRangeRefreshRequest2.type = new messages_1.ProtocolRequestType0(FoldingRangeRefreshRequest2.method);
        FoldingRangeRefreshRequest2.capabilities = messages_1.CM.create("workspace.foldingRange.refreshSupport", void 0);
      })(FoldingRangeRefreshRequest || (exports.FoldingRangeRefreshRequest = FoldingRangeRefreshRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js
  var require_protocol_declaration = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DeclarationRequest = void 0;
      var messages_1 = require_messages2();
      var DeclarationRequest;
      (function(DeclarationRequest2) {
        DeclarationRequest2.method = "textDocument/declaration";
        DeclarationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DeclarationRequest2.type = new messages_1.ProtocolRequestType(DeclarationRequest2.method);
        DeclarationRequest2.capabilities = messages_1.CM.create("textDocument.declaration", "declarationProvider");
      })(DeclarationRequest || (exports.DeclarationRequest = DeclarationRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js
  var require_protocol_selectionRange = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SelectionRangeRequest = void 0;
      var messages_1 = require_messages2();
      var SelectionRangeRequest;
      (function(SelectionRangeRequest2) {
        SelectionRangeRequest2.method = "textDocument/selectionRange";
        SelectionRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SelectionRangeRequest2.type = new messages_1.ProtocolRequestType(SelectionRangeRequest2.method);
        SelectionRangeRequest2.capabilities = messages_1.CM.create("textDocument.selectionRange", "selectionRangeProvider");
      })(SelectionRangeRequest || (exports.SelectionRangeRequest = SelectionRangeRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js
  var require_protocol_progress = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = void 0;
      var vscode_jsonrpc_1 = require_api();
      var messages_1 = require_messages2();
      var WorkDoneProgress;
      (function(WorkDoneProgress2) {
        WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType();
        function is(value) {
          return value === WorkDoneProgress2.type;
        }
        WorkDoneProgress2.is = is;
      })(WorkDoneProgress || (exports.WorkDoneProgress = WorkDoneProgress = {}));
      var WorkDoneProgressCreateRequest;
      (function(WorkDoneProgressCreateRequest2) {
        WorkDoneProgressCreateRequest2.method = "window/workDoneProgress/create";
        WorkDoneProgressCreateRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        WorkDoneProgressCreateRequest2.type = new messages_1.ProtocolRequestType(WorkDoneProgressCreateRequest2.method);
        WorkDoneProgressCreateRequest2.capabilities = messages_1.CM.create("window.workDoneProgress", void 0);
      })(WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = WorkDoneProgressCreateRequest = {}));
      var WorkDoneProgressCancelNotification;
      (function(WorkDoneProgressCancelNotification2) {
        WorkDoneProgressCancelNotification2.method = "window/workDoneProgress/cancel";
        WorkDoneProgressCancelNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        WorkDoneProgressCancelNotification2.type = new messages_1.ProtocolNotificationType(WorkDoneProgressCancelNotification2.method);
      })(WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = WorkDoneProgressCancelNotification = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js
  var require_protocol_callHierarchy = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.CallHierarchyPrepareRequest = void 0;
      var messages_1 = require_messages2();
      var CallHierarchyPrepareRequest;
      (function(CallHierarchyPrepareRequest2) {
        CallHierarchyPrepareRequest2.method = "textDocument/prepareCallHierarchy";
        CallHierarchyPrepareRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest2.method);
        CallHierarchyPrepareRequest2.capabilities = messages_1.CM.create("textDocument.callHierarchy", "callHierarchyProvider");
      })(CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = CallHierarchyPrepareRequest = {}));
      var CallHierarchyIncomingCallsRequest;
      (function(CallHierarchyIncomingCallsRequest2) {
        CallHierarchyIncomingCallsRequest2.method = "callHierarchy/incomingCalls";
        CallHierarchyIncomingCallsRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest2.method);
        CallHierarchyIncomingCallsRequest2.capabilities = messages_1.CM.create("textDocument.callHierarchy", "callHierarchyProvider");
      })(CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = CallHierarchyIncomingCallsRequest = {}));
      var CallHierarchyOutgoingCallsRequest;
      (function(CallHierarchyOutgoingCallsRequest2) {
        CallHierarchyOutgoingCallsRequest2.method = "callHierarchy/outgoingCalls";
        CallHierarchyOutgoingCallsRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest2.method);
        CallHierarchyOutgoingCallsRequest2.capabilities = messages_1.CM.create("textDocument.callHierarchy", "callHierarchyProvider");
      })(CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = CallHierarchyOutgoingCallsRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js
  var require_protocol_semanticTokens = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.SemanticTokensRegistrationType = exports.TokenFormat = void 0;
      var messages_1 = require_messages2();
      var TokenFormat;
      (function(TokenFormat2) {
        TokenFormat2.Relative = "relative";
      })(TokenFormat || (exports.TokenFormat = TokenFormat = {}));
      var SemanticTokensRegistrationType;
      (function(SemanticTokensRegistrationType2) {
        SemanticTokensRegistrationType2.method = "textDocument/semanticTokens";
        SemanticTokensRegistrationType2.type = new messages_1.RegistrationType(SemanticTokensRegistrationType2.method);
      })(SemanticTokensRegistrationType || (exports.SemanticTokensRegistrationType = SemanticTokensRegistrationType = {}));
      var SemanticTokensRequest;
      (function(SemanticTokensRequest2) {
        SemanticTokensRequest2.method = "textDocument/semanticTokens/full";
        SemanticTokensRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SemanticTokensRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRequest2.method);
        SemanticTokensRequest2.registrationMethod = SemanticTokensRegistrationType.method;
        SemanticTokensRequest2.capabilities = messages_1.CM.create("textDocument.semanticTokens", "semanticTokensProvider");
      })(SemanticTokensRequest || (exports.SemanticTokensRequest = SemanticTokensRequest = {}));
      var SemanticTokensDeltaRequest;
      (function(SemanticTokensDeltaRequest2) {
        SemanticTokensDeltaRequest2.method = "textDocument/semanticTokens/full/delta";
        SemanticTokensDeltaRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SemanticTokensDeltaRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest2.method);
        SemanticTokensDeltaRequest2.registrationMethod = SemanticTokensRegistrationType.method;
        SemanticTokensDeltaRequest2.capabilities = messages_1.CM.create("textDocument.semanticTokens.requests.full.delta", "semanticTokensProvider.full.delta");
      })(SemanticTokensDeltaRequest || (exports.SemanticTokensDeltaRequest = SemanticTokensDeltaRequest = {}));
      var SemanticTokensRangeRequest;
      (function(SemanticTokensRangeRequest2) {
        SemanticTokensRangeRequest2.method = "textDocument/semanticTokens/range";
        SemanticTokensRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest2.method);
        SemanticTokensRangeRequest2.registrationMethod = SemanticTokensRegistrationType.method;
        SemanticTokensRangeRequest2.capabilities = messages_1.CM.create("textDocument.semanticTokens.requests.range", "semanticTokensProvider.range");
      })(SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = SemanticTokensRangeRequest = {}));
      var SemanticTokensRefreshRequest;
      (function(SemanticTokensRefreshRequest2) {
        SemanticTokensRefreshRequest2.method = `workspace/semanticTokens/refresh`;
        SemanticTokensRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        SemanticTokensRefreshRequest2.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest2.method);
        SemanticTokensRefreshRequest2.capabilities = messages_1.CM.create("workspace.semanticTokens.refreshSupport", void 0);
      })(SemanticTokensRefreshRequest || (exports.SemanticTokensRefreshRequest = SemanticTokensRefreshRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js
  var require_protocol_showDocument = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ShowDocumentRequest = void 0;
      var messages_1 = require_messages2();
      var ShowDocumentRequest;
      (function(ShowDocumentRequest2) {
        ShowDocumentRequest2.method = "window/showDocument";
        ShowDocumentRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        ShowDocumentRequest2.type = new messages_1.ProtocolRequestType(ShowDocumentRequest2.method);
        ShowDocumentRequest2.capabilities = messages_1.CM.create("window.showDocument.support", void 0);
      })(ShowDocumentRequest || (exports.ShowDocumentRequest = ShowDocumentRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js
  var require_protocol_linkedEditingRange = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LinkedEditingRangeRequest = void 0;
      var messages_1 = require_messages2();
      var LinkedEditingRangeRequest;
      (function(LinkedEditingRangeRequest2) {
        LinkedEditingRangeRequest2.method = "textDocument/linkedEditingRange";
        LinkedEditingRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        LinkedEditingRangeRequest2.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest2.method);
        LinkedEditingRangeRequest2.capabilities = messages_1.CM.create("textDocument.linkedEditingRange", "linkedEditingRangeProvider");
      })(LinkedEditingRangeRequest || (exports.LinkedEditingRangeRequest = LinkedEditingRangeRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js
  var require_protocol_fileOperations = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.DidRenameFilesNotification = exports.WillRenameFilesRequest = exports.DidCreateFilesNotification = exports.WillCreateFilesRequest = exports.FileOperationPatternKind = void 0;
      var messages_1 = require_messages2();
      var FileOperationPatternKind;
      (function(FileOperationPatternKind2) {
        FileOperationPatternKind2.file = "file";
        FileOperationPatternKind2.folder = "folder";
      })(FileOperationPatternKind || (exports.FileOperationPatternKind = FileOperationPatternKind = {}));
      var WillCreateFilesRequest;
      (function(WillCreateFilesRequest2) {
        WillCreateFilesRequest2.method = "workspace/willCreateFiles";
        WillCreateFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillCreateFilesRequest2.type = new messages_1.ProtocolRequestType(WillCreateFilesRequest2.method);
        WillCreateFilesRequest2.capabilities = messages_1.CM.create("workspace.fileOperations.willCreate", "workspace.fileOperations.willCreate");
      })(WillCreateFilesRequest || (exports.WillCreateFilesRequest = WillCreateFilesRequest = {}));
      var DidCreateFilesNotification;
      (function(DidCreateFilesNotification2) {
        DidCreateFilesNotification2.method = "workspace/didCreateFiles";
        DidCreateFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidCreateFilesNotification2.type = new messages_1.ProtocolNotificationType(DidCreateFilesNotification2.method);
        DidCreateFilesNotification2.capabilities = messages_1.CM.create("workspace.fileOperations.didCreate", "workspace.fileOperations.didCreate");
      })(DidCreateFilesNotification || (exports.DidCreateFilesNotification = DidCreateFilesNotification = {}));
      var WillRenameFilesRequest;
      (function(WillRenameFilesRequest2) {
        WillRenameFilesRequest2.method = "workspace/willRenameFiles";
        WillRenameFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillRenameFilesRequest2.type = new messages_1.ProtocolRequestType(WillRenameFilesRequest2.method);
        WillRenameFilesRequest2.capabilities = messages_1.CM.create("workspace.fileOperations.willRename", "workspace.fileOperations.willRename");
      })(WillRenameFilesRequest || (exports.WillRenameFilesRequest = WillRenameFilesRequest = {}));
      var DidRenameFilesNotification;
      (function(DidRenameFilesNotification2) {
        DidRenameFilesNotification2.method = "workspace/didRenameFiles";
        DidRenameFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidRenameFilesNotification2.type = new messages_1.ProtocolNotificationType(DidRenameFilesNotification2.method);
        DidRenameFilesNotification2.capabilities = messages_1.CM.create("workspace.fileOperations.didRename", "workspace.fileOperations.didRename");
      })(DidRenameFilesNotification || (exports.DidRenameFilesNotification = DidRenameFilesNotification = {}));
      var DidDeleteFilesNotification;
      (function(DidDeleteFilesNotification2) {
        DidDeleteFilesNotification2.method = "workspace/didDeleteFiles";
        DidDeleteFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidDeleteFilesNotification2.type = new messages_1.ProtocolNotificationType(DidDeleteFilesNotification2.method);
        DidDeleteFilesNotification2.capabilities = messages_1.CM.create("workspace.fileOperations.didDelete", "workspace.fileOperations.didDelete");
      })(DidDeleteFilesNotification || (exports.DidDeleteFilesNotification = DidDeleteFilesNotification = {}));
      var WillDeleteFilesRequest;
      (function(WillDeleteFilesRequest2) {
        WillDeleteFilesRequest2.method = "workspace/willDeleteFiles";
        WillDeleteFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillDeleteFilesRequest2.type = new messages_1.ProtocolRequestType(WillDeleteFilesRequest2.method);
        WillDeleteFilesRequest2.capabilities = messages_1.CM.create("workspace.fileOperations.willDelete", "workspace.fileOperations.willDelete");
      })(WillDeleteFilesRequest || (exports.WillDeleteFilesRequest = WillDeleteFilesRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js
  var require_protocol_moniker = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0;
      var messages_1 = require_messages2();
      var UniquenessLevel;
      (function(UniquenessLevel2) {
        UniquenessLevel2.document = "document";
        UniquenessLevel2.project = "project";
        UniquenessLevel2.group = "group";
        UniquenessLevel2.scheme = "scheme";
        UniquenessLevel2.global = "global";
      })(UniquenessLevel || (exports.UniquenessLevel = UniquenessLevel = {}));
      var MonikerKind;
      (function(MonikerKind2) {
        MonikerKind2.$import = "import";
        MonikerKind2.$export = "export";
        MonikerKind2.local = "local";
      })(MonikerKind || (exports.MonikerKind = MonikerKind = {}));
      var MonikerRequest;
      (function(MonikerRequest2) {
        MonikerRequest2.method = "textDocument/moniker";
        MonikerRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        MonikerRequest2.type = new messages_1.ProtocolRequestType(MonikerRequest2.method);
        MonikerRequest2.capabilities = messages_1.CM.create("textDocument.moniker", "monikerProvider");
      })(MonikerRequest || (exports.MonikerRequest = MonikerRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.typeHierarchy.js
  var require_protocol_typeHierarchy = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.typeHierarchy.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TypeHierarchySubtypesRequest = exports.TypeHierarchySupertypesRequest = exports.TypeHierarchyPrepareRequest = void 0;
      var messages_1 = require_messages2();
      var TypeHierarchyPrepareRequest;
      (function(TypeHierarchyPrepareRequest2) {
        TypeHierarchyPrepareRequest2.method = "textDocument/prepareTypeHierarchy";
        TypeHierarchyPrepareRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TypeHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchyPrepareRequest2.method);
        TypeHierarchyPrepareRequest2.capabilities = messages_1.CM.create("textDocument.typeHierarchy", "typeHierarchyProvider");
      })(TypeHierarchyPrepareRequest || (exports.TypeHierarchyPrepareRequest = TypeHierarchyPrepareRequest = {}));
      var TypeHierarchySupertypesRequest;
      (function(TypeHierarchySupertypesRequest2) {
        TypeHierarchySupertypesRequest2.method = "typeHierarchy/supertypes";
        TypeHierarchySupertypesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TypeHierarchySupertypesRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchySupertypesRequest2.method);
      })(TypeHierarchySupertypesRequest || (exports.TypeHierarchySupertypesRequest = TypeHierarchySupertypesRequest = {}));
      var TypeHierarchySubtypesRequest;
      (function(TypeHierarchySubtypesRequest2) {
        TypeHierarchySubtypesRequest2.method = "typeHierarchy/subtypes";
        TypeHierarchySubtypesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TypeHierarchySubtypesRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchySubtypesRequest2.method);
      })(TypeHierarchySubtypesRequest || (exports.TypeHierarchySubtypesRequest = TypeHierarchySubtypesRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.js
  var require_protocol_inlineValue = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlineValueRefreshRequest = exports.InlineValueRequest = void 0;
      var messages_1 = require_messages2();
      var InlineValueRequest;
      (function(InlineValueRequest2) {
        InlineValueRequest2.method = "textDocument/inlineValue";
        InlineValueRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InlineValueRequest2.type = new messages_1.ProtocolRequestType(InlineValueRequest2.method);
        InlineValueRequest2.capabilities = messages_1.CM.create("textDocument.inlineValue", "inlineValueProvider");
      })(InlineValueRequest || (exports.InlineValueRequest = InlineValueRequest = {}));
      var InlineValueRefreshRequest;
      (function(InlineValueRefreshRequest2) {
        InlineValueRefreshRequest2.method = `workspace/inlineValue/refresh`;
        InlineValueRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        InlineValueRefreshRequest2.type = new messages_1.ProtocolRequestType0(InlineValueRefreshRequest2.method);
        InlineValueRefreshRequest2.capabilities = messages_1.CM.create("workspace.inlineValue.refreshSupport", void 0);
      })(InlineValueRefreshRequest || (exports.InlineValueRefreshRequest = InlineValueRefreshRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.js
  var require_protocol_inlayHint = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlayHintRefreshRequest = exports.InlayHintResolveRequest = exports.InlayHintRequest = void 0;
      var messages_1 = require_messages2();
      var InlayHintRequest;
      (function(InlayHintRequest2) {
        InlayHintRequest2.method = "textDocument/inlayHint";
        InlayHintRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InlayHintRequest2.type = new messages_1.ProtocolRequestType(InlayHintRequest2.method);
        InlayHintRequest2.capabilities = messages_1.CM.create("textDocument.inlayHint", "inlayHintProvider");
      })(InlayHintRequest || (exports.InlayHintRequest = InlayHintRequest = {}));
      var InlayHintResolveRequest;
      (function(InlayHintResolveRequest2) {
        InlayHintResolveRequest2.method = "inlayHint/resolve";
        InlayHintResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InlayHintResolveRequest2.type = new messages_1.ProtocolRequestType(InlayHintResolveRequest2.method);
        InlayHintResolveRequest2.capabilities = messages_1.CM.create("textDocument.inlayHint.resolveSupport", "inlayHintProvider.resolveProvider");
      })(InlayHintResolveRequest || (exports.InlayHintResolveRequest = InlayHintResolveRequest = {}));
      var InlayHintRefreshRequest;
      (function(InlayHintRefreshRequest2) {
        InlayHintRefreshRequest2.method = `workspace/inlayHint/refresh`;
        InlayHintRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        InlayHintRefreshRequest2.type = new messages_1.ProtocolRequestType0(InlayHintRefreshRequest2.method);
        InlayHintRefreshRequest2.capabilities = messages_1.CM.create("workspace.inlayHint.refreshSupport", void 0);
      })(InlayHintRefreshRequest || (exports.InlayHintRefreshRequest = InlayHintRefreshRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.diagnostic.js
  var require_protocol_diagnostic = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.diagnostic.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = void 0;
      var vscode_jsonrpc_1 = require_api();
      var Is3 = __importStar(require_is2());
      var messages_1 = require_messages2();
      var DiagnosticServerCancellationData;
      (function(DiagnosticServerCancellationData2) {
        function is(value) {
          const candidate = value;
          return candidate && Is3.boolean(candidate.retriggerRequest);
        }
        DiagnosticServerCancellationData2.is = is;
      })(DiagnosticServerCancellationData || (exports.DiagnosticServerCancellationData = DiagnosticServerCancellationData = {}));
      var DocumentDiagnosticReportKind;
      (function(DocumentDiagnosticReportKind2) {
        DocumentDiagnosticReportKind2.Full = "full";
        DocumentDiagnosticReportKind2.Unchanged = "unchanged";
      })(DocumentDiagnosticReportKind || (exports.DocumentDiagnosticReportKind = DocumentDiagnosticReportKind = {}));
      var DocumentDiagnosticRequest;
      (function(DocumentDiagnosticRequest2) {
        DocumentDiagnosticRequest2.method = "textDocument/diagnostic";
        DocumentDiagnosticRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentDiagnosticRequest2.type = new messages_1.ProtocolRequestType(DocumentDiagnosticRequest2.method);
        DocumentDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType();
        DocumentDiagnosticRequest2.capabilities = messages_1.CM.create("textDocument.diagnostic", "diagnosticProvider");
      })(DocumentDiagnosticRequest || (exports.DocumentDiagnosticRequest = DocumentDiagnosticRequest = {}));
      var WorkspaceDiagnosticRequest;
      (function(WorkspaceDiagnosticRequest2) {
        WorkspaceDiagnosticRequest2.method = "workspace/diagnostic";
        WorkspaceDiagnosticRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WorkspaceDiagnosticRequest2.type = new messages_1.ProtocolRequestType(WorkspaceDiagnosticRequest2.method);
        WorkspaceDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType();
        WorkspaceDiagnosticRequest2.capabilities = messages_1.CM.create("workspace.diagnostics", "diagnosticProvider.workspaceDiagnostics");
      })(WorkspaceDiagnosticRequest || (exports.WorkspaceDiagnosticRequest = WorkspaceDiagnosticRequest = {}));
      var DiagnosticRefreshRequest;
      (function(DiagnosticRefreshRequest2) {
        DiagnosticRefreshRequest2.method = `workspace/diagnostic/refresh`;
        DiagnosticRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        DiagnosticRefreshRequest2.type = new messages_1.ProtocolRequestType0(DiagnosticRefreshRequest2.method);
        DiagnosticRefreshRequest2.capabilities = messages_1.CM.create("workspace.diagnostics.refreshSupport", void 0);
      })(DiagnosticRefreshRequest || (exports.DiagnosticRefreshRequest = DiagnosticRefreshRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.js
  var require_protocol_notebook = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DidCloseNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification = exports.NotebookCellArrayChange = exports.DidOpenNotebookDocumentNotification = exports.NotebookDocumentSyncRegistrationType = exports.NotebookDocument = exports.NotebookCell = exports.ExecutionSummary = exports.NotebookCellKind = void 0;
      var vscode_languageserver_types_1 = (init_main(), __toCommonJS(main_exports));
      var Is3 = __importStar(require_is2());
      var messages_1 = require_messages2();
      var NotebookCellKind;
      (function(NotebookCellKind2) {
        NotebookCellKind2.Markup = 1;
        NotebookCellKind2.Code = 2;
        function is(value) {
          return value === 1 || value === 2;
        }
        NotebookCellKind2.is = is;
      })(NotebookCellKind || (exports.NotebookCellKind = NotebookCellKind = {}));
      var ExecutionSummary;
      (function(ExecutionSummary2) {
        function create(executionOrder, success) {
          const result = { executionOrder };
          if (success === true || success === false) {
            result.success = success;
          }
          return result;
        }
        ExecutionSummary2.create = create;
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.executionOrder) && (candidate.success === void 0 || Is3.boolean(candidate.success));
        }
        ExecutionSummary2.is = is;
        function equals(one, other) {
          if (one === other) {
            return true;
          }
          if (one === null || one === void 0 || other === null || other === void 0) {
            return false;
          }
          return one.executionOrder === other.executionOrder && one.success === other.success;
        }
        ExecutionSummary2.equals = equals;
      })(ExecutionSummary || (exports.ExecutionSummary = ExecutionSummary = {}));
      var NotebookCell;
      (function(NotebookCell2) {
        function create(kind, document) {
          return { kind, document };
        }
        NotebookCell2.create = create;
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && NotebookCellKind.is(candidate.kind) && vscode_languageserver_types_1.DocumentUri.is(candidate.document) && (candidate.metadata === void 0 || Is3.objectLiteral(candidate.metadata));
        }
        NotebookCell2.is = is;
        function diff(one, two) {
          const result = /* @__PURE__ */ new Set();
          if (one.document !== two.document) {
            result.add("document");
          }
          if (one.kind !== two.kind) {
            result.add("kind");
          }
          if (one.executionSummary !== two.executionSummary) {
            result.add("executionSummary");
          }
          if ((one.metadata !== void 0 || two.metadata !== void 0) && !equalsMetadata(one.metadata, two.metadata)) {
            result.add("metadata");
          }
          if ((one.executionSummary !== void 0 || two.executionSummary !== void 0) && !ExecutionSummary.equals(one.executionSummary, two.executionSummary)) {
            result.add("executionSummary");
          }
          return result;
        }
        NotebookCell2.diff = diff;
        function equalsMetadata(one, other) {
          if (one === other) {
            return true;
          }
          if (one === null || one === void 0 || other === null || other === void 0) {
            return false;
          }
          if (typeof one !== typeof other) {
            return false;
          }
          if (typeof one !== "object") {
            return false;
          }
          const oneArray = Array.isArray(one);
          const otherArray = Array.isArray(other);
          if (oneArray !== otherArray) {
            return false;
          }
          if (oneArray && otherArray) {
            if (one.length !== other.length) {
              return false;
            }
            for (let i = 0; i < one.length; i++) {
              if (!equalsMetadata(one[i], other[i])) {
                return false;
              }
            }
          }
          if (Is3.objectLiteral(one) && Is3.objectLiteral(other)) {
            const oneKeys = Object.keys(one);
            const otherKeys = Object.keys(other);
            if (oneKeys.length !== otherKeys.length) {
              return false;
            }
            oneKeys.sort();
            otherKeys.sort();
            if (!equalsMetadata(oneKeys, otherKeys)) {
              return false;
            }
            for (let i = 0; i < oneKeys.length; i++) {
              const prop = oneKeys[i];
              if (!equalsMetadata(one[prop], other[prop])) {
                return false;
              }
            }
          }
          return true;
        }
      })(NotebookCell || (exports.NotebookCell = NotebookCell = {}));
      var NotebookDocument;
      (function(NotebookDocument2) {
        function create(uri, notebookType, version, cells) {
          return { uri, notebookType, version, cells };
        }
        NotebookDocument2.create = create;
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && Is3.string(candidate.uri) && vscode_languageserver_types_1.integer.is(candidate.version) && Is3.typedArray(candidate.cells, NotebookCell.is);
        }
        NotebookDocument2.is = is;
      })(NotebookDocument || (exports.NotebookDocument = NotebookDocument = {}));
      var NotebookDocumentSyncRegistrationType;
      (function(NotebookDocumentSyncRegistrationType2) {
        NotebookDocumentSyncRegistrationType2.method = "notebookDocument/sync";
        NotebookDocumentSyncRegistrationType2.messageDirection = messages_1.MessageDirection.clientToServer;
        NotebookDocumentSyncRegistrationType2.type = new messages_1.RegistrationType(NotebookDocumentSyncRegistrationType2.method);
      })(NotebookDocumentSyncRegistrationType || (exports.NotebookDocumentSyncRegistrationType = NotebookDocumentSyncRegistrationType = {}));
      var DidOpenNotebookDocumentNotification;
      (function(DidOpenNotebookDocumentNotification2) {
        DidOpenNotebookDocumentNotification2.method = "notebookDocument/didOpen";
        DidOpenNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidOpenNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenNotebookDocumentNotification2.method);
        DidOpenNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
      })(DidOpenNotebookDocumentNotification || (exports.DidOpenNotebookDocumentNotification = DidOpenNotebookDocumentNotification = {}));
      var NotebookCellArrayChange;
      (function(NotebookCellArrayChange2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.start) && vscode_languageserver_types_1.uinteger.is(candidate.deleteCount) && (candidate.cells === void 0 || Is3.typedArray(candidate.cells, NotebookCell.is));
        }
        NotebookCellArrayChange2.is = is;
        function create(start, deleteCount, cells) {
          const result = { start, deleteCount };
          if (cells !== void 0) {
            result.cells = cells;
          }
          return result;
        }
        NotebookCellArrayChange2.create = create;
      })(NotebookCellArrayChange || (exports.NotebookCellArrayChange = NotebookCellArrayChange = {}));
      var DidChangeNotebookDocumentNotification;
      (function(DidChangeNotebookDocumentNotification2) {
        DidChangeNotebookDocumentNotification2.method = "notebookDocument/didChange";
        DidChangeNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidChangeNotebookDocumentNotification2.method);
        DidChangeNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
      })(DidChangeNotebookDocumentNotification || (exports.DidChangeNotebookDocumentNotification = DidChangeNotebookDocumentNotification = {}));
      var DidSaveNotebookDocumentNotification;
      (function(DidSaveNotebookDocumentNotification2) {
        DidSaveNotebookDocumentNotification2.method = "notebookDocument/didSave";
        DidSaveNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidSaveNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidSaveNotebookDocumentNotification2.method);
        DidSaveNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
      })(DidSaveNotebookDocumentNotification || (exports.DidSaveNotebookDocumentNotification = DidSaveNotebookDocumentNotification = {}));
      var DidCloseNotebookDocumentNotification;
      (function(DidCloseNotebookDocumentNotification2) {
        DidCloseNotebookDocumentNotification2.method = "notebookDocument/didClose";
        DidCloseNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidCloseNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidCloseNotebookDocumentNotification2.method);
        DidCloseNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
      })(DidCloseNotebookDocumentNotification || (exports.DidCloseNotebookDocumentNotification = DidCloseNotebookDocumentNotification = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineCompletion.js
  var require_protocol_inlineCompletion = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineCompletion.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlineCompletionRequest = void 0;
      var messages_1 = require_messages2();
      var InlineCompletionRequest;
      (function(InlineCompletionRequest2) {
        InlineCompletionRequest2.method = "textDocument/inlineCompletion";
        InlineCompletionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InlineCompletionRequest2.type = new messages_1.ProtocolRequestType(InlineCompletionRequest2.method);
        InlineCompletionRequest2.capabilities = messages_1.CM.create("textDocument.inlineCompletion", "inlineCompletionProvider");
      })(InlineCompletionRequest || (exports.InlineCompletionRequest = InlineCompletionRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.textDocumentContent.js
  var require_protocol_textDocumentContent = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.textDocumentContent.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TextDocumentContentRefreshRequest = exports.TextDocumentContentRequest = void 0;
      var messages_1 = require_messages2();
      var TextDocumentContentRequest;
      (function(TextDocumentContentRequest2) {
        TextDocumentContentRequest2.method = "workspace/textDocumentContent";
        TextDocumentContentRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TextDocumentContentRequest2.type = new messages_1.ProtocolRequestType(TextDocumentContentRequest2.method);
        TextDocumentContentRequest2.capabilities = messages_1.CM.create("workspace.textDocumentContent", "workspace.textDocumentContent");
      })(TextDocumentContentRequest || (exports.TextDocumentContentRequest = TextDocumentContentRequest = {}));
      var TextDocumentContentRefreshRequest;
      (function(TextDocumentContentRefreshRequest2) {
        TextDocumentContentRefreshRequest2.method = `workspace/textDocumentContent/refresh`;
        TextDocumentContentRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        TextDocumentContentRefreshRequest2.type = new messages_1.ProtocolRequestType(TextDocumentContentRefreshRequest2.method);
      })(TextDocumentContentRefreshRequest || (exports.TextDocumentContentRefreshRequest = TextDocumentContentRefreshRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/protocol.js
  var require_protocol = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/protocol.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CodeActionRequest = exports.DocumentSymbolRequest = exports.DocumentHighlightRequest = exports.ReferencesRequest = exports.DefinitionRequest = exports.SignatureHelpRequest = exports.SignatureHelpTriggerKind = exports.HoverRequest = exports.CompletionResolveRequest = exports.CompletionRequest = exports.CompletionTriggerKind = exports.PublishDiagnosticsNotification = exports.WatchKind = exports.GlobPattern = exports.RelativePattern = exports.FileChangeType = exports.DidChangeWatchedFilesNotification = exports.WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentNotification = exports.TextDocumentSaveReason = exports.DidSaveTextDocumentNotification = exports.DidCloseTextDocumentNotification = exports.DidChangeTextDocumentNotification = exports.TextDocumentContentChangeEvent = exports.DidOpenTextDocumentNotification = exports.TextDocumentSyncKind = exports.TelemetryEventNotification = exports.LogMessageNotification = exports.ShowMessageRequest = exports.ShowMessageNotification = exports.MessageType = exports.DidChangeConfigurationNotification = exports.ExitNotification = exports.ShutdownRequest = exports.InitializedNotification = exports.InitializeErrorCodes = exports.InitializeRequest = exports.WorkDoneProgressOptions = exports.TextDocumentRegistrationOptions = exports.StaticRegistrationOptions = exports.PositionEncodingKind = exports.RegularExpressionEngineKind = exports.FailureHandlingKind = exports.ResourceOperationKind = exports.UnregistrationRequest = exports.RegistrationRequest = exports.DocumentSelector = exports.NotebookCellTextDocumentFilter = exports.NotebookDocumentFilter = exports.TextDocumentFilter = void 0;
      exports.UniquenessLevel = exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.WillRenameFilesRequest = exports.DidRenameFilesNotification = exports.WillCreateFilesRequest = exports.DidCreateFilesNotification = exports.FileOperationPatternKind = exports.LinkedEditingRangeRequest = exports.ShowDocumentRequest = exports.SemanticTokensRegistrationType = exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.TokenFormat = exports.CallHierarchyPrepareRequest = exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = exports.SelectionRangeRequest = exports.DeclarationRequest = exports.FoldingRangeRefreshRequest = exports.FoldingRangeRequest = exports.ColorPresentationRequest = exports.DocumentColorRequest = exports.ConfigurationRequest = exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = exports.TypeDefinitionRequest = exports.ImplementationRequest = exports.ApplyWorkspaceEditRequest = exports.ExecuteCommandRequest = exports.PrepareRenameRequest = exports.RenameRequest = exports.PrepareSupportDefaultBehavior = exports.DocumentOnTypeFormattingRequest = exports.DocumentRangesFormattingRequest = exports.DocumentRangeFormattingRequest = exports.DocumentFormattingRequest = exports.DocumentLinkResolveRequest = exports.DocumentLinkRequest = exports.CodeLensRefreshRequest = exports.CodeLensResolveRequest = exports.CodeLensRequest = exports.WorkspaceSymbolResolveRequest = exports.WorkspaceSymbolRequest = exports.CodeActionResolveRequest = void 0;
      exports.TextDocumentContentRefreshRequest = exports.TextDocumentContentRequest = exports.InlineCompletionRequest = exports.DidCloseNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification = exports.NotebookCellArrayChange = exports.DidOpenNotebookDocumentNotification = exports.NotebookDocumentSyncRegistrationType = exports.NotebookDocument = exports.NotebookCell = exports.ExecutionSummary = exports.NotebookCellKind = exports.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = exports.InlayHintRefreshRequest = exports.InlayHintResolveRequest = exports.InlayHintRequest = exports.InlineValueRefreshRequest = exports.InlineValueRequest = exports.TypeHierarchySupertypesRequest = exports.TypeHierarchySubtypesRequest = exports.TypeHierarchyPrepareRequest = exports.MonikerRequest = exports.MonikerKind = void 0;
      var messages_1 = require_messages2();
      var vscode_languageserver_types_1 = (init_main(), __toCommonJS(main_exports));
      var Is3 = __importStar(require_is2());
      var protocol_implementation_1 = require_protocol_implementation();
      Object.defineProperty(exports, "ImplementationRequest", { enumerable: true, get: function() {
        return protocol_implementation_1.ImplementationRequest;
      } });
      var protocol_typeDefinition_1 = require_protocol_typeDefinition();
      Object.defineProperty(exports, "TypeDefinitionRequest", { enumerable: true, get: function() {
        return protocol_typeDefinition_1.TypeDefinitionRequest;
      } });
      var protocol_workspaceFolder_1 = require_protocol_workspaceFolder();
      Object.defineProperty(exports, "WorkspaceFoldersRequest", { enumerable: true, get: function() {
        return protocol_workspaceFolder_1.WorkspaceFoldersRequest;
      } });
      Object.defineProperty(exports, "DidChangeWorkspaceFoldersNotification", { enumerable: true, get: function() {
        return protocol_workspaceFolder_1.DidChangeWorkspaceFoldersNotification;
      } });
      var protocol_configuration_1 = require_protocol_configuration();
      Object.defineProperty(exports, "ConfigurationRequest", { enumerable: true, get: function() {
        return protocol_configuration_1.ConfigurationRequest;
      } });
      var protocol_colorProvider_1 = require_protocol_colorProvider();
      Object.defineProperty(exports, "DocumentColorRequest", { enumerable: true, get: function() {
        return protocol_colorProvider_1.DocumentColorRequest;
      } });
      Object.defineProperty(exports, "ColorPresentationRequest", { enumerable: true, get: function() {
        return protocol_colorProvider_1.ColorPresentationRequest;
      } });
      var protocol_foldingRange_1 = require_protocol_foldingRange();
      Object.defineProperty(exports, "FoldingRangeRequest", { enumerable: true, get: function() {
        return protocol_foldingRange_1.FoldingRangeRequest;
      } });
      Object.defineProperty(exports, "FoldingRangeRefreshRequest", { enumerable: true, get: function() {
        return protocol_foldingRange_1.FoldingRangeRefreshRequest;
      } });
      var protocol_declaration_1 = require_protocol_declaration();
      Object.defineProperty(exports, "DeclarationRequest", { enumerable: true, get: function() {
        return protocol_declaration_1.DeclarationRequest;
      } });
      var protocol_selectionRange_1 = require_protocol_selectionRange();
      Object.defineProperty(exports, "SelectionRangeRequest", { enumerable: true, get: function() {
        return protocol_selectionRange_1.SelectionRangeRequest;
      } });
      var protocol_progress_1 = require_protocol_progress();
      Object.defineProperty(exports, "WorkDoneProgress", { enumerable: true, get: function() {
        return protocol_progress_1.WorkDoneProgress;
      } });
      Object.defineProperty(exports, "WorkDoneProgressCreateRequest", { enumerable: true, get: function() {
        return protocol_progress_1.WorkDoneProgressCreateRequest;
      } });
      Object.defineProperty(exports, "WorkDoneProgressCancelNotification", { enumerable: true, get: function() {
        return protocol_progress_1.WorkDoneProgressCancelNotification;
      } });
      var protocol_callHierarchy_1 = require_protocol_callHierarchy();
      Object.defineProperty(exports, "CallHierarchyIncomingCallsRequest", { enumerable: true, get: function() {
        return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest;
      } });
      Object.defineProperty(exports, "CallHierarchyOutgoingCallsRequest", { enumerable: true, get: function() {
        return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest;
      } });
      Object.defineProperty(exports, "CallHierarchyPrepareRequest", { enumerable: true, get: function() {
        return protocol_callHierarchy_1.CallHierarchyPrepareRequest;
      } });
      var protocol_semanticTokens_1 = require_protocol_semanticTokens();
      Object.defineProperty(exports, "TokenFormat", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.TokenFormat;
      } });
      Object.defineProperty(exports, "SemanticTokensRequest", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensRequest;
      } });
      Object.defineProperty(exports, "SemanticTokensDeltaRequest", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensDeltaRequest;
      } });
      Object.defineProperty(exports, "SemanticTokensRangeRequest", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensRangeRequest;
      } });
      Object.defineProperty(exports, "SemanticTokensRefreshRequest", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensRefreshRequest;
      } });
      Object.defineProperty(exports, "SemanticTokensRegistrationType", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensRegistrationType;
      } });
      var protocol_showDocument_1 = require_protocol_showDocument();
      Object.defineProperty(exports, "ShowDocumentRequest", { enumerable: true, get: function() {
        return protocol_showDocument_1.ShowDocumentRequest;
      } });
      var protocol_linkedEditingRange_1 = require_protocol_linkedEditingRange();
      Object.defineProperty(exports, "LinkedEditingRangeRequest", { enumerable: true, get: function() {
        return protocol_linkedEditingRange_1.LinkedEditingRangeRequest;
      } });
      var protocol_fileOperations_1 = require_protocol_fileOperations();
      Object.defineProperty(exports, "FileOperationPatternKind", { enumerable: true, get: function() {
        return protocol_fileOperations_1.FileOperationPatternKind;
      } });
      Object.defineProperty(exports, "DidCreateFilesNotification", { enumerable: true, get: function() {
        return protocol_fileOperations_1.DidCreateFilesNotification;
      } });
      Object.defineProperty(exports, "WillCreateFilesRequest", { enumerable: true, get: function() {
        return protocol_fileOperations_1.WillCreateFilesRequest;
      } });
      Object.defineProperty(exports, "DidRenameFilesNotification", { enumerable: true, get: function() {
        return protocol_fileOperations_1.DidRenameFilesNotification;
      } });
      Object.defineProperty(exports, "WillRenameFilesRequest", { enumerable: true, get: function() {
        return protocol_fileOperations_1.WillRenameFilesRequest;
      } });
      Object.defineProperty(exports, "DidDeleteFilesNotification", { enumerable: true, get: function() {
        return protocol_fileOperations_1.DidDeleteFilesNotification;
      } });
      Object.defineProperty(exports, "WillDeleteFilesRequest", { enumerable: true, get: function() {
        return protocol_fileOperations_1.WillDeleteFilesRequest;
      } });
      var protocol_moniker_1 = require_protocol_moniker();
      Object.defineProperty(exports, "UniquenessLevel", { enumerable: true, get: function() {
        return protocol_moniker_1.UniquenessLevel;
      } });
      Object.defineProperty(exports, "MonikerKind", { enumerable: true, get: function() {
        return protocol_moniker_1.MonikerKind;
      } });
      Object.defineProperty(exports, "MonikerRequest", { enumerable: true, get: function() {
        return protocol_moniker_1.MonikerRequest;
      } });
      var protocol_typeHierarchy_1 = require_protocol_typeHierarchy();
      Object.defineProperty(exports, "TypeHierarchyPrepareRequest", { enumerable: true, get: function() {
        return protocol_typeHierarchy_1.TypeHierarchyPrepareRequest;
      } });
      Object.defineProperty(exports, "TypeHierarchySubtypesRequest", { enumerable: true, get: function() {
        return protocol_typeHierarchy_1.TypeHierarchySubtypesRequest;
      } });
      Object.defineProperty(exports, "TypeHierarchySupertypesRequest", { enumerable: true, get: function() {
        return protocol_typeHierarchy_1.TypeHierarchySupertypesRequest;
      } });
      var protocol_inlineValue_1 = require_protocol_inlineValue();
      Object.defineProperty(exports, "InlineValueRequest", { enumerable: true, get: function() {
        return protocol_inlineValue_1.InlineValueRequest;
      } });
      Object.defineProperty(exports, "InlineValueRefreshRequest", { enumerable: true, get: function() {
        return protocol_inlineValue_1.InlineValueRefreshRequest;
      } });
      var protocol_inlayHint_1 = require_protocol_inlayHint();
      Object.defineProperty(exports, "InlayHintRequest", { enumerable: true, get: function() {
        return protocol_inlayHint_1.InlayHintRequest;
      } });
      Object.defineProperty(exports, "InlayHintResolveRequest", { enumerable: true, get: function() {
        return protocol_inlayHint_1.InlayHintResolveRequest;
      } });
      Object.defineProperty(exports, "InlayHintRefreshRequest", { enumerable: true, get: function() {
        return protocol_inlayHint_1.InlayHintRefreshRequest;
      } });
      var protocol_diagnostic_1 = require_protocol_diagnostic();
      Object.defineProperty(exports, "DiagnosticServerCancellationData", { enumerable: true, get: function() {
        return protocol_diagnostic_1.DiagnosticServerCancellationData;
      } });
      Object.defineProperty(exports, "DocumentDiagnosticReportKind", { enumerable: true, get: function() {
        return protocol_diagnostic_1.DocumentDiagnosticReportKind;
      } });
      Object.defineProperty(exports, "DocumentDiagnosticRequest", { enumerable: true, get: function() {
        return protocol_diagnostic_1.DocumentDiagnosticRequest;
      } });
      Object.defineProperty(exports, "WorkspaceDiagnosticRequest", { enumerable: true, get: function() {
        return protocol_diagnostic_1.WorkspaceDiagnosticRequest;
      } });
      Object.defineProperty(exports, "DiagnosticRefreshRequest", { enumerable: true, get: function() {
        return protocol_diagnostic_1.DiagnosticRefreshRequest;
      } });
      var protocol_notebook_1 = require_protocol_notebook();
      Object.defineProperty(exports, "NotebookCellKind", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookCellKind;
      } });
      Object.defineProperty(exports, "ExecutionSummary", { enumerable: true, get: function() {
        return protocol_notebook_1.ExecutionSummary;
      } });
      Object.defineProperty(exports, "NotebookCell", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookCell;
      } });
      Object.defineProperty(exports, "NotebookDocument", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookDocument;
      } });
      Object.defineProperty(exports, "NotebookDocumentSyncRegistrationType", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookDocumentSyncRegistrationType;
      } });
      Object.defineProperty(exports, "DidOpenNotebookDocumentNotification", { enumerable: true, get: function() {
        return protocol_notebook_1.DidOpenNotebookDocumentNotification;
      } });
      Object.defineProperty(exports, "NotebookCellArrayChange", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookCellArrayChange;
      } });
      Object.defineProperty(exports, "DidChangeNotebookDocumentNotification", { enumerable: true, get: function() {
        return protocol_notebook_1.DidChangeNotebookDocumentNotification;
      } });
      Object.defineProperty(exports, "DidSaveNotebookDocumentNotification", { enumerable: true, get: function() {
        return protocol_notebook_1.DidSaveNotebookDocumentNotification;
      } });
      Object.defineProperty(exports, "DidCloseNotebookDocumentNotification", { enumerable: true, get: function() {
        return protocol_notebook_1.DidCloseNotebookDocumentNotification;
      } });
      var protocol_inlineCompletion_1 = require_protocol_inlineCompletion();
      Object.defineProperty(exports, "InlineCompletionRequest", { enumerable: true, get: function() {
        return protocol_inlineCompletion_1.InlineCompletionRequest;
      } });
      var protocol_textDocumentContent_1 = require_protocol_textDocumentContent();
      Object.defineProperty(exports, "TextDocumentContentRequest", { enumerable: true, get: function() {
        return protocol_textDocumentContent_1.TextDocumentContentRequest;
      } });
      Object.defineProperty(exports, "TextDocumentContentRefreshRequest", { enumerable: true, get: function() {
        return protocol_textDocumentContent_1.TextDocumentContentRefreshRequest;
      } });
      var TextDocumentFilter;
      (function(TextDocumentFilter2) {
        function is(value) {
          const candidate = value;
          return Is3.string(candidate) || (Is3.string(candidate.language) || Is3.string(candidate.scheme) || GlobPattern.is(candidate.pattern));
        }
        TextDocumentFilter2.is = is;
      })(TextDocumentFilter || (exports.TextDocumentFilter = TextDocumentFilter = {}));
      var NotebookDocumentFilter;
      (function(NotebookDocumentFilter2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && (Is3.string(candidate.notebookType) || Is3.string(candidate.scheme) || Is3.string(candidate.pattern));
        }
        NotebookDocumentFilter2.is = is;
      })(NotebookDocumentFilter || (exports.NotebookDocumentFilter = NotebookDocumentFilter = {}));
      var NotebookCellTextDocumentFilter;
      (function(NotebookCellTextDocumentFilter2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && (Is3.string(candidate.notebook) || NotebookDocumentFilter.is(candidate.notebook)) && (candidate.language === void 0 || Is3.string(candidate.language));
        }
        NotebookCellTextDocumentFilter2.is = is;
      })(NotebookCellTextDocumentFilter || (exports.NotebookCellTextDocumentFilter = NotebookCellTextDocumentFilter = {}));
      var DocumentSelector;
      (function(DocumentSelector2) {
        function is(value) {
          if (!Array.isArray(value)) {
            return false;
          }
          for (const elem of value) {
            if (!Is3.string(elem) && !TextDocumentFilter.is(elem) && !NotebookCellTextDocumentFilter.is(elem)) {
              return false;
            }
          }
          return true;
        }
        DocumentSelector2.is = is;
      })(DocumentSelector || (exports.DocumentSelector = DocumentSelector = {}));
      var RegistrationRequest;
      (function(RegistrationRequest2) {
        RegistrationRequest2.method = "client/registerCapability";
        RegistrationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        RegistrationRequest2.type = new messages_1.ProtocolRequestType(RegistrationRequest2.method);
      })(RegistrationRequest || (exports.RegistrationRequest = RegistrationRequest = {}));
      var UnregistrationRequest;
      (function(UnregistrationRequest2) {
        UnregistrationRequest2.method = "client/unregisterCapability";
        UnregistrationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        UnregistrationRequest2.type = new messages_1.ProtocolRequestType(UnregistrationRequest2.method);
      })(UnregistrationRequest || (exports.UnregistrationRequest = UnregistrationRequest = {}));
      var ResourceOperationKind;
      (function(ResourceOperationKind2) {
        ResourceOperationKind2.Create = "create";
        ResourceOperationKind2.Rename = "rename";
        ResourceOperationKind2.Delete = "delete";
      })(ResourceOperationKind || (exports.ResourceOperationKind = ResourceOperationKind = {}));
      var FailureHandlingKind;
      (function(FailureHandlingKind2) {
        FailureHandlingKind2.Abort = "abort";
        FailureHandlingKind2.Transactional = "transactional";
        FailureHandlingKind2.TextOnlyTransactional = "textOnlyTransactional";
        FailureHandlingKind2.Undo = "undo";
      })(FailureHandlingKind || (exports.FailureHandlingKind = FailureHandlingKind = {}));
      var RegularExpressionEngineKind;
      (function(RegularExpressionEngineKind2) {
        RegularExpressionEngineKind2.ES2020 = "ES2020";
      })(RegularExpressionEngineKind || (exports.RegularExpressionEngineKind = RegularExpressionEngineKind = {}));
      var PositionEncodingKind;
      (function(PositionEncodingKind2) {
        PositionEncodingKind2.UTF8 = "utf-8";
        PositionEncodingKind2.UTF16 = "utf-16";
        PositionEncodingKind2.UTF32 = "utf-32";
      })(PositionEncodingKind || (exports.PositionEncodingKind = PositionEncodingKind = {}));
      var StaticRegistrationOptions;
      (function(StaticRegistrationOptions2) {
        function hasId(value) {
          const candidate = value;
          return candidate && Is3.string(candidate.id) && candidate.id.length > 0;
        }
        StaticRegistrationOptions2.hasId = hasId;
      })(StaticRegistrationOptions || (exports.StaticRegistrationOptions = StaticRegistrationOptions = {}));
      var TextDocumentRegistrationOptions;
      (function(TextDocumentRegistrationOptions2) {
        function is(value) {
          const candidate = value;
          return candidate && (candidate.documentSelector === null || DocumentSelector.is(candidate.documentSelector));
        }
        TextDocumentRegistrationOptions2.is = is;
      })(TextDocumentRegistrationOptions || (exports.TextDocumentRegistrationOptions = TextDocumentRegistrationOptions = {}));
      var WorkDoneProgressOptions;
      (function(WorkDoneProgressOptions2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && (candidate.workDoneProgress === void 0 || Is3.boolean(candidate.workDoneProgress));
        }
        WorkDoneProgressOptions2.is = is;
        function hasWorkDoneProgress(value) {
          const candidate = value;
          return candidate && Is3.boolean(candidate.workDoneProgress);
        }
        WorkDoneProgressOptions2.hasWorkDoneProgress = hasWorkDoneProgress;
      })(WorkDoneProgressOptions || (exports.WorkDoneProgressOptions = WorkDoneProgressOptions = {}));
      var InitializeRequest;
      (function(InitializeRequest2) {
        InitializeRequest2.method = "initialize";
        InitializeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InitializeRequest2.type = new messages_1.ProtocolRequestType(InitializeRequest2.method);
      })(InitializeRequest || (exports.InitializeRequest = InitializeRequest = {}));
      var InitializeErrorCodes;
      (function(InitializeErrorCodes2) {
        InitializeErrorCodes2.unknownProtocolVersion = 1;
      })(InitializeErrorCodes || (exports.InitializeErrorCodes = InitializeErrorCodes = {}));
      var InitializedNotification;
      (function(InitializedNotification2) {
        InitializedNotification2.method = "initialized";
        InitializedNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        InitializedNotification2.type = new messages_1.ProtocolNotificationType(InitializedNotification2.method);
      })(InitializedNotification || (exports.InitializedNotification = InitializedNotification = {}));
      var ShutdownRequest;
      (function(ShutdownRequest2) {
        ShutdownRequest2.method = "shutdown";
        ShutdownRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ShutdownRequest2.type = new messages_1.ProtocolRequestType0(ShutdownRequest2.method);
      })(ShutdownRequest || (exports.ShutdownRequest = ShutdownRequest = {}));
      var ExitNotification;
      (function(ExitNotification2) {
        ExitNotification2.method = "exit";
        ExitNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        ExitNotification2.type = new messages_1.ProtocolNotificationType0(ExitNotification2.method);
      })(ExitNotification || (exports.ExitNotification = ExitNotification = {}));
      var DidChangeConfigurationNotification2;
      (function(DidChangeConfigurationNotification3) {
        DidChangeConfigurationNotification3.method = "workspace/didChangeConfiguration";
        DidChangeConfigurationNotification3.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeConfigurationNotification3.type = new messages_1.ProtocolNotificationType(DidChangeConfigurationNotification3.method);
        DidChangeConfigurationNotification3.capabilities = messages_1.CM.create("workspace.didChangeConfiguration", void 0);
      })(DidChangeConfigurationNotification2 || (exports.DidChangeConfigurationNotification = DidChangeConfigurationNotification2 = {}));
      var MessageType;
      (function(MessageType2) {
        MessageType2.Error = 1;
        MessageType2.Warning = 2;
        MessageType2.Info = 3;
        MessageType2.Log = 4;
        MessageType2.Debug = 5;
      })(MessageType || (exports.MessageType = MessageType = {}));
      var ShowMessageNotification;
      (function(ShowMessageNotification2) {
        ShowMessageNotification2.method = "window/showMessage";
        ShowMessageNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
        ShowMessageNotification2.type = new messages_1.ProtocolNotificationType(ShowMessageNotification2.method);
        ShowMessageNotification2.capabilities = messages_1.CM.create("window.showMessage", void 0);
      })(ShowMessageNotification || (exports.ShowMessageNotification = ShowMessageNotification = {}));
      var ShowMessageRequest;
      (function(ShowMessageRequest2) {
        ShowMessageRequest2.method = "window/showMessageRequest";
        ShowMessageRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        ShowMessageRequest2.type = new messages_1.ProtocolRequestType(ShowMessageRequest2.method);
        ShowMessageRequest2.capabilities = messages_1.CM.create("window.showMessage", void 0);
      })(ShowMessageRequest || (exports.ShowMessageRequest = ShowMessageRequest = {}));
      var LogMessageNotification;
      (function(LogMessageNotification2) {
        LogMessageNotification2.method = "window/logMessage";
        LogMessageNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
        LogMessageNotification2.type = new messages_1.ProtocolNotificationType(LogMessageNotification2.method);
      })(LogMessageNotification || (exports.LogMessageNotification = LogMessageNotification = {}));
      var TelemetryEventNotification;
      (function(TelemetryEventNotification2) {
        TelemetryEventNotification2.method = "telemetry/event";
        TelemetryEventNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
        TelemetryEventNotification2.type = new messages_1.ProtocolNotificationType(TelemetryEventNotification2.method);
      })(TelemetryEventNotification || (exports.TelemetryEventNotification = TelemetryEventNotification = {}));
      var TextDocumentSyncKind2;
      (function(TextDocumentSyncKind3) {
        TextDocumentSyncKind3.None = 0;
        TextDocumentSyncKind3.Full = 1;
        TextDocumentSyncKind3.Incremental = 2;
      })(TextDocumentSyncKind2 || (exports.TextDocumentSyncKind = TextDocumentSyncKind2 = {}));
      var DidOpenTextDocumentNotification;
      (function(DidOpenTextDocumentNotification2) {
        DidOpenTextDocumentNotification2.method = "textDocument/didOpen";
        DidOpenTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification2.method);
        DidOpenTextDocumentNotification2.capabilities = messages_1.CM.create("textDocument.synchronization", "textDocumentSync.openClose");
      })(DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = DidOpenTextDocumentNotification = {}));
      var TextDocumentContentChangeEvent;
      (function(TextDocumentContentChangeEvent2) {
        function isIncremental(event) {
          const candidate = event;
          return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
        }
        TextDocumentContentChangeEvent2.isIncremental = isIncremental;
        function isFull(event) {
          const candidate = event;
          return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
        }
        TextDocumentContentChangeEvent2.isFull = isFull;
      })(TextDocumentContentChangeEvent || (exports.TextDocumentContentChangeEvent = TextDocumentContentChangeEvent = {}));
      var DidChangeTextDocumentNotification;
      (function(DidChangeTextDocumentNotification2) {
        DidChangeTextDocumentNotification2.method = "textDocument/didChange";
        DidChangeTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification2.method);
        DidChangeTextDocumentNotification2.capabilities = messages_1.CM.create("textDocument.synchronization", "textDocumentSync");
      })(DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = DidChangeTextDocumentNotification = {}));
      var DidCloseTextDocumentNotification;
      (function(DidCloseTextDocumentNotification2) {
        DidCloseTextDocumentNotification2.method = "textDocument/didClose";
        DidCloseTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidCloseTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification2.method);
        DidCloseTextDocumentNotification2.capabilities = messages_1.CM.create("textDocument.synchronization", "textDocumentSync.openClose");
      })(DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = DidCloseTextDocumentNotification = {}));
      var DidSaveTextDocumentNotification;
      (function(DidSaveTextDocumentNotification2) {
        DidSaveTextDocumentNotification2.method = "textDocument/didSave";
        DidSaveTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification2.method);
        DidSaveTextDocumentNotification2.capabilities = messages_1.CM.create("textDocument.synchronization.didSave", "textDocumentSync.save");
      })(DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = DidSaveTextDocumentNotification = {}));
      var TextDocumentSaveReason;
      (function(TextDocumentSaveReason2) {
        TextDocumentSaveReason2.Manual = 1;
        TextDocumentSaveReason2.AfterDelay = 2;
        TextDocumentSaveReason2.FocusOut = 3;
      })(TextDocumentSaveReason || (exports.TextDocumentSaveReason = TextDocumentSaveReason = {}));
      var WillSaveTextDocumentNotification;
      (function(WillSaveTextDocumentNotification2) {
        WillSaveTextDocumentNotification2.method = "textDocument/willSave";
        WillSaveTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification2.method);
        WillSaveTextDocumentNotification2.capabilities = messages_1.CM.create("textDocument.synchronization.willSave", "textDocumentSync.willSave");
      })(WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = WillSaveTextDocumentNotification = {}));
      var WillSaveTextDocumentWaitUntilRequest;
      (function(WillSaveTextDocumentWaitUntilRequest2) {
        WillSaveTextDocumentWaitUntilRequest2.method = "textDocument/willSaveWaitUntil";
        WillSaveTextDocumentWaitUntilRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillSaveTextDocumentWaitUntilRequest2.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest2.method);
        WillSaveTextDocumentWaitUntilRequest2.capabilities = messages_1.CM.create("textDocument.synchronization.willSaveWaitUntil", "textDocumentSync.willSaveWaitUntil");
      })(WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = WillSaveTextDocumentWaitUntilRequest = {}));
      var DidChangeWatchedFilesNotification;
      (function(DidChangeWatchedFilesNotification2) {
        DidChangeWatchedFilesNotification2.method = "workspace/didChangeWatchedFiles";
        DidChangeWatchedFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeWatchedFilesNotification2.type = new messages_1.ProtocolNotificationType(DidChangeWatchedFilesNotification2.method);
        DidChangeWatchedFilesNotification2.capabilities = messages_1.CM.create("workspace.didChangeWatchedFiles", void 0);
      })(DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = DidChangeWatchedFilesNotification = {}));
      var FileChangeType;
      (function(FileChangeType2) {
        FileChangeType2.Created = 1;
        FileChangeType2.Changed = 2;
        FileChangeType2.Deleted = 3;
      })(FileChangeType || (exports.FileChangeType = FileChangeType = {}));
      var RelativePattern;
      (function(RelativePattern2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && (vscode_languageserver_types_1.URI.is(candidate.baseUri) || vscode_languageserver_types_1.WorkspaceFolder.is(candidate.baseUri)) && Is3.string(candidate.pattern);
        }
        RelativePattern2.is = is;
      })(RelativePattern || (exports.RelativePattern = RelativePattern = {}));
      var GlobPattern;
      (function(GlobPattern2) {
        function is(value) {
          const candidate = value;
          return Is3.string(candidate) || RelativePattern.is(candidate);
        }
        GlobPattern2.is = is;
      })(GlobPattern || (exports.GlobPattern = GlobPattern = {}));
      var WatchKind;
      (function(WatchKind2) {
        WatchKind2.Create = 1;
        WatchKind2.Change = 2;
        WatchKind2.Delete = 4;
      })(WatchKind || (exports.WatchKind = WatchKind = {}));
      var PublishDiagnosticsNotification;
      (function(PublishDiagnosticsNotification2) {
        PublishDiagnosticsNotification2.method = "textDocument/publishDiagnostics";
        PublishDiagnosticsNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
        PublishDiagnosticsNotification2.type = new messages_1.ProtocolNotificationType(PublishDiagnosticsNotification2.method);
        PublishDiagnosticsNotification2.capabilities = messages_1.CM.create("textDocument.publishDiagnostics", void 0);
      })(PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = PublishDiagnosticsNotification = {}));
      var CompletionTriggerKind;
      (function(CompletionTriggerKind2) {
        CompletionTriggerKind2.Invoked = 1;
        CompletionTriggerKind2.TriggerCharacter = 2;
        CompletionTriggerKind2.TriggerForIncompleteCompletions = 3;
      })(CompletionTriggerKind || (exports.CompletionTriggerKind = CompletionTriggerKind = {}));
      var CompletionRequest;
      (function(CompletionRequest2) {
        CompletionRequest2.method = "textDocument/completion";
        CompletionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CompletionRequest2.type = new messages_1.ProtocolRequestType(CompletionRequest2.method);
        CompletionRequest2.capabilities = messages_1.CM.create("textDocument.completion", "completionProvider");
      })(CompletionRequest || (exports.CompletionRequest = CompletionRequest = {}));
      var CompletionResolveRequest;
      (function(CompletionResolveRequest2) {
        CompletionResolveRequest2.method = "completionItem/resolve";
        CompletionResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CompletionResolveRequest2.type = new messages_1.ProtocolRequestType(CompletionResolveRequest2.method);
        CompletionResolveRequest2.capabilities = messages_1.CM.create("textDocument.completion.completionItem.resolveSupport", "completionProvider.resolveProvider");
      })(CompletionResolveRequest || (exports.CompletionResolveRequest = CompletionResolveRequest = {}));
      var HoverRequest;
      (function(HoverRequest2) {
        HoverRequest2.method = "textDocument/hover";
        HoverRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        HoverRequest2.type = new messages_1.ProtocolRequestType(HoverRequest2.method);
        HoverRequest2.capabilities = messages_1.CM.create("textDocument.hover", "hoverProvider");
      })(HoverRequest || (exports.HoverRequest = HoverRequest = {}));
      var SignatureHelpTriggerKind;
      (function(SignatureHelpTriggerKind2) {
        SignatureHelpTriggerKind2.Invoked = 1;
        SignatureHelpTriggerKind2.TriggerCharacter = 2;
        SignatureHelpTriggerKind2.ContentChange = 3;
      })(SignatureHelpTriggerKind || (exports.SignatureHelpTriggerKind = SignatureHelpTriggerKind = {}));
      var SignatureHelpRequest;
      (function(SignatureHelpRequest2) {
        SignatureHelpRequest2.method = "textDocument/signatureHelp";
        SignatureHelpRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SignatureHelpRequest2.type = new messages_1.ProtocolRequestType(SignatureHelpRequest2.method);
        SignatureHelpRequest2.capabilities = messages_1.CM.create("textDocument.signatureHelp", "signatureHelpProvider");
      })(SignatureHelpRequest || (exports.SignatureHelpRequest = SignatureHelpRequest = {}));
      var DefinitionRequest;
      (function(DefinitionRequest2) {
        DefinitionRequest2.method = "textDocument/definition";
        DefinitionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DefinitionRequest2.type = new messages_1.ProtocolRequestType(DefinitionRequest2.method);
        DefinitionRequest2.capabilities = messages_1.CM.create("textDocument.definition", "definitionProvider");
      })(DefinitionRequest || (exports.DefinitionRequest = DefinitionRequest = {}));
      var ReferencesRequest;
      (function(ReferencesRequest2) {
        ReferencesRequest2.method = "textDocument/references";
        ReferencesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ReferencesRequest2.type = new messages_1.ProtocolRequestType(ReferencesRequest2.method);
        ReferencesRequest2.capabilities = messages_1.CM.create("textDocument.references", "referencesProvider");
      })(ReferencesRequest || (exports.ReferencesRequest = ReferencesRequest = {}));
      var DocumentHighlightRequest;
      (function(DocumentHighlightRequest2) {
        DocumentHighlightRequest2.method = "textDocument/documentHighlight";
        DocumentHighlightRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentHighlightRequest2.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest2.method);
        DocumentHighlightRequest2.capabilities = messages_1.CM.create("textDocument.documentHighlight", "documentHighlightProvider");
      })(DocumentHighlightRequest || (exports.DocumentHighlightRequest = DocumentHighlightRequest = {}));
      var DocumentSymbolRequest;
      (function(DocumentSymbolRequest2) {
        DocumentSymbolRequest2.method = "textDocument/documentSymbol";
        DocumentSymbolRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentSymbolRequest2.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest2.method);
        DocumentSymbolRequest2.capabilities = messages_1.CM.create("textDocument.documentSymbol", "documentSymbolProvider");
      })(DocumentSymbolRequest || (exports.DocumentSymbolRequest = DocumentSymbolRequest = {}));
      var CodeActionRequest;
      (function(CodeActionRequest2) {
        CodeActionRequest2.method = "textDocument/codeAction";
        CodeActionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CodeActionRequest2.type = new messages_1.ProtocolRequestType(CodeActionRequest2.method);
        CodeActionRequest2.capabilities = messages_1.CM.create("textDocument.codeAction", "codeActionProvider");
      })(CodeActionRequest || (exports.CodeActionRequest = CodeActionRequest = {}));
      var CodeActionResolveRequest;
      (function(CodeActionResolveRequest2) {
        CodeActionResolveRequest2.method = "codeAction/resolve";
        CodeActionResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CodeActionResolveRequest2.type = new messages_1.ProtocolRequestType(CodeActionResolveRequest2.method);
        CodeActionResolveRequest2.capabilities = messages_1.CM.create("textDocument.codeAction.resolveSupport", "codeActionProvider.resolveProvider");
      })(CodeActionResolveRequest || (exports.CodeActionResolveRequest = CodeActionResolveRequest = {}));
      var WorkspaceSymbolRequest;
      (function(WorkspaceSymbolRequest2) {
        WorkspaceSymbolRequest2.method = "workspace/symbol";
        WorkspaceSymbolRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WorkspaceSymbolRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest2.method);
        WorkspaceSymbolRequest2.capabilities = messages_1.CM.create("workspace.symbol", "workspaceSymbolProvider");
      })(WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = WorkspaceSymbolRequest = {}));
      var WorkspaceSymbolResolveRequest;
      (function(WorkspaceSymbolResolveRequest2) {
        WorkspaceSymbolResolveRequest2.method = "workspaceSymbol/resolve";
        WorkspaceSymbolResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WorkspaceSymbolResolveRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolResolveRequest2.method);
        WorkspaceSymbolResolveRequest2.capabilities = messages_1.CM.create("workspace.symbol.resolveSupport", "workspaceSymbolProvider.resolveProvider");
      })(WorkspaceSymbolResolveRequest || (exports.WorkspaceSymbolResolveRequest = WorkspaceSymbolResolveRequest = {}));
      var CodeLensRequest;
      (function(CodeLensRequest2) {
        CodeLensRequest2.method = "textDocument/codeLens";
        CodeLensRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CodeLensRequest2.type = new messages_1.ProtocolRequestType(CodeLensRequest2.method);
        CodeLensRequest2.capabilities = messages_1.CM.create("textDocument.codeLens", "codeLensProvider");
      })(CodeLensRequest || (exports.CodeLensRequest = CodeLensRequest = {}));
      var CodeLensResolveRequest;
      (function(CodeLensResolveRequest2) {
        CodeLensResolveRequest2.method = "codeLens/resolve";
        CodeLensResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType(CodeLensResolveRequest2.method);
        CodeLensResolveRequest2.capabilities = messages_1.CM.create("textDocument.codeLens.resolveSupport", "codeLensProvider.resolveProvider");
      })(CodeLensResolveRequest || (exports.CodeLensResolveRequest = CodeLensResolveRequest = {}));
      var CodeLensRefreshRequest;
      (function(CodeLensRefreshRequest2) {
        CodeLensRefreshRequest2.method = `workspace/codeLens/refresh`;
        CodeLensRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        CodeLensRefreshRequest2.type = new messages_1.ProtocolRequestType0(CodeLensRefreshRequest2.method);
        CodeLensRefreshRequest2.capabilities = messages_1.CM.create("workspace.codeLens", void 0);
      })(CodeLensRefreshRequest || (exports.CodeLensRefreshRequest = CodeLensRefreshRequest = {}));
      var DocumentLinkRequest;
      (function(DocumentLinkRequest2) {
        DocumentLinkRequest2.method = "textDocument/documentLink";
        DocumentLinkRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentLinkRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkRequest2.method);
        DocumentLinkRequest2.capabilities = messages_1.CM.create("textDocument.documentLink", "documentLinkProvider");
      })(DocumentLinkRequest || (exports.DocumentLinkRequest = DocumentLinkRequest = {}));
      var DocumentLinkResolveRequest;
      (function(DocumentLinkResolveRequest2) {
        DocumentLinkResolveRequest2.method = "documentLink/resolve";
        DocumentLinkResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkResolveRequest2.method);
        DocumentLinkResolveRequest2.capabilities = messages_1.CM.create("textDocument.documentLink", "documentLinkProvider.resolveProvider");
      })(DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = DocumentLinkResolveRequest = {}));
      var DocumentFormattingRequest;
      (function(DocumentFormattingRequest2) {
        DocumentFormattingRequest2.method = "textDocument/formatting";
        DocumentFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest2.method);
        DocumentFormattingRequest2.capabilities = messages_1.CM.create("textDocument.formatting", "documentFormattingProvider");
      })(DocumentFormattingRequest || (exports.DocumentFormattingRequest = DocumentFormattingRequest = {}));
      var DocumentRangeFormattingRequest;
      (function(DocumentRangeFormattingRequest2) {
        DocumentRangeFormattingRequest2.method = "textDocument/rangeFormatting";
        DocumentRangeFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentRangeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest2.method);
        DocumentRangeFormattingRequest2.capabilities = messages_1.CM.create("textDocument.rangeFormatting", "documentRangeFormattingProvider");
      })(DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = DocumentRangeFormattingRequest = {}));
      var DocumentRangesFormattingRequest;
      (function(DocumentRangesFormattingRequest2) {
        DocumentRangesFormattingRequest2.method = "textDocument/rangesFormatting";
        DocumentRangesFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentRangesFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentRangesFormattingRequest2.method);
        DocumentRangesFormattingRequest2.capabilities = messages_1.CM.create("textDocument.rangeFormatting.rangesSupport", "documentRangeFormattingProvider.rangesSupport");
      })(DocumentRangesFormattingRequest || (exports.DocumentRangesFormattingRequest = DocumentRangesFormattingRequest = {}));
      var DocumentOnTypeFormattingRequest;
      (function(DocumentOnTypeFormattingRequest2) {
        DocumentOnTypeFormattingRequest2.method = "textDocument/onTypeFormatting";
        DocumentOnTypeFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest2.method);
        DocumentOnTypeFormattingRequest2.capabilities = messages_1.CM.create("textDocument.onTypeFormatting", "documentOnTypeFormattingProvider");
      })(DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = DocumentOnTypeFormattingRequest = {}));
      var PrepareSupportDefaultBehavior;
      (function(PrepareSupportDefaultBehavior2) {
        PrepareSupportDefaultBehavior2.Identifier = 1;
      })(PrepareSupportDefaultBehavior || (exports.PrepareSupportDefaultBehavior = PrepareSupportDefaultBehavior = {}));
      var RenameRequest;
      (function(RenameRequest2) {
        RenameRequest2.method = "textDocument/rename";
        RenameRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        RenameRequest2.type = new messages_1.ProtocolRequestType(RenameRequest2.method);
        RenameRequest2.capabilities = messages_1.CM.create("textDocument.rename", "renameProvider");
      })(RenameRequest || (exports.RenameRequest = RenameRequest = {}));
      var PrepareRenameRequest;
      (function(PrepareRenameRequest2) {
        PrepareRenameRequest2.method = "textDocument/prepareRename";
        PrepareRenameRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        PrepareRenameRequest2.type = new messages_1.ProtocolRequestType(PrepareRenameRequest2.method);
        PrepareRenameRequest2.capabilities = messages_1.CM.create("textDocument.rename.prepareSupport", "renameProvider.prepareProvider");
      })(PrepareRenameRequest || (exports.PrepareRenameRequest = PrepareRenameRequest = {}));
      var ExecuteCommandRequest;
      (function(ExecuteCommandRequest2) {
        ExecuteCommandRequest2.method = "workspace/executeCommand";
        ExecuteCommandRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ExecuteCommandRequest2.type = new messages_1.ProtocolRequestType(ExecuteCommandRequest2.method);
        ExecuteCommandRequest2.capabilities = messages_1.CM.create("workspace.executeCommand", "executeCommandProvider");
      })(ExecuteCommandRequest || (exports.ExecuteCommandRequest = ExecuteCommandRequest = {}));
      var ApplyWorkspaceEditRequest;
      (function(ApplyWorkspaceEditRequest2) {
        ApplyWorkspaceEditRequest2.method = "workspace/applyEdit";
        ApplyWorkspaceEditRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        ApplyWorkspaceEditRequest2.type = new messages_1.ProtocolRequestType("workspace/applyEdit");
        ApplyWorkspaceEditRequest2.capabilities = messages_1.CM.create("workspace.applyEdit", void 0);
      })(ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = ApplyWorkspaceEditRequest = {}));
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/connection.js
  var require_connection2 = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/connection.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createProtocolConnection = createProtocolConnection;
      var vscode_jsonrpc_1 = require_api();
      function createProtocolConnection(input, output, logger, options) {
        if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
          options = { connectionStrategy: options };
        }
        return (0, vscode_jsonrpc_1.createMessageConnection)(input, output, logger, options);
      }
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/common/api.js
  var require_api2 = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/common/api.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LSPErrorCodes = exports.createProtocolConnection = void 0;
      __exportStar(require_api(), exports);
      __exportStar((init_main(), __toCommonJS(main_exports)), exports);
      __exportStar(require_messages2(), exports);
      __exportStar(require_protocol(), exports);
      var connection_1 = require_connection2();
      Object.defineProperty(exports, "createProtocolConnection", { enumerable: true, get: function() {
        return connection_1.createProtocolConnection;
      } });
      var LSPErrorCodes;
      (function(LSPErrorCodes2) {
        LSPErrorCodes2.lspReservedErrorRangeStart = -32899;
        LSPErrorCodes2.RequestFailed = -32803;
        LSPErrorCodes2.ServerCancelled = -32802;
        LSPErrorCodes2.ContentModified = -32801;
        LSPErrorCodes2.RequestCancelled = -32800;
        LSPErrorCodes2.lspReservedErrorRangeEnd = -32800;
      })(LSPErrorCodes || (exports.LSPErrorCodes = LSPErrorCodes = {}));
    }
  });

  // node_modules/vscode-languageserver/lib/common/semanticTokens.js
  var require_semanticTokens = __commonJS({
    "node_modules/vscode-languageserver/lib/common/semanticTokens.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SemanticTokensBuilder = exports.SemanticTokensDiff = exports.SemanticTokensFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var SemanticTokensFeature = (Base) => {
        return class extends Base {
          get semanticTokens() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRefreshRequest.type);
              },
              on: (handler) => {
                const type = vscode_languageserver_protocol_1.SemanticTokensRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              },
              onDelta: (handler) => {
                const type = vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              },
              onRange: (handler) => {
                const type = vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.SemanticTokensFeature = SemanticTokensFeature;
      var SemanticTokensDiff = class {
        originalSequence;
        modifiedSequence;
        constructor(originalSequence, modifiedSequence) {
          this.originalSequence = originalSequence;
          this.modifiedSequence = modifiedSequence;
        }
        computeDiff() {
          const originalLength = this.originalSequence.length;
          const modifiedLength = this.modifiedSequence.length;
          let startIndex = 0;
          while (startIndex < modifiedLength && startIndex < originalLength && this.originalSequence[startIndex] === this.modifiedSequence[startIndex]) {
            startIndex++;
          }
          if (startIndex < modifiedLength && startIndex < originalLength) {
            let originalEndIndex = originalLength - 1;
            let modifiedEndIndex = modifiedLength - 1;
            while (originalEndIndex >= startIndex && modifiedEndIndex >= startIndex && this.originalSequence[originalEndIndex] === this.modifiedSequence[modifiedEndIndex]) {
              originalEndIndex--;
              modifiedEndIndex--;
            }
            if (originalEndIndex < startIndex || modifiedEndIndex < startIndex) {
              originalEndIndex++;
              modifiedEndIndex++;
            }
            const deleteCount = originalEndIndex - startIndex + 1;
            const newData = this.modifiedSequence.slice(startIndex, modifiedEndIndex + 1);
            if (newData.length === 1 && newData[0] === this.originalSequence[originalEndIndex]) {
              return [
                { start: startIndex, deleteCount: deleteCount - 1 }
              ];
            } else {
              return [
                { start: startIndex, deleteCount, data: newData }
              ];
            }
          } else if (startIndex < modifiedLength) {
            return [
              { start: startIndex, deleteCount: 0, data: this.modifiedSequence.slice(startIndex) }
            ];
          } else if (startIndex < originalLength) {
            return [
              { start: startIndex, deleteCount: originalLength - startIndex }
            ];
          } else {
            return [];
          }
        }
      };
      exports.SemanticTokensDiff = SemanticTokensDiff;
      var SemanticTokensBuilder2 = class _SemanticTokensBuilder {
        _id;
        _prevLine;
        _prevChar;
        _dataIsSortedAndDeltaEncoded;
        _data;
        _dataNonDelta;
        _dataLen;
        _prevData;
        constructor() {
          this._prevData = void 0;
          this.initialize();
        }
        initialize() {
          this._id = Date.now();
          this._prevLine = 0;
          this._prevChar = 0;
          this._data = [];
          this._dataNonDelta = [];
          this._dataLen = 0;
          this._dataIsSortedAndDeltaEncoded = true;
        }
        push(line, char, length, tokenType, tokenModifiers2) {
          if (this._dataIsSortedAndDeltaEncoded && (line < this._prevLine || line === this._prevLine && char < this._prevChar)) {
            this._dataIsSortedAndDeltaEncoded = false;
            this._dataNonDelta = _SemanticTokensBuilder._deltaDecode(this._data);
          }
          let pushLine = line;
          let pushChar = char;
          if (this._dataIsSortedAndDeltaEncoded && this._dataLen > 0) {
            pushLine -= this._prevLine;
            if (pushLine === 0) {
              pushChar -= this._prevChar;
            }
          }
          const dataSource = this._dataIsSortedAndDeltaEncoded ? this._data : this._dataNonDelta;
          dataSource[this._dataLen++] = pushLine;
          dataSource[this._dataLen++] = pushChar;
          dataSource[this._dataLen++] = length;
          dataSource[this._dataLen++] = tokenType;
          dataSource[this._dataLen++] = tokenModifiers2;
          this._prevLine = line;
          this._prevChar = char;
        }
        get id() {
          return this._id.toString();
        }
        static _deltaDecode(data) {
          const tokenCount = data.length / 5 | 0;
          let prevLine = 0;
          let prevChar = 0;
          const result = [];
          for (let i = 0; i < tokenCount; i++) {
            const dstOffset = 5 * i;
            let line = data[dstOffset];
            let char = data[dstOffset + 1];
            if (line === 0) {
              line = prevLine;
              char += prevChar;
            } else {
              line += prevLine;
            }
            const length = data[dstOffset + 2];
            const tokenType = data[dstOffset + 3];
            const tokenModifiers2 = data[dstOffset + 4];
            result[dstOffset + 0] = line;
            result[dstOffset + 1] = char;
            result[dstOffset + 2] = length;
            result[dstOffset + 3] = tokenType;
            result[dstOffset + 4] = tokenModifiers2;
            prevLine = line;
            prevChar = char;
          }
          return result;
        }
        static _sortAndDeltaEncode(data) {
          const pos = [];
          const tokenCount = data.length / 5 | 0;
          for (let i = 0; i < tokenCount; i++) {
            pos[i] = i;
          }
          pos.sort((a, b) => {
            const aLine = data[5 * a];
            const bLine = data[5 * b];
            if (aLine === bLine) {
              const aChar = data[5 * a + 1];
              const bChar = data[5 * b + 1];
              return aChar - bChar;
            }
            return aLine - bLine;
          });
          const result = [];
          let prevLine = 0;
          let prevChar = 0;
          for (let i = 0; i < tokenCount; i++) {
            const srcOffset = 5 * pos[i];
            const line = data[srcOffset + 0];
            const char = data[srcOffset + 1];
            const length = data[srcOffset + 2];
            const tokenType = data[srcOffset + 3];
            const tokenModifiers2 = data[srcOffset + 4];
            const pushLine = line - prevLine;
            const pushChar = pushLine === 0 ? char - prevChar : char;
            const dstOffset = 5 * i;
            result[dstOffset + 0] = pushLine;
            result[dstOffset + 1] = pushChar;
            result[dstOffset + 2] = length;
            result[dstOffset + 3] = tokenType;
            result[dstOffset + 4] = tokenModifiers2;
            prevLine = line;
            prevChar = char;
          }
          return result;
        }
        getFinalDataDelta() {
          if (this._dataIsSortedAndDeltaEncoded) {
            return this._data;
          } else {
            return _SemanticTokensBuilder._sortAndDeltaEncode(this._dataNonDelta);
          }
        }
        previousResult(id) {
          if (this.id === id) {
            this._prevData = this.getFinalDataDelta();
          }
          this.initialize();
        }
        build() {
          this._prevData = void 0;
          return {
            resultId: this.id,
            data: this.getFinalDataDelta()
          };
        }
        canBuildEdits() {
          return this._prevData !== void 0;
        }
        buildEdits() {
          if (this._prevData !== void 0) {
            return {
              resultId: this.id,
              edits: new SemanticTokensDiff(this._prevData, this.getFinalDataDelta()).computeDiff()
            };
          } else {
            return this.build();
          }
        }
      };
      exports.SemanticTokensBuilder = SemanticTokensBuilder2;
    }
  });

  // node_modules/vscode-languageserver/lib/common/inlineCompletion.proposed.js
  var require_inlineCompletion_proposed = __commonJS({
    "node_modules/vscode-languageserver/lib/common/inlineCompletion.proposed.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlineCompletionFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var InlineCompletionFeature = (Base) => {
        return class extends Base {
          get inlineCompletion() {
            return {
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.InlineCompletionRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params));
                });
              }
            };
          }
        };
      };
      exports.InlineCompletionFeature = InlineCompletionFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/textDocumentContent.js
  var require_textDocumentContent = __commonJS({
    "node_modules/vscode-languageserver/lib/common/textDocumentContent.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TextDocumentContentFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var TextDocumentContentFeature = (Base) => {
        return class extends Base {
          get textDocumentContent() {
            return {
              refresh: (uri) => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.TextDocumentContentRefreshRequest.type, { uri });
              },
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.TextDocumentContentRequest.type, (params, cancel) => {
                  return handler(params, cancel);
                });
              }
            };
          }
        };
      };
      exports.TextDocumentContentFeature = TextDocumentContentFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/textDocuments.js
  var require_textDocuments = __commonJS({
    "node_modules/vscode-languageserver/lib/common/textDocuments.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TextDocuments = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var TextDocuments2 = class {
        _configuration;
        _syncedDocuments;
        _onDidChangeContent;
        _onDidOpen;
        _onDidClose;
        _onDidSave;
        _onWillSave;
        _willSaveWaitUntil;
        /**
         * Create a new text document manager.
         */
        constructor(configuration) {
          this._configuration = configuration;
          this._syncedDocuments = /* @__PURE__ */ new Map();
          this._onDidChangeContent = new vscode_languageserver_protocol_1.Emitter();
          this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
          this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
          this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
          this._onWillSave = new vscode_languageserver_protocol_1.Emitter();
        }
        /**
         * An event that fires when a text document managed by this manager
         * has been opened.
         */
        get onDidOpen() {
          return this._onDidOpen.event;
        }
        /**
         * An event that fires when a text document managed by this manager
         * has been opened or the content changes.
         */
        get onDidChangeContent() {
          return this._onDidChangeContent.event;
        }
        /**
         * An event that fires when a text document managed by this manager
         * will be saved.
         */
        get onWillSave() {
          return this._onWillSave.event;
        }
        /**
         * Sets a handler that will be called if a participant wants to provide
         * edits during a text document save.
         */
        onWillSaveWaitUntil(handler) {
          this._willSaveWaitUntil = handler;
        }
        /**
         * An event that fires when a text document managed by this manager
         * has been saved.
         */
        get onDidSave() {
          return this._onDidSave.event;
        }
        /**
         * An event that fires when a text document managed by this manager
         * has been closed.
         */
        get onDidClose() {
          return this._onDidClose.event;
        }
        /**
         * Returns the document for the given URI. Returns undefined if
         * the document is not managed by this instance.
         *
         * @param uri The text document's URI to retrieve.
         * @return the text document or `undefined`.
         */
        get(uri) {
          return this._syncedDocuments.get(uri);
        }
        /**
         * Returns all text documents managed by this instance.
         *
         * @return all text documents.
         */
        all() {
          return Array.from(this._syncedDocuments.values());
        }
        /**
         * Returns the URIs of all text documents managed by this instance.
         *
         * @return the URI's of all text documents.
         */
        keys() {
          return Array.from(this._syncedDocuments.keys());
        }
        /**
         * Listens for `low level` notification on the given connection to
         * update the text documents managed by this instance.
         *
         * Please note that the connection only provides handlers not an event model. Therefore
         * listening on a connection will overwrite the following handlers on a connection:
         * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
         * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
         *
         * Use the corresponding events on the TextDocuments instance instead.
         *
         * @param connection The connection to listen on.
         */
        listen(connection2) {
          connection2.__textDocumentSync = vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental;
          const disposables = [];
          disposables.push(connection2.onDidOpenTextDocument((event) => {
            const td = event.textDocument;
            const document = this._configuration.create(td.uri, td.languageId, td.version, td.text);
            this._syncedDocuments.set(td.uri, document);
            const toFire = Object.freeze({ document });
            this._onDidOpen.fire(toFire);
            this._onDidChangeContent.fire(toFire);
          }));
          disposables.push(connection2.onDidChangeTextDocument((event) => {
            const td = event.textDocument;
            const changes = event.contentChanges;
            if (changes.length === 0) {
              return;
            }
            const { version } = td;
            if (version === null || version === void 0) {
              throw new Error(`Received document change event for ${td.uri} without valid version identifier`);
            }
            let syncedDocument = this._syncedDocuments.get(td.uri);
            if (syncedDocument !== void 0) {
              syncedDocument = this._configuration.update(syncedDocument, changes, version);
              this._syncedDocuments.set(td.uri, syncedDocument);
              this._onDidChangeContent.fire(Object.freeze({ document: syncedDocument }));
            }
          }));
          disposables.push(connection2.onDidCloseTextDocument((event) => {
            const syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
            if (syncedDocument !== void 0) {
              this._syncedDocuments.delete(event.textDocument.uri);
              this._onDidClose.fire(Object.freeze({ document: syncedDocument }));
            }
          }));
          disposables.push(connection2.onWillSaveTextDocument((event) => {
            const syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
            if (syncedDocument !== void 0) {
              this._onWillSave.fire(Object.freeze({ document: syncedDocument, reason: event.reason }));
            }
          }));
          disposables.push(connection2.onWillSaveTextDocumentWaitUntil((event, token) => {
            const syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
            if (syncedDocument !== void 0 && this._willSaveWaitUntil) {
              return this._willSaveWaitUntil(Object.freeze({ document: syncedDocument, reason: event.reason }), token);
            } else {
              return [];
            }
          }));
          disposables.push(connection2.onDidSaveTextDocument((event) => {
            const syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
            if (syncedDocument !== void 0) {
              this._onDidSave.fire(Object.freeze({ document: syncedDocument }));
            }
          }));
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            disposables.forEach((disposable) => disposable.dispose());
          });
        }
      };
      exports.TextDocuments = TextDocuments2;
    }
  });

  // node_modules/vscode-languageserver/lib/common/notebook.js
  var require_notebook = __commonJS({
    "node_modules/vscode-languageserver/lib/common/notebook.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.NotebookDocuments = exports.NotebookSyncFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var textDocuments_1 = require_textDocuments();
      var NotebookSyncFeature = (Base) => {
        return class extends Base {
          get synchronization() {
            return {
              onDidOpenNotebookDocument: (handler) => {
                return this.connection.onNotification(vscode_languageserver_protocol_1.DidOpenNotebookDocumentNotification.type, (params) => {
                  return handler(params);
                });
              },
              onDidChangeNotebookDocument: (handler) => {
                return this.connection.onNotification(vscode_languageserver_protocol_1.DidChangeNotebookDocumentNotification.type, (params) => {
                  return handler(params);
                });
              },
              onDidSaveNotebookDocument: (handler) => {
                return this.connection.onNotification(vscode_languageserver_protocol_1.DidSaveNotebookDocumentNotification.type, (params) => {
                  return handler(params);
                });
              },
              onDidCloseNotebookDocument: (handler) => {
                return this.connection.onNotification(vscode_languageserver_protocol_1.DidCloseNotebookDocumentNotification.type, (params) => {
                  return handler(params);
                });
              }
            };
          }
        };
      };
      exports.NotebookSyncFeature = NotebookSyncFeature;
      var CellTextDocumentConnection = class _CellTextDocumentConnection {
        static NULL_DISPOSE = Object.freeze({ dispose: () => {
        } });
        openHandler;
        changeHandler;
        closeHandler;
        onDidOpenTextDocument(handler) {
          this.openHandler = handler;
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            this.openHandler = void 0;
          });
        }
        openTextDocument(params) {
          return this.openHandler && this.openHandler(params);
        }
        onDidChangeTextDocument(handler) {
          this.changeHandler = handler;
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            this.changeHandler = handler;
          });
        }
        changeTextDocument(params) {
          return this.changeHandler && this.changeHandler(params);
        }
        onDidCloseTextDocument(handler) {
          this.closeHandler = handler;
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            this.closeHandler = void 0;
          });
        }
        closeTextDocument(params) {
          return this.closeHandler && this.closeHandler(params);
        }
        onWillSaveTextDocument() {
          return _CellTextDocumentConnection.NULL_DISPOSE;
        }
        onWillSaveTextDocumentWaitUntil() {
          return _CellTextDocumentConnection.NULL_DISPOSE;
        }
        onDidSaveTextDocument() {
          return _CellTextDocumentConnection.NULL_DISPOSE;
        }
      };
      var NotebookDocuments = class {
        notebookDocuments;
        notebookCellMap;
        _onDidOpen;
        _onDidSave;
        _onDidChange;
        _onDidClose;
        _cellTextDocuments;
        constructor(configurationOrTextDocuments) {
          if (configurationOrTextDocuments instanceof textDocuments_1.TextDocuments) {
            this._cellTextDocuments = configurationOrTextDocuments;
          } else {
            this._cellTextDocuments = new textDocuments_1.TextDocuments(configurationOrTextDocuments);
          }
          this.notebookDocuments = /* @__PURE__ */ new Map();
          this.notebookCellMap = /* @__PURE__ */ new Map();
          this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
          this._onDidChange = new vscode_languageserver_protocol_1.Emitter();
          this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
          this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
        }
        get cellTextDocuments() {
          return this._cellTextDocuments;
        }
        getCellTextDocument(cell) {
          return this._cellTextDocuments.get(cell.document);
        }
        getNotebookDocument(uri) {
          return this.notebookDocuments.get(uri);
        }
        getNotebookCell(uri) {
          const value = this.notebookCellMap.get(uri);
          return value && value[0];
        }
        findNotebookDocumentForCell(cell) {
          const key = typeof cell === "string" ? cell : cell.document;
          const value = this.notebookCellMap.get(key);
          return value && value[1];
        }
        get onDidOpen() {
          return this._onDidOpen.event;
        }
        get onDidSave() {
          return this._onDidSave.event;
        }
        get onDidChange() {
          return this._onDidChange.event;
        }
        get onDidClose() {
          return this._onDidClose.event;
        }
        /**
         * Listens for `low level` notification on the given connection to
         * update the notebook documents managed by this instance.
         *
         * Please note that the connection only provides handlers not an event model. Therefore
         * listening on a connection will overwrite the following handlers on a connection:
         * `onDidOpenNotebookDocument`, `onDidChangeNotebookDocument`, `onDidSaveNotebookDocument`,
         *  and `onDidCloseNotebookDocument`.
         *
         * @param connection The connection to listen on.
         */
        listen(connection2) {
          const cellTextDocumentConnection = new CellTextDocumentConnection();
          const disposables = [];
          disposables.push(this.cellTextDocuments.listen(cellTextDocumentConnection));
          disposables.push(connection2.notebooks.synchronization.onDidOpenNotebookDocument(async (params) => {
            this.notebookDocuments.set(params.notebookDocument.uri, params.notebookDocument);
            for (const cellTextDocument of params.cellTextDocuments) {
              await cellTextDocumentConnection.openTextDocument({ textDocument: cellTextDocument });
            }
            this.updateCellMap(params.notebookDocument);
            this._onDidOpen.fire(params.notebookDocument);
          }));
          disposables.push(connection2.notebooks.synchronization.onDidChangeNotebookDocument(async (params) => {
            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
            if (notebookDocument === void 0) {
              return;
            }
            notebookDocument.version = params.notebookDocument.version;
            const oldMetadata = notebookDocument.metadata;
            let metadataChanged = false;
            const change = params.change;
            if (change.metadata !== void 0) {
              metadataChanged = true;
              notebookDocument.metadata = change.metadata;
            }
            const opened = [];
            const closed = [];
            const data = [];
            const text = [];
            if (change.cells !== void 0) {
              const changedCells = change.cells;
              if (changedCells.structure !== void 0) {
                const array = changedCells.structure.array;
                notebookDocument.cells.splice(array.start, array.deleteCount, ...array.cells !== void 0 ? array.cells : []);
                if (changedCells.structure.didOpen !== void 0) {
                  for (const open of changedCells.structure.didOpen) {
                    await cellTextDocumentConnection.openTextDocument({ textDocument: open });
                    opened.push(open.uri);
                  }
                }
                if (changedCells.structure.didClose) {
                  for (const close of changedCells.structure.didClose) {
                    await cellTextDocumentConnection.closeTextDocument({ textDocument: close });
                    closed.push(close.uri);
                  }
                }
              }
              if (changedCells.data !== void 0) {
                const cellUpdates = new Map(changedCells.data.map((cell) => [cell.document, cell]));
                for (let i = 0; i <= notebookDocument.cells.length; i++) {
                  const change2 = cellUpdates.get(notebookDocument.cells[i].document);
                  if (change2 !== void 0) {
                    const old = notebookDocument.cells.splice(i, 1, change2);
                    data.push({ old: old[0], new: change2 });
                    cellUpdates.delete(change2.document);
                    if (cellUpdates.size === 0) {
                      break;
                    }
                  }
                }
              }
              if (changedCells.textContent !== void 0) {
                for (const cellTextDocument of changedCells.textContent) {
                  await cellTextDocumentConnection.changeTextDocument({ textDocument: cellTextDocument.document, contentChanges: cellTextDocument.changes });
                  text.push(cellTextDocument.document.uri);
                }
              }
            }
            this.updateCellMap(notebookDocument);
            const changeEvent = { notebookDocument };
            if (metadataChanged) {
              changeEvent.metadata = { old: oldMetadata, new: notebookDocument.metadata };
            }
            const added = [];
            for (const open of opened) {
              added.push(this.getNotebookCell(open));
            }
            const removed = [];
            for (const close of closed) {
              removed.push(this.getNotebookCell(close));
            }
            const textContent = [];
            for (const change2 of text) {
              textContent.push(this.getNotebookCell(change2));
            }
            if (added.length > 0 || removed.length > 0 || data.length > 0 || textContent.length > 0) {
              changeEvent.cells = { added, removed, changed: { data, textContent } };
            }
            if (changeEvent.metadata !== void 0 || changeEvent.cells !== void 0) {
              this._onDidChange.fire(changeEvent);
            }
          }));
          disposables.push(connection2.notebooks.synchronization.onDidSaveNotebookDocument((params) => {
            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
            if (notebookDocument === void 0) {
              return;
            }
            this._onDidSave.fire(notebookDocument);
          }));
          disposables.push(connection2.notebooks.synchronization.onDidCloseNotebookDocument(async (params) => {
            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
            if (notebookDocument === void 0) {
              return;
            }
            this._onDidClose.fire(notebookDocument);
            for (const cellTextDocument of params.cellTextDocuments) {
              await cellTextDocumentConnection.closeTextDocument({ textDocument: cellTextDocument });
            }
            this.notebookDocuments.delete(params.notebookDocument.uri);
            for (const cell of notebookDocument.cells) {
              this.notebookCellMap.delete(cell.document);
            }
          }));
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            disposables.forEach((disposable) => disposable.dispose());
          });
        }
        updateCellMap(notebookDocument) {
          for (const cell of notebookDocument.cells) {
            this.notebookCellMap.set(cell.document, [cell, notebookDocument]);
          }
        }
      };
      exports.NotebookDocuments = NotebookDocuments;
    }
  });

  // node_modules/vscode-languageserver/lib/common/utils/is.js
  var require_is3 = __commonJS({
    "node_modules/vscode-languageserver/lib/common/utils/is.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.boolean = boolean;
      exports.string = string;
      exports.number = number;
      exports.error = error;
      exports.func = func;
      exports.array = array;
      exports.stringArray = stringArray;
      exports.typedArray = typedArray;
      exports.thenable = thenable;
      function boolean(value) {
        return value === true || value === false;
      }
      function string(value) {
        return typeof value === "string" || value instanceof String;
      }
      function number(value) {
        return typeof value === "number" || value instanceof Number;
      }
      function error(value) {
        return value instanceof Error;
      }
      function func(value) {
        return typeof value === "function";
      }
      function array(value) {
        return Array.isArray(value);
      }
      function stringArray(value) {
        return array(value) && value.every((elem) => string(elem));
      }
      function typedArray(value, check) {
        return Array.isArray(value) && value.every(check);
      }
      function thenable(value) {
        return value && func(value.then);
      }
    }
  });

  // node_modules/vscode-languageserver/lib/common/utils/uuid.js
  var require_uuid = __commonJS({
    "node_modules/vscode-languageserver/lib/common/utils/uuid.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.empty = void 0;
      exports.v4 = v4;
      exports.isUUID = isUUID;
      exports.parse = parse;
      exports.generateUuid = generateUuid;
      var ValueUUID = class {
        _value;
        constructor(_value) {
          this._value = _value;
        }
        asHex() {
          return this._value;
        }
        equals(other) {
          return this.asHex() === other.asHex();
        }
      };
      var V4UUID = class _V4UUID extends ValueUUID {
        static _chars = ["0", "1", "2", "3", "4", "5", "6", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
        static _timeHighBits = ["8", "9", "a", "b"];
        static _oneOf(array) {
          return array[Math.floor(array.length * Math.random())];
        }
        static _randomHex() {
          return _V4UUID._oneOf(_V4UUID._chars);
        }
        constructor() {
          super([
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            "-",
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            "-",
            "4",
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            "-",
            _V4UUID._oneOf(_V4UUID._timeHighBits),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            "-",
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex()
          ].join(""));
        }
      };
      exports.empty = new ValueUUID("00000000-0000-0000-0000-000000000000");
      function v4() {
        return new V4UUID();
      }
      var _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
      function isUUID(value) {
        return _UUIDPattern.test(value);
      }
      function parse(value) {
        if (!isUUID(value)) {
          throw new Error("invalid uuid");
        }
        return new ValueUUID(value);
      }
      function generateUuid() {
        return v4().asHex();
      }
    }
  });

  // node_modules/vscode-languageserver/lib/common/progress.js
  var require_progress = __commonJS({
    "node_modules/vscode-languageserver/lib/common/progress.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ProgressFeature = void 0;
      exports.attachWorkDone = attachWorkDone;
      exports.attachPartialResult = attachPartialResult;
      var vscode_languageserver_protocol_1 = require_api2();
      var uuid_1 = require_uuid();
      var WorkDoneProgressReporterImpl = class _WorkDoneProgressReporterImpl {
        _connection;
        _token;
        static Instances = /* @__PURE__ */ new Map();
        constructor(_connection, _token) {
          this._connection = _connection;
          this._token = _token;
          _WorkDoneProgressReporterImpl.Instances.set(this._token, this);
        }
        begin(title, percentage, message, cancellable) {
          const param = {
            kind: "begin",
            title,
            message,
            cancellable
          };
          if (typeof percentage === "number") {
            param.percentage = Math.round(percentage);
          }
          this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, param);
        }
        report(arg0, arg1) {
          const param = {
            kind: "report"
          };
          if (typeof arg0 === "number") {
            param.percentage = Math.round(arg0);
            if (arg1 !== void 0) {
              param.message = arg1;
            }
          } else {
            param.message = arg0;
          }
          this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, param);
        }
        done() {
          _WorkDoneProgressReporterImpl.Instances.delete(this._token);
          this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, { kind: "end" });
        }
      };
      var WorkDoneProgressServerReporterImpl = class extends WorkDoneProgressReporterImpl {
        _source;
        constructor(connection2, token) {
          super(connection2, token);
          this._source = new vscode_languageserver_protocol_1.CancellationTokenSource();
        }
        get token() {
          return this._source.token;
        }
        done() {
          this._source.dispose();
          super.done();
        }
        cancel() {
          this._source.cancel();
        }
      };
      var NullProgressReporter = class {
        constructor() {
        }
        begin() {
        }
        report() {
        }
        done() {
        }
      };
      var NullProgressServerReporter = class extends NullProgressReporter {
        _source;
        constructor() {
          super();
          this._source = new vscode_languageserver_protocol_1.CancellationTokenSource();
        }
        get token() {
          return this._source.token;
        }
        done() {
          this._source.dispose();
        }
        cancel() {
          this._source.cancel();
        }
      };
      function attachWorkDone(connection2, params) {
        if (params === void 0 || params.workDoneToken === void 0) {
          return new NullProgressReporter();
        }
        const token = params.workDoneToken;
        delete params.workDoneToken;
        return new WorkDoneProgressReporterImpl(connection2, token);
      }
      var ProgressFeature = (Base) => {
        return class extends Base {
          _progressSupported;
          constructor() {
            super();
            this._progressSupported = false;
          }
          initialize(capabilities) {
            super.initialize(capabilities);
            if (capabilities?.window?.workDoneProgress === true) {
              this._progressSupported = true;
              this.connection.onNotification(vscode_languageserver_protocol_1.WorkDoneProgressCancelNotification.type, (params) => {
                const progress = WorkDoneProgressReporterImpl.Instances.get(params.token);
                if (progress instanceof WorkDoneProgressServerReporterImpl || progress instanceof NullProgressServerReporter) {
                  progress.cancel();
                }
              });
            }
          }
          attachWorkDoneProgress(token) {
            if (token === void 0) {
              return new NullProgressReporter();
            } else {
              return new WorkDoneProgressReporterImpl(this.connection, token);
            }
          }
          createWorkDoneProgress() {
            if (this._progressSupported) {
              const token = (0, uuid_1.generateUuid)();
              return this.connection.sendRequest(vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.type, { token }).then(() => {
                const result = new WorkDoneProgressServerReporterImpl(this.connection, token);
                return result;
              });
            } else {
              return Promise.resolve(new NullProgressServerReporter());
            }
          }
        };
      };
      exports.ProgressFeature = ProgressFeature;
      var ResultProgress;
      (function(ResultProgress2) {
        ResultProgress2.type = new vscode_languageserver_protocol_1.ProgressType();
      })(ResultProgress || (ResultProgress = {}));
      var ResultProgressReporterImpl = class {
        _connection;
        _token;
        constructor(_connection, _token) {
          this._connection = _connection;
          this._token = _token;
        }
        report(data) {
          this._connection.sendProgress(ResultProgress.type, this._token, data);
        }
      };
      function attachPartialResult(connection2, params) {
        if (params === void 0 || params.partialResultToken === void 0) {
          return void 0;
        }
        const token = params.partialResultToken;
        delete params.partialResultToken;
        return new ResultProgressReporterImpl(connection2, token);
      }
    }
  });

  // node_modules/vscode-languageserver/lib/common/configuration.js
  var require_configuration = __commonJS({
    "node_modules/vscode-languageserver/lib/common/configuration.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ConfigurationFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var Is3 = __importStar(require_is3());
      var ConfigurationFeature = (Base) => {
        return class extends Base {
          getConfiguration(arg) {
            if (!arg) {
              return this._getConfiguration({});
            } else if (Is3.string(arg)) {
              return this._getConfiguration({ section: arg });
            } else {
              return this._getConfiguration(arg);
            }
          }
          _getConfiguration(arg) {
            const params = {
              items: Array.isArray(arg) ? arg : [arg]
            };
            return this.connection.sendRequest(vscode_languageserver_protocol_1.ConfigurationRequest.type, params).then((result) => {
              if (Array.isArray(result)) {
                return Array.isArray(arg) ? result : result[0];
              } else {
                return Array.isArray(arg) ? [] : null;
              }
            });
          }
        };
      };
      exports.ConfigurationFeature = ConfigurationFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/workspaceFolder.js
  var require_workspaceFolder = __commonJS({
    "node_modules/vscode-languageserver/lib/common/workspaceFolder.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WorkspaceFoldersFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var WorkspaceFoldersFeature = (Base) => {
        return class extends Base {
          _onDidChangeWorkspaceFolders;
          _unregistration;
          _notificationIsAutoRegistered;
          constructor() {
            super();
            this._notificationIsAutoRegistered = false;
          }
          initialize(capabilities) {
            super.initialize(capabilities);
            const workspaceCapabilities = capabilities.workspace;
            if (workspaceCapabilities && workspaceCapabilities.workspaceFolders) {
              this._onDidChangeWorkspaceFolders = new vscode_languageserver_protocol_1.Emitter();
              this.connection.onNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, (params) => {
                this._onDidChangeWorkspaceFolders.fire(params.event);
              });
            }
          }
          fillServerCapabilities(capabilities) {
            super.fillServerCapabilities(capabilities);
            const changeNotifications = capabilities.workspace?.workspaceFolders?.changeNotifications;
            this._notificationIsAutoRegistered = changeNotifications === true || typeof changeNotifications === "string";
          }
          getWorkspaceFolders() {
            return this.connection.sendRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type);
          }
          get onDidChangeWorkspaceFolders() {
            if (!this._onDidChangeWorkspaceFolders) {
              throw new Error("Client doesn't support sending workspace folder change events.");
            }
            if (!this._notificationIsAutoRegistered && !this._unregistration) {
              this._unregistration = this.connection.client.register(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type);
            }
            return this._onDidChangeWorkspaceFolders.event;
          }
        };
      };
      exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/callHierarchy.js
  var require_callHierarchy = __commonJS({
    "node_modules/vscode-languageserver/lib/common/callHierarchy.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CallHierarchyFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var CallHierarchyFeature = (Base) => {
        return class extends Base {
          get callHierarchy() {
            return {
              onPrepare: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), void 0);
                });
              },
              onIncomingCalls: (handler) => {
                const type = vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              },
              onOutgoingCalls: (handler) => {
                const type = vscode_languageserver_protocol_1.CallHierarchyOutgoingCallsRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.CallHierarchyFeature = CallHierarchyFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/showDocument.js
  var require_showDocument = __commonJS({
    "node_modules/vscode-languageserver/lib/common/showDocument.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ShowDocumentFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var ShowDocumentFeature = (Base) => {
        return class extends Base {
          showDocument(params) {
            return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowDocumentRequest.type, params);
          }
        };
      };
      exports.ShowDocumentFeature = ShowDocumentFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/fileOperations.js
  var require_fileOperations = __commonJS({
    "node_modules/vscode-languageserver/lib/common/fileOperations.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.FileOperationsFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var FileOperationsFeature = (Base) => {
        return class extends Base {
          onDidCreateFiles(handler) {
            return this.connection.onNotification(vscode_languageserver_protocol_1.DidCreateFilesNotification.type, (params) => {
              return handler(params);
            });
          }
          onDidRenameFiles(handler) {
            return this.connection.onNotification(vscode_languageserver_protocol_1.DidRenameFilesNotification.type, (params) => {
              return handler(params);
            });
          }
          onDidDeleteFiles(handler) {
            return this.connection.onNotification(vscode_languageserver_protocol_1.DidDeleteFilesNotification.type, (params) => {
              return handler(params);
            });
          }
          onWillCreateFiles(handler) {
            return this.connection.onRequest(vscode_languageserver_protocol_1.WillCreateFilesRequest.type, (params, cancel) => {
              return handler(params, cancel);
            });
          }
          onWillRenameFiles(handler) {
            return this.connection.onRequest(vscode_languageserver_protocol_1.WillRenameFilesRequest.type, (params, cancel) => {
              return handler(params, cancel);
            });
          }
          onWillDeleteFiles(handler) {
            return this.connection.onRequest(vscode_languageserver_protocol_1.WillDeleteFilesRequest.type, (params, cancel) => {
              return handler(params, cancel);
            });
          }
        };
      };
      exports.FileOperationsFeature = FileOperationsFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/linkedEditingRange.js
  var require_linkedEditingRange = __commonJS({
    "node_modules/vscode-languageserver/lib/common/linkedEditingRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LinkedEditingRangeFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var LinkedEditingRangeFeature = (Base) => {
        return class extends Base {
          onLinkedEditingRange(handler) {
            return this.connection.onRequest(vscode_languageserver_protocol_1.LinkedEditingRangeRequest.type, (params, cancel) => {
              return handler(params, cancel, this.attachWorkDoneProgress(params), void 0);
            });
          }
        };
      };
      exports.LinkedEditingRangeFeature = LinkedEditingRangeFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/typeHierarchy.js
  var require_typeHierarchy = __commonJS({
    "node_modules/vscode-languageserver/lib/common/typeHierarchy.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TypeHierarchyFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var TypeHierarchyFeature = (Base) => {
        return class extends Base {
          get typeHierarchy() {
            return {
              onPrepare: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), void 0);
                });
              },
              onSupertypes: (handler) => {
                const type = vscode_languageserver_protocol_1.TypeHierarchySupertypesRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              },
              onSubtypes: (handler) => {
                const type = vscode_languageserver_protocol_1.TypeHierarchySubtypesRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.TypeHierarchyFeature = TypeHierarchyFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/inlineValue.js
  var require_inlineValue = __commonJS({
    "node_modules/vscode-languageserver/lib/common/inlineValue.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlineValueFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var InlineValueFeature = (Base) => {
        return class extends Base {
          get inlineValue() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.InlineValueRefreshRequest.type);
              },
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.InlineValueRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params));
                });
              }
            };
          }
        };
      };
      exports.InlineValueFeature = InlineValueFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/foldingRange.js
  var require_foldingRange = __commonJS({
    "node_modules/vscode-languageserver/lib/common/foldingRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.FoldingRangeFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var FoldingRangeFeature = (Base) => {
        return class extends Base {
          get foldingRange() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.FoldingRangeRefreshRequest.type);
              },
              on: (handler) => {
                const type = vscode_languageserver_protocol_1.FoldingRangeRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.FoldingRangeFeature = FoldingRangeFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/inlayHint.js
  var require_inlayHint = __commonJS({
    "node_modules/vscode-languageserver/lib/common/inlayHint.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlayHintFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var InlayHintFeature = (Base) => {
        return class extends Base {
          get inlayHint() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.InlayHintRefreshRequest.type);
              },
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.InlayHintRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params));
                });
              },
              resolve: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.InlayHintResolveRequest.type, (params, cancel) => {
                  return handler(params, cancel);
                });
              }
            };
          }
        };
      };
      exports.InlayHintFeature = InlayHintFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/diagnostic.js
  var require_diagnostic = __commonJS({
    "node_modules/vscode-languageserver/lib/common/diagnostic.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DiagnosticFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var DiagnosticFeature = (Base) => {
        return class extends Base {
          get diagnostics() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.DiagnosticRefreshRequest.type);
              },
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.partialResult, params));
                });
              },
              onWorkspace: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.WorkspaceDiagnosticRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(vscode_languageserver_protocol_1.WorkspaceDiagnosticRequest.partialResult, params));
                });
              }
            };
          }
        };
      };
      exports.DiagnosticFeature = DiagnosticFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/moniker.js
  var require_moniker = __commonJS({
    "node_modules/vscode-languageserver/lib/common/moniker.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.MonikerFeature = void 0;
      var vscode_languageserver_protocol_1 = require_api2();
      var MonikerFeature = (Base) => {
        return class extends Base {
          get moniker() {
            return {
              on: (handler) => {
                const type = vscode_languageserver_protocol_1.MonikerRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.MonikerFeature = MonikerFeature;
    }
  });

  // node_modules/vscode-languageserver/lib/common/server.js
  var require_server = __commonJS({
    "node_modules/vscode-languageserver/lib/common/server.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      Object.defineProperty(exports, "__esModule", { value: true });
      exports._NotebooksImpl = exports._LanguagesImpl = exports.BulkUnregistration = exports.BulkRegistration = exports.ErrorMessageTracker = void 0;
      exports.combineConsoleFeatures = combineConsoleFeatures;
      exports.combineTelemetryFeatures = combineTelemetryFeatures;
      exports.combineTracerFeatures = combineTracerFeatures;
      exports.combineClientFeatures = combineClientFeatures;
      exports.combineWindowFeatures = combineWindowFeatures;
      exports.combineWorkspaceFeatures = combineWorkspaceFeatures;
      exports.combineLanguagesFeatures = combineLanguagesFeatures;
      exports.combineNotebooksFeatures = combineNotebooksFeatures;
      exports.combineFeatures = combineFeatures;
      exports.createConnection = createConnection2;
      var vscode_languageserver_protocol_1 = require_api2();
      var Is3 = __importStar(require_is3());
      var UUID = __importStar(require_uuid());
      var progress_1 = require_progress();
      var configuration_1 = require_configuration();
      var workspaceFolder_1 = require_workspaceFolder();
      var callHierarchy_1 = require_callHierarchy();
      var semanticTokens_1 = require_semanticTokens();
      var showDocument_1 = require_showDocument();
      var fileOperations_1 = require_fileOperations();
      var linkedEditingRange_1 = require_linkedEditingRange();
      var typeHierarchy_1 = require_typeHierarchy();
      var inlineValue_1 = require_inlineValue();
      var foldingRange_1 = require_foldingRange();
      var inlayHint_1 = require_inlayHint();
      var diagnostic_1 = require_diagnostic();
      var notebook_1 = require_notebook();
      var moniker_1 = require_moniker();
      function null2Undefined(value) {
        if (value === null) {
          return void 0;
        }
        return value;
      }
      var ErrorMessageTracker = class {
        _messages;
        constructor() {
          this._messages = /* @__PURE__ */ Object.create(null);
        }
        /**
         * Add a message to the tracker.
         *
         * @param message The message to add.
         */
        add(message) {
          let count = this._messages[message];
          if (!count) {
            count = 0;
          }
          count++;
          this._messages[message] = count;
        }
        /**
         * Send all tracked messages to the connection's window.
         *
         * @param connection The connection established between client and server.
         */
        sendErrors(connection2) {
          Object.keys(this._messages).forEach((message) => {
            connection2.window.showErrorMessage(message);
          });
        }
      };
      exports.ErrorMessageTracker = ErrorMessageTracker;
      var RemoteConsoleImpl = class {
        _rawConnection;
        _connection;
        constructor() {
        }
        rawAttach(connection2) {
          this._rawConnection = connection2;
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        fillServerCapabilities(_capabilities) {
        }
        initialize(_capabilities) {
        }
        error(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Error, message);
        }
        warn(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Warning, message);
        }
        info(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Info, message);
        }
        log(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Log, message);
        }
        debug(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Debug, message);
        }
        send(type, message) {
          if (this._rawConnection) {
            this._rawConnection.sendNotification(vscode_languageserver_protocol_1.LogMessageNotification.type, { type, message }).catch(() => {
              (0, vscode_languageserver_protocol_1.RAL)().console.error(`Sending log message failed`);
            });
          }
        }
      };
      var _RemoteWindowImpl = class {
        _connection;
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        showErrorMessage(message, ...actions) {
          const params = { type: vscode_languageserver_protocol_1.MessageType.Error, message, actions };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
        }
        showWarningMessage(message, ...actions) {
          const params = { type: vscode_languageserver_protocol_1.MessageType.Warning, message, actions };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
        }
        showInformationMessage(message, ...actions) {
          const params = { type: vscode_languageserver_protocol_1.MessageType.Info, message, actions };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
        }
      };
      var RemoteWindowImpl = (0, showDocument_1.ShowDocumentFeature)((0, progress_1.ProgressFeature)(_RemoteWindowImpl));
      var BulkRegistration;
      (function(BulkRegistration2) {
        function create() {
          return new BulkRegistrationImpl();
        }
        BulkRegistration2.create = create;
      })(BulkRegistration || (exports.BulkRegistration = BulkRegistration = {}));
      var BulkRegistrationImpl = class {
        _registrations = [];
        _registered = /* @__PURE__ */ new Set();
        add(type, registerOptions) {
          const method = Is3.string(type) ? type : type.method;
          if (this._registered.has(method)) {
            throw new Error(`${method} is already added to this registration`);
          }
          const id = UUID.generateUuid();
          this._registrations.push({
            id,
            method,
            registerOptions: registerOptions || {}
          });
          this._registered.add(method);
        }
        asRegistrationParams() {
          return {
            registrations: this._registrations
          };
        }
      };
      var BulkUnregistration;
      (function(BulkUnregistration2) {
        function create() {
          return new BulkUnregistrationImpl(void 0, []);
        }
        BulkUnregistration2.create = create;
      })(BulkUnregistration || (exports.BulkUnregistration = BulkUnregistration = {}));
      var BulkUnregistrationImpl = class {
        _connection;
        _unregistrations = /* @__PURE__ */ new Map();
        constructor(_connection, unregistrations) {
          this._connection = _connection;
          unregistrations.forEach((unregistration) => {
            this._unregistrations.set(unregistration.method, unregistration);
          });
        }
        get isAttached() {
          return !!this._connection;
        }
        attach(connection2) {
          this._connection = connection2;
        }
        add(unregistration) {
          this._unregistrations.set(unregistration.method, unregistration);
        }
        dispose() {
          const unregistrations = [];
          for (const unregistration of this._unregistrations.values()) {
            unregistrations.push(unregistration);
          }
          const params = {
            unregisterations: unregistrations
          };
          this._connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).catch(() => {
            this._connection.console.info(`Bulk unregistration failed.`);
          });
        }
        disposeSingle(arg) {
          const method = Is3.string(arg) ? arg : arg.method;
          const unregistration = this._unregistrations.get(method);
          if (!unregistration) {
            return false;
          }
          const params = {
            unregisterations: [unregistration]
          };
          this._connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).then(() => {
            this._unregistrations.delete(method);
          }, (_error) => {
            this._connection.console.info(`Un-registering request handler for ${unregistration.id} failed.`);
          });
          return true;
        }
      };
      var RemoteClientImpl = class {
        _connection;
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        register(typeOrRegistrations, registerOptionsOrType, registerOptions) {
          if (typeOrRegistrations instanceof BulkRegistrationImpl) {
            return this.registerMany(typeOrRegistrations);
          } else if (typeOrRegistrations instanceof BulkUnregistrationImpl) {
            return this.registerSingle1(typeOrRegistrations, registerOptionsOrType, registerOptions);
          } else {
            return this.registerSingle2(typeOrRegistrations, registerOptionsOrType);
          }
        }
        registerSingle1(unregistration, type, registerOptions) {
          const method = Is3.string(type) ? type : type.method;
          const id = UUID.generateUuid();
          const params = {
            registrations: [{ id, method, registerOptions: registerOptions || {} }]
          };
          if (!unregistration.isAttached) {
            unregistration.attach(this.connection);
          }
          return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then((_result) => {
            unregistration.add({ id, method });
            return unregistration;
          }, (_error) => {
            this.connection.console.info(`Registering request handler for ${method} failed.`);
            return Promise.reject(_error);
          });
        }
        registerSingle2(type, registerOptions) {
          const method = Is3.string(type) ? type : type.method;
          const id = UUID.generateUuid();
          const params = {
            registrations: [{ id, method, registerOptions: registerOptions || {} }]
          };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then((_result) => {
            return vscode_languageserver_protocol_1.Disposable.create(() => {
              this.unregisterSingle(id, method).catch(() => {
                this.connection.console.info(`Un-registering capability with id ${id} failed.`);
              });
            });
          }, (_error) => {
            this.connection.console.info(`Registering request handler for ${method} failed.`);
            return Promise.reject(_error);
          });
        }
        unregisterSingle(id, method) {
          const params = {
            unregisterations: [{ id, method }]
          };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).catch(() => {
            this.connection.console.info(`Un-registering request handler for ${id} failed.`);
          });
        }
        registerMany(registrations) {
          const params = registrations.asRegistrationParams();
          return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then(() => {
            return new BulkUnregistrationImpl(this._connection, params.registrations.map((registration) => {
              return { id: registration.id, method: registration.method };
            }));
          }, (_error) => {
            this.connection.console.info(`Bulk registration failed.`);
            return Promise.reject(_error);
          });
        }
      };
      var _RemoteWorkspaceImpl = class {
        _connection;
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        applyEdit(paramOrEdit) {
          function isApplyWorkspaceEditParams(value) {
            return value && !!value.edit;
          }
          const params = isApplyWorkspaceEditParams(paramOrEdit) ? paramOrEdit : { edit: paramOrEdit };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.ApplyWorkspaceEditRequest.type, params);
        }
      };
      var RemoteWorkspaceImpl = (0, fileOperations_1.FileOperationsFeature)((0, workspaceFolder_1.WorkspaceFoldersFeature)((0, configuration_1.ConfigurationFeature)(_RemoteWorkspaceImpl)));
      var TracerImpl = class {
        _trace;
        _connection;
        constructor() {
          this._trace = vscode_languageserver_protocol_1.Trace.Off;
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        set trace(value) {
          this._trace = value;
        }
        log(message, verbose) {
          if (this._trace === vscode_languageserver_protocol_1.Trace.Off) {
            return;
          }
          this.connection.sendNotification(vscode_languageserver_protocol_1.LogTraceNotification.type, {
            message,
            verbose: this._trace === vscode_languageserver_protocol_1.Trace.Verbose ? verbose : void 0
          }).catch(() => {
          });
        }
      };
      var TelemetryImpl = class {
        _connection;
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        logEvent(data) {
          this.connection.sendNotification(vscode_languageserver_protocol_1.TelemetryEventNotification.type, data).catch(() => {
            this.connection.console.log(`Sending TelemetryEventNotification failed`);
          });
        }
      };
      var _LanguagesImpl = class {
        _connection;
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        attachWorkDoneProgress(params) {
          return (0, progress_1.attachWorkDone)(this.connection, params);
        }
        attachPartialResultProgress(_type, params) {
          return (0, progress_1.attachPartialResult)(this.connection, params);
        }
      };
      exports._LanguagesImpl = _LanguagesImpl;
      var LanguagesImpl = (0, foldingRange_1.FoldingRangeFeature)((0, moniker_1.MonikerFeature)((0, diagnostic_1.DiagnosticFeature)((0, inlayHint_1.InlayHintFeature)((0, inlineValue_1.InlineValueFeature)((0, typeHierarchy_1.TypeHierarchyFeature)((0, linkedEditingRange_1.LinkedEditingRangeFeature)((0, semanticTokens_1.SemanticTokensFeature)((0, callHierarchy_1.CallHierarchyFeature)(_LanguagesImpl)))))))));
      var _NotebooksImpl = class {
        _connection;
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        attachWorkDoneProgress(params) {
          return (0, progress_1.attachWorkDone)(this.connection, params);
        }
        attachPartialResultProgress(_type, params) {
          return (0, progress_1.attachPartialResult)(this.connection, params);
        }
      };
      exports._NotebooksImpl = _NotebooksImpl;
      var NotebooksImpl = (0, notebook_1.NotebookSyncFeature)(_NotebooksImpl);
      function combineConsoleFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      function combineTelemetryFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      function combineTracerFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      function combineClientFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      function combineWindowFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      function combineWorkspaceFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      function combineLanguagesFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      function combineNotebooksFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      function combineFeatures(one, two) {
        function combine(one2, two2, func) {
          if (one2 && two2) {
            return func(one2, two2);
          } else if (one2) {
            return one2;
          } else {
            return two2;
          }
        }
        const result = {
          __brand: "features",
          console: combine(one.console, two.console, combineConsoleFeatures),
          tracer: combine(one.tracer, two.tracer, combineTracerFeatures),
          telemetry: combine(one.telemetry, two.telemetry, combineTelemetryFeatures),
          client: combine(one.client, two.client, combineClientFeatures),
          window: combine(one.window, two.window, combineWindowFeatures),
          workspace: combine(one.workspace, two.workspace, combineWorkspaceFeatures),
          languages: combine(one.languages, two.languages, combineLanguagesFeatures),
          notebooks: combine(one.notebooks, two.notebooks, combineNotebooksFeatures)
        };
        return result;
      }
      function createConnection2(connectionFactory, watchDog, factories) {
        const logger = factories && factories.console ? new (factories.console(RemoteConsoleImpl))() : new RemoteConsoleImpl();
        const connection2 = connectionFactory(logger);
        logger.rawAttach(connection2);
        const tracer = factories && factories.tracer ? new (factories.tracer(TracerImpl))() : new TracerImpl();
        const telemetry = factories && factories.telemetry ? new (factories.telemetry(TelemetryImpl))() : new TelemetryImpl();
        const client = factories && factories.client ? new (factories.client(RemoteClientImpl))() : new RemoteClientImpl();
        const remoteWindow = factories && factories.window ? new (factories.window(RemoteWindowImpl))() : new RemoteWindowImpl();
        const workspace = factories && factories.workspace ? new (factories.workspace(RemoteWorkspaceImpl))() : new RemoteWorkspaceImpl();
        const languages = factories && factories.languages ? new (factories.languages(LanguagesImpl))() : new LanguagesImpl();
        const notebooks = factories && factories.notebooks ? new (factories.notebooks(NotebooksImpl))() : new NotebooksImpl();
        const allRemotes = [logger, tracer, telemetry, client, remoteWindow, workspace, languages, notebooks];
        function asPromise(value) {
          if (value instanceof Promise) {
            return value;
          } else if (Is3.thenable(value)) {
            return new Promise((resolve, reject) => {
              value.then((resolved) => resolve(resolved), (error) => reject(error));
            });
          } else {
            return Promise.resolve(value);
          }
        }
        let shutdownHandler = void 0;
        let initializeHandler = void 0;
        let exitHandler = void 0;
        const protocolConnection = {
          listen: () => connection2.listen(),
          sendRequest: (type, ...params) => connection2.sendRequest(Is3.string(type) ? type : type.method, ...params),
          onRequest: (type, handler) => connection2.onRequest(type, handler),
          sendNotification: (type, param) => {
            const method = Is3.string(type) ? type : type.method;
            return connection2.sendNotification(method, param);
          },
          onNotification: (type, handler) => connection2.onNotification(type, handler),
          onProgress: connection2.onProgress,
          sendProgress: connection2.sendProgress,
          onInitialize: (handler) => {
            initializeHandler = handler;
            return {
              dispose: () => {
                initializeHandler = void 0;
              }
            };
          },
          onInitialized: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.InitializedNotification.type, handler),
          onShutdown: (handler) => {
            shutdownHandler = handler;
            return {
              dispose: () => {
                shutdownHandler = void 0;
              }
            };
          },
          onExit: (handler) => {
            exitHandler = handler;
            return {
              dispose: () => {
                exitHandler = void 0;
              }
            };
          },
          get console() {
            return logger;
          },
          get telemetry() {
            return telemetry;
          },
          get tracer() {
            return tracer;
          },
          get client() {
            return client;
          },
          get window() {
            return remoteWindow;
          },
          get workspace() {
            return workspace;
          },
          get languages() {
            return languages;
          },
          get notebooks() {
            return notebooks;
          },
          onDidChangeConfiguration: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, handler),
          onDidChangeWatchedFiles: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type, handler),
          __textDocumentSync: void 0,
          onDidOpenTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, handler),
          onDidChangeTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, handler),
          onDidCloseTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, handler),
          onWillSaveTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type, handler),
          onWillSaveTextDocumentWaitUntil: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type, handler),
          onDidSaveTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, handler),
          sendDiagnostics: (params) => connection2.sendNotification(vscode_languageserver_protocol_1.PublishDiagnosticsNotification.type, params),
          onHover: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.HoverRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onCompletion: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CompletionRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onCompletionResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, handler),
          onSignatureHelp: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onDeclaration: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onDefinition: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onTypeDefinition: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onImplementation: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onReferences: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onDocumentHighlight: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onDocumentSymbol: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onWorkspaceSymbol: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onWorkspaceSymbolResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest.type, handler),
          onCodeAction: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onCodeActionResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CodeActionResolveRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onCodeLens: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onCodeLensResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onDocumentFormatting: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onDocumentRangeFormatting: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onDocumentOnTypeFormatting: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onRenameRequest: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.RenameRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onPrepareRename: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onDocumentLinks: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onDocumentLinkResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onDocumentColor: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onColorPresentation: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onFoldingRanges: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onSelectionRanges: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onExecuteCommand: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          dispose: () => connection2.dispose()
        };
        for (const remote of allRemotes) {
          remote.attach(protocolConnection);
        }
        connection2.onRequest(vscode_languageserver_protocol_1.InitializeRequest.type, (params) => {
          watchDog.initialize(params);
          if (Is3.string(params.trace)) {
            tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.trace);
          }
          for (const remote of allRemotes) {
            remote.initialize(params.capabilities);
          }
          if (initializeHandler) {
            const result = initializeHandler(params, new vscode_languageserver_protocol_1.CancellationTokenSource().token, (0, progress_1.attachWorkDone)(connection2, params), void 0);
            return asPromise(result).then((value) => {
              if (value instanceof vscode_languageserver_protocol_1.ResponseError) {
                return value;
              }
              let result2 = value;
              if (!result2) {
                result2 = { capabilities: {} };
              }
              let capabilities = result2.capabilities;
              if (!capabilities) {
                capabilities = {};
                result2.capabilities = capabilities;
              }
              if (capabilities.textDocumentSync === void 0 || capabilities.textDocumentSync === null) {
                capabilities.textDocumentSync = Is3.number(protocolConnection.__textDocumentSync) ? protocolConnection.__textDocumentSync : vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
              } else if (!Is3.number(capabilities.textDocumentSync) && !Is3.number(capabilities.textDocumentSync.change)) {
                capabilities.textDocumentSync.change = Is3.number(protocolConnection.__textDocumentSync) ? protocolConnection.__textDocumentSync : vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
              }
              for (const remote of allRemotes) {
                remote.fillServerCapabilities(capabilities);
              }
              return result2;
            });
          } else {
            const result = { capabilities: { textDocumentSync: vscode_languageserver_protocol_1.TextDocumentSyncKind.None } };
            for (const remote of allRemotes) {
              remote.fillServerCapabilities(result.capabilities);
            }
            return result;
          }
        });
        connection2.onRequest(vscode_languageserver_protocol_1.ShutdownRequest.type, () => {
          watchDog.shutdownReceived = true;
          if (shutdownHandler) {
            return shutdownHandler(new vscode_languageserver_protocol_1.CancellationTokenSource().token);
          } else {
            return void 0;
          }
        });
        connection2.onNotification(vscode_languageserver_protocol_1.ExitNotification.type, () => {
          try {
            if (exitHandler) {
              return exitHandler();
            }
          } finally {
            if (watchDog.shutdownReceived) {
              watchDog.exit(0);
            } else {
              watchDog.exit(1);
            }
          }
        });
        connection2.onNotification(vscode_languageserver_protocol_1.SetTraceNotification.type, (params) => {
          tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.value);
        });
        return protocolConnection;
      }
    }
  });

  // node_modules/vscode-languageserver/lib/common/api.js
  var require_api3 = __commonJS({
    "node_modules/vscode-languageserver/lib/common/api.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      }) : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
        var ownKeys = function(o) {
          ownKeys = Object.getOwnPropertyNames || function(o2) {
            var ar = [];
            for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
            return ar;
          };
          return ownKeys(o);
        };
        return function(mod) {
          if (mod && mod.__esModule) return mod;
          var result = {};
          if (mod != null) {
            for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
          }
          __setModuleDefault(result, mod);
          return result;
        };
      })();
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ProposedFeatures = exports.NotebookDocuments = exports.TextDocuments = exports.SemanticTokensBuilder = void 0;
      var semanticTokens_1 = require_semanticTokens();
      Object.defineProperty(exports, "SemanticTokensBuilder", { enumerable: true, get: function() {
        return semanticTokens_1.SemanticTokensBuilder;
      } });
      var ic = __importStar(require_inlineCompletion_proposed());
      var tdc = __importStar(require_textDocumentContent());
      __exportStar(require_api2(), exports);
      var textDocuments_1 = require_textDocuments();
      Object.defineProperty(exports, "TextDocuments", { enumerable: true, get: function() {
        return textDocuments_1.TextDocuments;
      } });
      var notebook_1 = require_notebook();
      Object.defineProperty(exports, "NotebookDocuments", { enumerable: true, get: function() {
        return notebook_1.NotebookDocuments;
      } });
      __exportStar(require_server(), exports);
      var ProposedFeatures2;
      (function(ProposedFeatures3) {
        ProposedFeatures3.all = {
          __brand: "features",
          workspace: tdc.TextDocumentContentFeature,
          languages: ic.InlineCompletionFeature
        };
      })(ProposedFeatures2 || (exports.ProposedFeatures = ProposedFeatures2 = {}));
    }
  });

  // node_modules/vscode-jsonrpc/lib/browser/ril.js
  var require_ril = __commonJS({
    "node_modules/vscode-jsonrpc/lib/browser/ril.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.PromiseImpl = exports.QueueMicrotaskImpl = void 0;
      var api_1 = require_api();
      var MessageBuffer = class _MessageBuffer extends api_1.AbstractMessageBuffer {
        static emptyBuffer = new Uint8Array(0);
        asciiDecoder;
        constructor(encoding = "utf-8") {
          super(encoding);
          this.asciiDecoder = new TextDecoder("ascii");
        }
        emptyBuffer() {
          return _MessageBuffer.emptyBuffer;
        }
        fromString(value, _encoding) {
          return new TextEncoder().encode(value);
        }
        toString(value, encoding) {
          if (encoding === "ascii") {
            return this.asciiDecoder.decode(value);
          } else {
            return new TextDecoder(encoding).decode(value);
          }
        }
        asNative(buffer, length) {
          if (length === void 0) {
            return buffer;
          } else {
            return buffer.slice(0, length);
          }
        }
        allocNative(length) {
          return new Uint8Array(length);
        }
      };
      var ReadableStreamWrapper = class {
        socket;
        _onData;
        _messageListener;
        constructor(socket) {
          this.socket = socket;
          this._onData = new api_1.Emitter();
          this._messageListener = (event) => {
            const blob = event.data;
            blob.arrayBuffer().then((buffer) => {
              this._onData.fire(new Uint8Array(buffer));
            }, () => {
              (0, api_1.RAL)().console.error(`Converting blob to array buffer failed.`);
            });
          };
          this.socket.addEventListener("message", this._messageListener);
        }
        onClose(listener) {
          this.socket.addEventListener("close", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("close", listener));
        }
        onError(listener) {
          this.socket.addEventListener("error", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("error", listener));
        }
        onEnd(listener) {
          this.socket.addEventListener("end", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("end", listener));
        }
        onData(listener) {
          return this._onData.event(listener);
        }
      };
      var WritableStreamWrapper = class {
        socket;
        constructor(socket) {
          this.socket = socket;
        }
        onClose(listener) {
          this.socket.addEventListener("close", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("close", listener));
        }
        onError(listener) {
          this.socket.addEventListener("error", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("error", listener));
        }
        onEnd(listener) {
          this.socket.addEventListener("end", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("end", listener));
        }
        write(data, encoding) {
          if (typeof data === "string") {
            if (encoding !== void 0 && encoding !== "utf-8") {
              throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${encoding}`);
            }
            this.socket.send(data);
          } else {
            if (data.buffer instanceof ArrayBuffer) {
              this.socket.send(data.buffer);
            } else {
              this.socket.send(new Uint8Array(data.buffer).slice().buffer);
            }
          }
          return Promise.resolve();
        }
        end() {
          this.socket.close();
        }
      };
      var QueueMicrotaskImpl = class {
        isDisposed;
        constructor(callback, ...args) {
          this.isDisposed = false;
          queueMicrotask(() => {
            if (!this.isDisposed) {
              callback(...args);
            }
          });
        }
        dispose() {
          this.isDisposed = true;
        }
      };
      exports.QueueMicrotaskImpl = QueueMicrotaskImpl;
      var PromiseImpl = class {
        isDisposed;
        constructor(callback, ...args) {
          this.isDisposed = false;
          Promise.resolve().then(() => {
            if (!this.isDisposed) {
              callback(...args);
            }
          }, () => {
          });
        }
        dispose() {
          this.isDisposed = true;
        }
      };
      exports.PromiseImpl = PromiseImpl;
      var _textEncoder = new TextEncoder();
      var _ril = Object.freeze({
        messageBuffer: Object.freeze({
          create: (encoding) => new MessageBuffer(encoding)
        }),
        applicationJson: Object.freeze({
          encoder: Object.freeze({
            name: "application/json",
            encode: (msg, options) => {
              if (options.charset !== "utf-8") {
                throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${options.charset}`);
              }
              return Promise.resolve(_textEncoder.encode(JSON.stringify(msg, void 0, 0)));
            }
          }),
          decoder: Object.freeze({
            name: "application/json",
            decode: (buffer, options) => {
              if (!(buffer instanceof Uint8Array)) {
                throw new Error(`In a Browser environments only Uint8Arrays are supported.`);
              }
              return Promise.resolve(JSON.parse(new TextDecoder(options.charset).decode(buffer)));
            }
          })
        }),
        stream: Object.freeze({
          asReadableStream: (socket) => new ReadableStreamWrapper(socket),
          asWritableStream: (socket) => new WritableStreamWrapper(socket)
        }),
        console,
        timer: Object.freeze({
          setTimeout(callback, ms, ...args) {
            const handle = setTimeout(callback, ms, ...args);
            return { dispose: () => clearTimeout(handle) };
          },
          setImmediate(callback, ...args) {
            if (typeof globalThis.queueMicrotask === "function") {
              return new QueueMicrotaskImpl(callback, ...args);
            } else if (Promise !== void 0) {
              return new PromiseImpl(callback, ...args);
            } else {
              const handle = setTimeout(callback, 0, ...args);
              return { dispose: () => clearTimeout(handle) };
            }
          },
          setInterval(callback, ms, ...args) {
            const handle = setInterval(callback, ms, ...args);
            return { dispose: () => clearInterval(handle) };
          }
        })
      });
      function RIL() {
        return _ril;
      }
      (function(RIL2) {
        function install() {
          api_1.RAL.install(_ril);
        }
        RIL2.install = install;
      })(RIL || (RIL = {}));
      exports.default = RIL;
    }
  });

  // node_modules/vscode-jsonrpc/lib/browser/main.js
  var require_main = __commonJS({
    "node_modules/vscode-jsonrpc/lib/browser/main.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      var __importDefault = exports && exports.__importDefault || function(mod) {
        return mod && mod.__esModule ? mod : { "default": mod };
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.BrowserMessageWriter = exports.BrowserMessageReader = void 0;
      exports.createMessageConnection = createMessageConnection;
      var ril_1 = __importDefault(require_ril());
      ril_1.default.install();
      var api_1 = require_api();
      __exportStar(require_api(), exports);
      var BrowserMessageReader2 = class extends api_1.AbstractMessageReader {
        _onData;
        _messageListener;
        constructor(port) {
          super();
          this._onData = new api_1.Emitter();
          this._messageListener = (event) => {
            this._onData.fire(event.data);
          };
          port.addEventListener("error", (event) => this.fireError(event));
          port.onmessage = this._messageListener;
        }
        listen(callback) {
          return this._onData.event(callback);
        }
      };
      exports.BrowserMessageReader = BrowserMessageReader2;
      var BrowserMessageWriter2 = class extends api_1.AbstractMessageWriter {
        port;
        errorCount;
        constructor(port) {
          super();
          this.port = port;
          this.errorCount = 0;
          port.addEventListener("error", (event) => this.fireError(event));
        }
        write(msg) {
          try {
            this.port.postMessage(msg);
            return Promise.resolve();
          } catch (error) {
            this.handleError(error, msg);
            return Promise.reject(error);
          }
        }
        handleError(error, msg) {
          this.errorCount++;
          this.fireError(error, msg, this.errorCount);
        }
        end() {
        }
      };
      exports.BrowserMessageWriter = BrowserMessageWriter2;
      function createMessageConnection(reader, writer, logger, options) {
        if (logger === void 0) {
          logger = api_1.NullLogger;
        }
        if (api_1.ConnectionStrategy.is(options)) {
          options = { connectionStrategy: options };
        }
        return (0, api_1.createMessageConnection)(reader, writer, logger, options);
      }
    }
  });

  // node_modules/vscode-languageserver-protocol/lib/browser/main.js
  var require_main2 = __commonJS({
    "node_modules/vscode-languageserver-protocol/lib/browser/main.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createProtocolConnection = createProtocolConnection;
      var browser_1 = require_main();
      __exportStar(require_main(), exports);
      __exportStar(require_api2(), exports);
      function createProtocolConnection(reader, writer, logger, options) {
        return (0, browser_1.createMessageConnection)(reader, writer, logger, options);
      }
    }
  });

  // node_modules/vscode-languageserver/lib/browser/main.js
  var require_main3 = __commonJS({
    "node_modules/vscode-languageserver/lib/browser/main.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createConnection = createConnection2;
      var api_1 = require_api3();
      __exportStar(require_main2(), exports);
      __exportStar(require_api3(), exports);
      var _shutdownReceived = false;
      var watchDog = {
        initialize: (_params) => {
        },
        get shutdownReceived() {
          return _shutdownReceived;
        },
        set shutdownReceived(value) {
          _shutdownReceived = value;
        },
        exit: (_code) => {
        }
      };
      function createConnection2(arg1, arg2, arg3, arg4) {
        let factories;
        let reader;
        let writer;
        let options;
        if (arg1 !== void 0 && arg1.__brand === "features") {
          factories = arg1;
          arg1 = arg2;
          arg2 = arg3;
          arg3 = arg4;
        }
        if (api_1.ConnectionStrategy.is(arg1) || api_1.ConnectionOptions.is(arg1)) {
          options = arg1;
        } else {
          reader = arg1;
          writer = arg2;
          options = arg3;
        }
        const connectionFactory = (logger) => {
          return (0, api_1.createProtocolConnection)(reader, writer, logger, options);
        };
        return (0, api_1.createConnection)(connectionFactory, watchDog, factories);
      }
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/is.js
  var require_is4 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/is.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
      function boolean(value) {
        return value === true || value === false;
      }
      exports.boolean = boolean;
      function string(value) {
        return typeof value === "string" || value instanceof String;
      }
      exports.string = string;
      function number(value) {
        return typeof value === "number" || value instanceof Number;
      }
      exports.number = number;
      function error(value) {
        return value instanceof Error;
      }
      exports.error = error;
      function func(value) {
        return typeof value === "function";
      }
      exports.func = func;
      function array(value) {
        return Array.isArray(value);
      }
      exports.array = array;
      function stringArray(value) {
        return array(value) && value.every((elem) => string(elem));
      }
      exports.stringArray = stringArray;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/messages.js
  var require_messages3 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/messages.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0;
      var is = require_is4();
      var ErrorCodes;
      (function(ErrorCodes2) {
        ErrorCodes2.ParseError = -32700;
        ErrorCodes2.InvalidRequest = -32600;
        ErrorCodes2.MethodNotFound = -32601;
        ErrorCodes2.InvalidParams = -32602;
        ErrorCodes2.InternalError = -32603;
        ErrorCodes2.jsonrpcReservedErrorRangeStart = -32099;
        ErrorCodes2.serverErrorStart = -32099;
        ErrorCodes2.MessageWriteError = -32099;
        ErrorCodes2.MessageReadError = -32098;
        ErrorCodes2.PendingResponseRejected = -32097;
        ErrorCodes2.ConnectionInactive = -32096;
        ErrorCodes2.ServerNotInitialized = -32002;
        ErrorCodes2.UnknownErrorCode = -32001;
        ErrorCodes2.jsonrpcReservedErrorRangeEnd = -32e3;
        ErrorCodes2.serverErrorEnd = -32e3;
      })(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));
      var ResponseError = class _ResponseError extends Error {
        constructor(code, message, data) {
          super(message);
          this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
          this.data = data;
          Object.setPrototypeOf(this, _ResponseError.prototype);
        }
        toJson() {
          const result = {
            code: this.code,
            message: this.message
          };
          if (this.data !== void 0) {
            result.data = this.data;
          }
          return result;
        }
      };
      exports.ResponseError = ResponseError;
      var ParameterStructures = class _ParameterStructures {
        constructor(kind) {
          this.kind = kind;
        }
        static is(value) {
          return value === _ParameterStructures.auto || value === _ParameterStructures.byName || value === _ParameterStructures.byPosition;
        }
        toString() {
          return this.kind;
        }
      };
      exports.ParameterStructures = ParameterStructures;
      ParameterStructures.auto = new ParameterStructures("auto");
      ParameterStructures.byPosition = new ParameterStructures("byPosition");
      ParameterStructures.byName = new ParameterStructures("byName");
      var AbstractMessageSignature = class {
        constructor(method, numberOfParams) {
          this.method = method;
          this.numberOfParams = numberOfParams;
        }
        get parameterStructures() {
          return ParameterStructures.auto;
        }
      };
      exports.AbstractMessageSignature = AbstractMessageSignature;
      var RequestType0 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 0);
        }
      };
      exports.RequestType0 = RequestType0;
      var RequestType = class extends AbstractMessageSignature {
        constructor(method, _parameterStructures = ParameterStructures.auto) {
          super(method, 1);
          this._parameterStructures = _parameterStructures;
        }
        get parameterStructures() {
          return this._parameterStructures;
        }
      };
      exports.RequestType = RequestType;
      var RequestType1 = class extends AbstractMessageSignature {
        constructor(method, _parameterStructures = ParameterStructures.auto) {
          super(method, 1);
          this._parameterStructures = _parameterStructures;
        }
        get parameterStructures() {
          return this._parameterStructures;
        }
      };
      exports.RequestType1 = RequestType1;
      var RequestType2 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 2);
        }
      };
      exports.RequestType2 = RequestType2;
      var RequestType3 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 3);
        }
      };
      exports.RequestType3 = RequestType3;
      var RequestType4 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 4);
        }
      };
      exports.RequestType4 = RequestType4;
      var RequestType5 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 5);
        }
      };
      exports.RequestType5 = RequestType5;
      var RequestType6 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 6);
        }
      };
      exports.RequestType6 = RequestType6;
      var RequestType7 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 7);
        }
      };
      exports.RequestType7 = RequestType7;
      var RequestType8 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 8);
        }
      };
      exports.RequestType8 = RequestType8;
      var RequestType9 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 9);
        }
      };
      exports.RequestType9 = RequestType9;
      var NotificationType = class extends AbstractMessageSignature {
        constructor(method, _parameterStructures = ParameterStructures.auto) {
          super(method, 1);
          this._parameterStructures = _parameterStructures;
        }
        get parameterStructures() {
          return this._parameterStructures;
        }
      };
      exports.NotificationType = NotificationType;
      var NotificationType0 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 0);
        }
      };
      exports.NotificationType0 = NotificationType0;
      var NotificationType1 = class extends AbstractMessageSignature {
        constructor(method, _parameterStructures = ParameterStructures.auto) {
          super(method, 1);
          this._parameterStructures = _parameterStructures;
        }
        get parameterStructures() {
          return this._parameterStructures;
        }
      };
      exports.NotificationType1 = NotificationType1;
      var NotificationType2 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 2);
        }
      };
      exports.NotificationType2 = NotificationType2;
      var NotificationType3 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 3);
        }
      };
      exports.NotificationType3 = NotificationType3;
      var NotificationType4 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 4);
        }
      };
      exports.NotificationType4 = NotificationType4;
      var NotificationType5 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 5);
        }
      };
      exports.NotificationType5 = NotificationType5;
      var NotificationType6 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 6);
        }
      };
      exports.NotificationType6 = NotificationType6;
      var NotificationType7 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 7);
        }
      };
      exports.NotificationType7 = NotificationType7;
      var NotificationType8 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 8);
        }
      };
      exports.NotificationType8 = NotificationType8;
      var NotificationType9 = class extends AbstractMessageSignature {
        constructor(method) {
          super(method, 9);
        }
      };
      exports.NotificationType9 = NotificationType9;
      var Message;
      (function(Message2) {
        function isRequest(message) {
          const candidate = message;
          return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
        }
        Message2.isRequest = isRequest;
        function isNotification(message) {
          const candidate = message;
          return candidate && is.string(candidate.method) && message.id === void 0;
        }
        Message2.isNotification = isNotification;
        function isResponse(message) {
          const candidate = message;
          return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
        }
        Message2.isResponse = isResponse;
      })(Message || (exports.Message = Message = {}));
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/linkedMap.js
  var require_linkedMap2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/linkedMap.js"(exports) {
      "use strict";
      var _a;
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LRUCache = exports.LinkedMap = exports.Touch = void 0;
      var Touch;
      (function(Touch2) {
        Touch2.None = 0;
        Touch2.First = 1;
        Touch2.AsOld = Touch2.First;
        Touch2.Last = 2;
        Touch2.AsNew = Touch2.Last;
      })(Touch || (exports.Touch = Touch = {}));
      var LinkedMap = class {
        constructor() {
          this[_a] = "LinkedMap";
          this._map = /* @__PURE__ */ new Map();
          this._head = void 0;
          this._tail = void 0;
          this._size = 0;
          this._state = 0;
        }
        clear() {
          this._map.clear();
          this._head = void 0;
          this._tail = void 0;
          this._size = 0;
          this._state++;
        }
        isEmpty() {
          return !this._head && !this._tail;
        }
        get size() {
          return this._size;
        }
        get first() {
          return this._head?.value;
        }
        get last() {
          return this._tail?.value;
        }
        has(key) {
          return this._map.has(key);
        }
        get(key, touch = Touch.None) {
          const item = this._map.get(key);
          if (!item) {
            return void 0;
          }
          if (touch !== Touch.None) {
            this.touch(item, touch);
          }
          return item.value;
        }
        set(key, value, touch = Touch.None) {
          let item = this._map.get(key);
          if (item) {
            item.value = value;
            if (touch !== Touch.None) {
              this.touch(item, touch);
            }
          } else {
            item = { key, value, next: void 0, previous: void 0 };
            switch (touch) {
              case Touch.None:
                this.addItemLast(item);
                break;
              case Touch.First:
                this.addItemFirst(item);
                break;
              case Touch.Last:
                this.addItemLast(item);
                break;
              default:
                this.addItemLast(item);
                break;
            }
            this._map.set(key, item);
            this._size++;
          }
          return this;
        }
        delete(key) {
          return !!this.remove(key);
        }
        remove(key) {
          const item = this._map.get(key);
          if (!item) {
            return void 0;
          }
          this._map.delete(key);
          this.removeItem(item);
          this._size--;
          return item.value;
        }
        shift() {
          if (!this._head && !this._tail) {
            return void 0;
          }
          if (!this._head || !this._tail) {
            throw new Error("Invalid list");
          }
          const item = this._head;
          this._map.delete(item.key);
          this.removeItem(item);
          this._size--;
          return item.value;
        }
        forEach(callbackfn, thisArg) {
          const state = this._state;
          let current = this._head;
          while (current) {
            if (thisArg) {
              callbackfn.bind(thisArg)(current.value, current.key, this);
            } else {
              callbackfn(current.value, current.key, this);
            }
            if (this._state !== state) {
              throw new Error(`LinkedMap got modified during iteration.`);
            }
            current = current.next;
          }
        }
        keys() {
          const state = this._state;
          let current = this._head;
          const iterator = {
            [Symbol.iterator]: () => {
              return iterator;
            },
            next: () => {
              if (this._state !== state) {
                throw new Error(`LinkedMap got modified during iteration.`);
              }
              if (current) {
                const result = { value: current.key, done: false };
                current = current.next;
                return result;
              } else {
                return { value: void 0, done: true };
              }
            }
          };
          return iterator;
        }
        values() {
          const state = this._state;
          let current = this._head;
          const iterator = {
            [Symbol.iterator]: () => {
              return iterator;
            },
            next: () => {
              if (this._state !== state) {
                throw new Error(`LinkedMap got modified during iteration.`);
              }
              if (current) {
                const result = { value: current.value, done: false };
                current = current.next;
                return result;
              } else {
                return { value: void 0, done: true };
              }
            }
          };
          return iterator;
        }
        entries() {
          const state = this._state;
          let current = this._head;
          const iterator = {
            [Symbol.iterator]: () => {
              return iterator;
            },
            next: () => {
              if (this._state !== state) {
                throw new Error(`LinkedMap got modified during iteration.`);
              }
              if (current) {
                const result = { value: [current.key, current.value], done: false };
                current = current.next;
                return result;
              } else {
                return { value: void 0, done: true };
              }
            }
          };
          return iterator;
        }
        [(_a = Symbol.toStringTag, Symbol.iterator)]() {
          return this.entries();
        }
        trimOld(newSize) {
          if (newSize >= this.size) {
            return;
          }
          if (newSize === 0) {
            this.clear();
            return;
          }
          let current = this._head;
          let currentSize = this.size;
          while (current && currentSize > newSize) {
            this._map.delete(current.key);
            current = current.next;
            currentSize--;
          }
          this._head = current;
          this._size = currentSize;
          if (current) {
            current.previous = void 0;
          }
          this._state++;
        }
        addItemFirst(item) {
          if (!this._head && !this._tail) {
            this._tail = item;
          } else if (!this._head) {
            throw new Error("Invalid list");
          } else {
            item.next = this._head;
            this._head.previous = item;
          }
          this._head = item;
          this._state++;
        }
        addItemLast(item) {
          if (!this._head && !this._tail) {
            this._head = item;
          } else if (!this._tail) {
            throw new Error("Invalid list");
          } else {
            item.previous = this._tail;
            this._tail.next = item;
          }
          this._tail = item;
          this._state++;
        }
        removeItem(item) {
          if (item === this._head && item === this._tail) {
            this._head = void 0;
            this._tail = void 0;
          } else if (item === this._head) {
            if (!item.next) {
              throw new Error("Invalid list");
            }
            item.next.previous = void 0;
            this._head = item.next;
          } else if (item === this._tail) {
            if (!item.previous) {
              throw new Error("Invalid list");
            }
            item.previous.next = void 0;
            this._tail = item.previous;
          } else {
            const next = item.next;
            const previous = item.previous;
            if (!next || !previous) {
              throw new Error("Invalid list");
            }
            next.previous = previous;
            previous.next = next;
          }
          item.next = void 0;
          item.previous = void 0;
          this._state++;
        }
        touch(item, touch) {
          if (!this._head || !this._tail) {
            throw new Error("Invalid list");
          }
          if (touch !== Touch.First && touch !== Touch.Last) {
            return;
          }
          if (touch === Touch.First) {
            if (item === this._head) {
              return;
            }
            const next = item.next;
            const previous = item.previous;
            if (item === this._tail) {
              previous.next = void 0;
              this._tail = previous;
            } else {
              next.previous = previous;
              previous.next = next;
            }
            item.previous = void 0;
            item.next = this._head;
            this._head.previous = item;
            this._head = item;
            this._state++;
          } else if (touch === Touch.Last) {
            if (item === this._tail) {
              return;
            }
            const next = item.next;
            const previous = item.previous;
            if (item === this._head) {
              next.previous = void 0;
              this._head = next;
            } else {
              next.previous = previous;
              previous.next = next;
            }
            item.next = void 0;
            item.previous = this._tail;
            this._tail.next = item;
            this._tail = item;
            this._state++;
          }
        }
        toJSON() {
          const data = [];
          this.forEach((value, key) => {
            data.push([key, value]);
          });
          return data;
        }
        fromJSON(data) {
          this.clear();
          for (const [key, value] of data) {
            this.set(key, value);
          }
        }
      };
      exports.LinkedMap = LinkedMap;
      var LRUCache = class extends LinkedMap {
        constructor(limit, ratio = 1) {
          super();
          this._limit = limit;
          this._ratio = Math.min(Math.max(0, ratio), 1);
        }
        get limit() {
          return this._limit;
        }
        set limit(limit) {
          this._limit = limit;
          this.checkTrim();
        }
        get ratio() {
          return this._ratio;
        }
        set ratio(ratio) {
          this._ratio = Math.min(Math.max(0, ratio), 1);
          this.checkTrim();
        }
        get(key, touch = Touch.AsNew) {
          return super.get(key, touch);
        }
        peek(key) {
          return super.get(key, Touch.None);
        }
        set(key, value) {
          super.set(key, value, Touch.Last);
          this.checkTrim();
          return this;
        }
        checkTrim() {
          if (this.size > this._limit) {
            this.trimOld(Math.round(this._limit * this._ratio));
          }
        }
      };
      exports.LRUCache = LRUCache;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/disposable.js
  var require_disposable2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/disposable.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Disposable = void 0;
      var Disposable;
      (function(Disposable2) {
        function create(func) {
          return {
            dispose: func
          };
        }
        Disposable2.create = create;
      })(Disposable || (exports.Disposable = Disposable = {}));
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/ral.js
  var require_ral2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/ral.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      var _ral;
      function RAL() {
        if (_ral === void 0) {
          throw new Error(`No runtime abstraction layer installed`);
        }
        return _ral;
      }
      (function(RAL2) {
        function install(ral) {
          if (ral === void 0) {
            throw new Error(`No runtime abstraction layer provided`);
          }
          _ral = ral;
        }
        RAL2.install = install;
      })(RAL || (RAL = {}));
      exports.default = RAL;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/events.js
  var require_events2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/events.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Emitter = exports.Event = void 0;
      var ral_1 = require_ral2();
      var Event;
      (function(Event2) {
        const _disposable = { dispose() {
        } };
        Event2.None = function() {
          return _disposable;
        };
      })(Event || (exports.Event = Event = {}));
      var CallbackList = class {
        add(callback, context = null, bucket) {
          if (!this._callbacks) {
            this._callbacks = [];
            this._contexts = [];
          }
          this._callbacks.push(callback);
          this._contexts.push(context);
          if (Array.isArray(bucket)) {
            bucket.push({ dispose: () => this.remove(callback, context) });
          }
        }
        remove(callback, context = null) {
          if (!this._callbacks) {
            return;
          }
          let foundCallbackWithDifferentContext = false;
          for (let i = 0, len = this._callbacks.length; i < len; i++) {
            if (this._callbacks[i] === callback) {
              if (this._contexts[i] === context) {
                this._callbacks.splice(i, 1);
                this._contexts.splice(i, 1);
                return;
              } else {
                foundCallbackWithDifferentContext = true;
              }
            }
          }
          if (foundCallbackWithDifferentContext) {
            throw new Error("When adding a listener with a context, you should remove it with the same context");
          }
        }
        invoke(...args) {
          if (!this._callbacks) {
            return [];
          }
          const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
          for (let i = 0, len = callbacks.length; i < len; i++) {
            try {
              ret.push(callbacks[i].apply(contexts[i], args));
            } catch (e) {
              (0, ral_1.default)().console.error(e);
            }
          }
          return ret;
        }
        isEmpty() {
          return !this._callbacks || this._callbacks.length === 0;
        }
        dispose() {
          this._callbacks = void 0;
          this._contexts = void 0;
        }
      };
      var Emitter = class _Emitter {
        constructor(_options) {
          this._options = _options;
        }
        /**
         * For the public to allow to subscribe
         * to events from this Emitter
         */
        get event() {
          if (!this._event) {
            this._event = (listener, thisArgs, disposables) => {
              if (!this._callbacks) {
                this._callbacks = new CallbackList();
              }
              if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
                this._options.onFirstListenerAdd(this);
              }
              this._callbacks.add(listener, thisArgs);
              const result = {
                dispose: () => {
                  if (!this._callbacks) {
                    return;
                  }
                  this._callbacks.remove(listener, thisArgs);
                  result.dispose = _Emitter._noop;
                  if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
                    this._options.onLastListenerRemove(this);
                  }
                }
              };
              if (Array.isArray(disposables)) {
                disposables.push(result);
              }
              return result;
            };
          }
          return this._event;
        }
        /**
         * To be kept private to fire an event to
         * subscribers
         */
        fire(event) {
          if (this._callbacks) {
            this._callbacks.invoke.call(this._callbacks, event);
          }
        }
        dispose() {
          if (this._callbacks) {
            this._callbacks.dispose();
            this._callbacks = void 0;
          }
        }
      };
      exports.Emitter = Emitter;
      Emitter._noop = function() {
      };
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/cancellation.js
  var require_cancellation2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/cancellation.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CancellationTokenSource = exports.CancellationToken = void 0;
      var ral_1 = require_ral2();
      var Is3 = require_is4();
      var events_1 = require_events2();
      var CancellationToken;
      (function(CancellationToken2) {
        CancellationToken2.None = Object.freeze({
          isCancellationRequested: false,
          onCancellationRequested: events_1.Event.None
        });
        CancellationToken2.Cancelled = Object.freeze({
          isCancellationRequested: true,
          onCancellationRequested: events_1.Event.None
        });
        function is(value) {
          const candidate = value;
          return candidate && (candidate === CancellationToken2.None || candidate === CancellationToken2.Cancelled || Is3.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
        }
        CancellationToken2.is = is;
      })(CancellationToken || (exports.CancellationToken = CancellationToken = {}));
      var shortcutEvent = Object.freeze(function(callback, context) {
        const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
        return { dispose() {
          handle.dispose();
        } };
      });
      var MutableToken = class {
        constructor() {
          this._isCancelled = false;
        }
        cancel() {
          if (!this._isCancelled) {
            this._isCancelled = true;
            if (this._emitter) {
              this._emitter.fire(void 0);
              this.dispose();
            }
          }
        }
        get isCancellationRequested() {
          return this._isCancelled;
        }
        get onCancellationRequested() {
          if (this._isCancelled) {
            return shortcutEvent;
          }
          if (!this._emitter) {
            this._emitter = new events_1.Emitter();
          }
          return this._emitter.event;
        }
        dispose() {
          if (this._emitter) {
            this._emitter.dispose();
            this._emitter = void 0;
          }
        }
      };
      var CancellationTokenSource = class {
        get token() {
          if (!this._token) {
            this._token = new MutableToken();
          }
          return this._token;
        }
        cancel() {
          if (!this._token) {
            this._token = CancellationToken.Cancelled;
          } else {
            this._token.cancel();
          }
        }
        dispose() {
          if (!this._token) {
            this._token = CancellationToken.None;
          } else if (this._token instanceof MutableToken) {
            this._token.dispose();
          }
        }
      };
      exports.CancellationTokenSource = CancellationTokenSource;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js
  var require_sharedArrayCancellation2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = void 0;
      var cancellation_1 = require_cancellation2();
      var CancellationState;
      (function(CancellationState2) {
        CancellationState2.Continue = 0;
        CancellationState2.Cancelled = 1;
      })(CancellationState || (CancellationState = {}));
      var SharedArraySenderStrategy = class {
        constructor() {
          this.buffers = /* @__PURE__ */ new Map();
        }
        enableCancellation(request) {
          if (request.id === null) {
            return;
          }
          const buffer = new SharedArrayBuffer(4);
          const data = new Int32Array(buffer, 0, 1);
          data[0] = CancellationState.Continue;
          this.buffers.set(request.id, buffer);
          request.$cancellationData = buffer;
        }
        async sendCancellation(_conn, id) {
          const buffer = this.buffers.get(id);
          if (buffer === void 0) {
            return;
          }
          const data = new Int32Array(buffer, 0, 1);
          Atomics.store(data, 0, CancellationState.Cancelled);
        }
        cleanup(id) {
          this.buffers.delete(id);
        }
        dispose() {
          this.buffers.clear();
        }
      };
      exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
      var SharedArrayBufferCancellationToken = class {
        constructor(buffer) {
          this.data = new Int32Array(buffer, 0, 1);
        }
        get isCancellationRequested() {
          return Atomics.load(this.data, 0) === CancellationState.Cancelled;
        }
        get onCancellationRequested() {
          throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
        }
      };
      var SharedArrayBufferCancellationTokenSource = class {
        constructor(buffer) {
          this.token = new SharedArrayBufferCancellationToken(buffer);
        }
        cancel() {
        }
        dispose() {
        }
      };
      var SharedArrayReceiverStrategy = class {
        constructor() {
          this.kind = "request";
        }
        createCancellationTokenSource(request) {
          const buffer = request.$cancellationData;
          if (buffer === void 0) {
            return new cancellation_1.CancellationTokenSource();
          }
          return new SharedArrayBufferCancellationTokenSource(buffer);
        }
      };
      exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/semaphore.js
  var require_semaphore2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/semaphore.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Semaphore = void 0;
      var ral_1 = require_ral2();
      var Semaphore = class {
        constructor(capacity = 1) {
          if (capacity <= 0) {
            throw new Error("Capacity must be greater than 0");
          }
          this._capacity = capacity;
          this._active = 0;
          this._waiting = [];
        }
        lock(thunk) {
          return new Promise((resolve, reject) => {
            this._waiting.push({ thunk, resolve, reject });
            this.runNext();
          });
        }
        get active() {
          return this._active;
        }
        runNext() {
          if (this._waiting.length === 0 || this._active === this._capacity) {
            return;
          }
          (0, ral_1.default)().timer.setImmediate(() => this.doRunNext());
        }
        doRunNext() {
          if (this._waiting.length === 0 || this._active === this._capacity) {
            return;
          }
          const next = this._waiting.shift();
          this._active++;
          if (this._active > this._capacity) {
            throw new Error(`To many thunks active`);
          }
          try {
            const result = next.thunk();
            if (result instanceof Promise) {
              result.then((value) => {
                this._active--;
                next.resolve(value);
                this.runNext();
              }, (err) => {
                this._active--;
                next.reject(err);
                this.runNext();
              });
            } else {
              this._active--;
              next.resolve(result);
              this.runNext();
            }
          } catch (err) {
            this._active--;
            next.reject(err);
            this.runNext();
          }
        }
      };
      exports.Semaphore = Semaphore;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/messageReader.js
  var require_messageReader2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/messageReader.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0;
      var ral_1 = require_ral2();
      var Is3 = require_is4();
      var events_1 = require_events2();
      var semaphore_1 = require_semaphore2();
      var MessageReader;
      (function(MessageReader2) {
        function is(value) {
          let candidate = value;
          return candidate && Is3.func(candidate.listen) && Is3.func(candidate.dispose) && Is3.func(candidate.onError) && Is3.func(candidate.onClose) && Is3.func(candidate.onPartialMessage);
        }
        MessageReader2.is = is;
      })(MessageReader || (exports.MessageReader = MessageReader = {}));
      var AbstractMessageReader = class {
        constructor() {
          this.errorEmitter = new events_1.Emitter();
          this.closeEmitter = new events_1.Emitter();
          this.partialMessageEmitter = new events_1.Emitter();
        }
        dispose() {
          this.errorEmitter.dispose();
          this.closeEmitter.dispose();
        }
        get onError() {
          return this.errorEmitter.event;
        }
        fireError(error) {
          this.errorEmitter.fire(this.asError(error));
        }
        get onClose() {
          return this.closeEmitter.event;
        }
        fireClose() {
          this.closeEmitter.fire(void 0);
        }
        get onPartialMessage() {
          return this.partialMessageEmitter.event;
        }
        firePartialMessage(info) {
          this.partialMessageEmitter.fire(info);
        }
        asError(error) {
          if (error instanceof Error) {
            return error;
          } else {
            return new Error(`Reader received error. Reason: ${Is3.string(error.message) ? error.message : "unknown"}`);
          }
        }
      };
      exports.AbstractMessageReader = AbstractMessageReader;
      var ResolvedMessageReaderOptions;
      (function(ResolvedMessageReaderOptions2) {
        function fromOptions(options) {
          let charset;
          let result;
          let contentDecoder;
          const contentDecoders = /* @__PURE__ */ new Map();
          let contentTypeDecoder;
          const contentTypeDecoders = /* @__PURE__ */ new Map();
          if (options === void 0 || typeof options === "string") {
            charset = options ?? "utf-8";
          } else {
            charset = options.charset ?? "utf-8";
            if (options.contentDecoder !== void 0) {
              contentDecoder = options.contentDecoder;
              contentDecoders.set(contentDecoder.name, contentDecoder);
            }
            if (options.contentDecoders !== void 0) {
              for (const decoder of options.contentDecoders) {
                contentDecoders.set(decoder.name, decoder);
              }
            }
            if (options.contentTypeDecoder !== void 0) {
              contentTypeDecoder = options.contentTypeDecoder;
              contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
            }
            if (options.contentTypeDecoders !== void 0) {
              for (const decoder of options.contentTypeDecoders) {
                contentTypeDecoders.set(decoder.name, decoder);
              }
            }
          }
          if (contentTypeDecoder === void 0) {
            contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder;
            contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
          }
          return { charset, contentDecoder, contentDecoders, contentTypeDecoder, contentTypeDecoders };
        }
        ResolvedMessageReaderOptions2.fromOptions = fromOptions;
      })(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
      var ReadableStreamMessageReader = class extends AbstractMessageReader {
        constructor(readable, options) {
          super();
          this.readable = readable;
          this.options = ResolvedMessageReaderOptions.fromOptions(options);
          this.buffer = (0, ral_1.default)().messageBuffer.create(this.options.charset);
          this._partialMessageTimeout = 1e4;
          this.nextMessageLength = -1;
          this.messageToken = 0;
          this.readSemaphore = new semaphore_1.Semaphore(1);
        }
        set partialMessageTimeout(timeout) {
          this._partialMessageTimeout = timeout;
        }
        get partialMessageTimeout() {
          return this._partialMessageTimeout;
        }
        listen(callback) {
          this.nextMessageLength = -1;
          this.messageToken = 0;
          this.partialMessageTimer = void 0;
          this.callback = callback;
          const result = this.readable.onData((data) => {
            this.onData(data);
          });
          this.readable.onError((error) => this.fireError(error));
          this.readable.onClose(() => this.fireClose());
          return result;
        }
        onData(data) {
          try {
            this.buffer.append(data);
            while (true) {
              if (this.nextMessageLength === -1) {
                const headers = this.buffer.tryReadHeaders(true);
                if (!headers) {
                  return;
                }
                const contentLength = headers.get("content-length");
                if (!contentLength) {
                  this.fireError(new Error(`Header must provide a Content-Length property.
${JSON.stringify(Object.fromEntries(headers))}`));
                  return;
                }
                const length = parseInt(contentLength);
                if (isNaN(length)) {
                  this.fireError(new Error(`Content-Length value must be a number. Got ${contentLength}`));
                  return;
                }
                this.nextMessageLength = length;
              }
              const body = this.buffer.tryReadBody(this.nextMessageLength);
              if (body === void 0) {
                this.setPartialMessageTimer();
                return;
              }
              this.clearPartialMessageTimer();
              this.nextMessageLength = -1;
              this.readSemaphore.lock(async () => {
                const bytes = this.options.contentDecoder !== void 0 ? await this.options.contentDecoder.decode(body) : body;
                const message = await this.options.contentTypeDecoder.decode(bytes, this.options);
                this.callback(message);
              }).catch((error) => {
                this.fireError(error);
              });
            }
          } catch (error) {
            this.fireError(error);
          }
        }
        clearPartialMessageTimer() {
          if (this.partialMessageTimer) {
            this.partialMessageTimer.dispose();
            this.partialMessageTimer = void 0;
          }
        }
        setPartialMessageTimer() {
          this.clearPartialMessageTimer();
          if (this._partialMessageTimeout <= 0) {
            return;
          }
          this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout((token, timeout) => {
            this.partialMessageTimer = void 0;
            if (token === this.messageToken) {
              this.firePartialMessage({ messageToken: token, waitingTime: timeout });
              this.setPartialMessageTimer();
            }
          }, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
        }
      };
      exports.ReadableStreamMessageReader = ReadableStreamMessageReader;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/messageWriter.js
  var require_messageWriter2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/messageWriter.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0;
      var ral_1 = require_ral2();
      var Is3 = require_is4();
      var semaphore_1 = require_semaphore2();
      var events_1 = require_events2();
      var ContentLength = "Content-Length: ";
      var CRLF = "\r\n";
      var MessageWriter;
      (function(MessageWriter2) {
        function is(value) {
          let candidate = value;
          return candidate && Is3.func(candidate.dispose) && Is3.func(candidate.onClose) && Is3.func(candidate.onError) && Is3.func(candidate.write);
        }
        MessageWriter2.is = is;
      })(MessageWriter || (exports.MessageWriter = MessageWriter = {}));
      var AbstractMessageWriter = class {
        constructor() {
          this.errorEmitter = new events_1.Emitter();
          this.closeEmitter = new events_1.Emitter();
        }
        dispose() {
          this.errorEmitter.dispose();
          this.closeEmitter.dispose();
        }
        get onError() {
          return this.errorEmitter.event;
        }
        fireError(error, message, count) {
          this.errorEmitter.fire([this.asError(error), message, count]);
        }
        get onClose() {
          return this.closeEmitter.event;
        }
        fireClose() {
          this.closeEmitter.fire(void 0);
        }
        asError(error) {
          if (error instanceof Error) {
            return error;
          } else {
            return new Error(`Writer received error. Reason: ${Is3.string(error.message) ? error.message : "unknown"}`);
          }
        }
      };
      exports.AbstractMessageWriter = AbstractMessageWriter;
      var ResolvedMessageWriterOptions;
      (function(ResolvedMessageWriterOptions2) {
        function fromOptions(options) {
          if (options === void 0 || typeof options === "string") {
            return { charset: options ?? "utf-8", contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder };
          } else {
            return { charset: options.charset ?? "utf-8", contentEncoder: options.contentEncoder, contentTypeEncoder: options.contentTypeEncoder ?? (0, ral_1.default)().applicationJson.encoder };
          }
        }
        ResolvedMessageWriterOptions2.fromOptions = fromOptions;
      })(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
      var WriteableStreamMessageWriter = class extends AbstractMessageWriter {
        constructor(writable, options) {
          super();
          this.writable = writable;
          this.options = ResolvedMessageWriterOptions.fromOptions(options);
          this.errorCount = 0;
          this.writeSemaphore = new semaphore_1.Semaphore(1);
          this.writable.onError((error) => this.fireError(error));
          this.writable.onClose(() => this.fireClose());
        }
        async write(msg) {
          return this.writeSemaphore.lock(async () => {
            const payload = this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
              if (this.options.contentEncoder !== void 0) {
                return this.options.contentEncoder.encode(buffer);
              } else {
                return buffer;
              }
            });
            return payload.then((buffer) => {
              const headers = [];
              headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
              headers.push(CRLF);
              return this.doWrite(msg, headers, buffer);
            }, (error) => {
              this.fireError(error);
              throw error;
            });
          });
        }
        async doWrite(msg, headers, data) {
          try {
            await this.writable.write(headers.join(""), "ascii");
            return this.writable.write(data);
          } catch (error) {
            this.handleError(error, msg);
            return Promise.reject(error);
          }
        }
        handleError(error, msg) {
          this.errorCount++;
          this.fireError(error, msg, this.errorCount);
        }
        end() {
          this.writable.end();
        }
      };
      exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
  var require_messageBuffer2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.AbstractMessageBuffer = void 0;
      var CR = 13;
      var LF = 10;
      var CRLF = "\r\n";
      var AbstractMessageBuffer = class {
        constructor(encoding = "utf-8") {
          this._encoding = encoding;
          this._chunks = [];
          this._totalLength = 0;
        }
        get encoding() {
          return this._encoding;
        }
        append(chunk) {
          const toAppend = typeof chunk === "string" ? this.fromString(chunk, this._encoding) : chunk;
          this._chunks.push(toAppend);
          this._totalLength += toAppend.byteLength;
        }
        tryReadHeaders(lowerCaseKeys = false) {
          if (this._chunks.length === 0) {
            return void 0;
          }
          let state = 0;
          let chunkIndex = 0;
          let offset = 0;
          let chunkBytesRead = 0;
          row: while (chunkIndex < this._chunks.length) {
            const chunk = this._chunks[chunkIndex];
            offset = 0;
            column: while (offset < chunk.length) {
              const value = chunk[offset];
              switch (value) {
                case CR:
                  switch (state) {
                    case 0:
                      state = 1;
                      break;
                    case 2:
                      state = 3;
                      break;
                    default:
                      state = 0;
                  }
                  break;
                case LF:
                  switch (state) {
                    case 1:
                      state = 2;
                      break;
                    case 3:
                      state = 4;
                      offset++;
                      break row;
                    default:
                      state = 0;
                  }
                  break;
                default:
                  state = 0;
              }
              offset++;
            }
            chunkBytesRead += chunk.byteLength;
            chunkIndex++;
          }
          if (state !== 4) {
            return void 0;
          }
          const buffer = this._read(chunkBytesRead + offset);
          const result = /* @__PURE__ */ new Map();
          const headers = this.toString(buffer, "ascii").split(CRLF);
          if (headers.length < 2) {
            return result;
          }
          for (let i = 0; i < headers.length - 2; i++) {
            const header = headers[i];
            const index2 = header.indexOf(":");
            if (index2 === -1) {
              throw new Error(`Message header must separate key and value using ':'
${header}`);
            }
            const key = header.substr(0, index2);
            const value = header.substr(index2 + 1).trim();
            result.set(lowerCaseKeys ? key.toLowerCase() : key, value);
          }
          return result;
        }
        tryReadBody(length) {
          if (this._totalLength < length) {
            return void 0;
          }
          return this._read(length);
        }
        get numberOfBytes() {
          return this._totalLength;
        }
        _read(byteCount) {
          if (byteCount === 0) {
            return this.emptyBuffer();
          }
          if (byteCount > this._totalLength) {
            throw new Error(`Cannot read so many bytes!`);
          }
          if (this._chunks[0].byteLength === byteCount) {
            const chunk = this._chunks[0];
            this._chunks.shift();
            this._totalLength -= byteCount;
            return this.asNative(chunk);
          }
          if (this._chunks[0].byteLength > byteCount) {
            const chunk = this._chunks[0];
            const result2 = this.asNative(chunk, byteCount);
            this._chunks[0] = chunk.slice(byteCount);
            this._totalLength -= byteCount;
            return result2;
          }
          const result = this.allocNative(byteCount);
          let resultOffset = 0;
          let chunkIndex = 0;
          while (byteCount > 0) {
            const chunk = this._chunks[chunkIndex];
            if (chunk.byteLength > byteCount) {
              const chunkPart = chunk.slice(0, byteCount);
              result.set(chunkPart, resultOffset);
              resultOffset += byteCount;
              this._chunks[chunkIndex] = chunk.slice(byteCount);
              this._totalLength -= byteCount;
              byteCount -= byteCount;
            } else {
              result.set(chunk, resultOffset);
              resultOffset += chunk.byteLength;
              this._chunks.shift();
              this._totalLength -= chunk.byteLength;
              byteCount -= chunk.byteLength;
            }
          }
          return result;
        }
      };
      exports.AbstractMessageBuffer = AbstractMessageBuffer;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/connection.js
  var require_connection3 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/connection.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createMessageConnection = exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0;
      var ral_1 = require_ral2();
      var Is3 = require_is4();
      var messages_1 = require_messages3();
      var linkedMap_1 = require_linkedMap2();
      var events_1 = require_events2();
      var cancellation_1 = require_cancellation2();
      var CancelNotification;
      (function(CancelNotification2) {
        CancelNotification2.type = new messages_1.NotificationType("$/cancelRequest");
      })(CancelNotification || (CancelNotification = {}));
      var ProgressToken;
      (function(ProgressToken2) {
        function is(value) {
          return typeof value === "string" || typeof value === "number";
        }
        ProgressToken2.is = is;
      })(ProgressToken || (exports.ProgressToken = ProgressToken = {}));
      var ProgressNotification;
      (function(ProgressNotification2) {
        ProgressNotification2.type = new messages_1.NotificationType("$/progress");
      })(ProgressNotification || (ProgressNotification = {}));
      var ProgressType = class {
        constructor() {
        }
      };
      exports.ProgressType = ProgressType;
      var StarRequestHandler;
      (function(StarRequestHandler2) {
        function is(value) {
          return Is3.func(value);
        }
        StarRequestHandler2.is = is;
      })(StarRequestHandler || (StarRequestHandler = {}));
      exports.NullLogger = Object.freeze({
        error: () => {
        },
        warn: () => {
        },
        info: () => {
        },
        log: () => {
        }
      });
      var Trace;
      (function(Trace2) {
        Trace2[Trace2["Off"] = 0] = "Off";
        Trace2[Trace2["Messages"] = 1] = "Messages";
        Trace2[Trace2["Compact"] = 2] = "Compact";
        Trace2[Trace2["Verbose"] = 3] = "Verbose";
      })(Trace || (exports.Trace = Trace = {}));
      var TraceValues;
      (function(TraceValues2) {
        TraceValues2.Off = "off";
        TraceValues2.Messages = "messages";
        TraceValues2.Compact = "compact";
        TraceValues2.Verbose = "verbose";
      })(TraceValues || (exports.TraceValues = TraceValues = {}));
      (function(Trace2) {
        function fromString(value) {
          if (!Is3.string(value)) {
            return Trace2.Off;
          }
          value = value.toLowerCase();
          switch (value) {
            case "off":
              return Trace2.Off;
            case "messages":
              return Trace2.Messages;
            case "compact":
              return Trace2.Compact;
            case "verbose":
              return Trace2.Verbose;
            default:
              return Trace2.Off;
          }
        }
        Trace2.fromString = fromString;
        function toString(value) {
          switch (value) {
            case Trace2.Off:
              return "off";
            case Trace2.Messages:
              return "messages";
            case Trace2.Compact:
              return "compact";
            case Trace2.Verbose:
              return "verbose";
            default:
              return "off";
          }
        }
        Trace2.toString = toString;
      })(Trace || (exports.Trace = Trace = {}));
      var TraceFormat;
      (function(TraceFormat2) {
        TraceFormat2["Text"] = "text";
        TraceFormat2["JSON"] = "json";
      })(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
      (function(TraceFormat2) {
        function fromString(value) {
          if (!Is3.string(value)) {
            return TraceFormat2.Text;
          }
          value = value.toLowerCase();
          if (value === "json") {
            return TraceFormat2.JSON;
          } else {
            return TraceFormat2.Text;
          }
        }
        TraceFormat2.fromString = fromString;
      })(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
      var SetTraceNotification;
      (function(SetTraceNotification2) {
        SetTraceNotification2.type = new messages_1.NotificationType("$/setTrace");
      })(SetTraceNotification || (exports.SetTraceNotification = SetTraceNotification = {}));
      var LogTraceNotification;
      (function(LogTraceNotification2) {
        LogTraceNotification2.type = new messages_1.NotificationType("$/logTrace");
      })(LogTraceNotification || (exports.LogTraceNotification = LogTraceNotification = {}));
      var ConnectionErrors;
      (function(ConnectionErrors2) {
        ConnectionErrors2[ConnectionErrors2["Closed"] = 1] = "Closed";
        ConnectionErrors2[ConnectionErrors2["Disposed"] = 2] = "Disposed";
        ConnectionErrors2[ConnectionErrors2["AlreadyListening"] = 3] = "AlreadyListening";
      })(ConnectionErrors || (exports.ConnectionErrors = ConnectionErrors = {}));
      var ConnectionError = class _ConnectionError extends Error {
        constructor(code, message) {
          super(message);
          this.code = code;
          Object.setPrototypeOf(this, _ConnectionError.prototype);
        }
      };
      exports.ConnectionError = ConnectionError;
      var ConnectionStrategy;
      (function(ConnectionStrategy2) {
        function is(value) {
          const candidate = value;
          return candidate && Is3.func(candidate.cancelUndispatched);
        }
        ConnectionStrategy2.is = is;
      })(ConnectionStrategy || (exports.ConnectionStrategy = ConnectionStrategy = {}));
      var IdCancellationReceiverStrategy;
      (function(IdCancellationReceiverStrategy2) {
        function is(value) {
          const candidate = value;
          return candidate && (candidate.kind === void 0 || candidate.kind === "id") && Is3.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is3.func(candidate.dispose));
        }
        IdCancellationReceiverStrategy2.is = is;
      })(IdCancellationReceiverStrategy || (exports.IdCancellationReceiverStrategy = IdCancellationReceiverStrategy = {}));
      var RequestCancellationReceiverStrategy;
      (function(RequestCancellationReceiverStrategy2) {
        function is(value) {
          const candidate = value;
          return candidate && candidate.kind === "request" && Is3.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is3.func(candidate.dispose));
        }
        RequestCancellationReceiverStrategy2.is = is;
      })(RequestCancellationReceiverStrategy || (exports.RequestCancellationReceiverStrategy = RequestCancellationReceiverStrategy = {}));
      var CancellationReceiverStrategy;
      (function(CancellationReceiverStrategy2) {
        CancellationReceiverStrategy2.Message = Object.freeze({
          createCancellationTokenSource(_) {
            return new cancellation_1.CancellationTokenSource();
          }
        });
        function is(value) {
          return IdCancellationReceiverStrategy.is(value) || RequestCancellationReceiverStrategy.is(value);
        }
        CancellationReceiverStrategy2.is = is;
      })(CancellationReceiverStrategy || (exports.CancellationReceiverStrategy = CancellationReceiverStrategy = {}));
      var CancellationSenderStrategy;
      (function(CancellationSenderStrategy2) {
        CancellationSenderStrategy2.Message = Object.freeze({
          sendCancellation(conn, id) {
            return conn.sendNotification(CancelNotification.type, { id });
          },
          cleanup(_) {
          }
        });
        function is(value) {
          const candidate = value;
          return candidate && Is3.func(candidate.sendCancellation) && Is3.func(candidate.cleanup);
        }
        CancellationSenderStrategy2.is = is;
      })(CancellationSenderStrategy || (exports.CancellationSenderStrategy = CancellationSenderStrategy = {}));
      var CancellationStrategy;
      (function(CancellationStrategy2) {
        CancellationStrategy2.Message = Object.freeze({
          receiver: CancellationReceiverStrategy.Message,
          sender: CancellationSenderStrategy.Message
        });
        function is(value) {
          const candidate = value;
          return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
        }
        CancellationStrategy2.is = is;
      })(CancellationStrategy || (exports.CancellationStrategy = CancellationStrategy = {}));
      var MessageStrategy;
      (function(MessageStrategy2) {
        function is(value) {
          const candidate = value;
          return candidate && Is3.func(candidate.handleMessage);
        }
        MessageStrategy2.is = is;
      })(MessageStrategy || (exports.MessageStrategy = MessageStrategy = {}));
      var ConnectionOptions;
      (function(ConnectionOptions2) {
        function is(value) {
          const candidate = value;
          return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy));
        }
        ConnectionOptions2.is = is;
      })(ConnectionOptions || (exports.ConnectionOptions = ConnectionOptions = {}));
      var ConnectionState;
      (function(ConnectionState2) {
        ConnectionState2[ConnectionState2["New"] = 1] = "New";
        ConnectionState2[ConnectionState2["Listening"] = 2] = "Listening";
        ConnectionState2[ConnectionState2["Closed"] = 3] = "Closed";
        ConnectionState2[ConnectionState2["Disposed"] = 4] = "Disposed";
      })(ConnectionState || (ConnectionState = {}));
      function createMessageConnection(messageReader, messageWriter, _logger, options) {
        const logger = _logger !== void 0 ? _logger : exports.NullLogger;
        let sequenceNumber = 0;
        let notificationSequenceNumber = 0;
        let unknownResponseSequenceNumber = 0;
        const version = "2.0";
        let starRequestHandler = void 0;
        const requestHandlers = /* @__PURE__ */ new Map();
        let starNotificationHandler = void 0;
        const notificationHandlers = /* @__PURE__ */ new Map();
        const progressHandlers = /* @__PURE__ */ new Map();
        let timer;
        let messageQueue = new linkedMap_1.LinkedMap();
        let responsePromises = /* @__PURE__ */ new Map();
        let knownCanceledRequests = /* @__PURE__ */ new Set();
        let requestTokens = /* @__PURE__ */ new Map();
        let trace = Trace.Off;
        let traceFormat = TraceFormat.Text;
        let tracer;
        let state = ConnectionState.New;
        const errorEmitter = new events_1.Emitter();
        const closeEmitter = new events_1.Emitter();
        const unhandledNotificationEmitter = new events_1.Emitter();
        const unhandledProgressEmitter = new events_1.Emitter();
        const disposeEmitter = new events_1.Emitter();
        const cancellationStrategy = options && options.cancellationStrategy ? options.cancellationStrategy : CancellationStrategy.Message;
        function createRequestQueueKey(id) {
          if (id === null) {
            throw new Error(`Can't send requests with id null since the response can't be correlated.`);
          }
          return "req-" + id.toString();
        }
        function createResponseQueueKey(id) {
          if (id === null) {
            return "res-unknown-" + (++unknownResponseSequenceNumber).toString();
          } else {
            return "res-" + id.toString();
          }
        }
        function createNotificationQueueKey() {
          return "not-" + (++notificationSequenceNumber).toString();
        }
        function addMessageToQueue(queue, message) {
          if (messages_1.Message.isRequest(message)) {
            queue.set(createRequestQueueKey(message.id), message);
          } else if (messages_1.Message.isResponse(message)) {
            queue.set(createResponseQueueKey(message.id), message);
          } else {
            queue.set(createNotificationQueueKey(), message);
          }
        }
        function cancelUndispatched(_message) {
          return void 0;
        }
        function isListening() {
          return state === ConnectionState.Listening;
        }
        function isClosed() {
          return state === ConnectionState.Closed;
        }
        function isDisposed() {
          return state === ConnectionState.Disposed;
        }
        function closeHandler() {
          if (state === ConnectionState.New || state === ConnectionState.Listening) {
            state = ConnectionState.Closed;
            closeEmitter.fire(void 0);
          }
        }
        function readErrorHandler(error) {
          errorEmitter.fire([error, void 0, void 0]);
        }
        function writeErrorHandler(data) {
          errorEmitter.fire(data);
        }
        messageReader.onClose(closeHandler);
        messageReader.onError(readErrorHandler);
        messageWriter.onClose(closeHandler);
        messageWriter.onError(writeErrorHandler);
        function triggerMessageQueue() {
          if (timer || messageQueue.size === 0) {
            return;
          }
          timer = (0, ral_1.default)().timer.setImmediate(() => {
            timer = void 0;
            processMessageQueue();
          });
        }
        function handleMessage(message) {
          if (messages_1.Message.isRequest(message)) {
            handleRequest(message);
          } else if (messages_1.Message.isNotification(message)) {
            handleNotification(message);
          } else if (messages_1.Message.isResponse(message)) {
            handleResponse(message);
          } else {
            handleInvalidMessage(message);
          }
        }
        function processMessageQueue() {
          if (messageQueue.size === 0) {
            return;
          }
          const message = messageQueue.shift();
          try {
            const messageStrategy = options?.messageStrategy;
            if (MessageStrategy.is(messageStrategy)) {
              messageStrategy.handleMessage(message, handleMessage);
            } else {
              handleMessage(message);
            }
          } finally {
            triggerMessageQueue();
          }
        }
        const callback = (message) => {
          try {
            if (messages_1.Message.isNotification(message) && message.method === CancelNotification.type.method) {
              const cancelId = message.params.id;
              const key = createRequestQueueKey(cancelId);
              const toCancel = messageQueue.get(key);
              if (messages_1.Message.isRequest(toCancel)) {
                const strategy = options?.connectionStrategy;
                const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
                if (response && (response.error !== void 0 || response.result !== void 0)) {
                  messageQueue.delete(key);
                  requestTokens.delete(cancelId);
                  response.id = toCancel.id;
                  traceSendingResponse(response, message.method, Date.now());
                  messageWriter.write(response).catch(() => logger.error(`Sending response for canceled message failed.`));
                  return;
                }
              }
              const cancellationToken = requestTokens.get(cancelId);
              if (cancellationToken !== void 0) {
                cancellationToken.cancel();
                traceReceivedNotification(message);
                return;
              } else {
                knownCanceledRequests.add(cancelId);
              }
            }
            addMessageToQueue(messageQueue, message);
          } finally {
            triggerMessageQueue();
          }
        };
        function handleRequest(requestMessage) {
          if (isDisposed()) {
            return;
          }
          function reply(resultOrError, method, startTime2) {
            const message = {
              jsonrpc: version,
              id: requestMessage.id
            };
            if (resultOrError instanceof messages_1.ResponseError) {
              message.error = resultOrError.toJson();
            } else {
              message.result = resultOrError === void 0 ? null : resultOrError;
            }
            traceSendingResponse(message, method, startTime2);
            messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
          }
          function replyError(error, method, startTime2) {
            const message = {
              jsonrpc: version,
              id: requestMessage.id,
              error: error.toJson()
            };
            traceSendingResponse(message, method, startTime2);
            messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
          }
          function replySuccess(result, method, startTime2) {
            if (result === void 0) {
              result = null;
            }
            const message = {
              jsonrpc: version,
              id: requestMessage.id,
              result
            };
            traceSendingResponse(message, method, startTime2);
            messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
          }
          traceReceivedRequest(requestMessage);
          const element = requestHandlers.get(requestMessage.method);
          let type;
          let requestHandler;
          if (element) {
            type = element.type;
            requestHandler = element.handler;
          }
          const startTime = Date.now();
          if (requestHandler || starRequestHandler) {
            const tokenKey = requestMessage.id ?? String(Date.now());
            const cancellationSource = IdCancellationReceiverStrategy.is(cancellationStrategy.receiver) ? cancellationStrategy.receiver.createCancellationTokenSource(tokenKey) : cancellationStrategy.receiver.createCancellationTokenSource(requestMessage);
            if (requestMessage.id !== null && knownCanceledRequests.has(requestMessage.id)) {
              cancellationSource.cancel();
            }
            if (requestMessage.id !== null) {
              requestTokens.set(tokenKey, cancellationSource);
            }
            try {
              let handlerResult;
              if (requestHandler) {
                if (requestMessage.params === void 0) {
                  if (type !== void 0 && type.numberOfParams !== 0) {
                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
                    return;
                  }
                  handlerResult = requestHandler(cancellationSource.token);
                } else if (Array.isArray(requestMessage.params)) {
                  if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byName) {
                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
                    return;
                  }
                  handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
                } else {
                  if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
                    return;
                  }
                  handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
                }
              } else if (starRequestHandler) {
                handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
              }
              const promise = handlerResult;
              if (!handlerResult) {
                requestTokens.delete(tokenKey);
                replySuccess(handlerResult, requestMessage.method, startTime);
              } else if (promise.then) {
                promise.then((resultOrError) => {
                  requestTokens.delete(tokenKey);
                  reply(resultOrError, requestMessage.method, startTime);
                }, (error) => {
                  requestTokens.delete(tokenKey);
                  if (error instanceof messages_1.ResponseError) {
                    replyError(error, requestMessage.method, startTime);
                  } else if (error && Is3.string(error.message)) {
                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
                  } else {
                    replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
                  }
                });
              } else {
                requestTokens.delete(tokenKey);
                reply(handlerResult, requestMessage.method, startTime);
              }
            } catch (error) {
              requestTokens.delete(tokenKey);
              if (error instanceof messages_1.ResponseError) {
                reply(error, requestMessage.method, startTime);
              } else if (error && Is3.string(error.message)) {
                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
              } else {
                replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
              }
            }
          } else {
            replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
          }
        }
        function handleResponse(responseMessage) {
          if (isDisposed()) {
            return;
          }
          if (responseMessage.id === null) {
            if (responseMessage.error) {
              logger.error(`Received response message without id: Error is: 
${JSON.stringify(responseMessage.error, void 0, 4)}`);
            } else {
              logger.error(`Received response message without id. No further error information provided.`);
            }
          } else {
            const key = responseMessage.id;
            const responsePromise = responsePromises.get(key);
            traceReceivedResponse(responseMessage, responsePromise);
            if (responsePromise !== void 0) {
              responsePromises.delete(key);
              try {
                if (responseMessage.error) {
                  const error = responseMessage.error;
                  responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
                } else if (responseMessage.result !== void 0) {
                  responsePromise.resolve(responseMessage.result);
                } else {
                  throw new Error("Should never happen.");
                }
              } catch (error) {
                if (error.message) {
                  logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
                } else {
                  logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
                }
              }
            }
          }
        }
        function handleNotification(message) {
          if (isDisposed()) {
            return;
          }
          let type = void 0;
          let notificationHandler;
          if (message.method === CancelNotification.type.method) {
            const cancelId = message.params.id;
            knownCanceledRequests.delete(cancelId);
            traceReceivedNotification(message);
            return;
          } else {
            const element = notificationHandlers.get(message.method);
            if (element) {
              notificationHandler = element.handler;
              type = element.type;
            }
          }
          if (notificationHandler || starNotificationHandler) {
            try {
              traceReceivedNotification(message);
              if (notificationHandler) {
                if (message.params === void 0) {
                  if (type !== void 0) {
                    if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) {
                      logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
                    }
                  }
                  notificationHandler();
                } else if (Array.isArray(message.params)) {
                  const params = message.params;
                  if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) {
                    notificationHandler({ token: params[0], value: params[1] });
                  } else {
                    if (type !== void 0) {
                      if (type.parameterStructures === messages_1.ParameterStructures.byName) {
                        logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
                      }
                      if (type.numberOfParams !== message.params.length) {
                        logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
                      }
                    }
                    notificationHandler(...params);
                  }
                } else {
                  if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
                    logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
                  }
                  notificationHandler(message.params);
                }
              } else if (starNotificationHandler) {
                starNotificationHandler(message.method, message.params);
              }
            } catch (error) {
              if (error.message) {
                logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
              } else {
                logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
              }
            }
          } else {
            unhandledNotificationEmitter.fire(message);
          }
        }
        function handleInvalidMessage(message) {
          if (!message) {
            logger.error("Received empty message.");
            return;
          }
          logger.error(`Received message which is neither a response nor a notification message:
${JSON.stringify(message, null, 4)}`);
          const responseMessage = message;
          if (Is3.string(responseMessage.id) || Is3.number(responseMessage.id)) {
            const key = responseMessage.id;
            const responseHandler = responsePromises.get(key);
            if (responseHandler) {
              responseHandler.reject(new Error("The received response has neither a result nor an error property."));
            }
          }
        }
        function stringifyTrace(params) {
          if (params === void 0 || params === null) {
            return void 0;
          }
          switch (trace) {
            case Trace.Verbose:
              return JSON.stringify(params, null, 4);
            case Trace.Compact:
              return JSON.stringify(params);
            default:
              return void 0;
          }
        }
        function traceSendingRequest(message) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
              data = `Params: ${stringifyTrace(message.params)}

`;
            }
            tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
          } else {
            logLSPMessage("send-request", message);
          }
        }
        function traceSendingNotification(message) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if (trace === Trace.Verbose || trace === Trace.Compact) {
              if (message.params) {
                data = `Params: ${stringifyTrace(message.params)}

`;
              } else {
                data = "No parameters provided.\n\n";
              }
            }
            tracer.log(`Sending notification '${message.method}'.`, data);
          } else {
            logLSPMessage("send-notification", message);
          }
        }
        function traceSendingResponse(message, method, startTime) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if (trace === Trace.Verbose || trace === Trace.Compact) {
              if (message.error && message.error.data) {
                data = `Error data: ${stringifyTrace(message.error.data)}

`;
              } else {
                if (message.result) {
                  data = `Result: ${stringifyTrace(message.result)}

`;
                } else if (message.error === void 0) {
                  data = "No result returned.\n\n";
                }
              }
            }
            tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
          } else {
            logLSPMessage("send-response", message);
          }
        }
        function traceReceivedRequest(message) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) {
              data = `Params: ${stringifyTrace(message.params)}

`;
            }
            tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
          } else {
            logLSPMessage("receive-request", message);
          }
        }
        function traceReceivedNotification(message) {
          if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if (trace === Trace.Verbose || trace === Trace.Compact) {
              if (message.params) {
                data = `Params: ${stringifyTrace(message.params)}

`;
              } else {
                data = "No parameters provided.\n\n";
              }
            }
            tracer.log(`Received notification '${message.method}'.`, data);
          } else {
            logLSPMessage("receive-notification", message);
          }
        }
        function traceReceivedResponse(message, responsePromise) {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          if (traceFormat === TraceFormat.Text) {
            let data = void 0;
            if (trace === Trace.Verbose || trace === Trace.Compact) {
              if (message.error && message.error.data) {
                data = `Error data: ${stringifyTrace(message.error.data)}

`;
              } else {
                if (message.result) {
                  data = `Result: ${stringifyTrace(message.result)}

`;
                } else if (message.error === void 0) {
                  data = "No result returned.\n\n";
                }
              }
            }
            if (responsePromise) {
              const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
              tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
            } else {
              tracer.log(`Received response ${message.id} without active response promise.`, data);
            }
          } else {
            logLSPMessage("receive-response", message);
          }
        }
        function logLSPMessage(type, message) {
          if (!tracer || trace === Trace.Off) {
            return;
          }
          const lspMessage = {
            isLSPMessage: true,
            type,
            message,
            timestamp: Date.now()
          };
          tracer.log(lspMessage);
        }
        function throwIfClosedOrDisposed() {
          if (isClosed()) {
            throw new ConnectionError(ConnectionErrors.Closed, "Connection is closed.");
          }
          if (isDisposed()) {
            throw new ConnectionError(ConnectionErrors.Disposed, "Connection is disposed.");
          }
        }
        function throwIfListening() {
          if (isListening()) {
            throw new ConnectionError(ConnectionErrors.AlreadyListening, "Connection is already listening");
          }
        }
        function throwIfNotListening() {
          if (!isListening()) {
            throw new Error("Call listen() first.");
          }
        }
        function undefinedToNull(param) {
          if (param === void 0) {
            return null;
          } else {
            return param;
          }
        }
        function nullToUndefined(param) {
          if (param === null) {
            return void 0;
          } else {
            return param;
          }
        }
        function isNamedParam(param) {
          return param !== void 0 && param !== null && !Array.isArray(param) && typeof param === "object";
        }
        function computeSingleParam(parameterStructures, param) {
          switch (parameterStructures) {
            case messages_1.ParameterStructures.auto:
              if (isNamedParam(param)) {
                return nullToUndefined(param);
              } else {
                return [undefinedToNull(param)];
              }
            case messages_1.ParameterStructures.byName:
              if (!isNamedParam(param)) {
                throw new Error(`Received parameters by name but param is not an object literal.`);
              }
              return nullToUndefined(param);
            case messages_1.ParameterStructures.byPosition:
              return [undefinedToNull(param)];
            default:
              throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
          }
        }
        function computeMessageParams(type, params) {
          let result;
          const numberOfParams = type.numberOfParams;
          switch (numberOfParams) {
            case 0:
              result = void 0;
              break;
            case 1:
              result = computeSingleParam(type.parameterStructures, params[0]);
              break;
            default:
              result = [];
              for (let i = 0; i < params.length && i < numberOfParams; i++) {
                result.push(undefinedToNull(params[i]));
              }
              if (params.length < numberOfParams) {
                for (let i = params.length; i < numberOfParams; i++) {
                  result.push(null);
                }
              }
              break;
          }
          return result;
        }
        const connection2 = {
          sendNotification: (type, ...args) => {
            throwIfClosedOrDisposed();
            let method;
            let messageParams;
            if (Is3.string(type)) {
              method = type;
              const first = args[0];
              let paramStart = 0;
              let parameterStructures = messages_1.ParameterStructures.auto;
              if (messages_1.ParameterStructures.is(first)) {
                paramStart = 1;
                parameterStructures = first;
              }
              let paramEnd = args.length;
              const numberOfParams = paramEnd - paramStart;
              switch (numberOfParams) {
                case 0:
                  messageParams = void 0;
                  break;
                case 1:
                  messageParams = computeSingleParam(parameterStructures, args[paramStart]);
                  break;
                default:
                  if (parameterStructures === messages_1.ParameterStructures.byName) {
                    throw new Error(`Received ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
                  }
                  messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
                  break;
              }
            } else {
              const params = args;
              method = type.method;
              messageParams = computeMessageParams(type, params);
            }
            const notificationMessage = {
              jsonrpc: version,
              method,
              params: messageParams
            };
            traceSendingNotification(notificationMessage);
            return messageWriter.write(notificationMessage).catch((error) => {
              logger.error(`Sending notification failed.`);
              throw error;
            });
          },
          onNotification: (type, handler) => {
            throwIfClosedOrDisposed();
            let method;
            if (Is3.func(type)) {
              starNotificationHandler = type;
            } else if (handler) {
              if (Is3.string(type)) {
                method = type;
                notificationHandlers.set(type, { type: void 0, handler });
              } else {
                method = type.method;
                notificationHandlers.set(type.method, { type, handler });
              }
            }
            return {
              dispose: () => {
                if (method !== void 0) {
                  notificationHandlers.delete(method);
                } else {
                  starNotificationHandler = void 0;
                }
              }
            };
          },
          onProgress: (_type, token, handler) => {
            if (progressHandlers.has(token)) {
              throw new Error(`Progress handler for token ${token} already registered`);
            }
            progressHandlers.set(token, handler);
            return {
              dispose: () => {
                progressHandlers.delete(token);
              }
            };
          },
          sendProgress: (_type, token, value) => {
            return connection2.sendNotification(ProgressNotification.type, { token, value });
          },
          onUnhandledProgress: unhandledProgressEmitter.event,
          sendRequest: (type, ...args) => {
            throwIfClosedOrDisposed();
            throwIfNotListening();
            let method;
            let messageParams;
            let token = void 0;
            if (Is3.string(type)) {
              method = type;
              const first = args[0];
              const last = args[args.length - 1];
              let paramStart = 0;
              let parameterStructures = messages_1.ParameterStructures.auto;
              if (messages_1.ParameterStructures.is(first)) {
                paramStart = 1;
                parameterStructures = first;
              }
              let paramEnd = args.length;
              if (cancellation_1.CancellationToken.is(last)) {
                paramEnd = paramEnd - 1;
                token = last;
              }
              const numberOfParams = paramEnd - paramStart;
              switch (numberOfParams) {
                case 0:
                  messageParams = void 0;
                  break;
                case 1:
                  messageParams = computeSingleParam(parameterStructures, args[paramStart]);
                  break;
                default:
                  if (parameterStructures === messages_1.ParameterStructures.byName) {
                    throw new Error(`Received ${numberOfParams} parameters for 'by Name' request parameter structure.`);
                  }
                  messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
                  break;
              }
            } else {
              const params = args;
              method = type.method;
              messageParams = computeMessageParams(type, params);
              const numberOfParams = type.numberOfParams;
              token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : void 0;
            }
            const id = sequenceNumber++;
            let disposable;
            if (token) {
              disposable = token.onCancellationRequested(() => {
                const p = cancellationStrategy.sender.sendCancellation(connection2, id);
                if (p === void 0) {
                  logger.log(`Received no promise from cancellation strategy when cancelling id ${id}`);
                  return Promise.resolve();
                } else {
                  return p.catch(() => {
                    logger.log(`Sending cancellation messages for id ${id} failed`);
                  });
                }
              });
            }
            const requestMessage = {
              jsonrpc: version,
              id,
              method,
              params: messageParams
            };
            traceSendingRequest(requestMessage);
            if (typeof cancellationStrategy.sender.enableCancellation === "function") {
              cancellationStrategy.sender.enableCancellation(requestMessage);
            }
            return new Promise(async (resolve, reject) => {
              const resolveWithCleanup = (r) => {
                resolve(r);
                cancellationStrategy.sender.cleanup(id);
                disposable?.dispose();
              };
              const rejectWithCleanup = (r) => {
                reject(r);
                cancellationStrategy.sender.cleanup(id);
                disposable?.dispose();
              };
              const responsePromise = { method, timerStart: Date.now(), resolve: resolveWithCleanup, reject: rejectWithCleanup };
              try {
                await messageWriter.write(requestMessage);
                responsePromises.set(id, responsePromise);
              } catch (error) {
                logger.error(`Sending request failed.`);
                responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : "Unknown reason"));
                throw error;
              }
            });
          },
          onRequest: (type, handler) => {
            throwIfClosedOrDisposed();
            let method = null;
            if (StarRequestHandler.is(type)) {
              method = void 0;
              starRequestHandler = type;
            } else if (Is3.string(type)) {
              method = null;
              if (handler !== void 0) {
                method = type;
                requestHandlers.set(type, { handler, type: void 0 });
              }
            } else {
              if (handler !== void 0) {
                method = type.method;
                requestHandlers.set(type.method, { type, handler });
              }
            }
            return {
              dispose: () => {
                if (method === null) {
                  return;
                }
                if (method !== void 0) {
                  requestHandlers.delete(method);
                } else {
                  starRequestHandler = void 0;
                }
              }
            };
          },
          hasPendingResponse: () => {
            return responsePromises.size > 0;
          },
          trace: async (_value, _tracer, sendNotificationOrTraceOptions) => {
            let _sendNotification = false;
            let _traceFormat = TraceFormat.Text;
            if (sendNotificationOrTraceOptions !== void 0) {
              if (Is3.boolean(sendNotificationOrTraceOptions)) {
                _sendNotification = sendNotificationOrTraceOptions;
              } else {
                _sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
                _traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
              }
            }
            trace = _value;
            traceFormat = _traceFormat;
            if (trace === Trace.Off) {
              tracer = void 0;
            } else {
              tracer = _tracer;
            }
            if (_sendNotification && !isClosed() && !isDisposed()) {
              await connection2.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
            }
          },
          onError: errorEmitter.event,
          onClose: closeEmitter.event,
          onUnhandledNotification: unhandledNotificationEmitter.event,
          onDispose: disposeEmitter.event,
          end: () => {
            messageWriter.end();
          },
          dispose: () => {
            if (isDisposed()) {
              return;
            }
            state = ConnectionState.Disposed;
            disposeEmitter.fire(void 0);
            const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, "Pending response rejected since connection got disposed");
            for (const promise of responsePromises.values()) {
              promise.reject(error);
            }
            responsePromises = /* @__PURE__ */ new Map();
            requestTokens = /* @__PURE__ */ new Map();
            knownCanceledRequests = /* @__PURE__ */ new Set();
            messageQueue = new linkedMap_1.LinkedMap();
            if (Is3.func(messageWriter.dispose)) {
              messageWriter.dispose();
            }
            if (Is3.func(messageReader.dispose)) {
              messageReader.dispose();
            }
          },
          listen: () => {
            throwIfClosedOrDisposed();
            throwIfListening();
            state = ConnectionState.Listening;
            messageReader.listen(callback);
          },
          inspect: () => {
            (0, ral_1.default)().console.log("inspect");
          }
        };
        connection2.onNotification(LogTraceNotification.type, (params) => {
          if (trace === Trace.Off || !tracer) {
            return;
          }
          const verbose = trace === Trace.Verbose || trace === Trace.Compact;
          tracer.log(params.message, verbose ? params.verbose : void 0);
        });
        connection2.onNotification(ProgressNotification.type, (params) => {
          const handler = progressHandlers.get(params.token);
          if (handler) {
            handler(params.value);
          } else {
            unhandledProgressEmitter.fire(params);
          }
        });
        return connection2;
      }
      exports.createMessageConnection = createMessageConnection;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/common/api.js
  var require_api4 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/common/api.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.AbstractMessageBuffer = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = exports.LRUCache = exports.Touch = exports.LinkedMap = exports.ParameterStructures = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.ErrorCodes = exports.ResponseError = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType0 = exports.RequestType = exports.Message = exports.RAL = void 0;
      exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = void 0;
      var messages_1 = require_messages3();
      Object.defineProperty(exports, "Message", { enumerable: true, get: function() {
        return messages_1.Message;
      } });
      Object.defineProperty(exports, "RequestType", { enumerable: true, get: function() {
        return messages_1.RequestType;
      } });
      Object.defineProperty(exports, "RequestType0", { enumerable: true, get: function() {
        return messages_1.RequestType0;
      } });
      Object.defineProperty(exports, "RequestType1", { enumerable: true, get: function() {
        return messages_1.RequestType1;
      } });
      Object.defineProperty(exports, "RequestType2", { enumerable: true, get: function() {
        return messages_1.RequestType2;
      } });
      Object.defineProperty(exports, "RequestType3", { enumerable: true, get: function() {
        return messages_1.RequestType3;
      } });
      Object.defineProperty(exports, "RequestType4", { enumerable: true, get: function() {
        return messages_1.RequestType4;
      } });
      Object.defineProperty(exports, "RequestType5", { enumerable: true, get: function() {
        return messages_1.RequestType5;
      } });
      Object.defineProperty(exports, "RequestType6", { enumerable: true, get: function() {
        return messages_1.RequestType6;
      } });
      Object.defineProperty(exports, "RequestType7", { enumerable: true, get: function() {
        return messages_1.RequestType7;
      } });
      Object.defineProperty(exports, "RequestType8", { enumerable: true, get: function() {
        return messages_1.RequestType8;
      } });
      Object.defineProperty(exports, "RequestType9", { enumerable: true, get: function() {
        return messages_1.RequestType9;
      } });
      Object.defineProperty(exports, "ResponseError", { enumerable: true, get: function() {
        return messages_1.ResponseError;
      } });
      Object.defineProperty(exports, "ErrorCodes", { enumerable: true, get: function() {
        return messages_1.ErrorCodes;
      } });
      Object.defineProperty(exports, "NotificationType", { enumerable: true, get: function() {
        return messages_1.NotificationType;
      } });
      Object.defineProperty(exports, "NotificationType0", { enumerable: true, get: function() {
        return messages_1.NotificationType0;
      } });
      Object.defineProperty(exports, "NotificationType1", { enumerable: true, get: function() {
        return messages_1.NotificationType1;
      } });
      Object.defineProperty(exports, "NotificationType2", { enumerable: true, get: function() {
        return messages_1.NotificationType2;
      } });
      Object.defineProperty(exports, "NotificationType3", { enumerable: true, get: function() {
        return messages_1.NotificationType3;
      } });
      Object.defineProperty(exports, "NotificationType4", { enumerable: true, get: function() {
        return messages_1.NotificationType4;
      } });
      Object.defineProperty(exports, "NotificationType5", { enumerable: true, get: function() {
        return messages_1.NotificationType5;
      } });
      Object.defineProperty(exports, "NotificationType6", { enumerable: true, get: function() {
        return messages_1.NotificationType6;
      } });
      Object.defineProperty(exports, "NotificationType7", { enumerable: true, get: function() {
        return messages_1.NotificationType7;
      } });
      Object.defineProperty(exports, "NotificationType8", { enumerable: true, get: function() {
        return messages_1.NotificationType8;
      } });
      Object.defineProperty(exports, "NotificationType9", { enumerable: true, get: function() {
        return messages_1.NotificationType9;
      } });
      Object.defineProperty(exports, "ParameterStructures", { enumerable: true, get: function() {
        return messages_1.ParameterStructures;
      } });
      var linkedMap_1 = require_linkedMap2();
      Object.defineProperty(exports, "LinkedMap", { enumerable: true, get: function() {
        return linkedMap_1.LinkedMap;
      } });
      Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function() {
        return linkedMap_1.LRUCache;
      } });
      Object.defineProperty(exports, "Touch", { enumerable: true, get: function() {
        return linkedMap_1.Touch;
      } });
      var disposable_1 = require_disposable2();
      Object.defineProperty(exports, "Disposable", { enumerable: true, get: function() {
        return disposable_1.Disposable;
      } });
      var events_1 = require_events2();
      Object.defineProperty(exports, "Event", { enumerable: true, get: function() {
        return events_1.Event;
      } });
      Object.defineProperty(exports, "Emitter", { enumerable: true, get: function() {
        return events_1.Emitter;
      } });
      var cancellation_1 = require_cancellation2();
      Object.defineProperty(exports, "CancellationTokenSource", { enumerable: true, get: function() {
        return cancellation_1.CancellationTokenSource;
      } });
      Object.defineProperty(exports, "CancellationToken", { enumerable: true, get: function() {
        return cancellation_1.CancellationToken;
      } });
      var sharedArrayCancellation_1 = require_sharedArrayCancellation2();
      Object.defineProperty(exports, "SharedArraySenderStrategy", { enumerable: true, get: function() {
        return sharedArrayCancellation_1.SharedArraySenderStrategy;
      } });
      Object.defineProperty(exports, "SharedArrayReceiverStrategy", { enumerable: true, get: function() {
        return sharedArrayCancellation_1.SharedArrayReceiverStrategy;
      } });
      var messageReader_1 = require_messageReader2();
      Object.defineProperty(exports, "MessageReader", { enumerable: true, get: function() {
        return messageReader_1.MessageReader;
      } });
      Object.defineProperty(exports, "AbstractMessageReader", { enumerable: true, get: function() {
        return messageReader_1.AbstractMessageReader;
      } });
      Object.defineProperty(exports, "ReadableStreamMessageReader", { enumerable: true, get: function() {
        return messageReader_1.ReadableStreamMessageReader;
      } });
      var messageWriter_1 = require_messageWriter2();
      Object.defineProperty(exports, "MessageWriter", { enumerable: true, get: function() {
        return messageWriter_1.MessageWriter;
      } });
      Object.defineProperty(exports, "AbstractMessageWriter", { enumerable: true, get: function() {
        return messageWriter_1.AbstractMessageWriter;
      } });
      Object.defineProperty(exports, "WriteableStreamMessageWriter", { enumerable: true, get: function() {
        return messageWriter_1.WriteableStreamMessageWriter;
      } });
      var messageBuffer_1 = require_messageBuffer2();
      Object.defineProperty(exports, "AbstractMessageBuffer", { enumerable: true, get: function() {
        return messageBuffer_1.AbstractMessageBuffer;
      } });
      var connection_1 = require_connection3();
      Object.defineProperty(exports, "ConnectionStrategy", { enumerable: true, get: function() {
        return connection_1.ConnectionStrategy;
      } });
      Object.defineProperty(exports, "ConnectionOptions", { enumerable: true, get: function() {
        return connection_1.ConnectionOptions;
      } });
      Object.defineProperty(exports, "NullLogger", { enumerable: true, get: function() {
        return connection_1.NullLogger;
      } });
      Object.defineProperty(exports, "createMessageConnection", { enumerable: true, get: function() {
        return connection_1.createMessageConnection;
      } });
      Object.defineProperty(exports, "ProgressToken", { enumerable: true, get: function() {
        return connection_1.ProgressToken;
      } });
      Object.defineProperty(exports, "ProgressType", { enumerable: true, get: function() {
        return connection_1.ProgressType;
      } });
      Object.defineProperty(exports, "Trace", { enumerable: true, get: function() {
        return connection_1.Trace;
      } });
      Object.defineProperty(exports, "TraceValues", { enumerable: true, get: function() {
        return connection_1.TraceValues;
      } });
      Object.defineProperty(exports, "TraceFormat", { enumerable: true, get: function() {
        return connection_1.TraceFormat;
      } });
      Object.defineProperty(exports, "SetTraceNotification", { enumerable: true, get: function() {
        return connection_1.SetTraceNotification;
      } });
      Object.defineProperty(exports, "LogTraceNotification", { enumerable: true, get: function() {
        return connection_1.LogTraceNotification;
      } });
      Object.defineProperty(exports, "ConnectionErrors", { enumerable: true, get: function() {
        return connection_1.ConnectionErrors;
      } });
      Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function() {
        return connection_1.ConnectionError;
      } });
      Object.defineProperty(exports, "CancellationReceiverStrategy", { enumerable: true, get: function() {
        return connection_1.CancellationReceiverStrategy;
      } });
      Object.defineProperty(exports, "CancellationSenderStrategy", { enumerable: true, get: function() {
        return connection_1.CancellationSenderStrategy;
      } });
      Object.defineProperty(exports, "CancellationStrategy", { enumerable: true, get: function() {
        return connection_1.CancellationStrategy;
      } });
      Object.defineProperty(exports, "MessageStrategy", { enumerable: true, get: function() {
        return connection_1.MessageStrategy;
      } });
      var ral_1 = require_ral2();
      exports.RAL = ral_1.default;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/browser/ril.js
  var require_ril2 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/browser/ril.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      var api_1 = require_api4();
      var MessageBuffer = class _MessageBuffer extends api_1.AbstractMessageBuffer {
        constructor(encoding = "utf-8") {
          super(encoding);
          this.asciiDecoder = new TextDecoder("ascii");
        }
        emptyBuffer() {
          return _MessageBuffer.emptyBuffer;
        }
        fromString(value, _encoding) {
          return new TextEncoder().encode(value);
        }
        toString(value, encoding) {
          if (encoding === "ascii") {
            return this.asciiDecoder.decode(value);
          } else {
            return new TextDecoder(encoding).decode(value);
          }
        }
        asNative(buffer, length) {
          if (length === void 0) {
            return buffer;
          } else {
            return buffer.slice(0, length);
          }
        }
        allocNative(length) {
          return new Uint8Array(length);
        }
      };
      MessageBuffer.emptyBuffer = new Uint8Array(0);
      var ReadableStreamWrapper = class {
        constructor(socket) {
          this.socket = socket;
          this._onData = new api_1.Emitter();
          this._messageListener = (event) => {
            const blob = event.data;
            blob.arrayBuffer().then((buffer) => {
              this._onData.fire(new Uint8Array(buffer));
            }, () => {
              (0, api_1.RAL)().console.error(`Converting blob to array buffer failed.`);
            });
          };
          this.socket.addEventListener("message", this._messageListener);
        }
        onClose(listener) {
          this.socket.addEventListener("close", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("close", listener));
        }
        onError(listener) {
          this.socket.addEventListener("error", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("error", listener));
        }
        onEnd(listener) {
          this.socket.addEventListener("end", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("end", listener));
        }
        onData(listener) {
          return this._onData.event(listener);
        }
      };
      var WritableStreamWrapper = class {
        constructor(socket) {
          this.socket = socket;
        }
        onClose(listener) {
          this.socket.addEventListener("close", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("close", listener));
        }
        onError(listener) {
          this.socket.addEventListener("error", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("error", listener));
        }
        onEnd(listener) {
          this.socket.addEventListener("end", listener);
          return api_1.Disposable.create(() => this.socket.removeEventListener("end", listener));
        }
        write(data, encoding) {
          if (typeof data === "string") {
            if (encoding !== void 0 && encoding !== "utf-8") {
              throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${encoding}`);
            }
            this.socket.send(data);
          } else {
            this.socket.send(data);
          }
          return Promise.resolve();
        }
        end() {
          this.socket.close();
        }
      };
      var _textEncoder = new TextEncoder();
      var _ril = Object.freeze({
        messageBuffer: Object.freeze({
          create: (encoding) => new MessageBuffer(encoding)
        }),
        applicationJson: Object.freeze({
          encoder: Object.freeze({
            name: "application/json",
            encode: (msg, options) => {
              if (options.charset !== "utf-8") {
                throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${options.charset}`);
              }
              return Promise.resolve(_textEncoder.encode(JSON.stringify(msg, void 0, 0)));
            }
          }),
          decoder: Object.freeze({
            name: "application/json",
            decode: (buffer, options) => {
              if (!(buffer instanceof Uint8Array)) {
                throw new Error(`In a Browser environments only Uint8Arrays are supported.`);
              }
              return Promise.resolve(JSON.parse(new TextDecoder(options.charset).decode(buffer)));
            }
          })
        }),
        stream: Object.freeze({
          asReadableStream: (socket) => new ReadableStreamWrapper(socket),
          asWritableStream: (socket) => new WritableStreamWrapper(socket)
        }),
        console,
        timer: Object.freeze({
          setTimeout(callback, ms, ...args) {
            const handle = setTimeout(callback, ms, ...args);
            return { dispose: () => clearTimeout(handle) };
          },
          setImmediate(callback, ...args) {
            const handle = setTimeout(callback, 0, ...args);
            return { dispose: () => clearTimeout(handle) };
          },
          setInterval(callback, ms, ...args) {
            const handle = setInterval(callback, ms, ...args);
            return { dispose: () => clearInterval(handle) };
          }
        })
      });
      function RIL() {
        return _ril;
      }
      (function(RIL2) {
        function install() {
          api_1.RAL.install(_ril);
        }
        RIL2.install = install;
      })(RIL || (RIL = {}));
      exports.default = RIL;
    }
  });

  // server/node_modules/vscode-jsonrpc/lib/browser/main.js
  var require_main4 = __commonJS({
    "server/node_modules/vscode-jsonrpc/lib/browser/main.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createMessageConnection = exports.BrowserMessageWriter = exports.BrowserMessageReader = void 0;
      var ril_1 = require_ril2();
      ril_1.default.install();
      var api_1 = require_api4();
      __exportStar(require_api4(), exports);
      var BrowserMessageReader2 = class extends api_1.AbstractMessageReader {
        constructor(port) {
          super();
          this._onData = new api_1.Emitter();
          this._messageListener = (event) => {
            this._onData.fire(event.data);
          };
          port.addEventListener("error", (event) => this.fireError(event));
          port.onmessage = this._messageListener;
        }
        listen(callback) {
          return this._onData.event(callback);
        }
      };
      exports.BrowserMessageReader = BrowserMessageReader2;
      var BrowserMessageWriter2 = class extends api_1.AbstractMessageWriter {
        constructor(port) {
          super();
          this.port = port;
          this.errorCount = 0;
          port.addEventListener("error", (event) => this.fireError(event));
        }
        write(msg) {
          try {
            this.port.postMessage(msg);
            return Promise.resolve();
          } catch (error) {
            this.handleError(error, msg);
            return Promise.reject(error);
          }
        }
        handleError(error, msg) {
          this.errorCount++;
          this.fireError(error, msg, this.errorCount);
        }
        end() {
        }
      };
      exports.BrowserMessageWriter = BrowserMessageWriter2;
      function createMessageConnection(reader, writer, logger, options) {
        if (logger === void 0) {
          logger = api_1.NullLogger;
        }
        if (api_1.ConnectionStrategy.is(options)) {
          options = { connectionStrategy: options };
        }
        return (0, api_1.createMessageConnection)(reader, writer, logger, options);
      }
      exports.createMessageConnection = createMessageConnection;
    }
  });

  // server/node_modules/vscode-jsonrpc/browser.js
  var require_browser = __commonJS({
    "server/node_modules/vscode-jsonrpc/browser.js"(exports, module) {
      "use strict";
      module.exports = require_main4();
    }
  });

  // server/node_modules/vscode-languageserver-types/lib/esm/main.js
  var main_exports2 = {};
  __export(main_exports2, {
    AnnotatedTextEdit: () => AnnotatedTextEdit2,
    ChangeAnnotation: () => ChangeAnnotation2,
    ChangeAnnotationIdentifier: () => ChangeAnnotationIdentifier2,
    CodeAction: () => CodeAction2,
    CodeActionContext: () => CodeActionContext2,
    CodeActionKind: () => CodeActionKind2,
    CodeActionTriggerKind: () => CodeActionTriggerKind2,
    CodeDescription: () => CodeDescription2,
    CodeLens: () => CodeLens2,
    Color: () => Color2,
    ColorInformation: () => ColorInformation2,
    ColorPresentation: () => ColorPresentation2,
    Command: () => Command2,
    CompletionItem: () => CompletionItem2,
    CompletionItemKind: () => CompletionItemKind2,
    CompletionItemLabelDetails: () => CompletionItemLabelDetails2,
    CompletionItemTag: () => CompletionItemTag2,
    CompletionList: () => CompletionList2,
    CreateFile: () => CreateFile2,
    DeleteFile: () => DeleteFile2,
    Diagnostic: () => Diagnostic2,
    DiagnosticRelatedInformation: () => DiagnosticRelatedInformation2,
    DiagnosticSeverity: () => DiagnosticSeverity2,
    DiagnosticTag: () => DiagnosticTag2,
    DocumentHighlight: () => DocumentHighlight2,
    DocumentHighlightKind: () => DocumentHighlightKind2,
    DocumentLink: () => DocumentLink2,
    DocumentSymbol: () => DocumentSymbol2,
    DocumentUri: () => DocumentUri2,
    EOL: () => EOL2,
    FoldingRange: () => FoldingRange2,
    FoldingRangeKind: () => FoldingRangeKind2,
    FormattingOptions: () => FormattingOptions2,
    Hover: () => Hover2,
    InlayHint: () => InlayHint2,
    InlayHintKind: () => InlayHintKind2,
    InlayHintLabelPart: () => InlayHintLabelPart2,
    InlineCompletionContext: () => InlineCompletionContext2,
    InlineCompletionItem: () => InlineCompletionItem2,
    InlineCompletionList: () => InlineCompletionList2,
    InlineCompletionTriggerKind: () => InlineCompletionTriggerKind2,
    InlineValueContext: () => InlineValueContext2,
    InlineValueEvaluatableExpression: () => InlineValueEvaluatableExpression2,
    InlineValueText: () => InlineValueText2,
    InlineValueVariableLookup: () => InlineValueVariableLookup2,
    InsertReplaceEdit: () => InsertReplaceEdit2,
    InsertTextFormat: () => InsertTextFormat2,
    InsertTextMode: () => InsertTextMode2,
    Location: () => Location2,
    LocationLink: () => LocationLink2,
    MarkedString: () => MarkedString2,
    MarkupContent: () => MarkupContent2,
    MarkupKind: () => MarkupKind2,
    OptionalVersionedTextDocumentIdentifier: () => OptionalVersionedTextDocumentIdentifier2,
    ParameterInformation: () => ParameterInformation2,
    Position: () => Position2,
    Range: () => Range2,
    RenameFile: () => RenameFile2,
    SelectedCompletionInfo: () => SelectedCompletionInfo2,
    SelectionRange: () => SelectionRange2,
    SemanticTokenModifiers: () => SemanticTokenModifiers2,
    SemanticTokenTypes: () => SemanticTokenTypes2,
    SemanticTokens: () => SemanticTokens2,
    SignatureInformation: () => SignatureInformation2,
    StringValue: () => StringValue2,
    SymbolInformation: () => SymbolInformation2,
    SymbolKind: () => SymbolKind2,
    SymbolTag: () => SymbolTag2,
    TextDocument: () => TextDocument3,
    TextDocumentEdit: () => TextDocumentEdit2,
    TextDocumentIdentifier: () => TextDocumentIdentifier2,
    TextDocumentItem: () => TextDocumentItem2,
    TextEdit: () => TextEdit2,
    URI: () => URI2,
    VersionedTextDocumentIdentifier: () => VersionedTextDocumentIdentifier2,
    WorkspaceChange: () => WorkspaceChange2,
    WorkspaceEdit: () => WorkspaceEdit2,
    WorkspaceFolder: () => WorkspaceFolder2,
    WorkspaceSymbol: () => WorkspaceSymbol2,
    integer: () => integer2,
    uinteger: () => uinteger2
  });
  var DocumentUri2, URI2, integer2, uinteger2, Position2, Range2, Location2, LocationLink2, Color2, ColorInformation2, ColorPresentation2, FoldingRangeKind2, FoldingRange2, DiagnosticRelatedInformation2, DiagnosticSeverity2, DiagnosticTag2, CodeDescription2, Diagnostic2, Command2, TextEdit2, ChangeAnnotation2, ChangeAnnotationIdentifier2, AnnotatedTextEdit2, TextDocumentEdit2, CreateFile2, RenameFile2, DeleteFile2, WorkspaceEdit2, TextEditChangeImpl2, ChangeAnnotations2, WorkspaceChange2, TextDocumentIdentifier2, VersionedTextDocumentIdentifier2, OptionalVersionedTextDocumentIdentifier2, TextDocumentItem2, MarkupKind2, MarkupContent2, CompletionItemKind2, InsertTextFormat2, CompletionItemTag2, InsertReplaceEdit2, InsertTextMode2, CompletionItemLabelDetails2, CompletionItem2, CompletionList2, MarkedString2, Hover2, ParameterInformation2, SignatureInformation2, DocumentHighlightKind2, DocumentHighlight2, SymbolKind2, SymbolTag2, SymbolInformation2, WorkspaceSymbol2, DocumentSymbol2, CodeActionKind2, CodeActionTriggerKind2, CodeActionContext2, CodeAction2, CodeLens2, FormattingOptions2, DocumentLink2, SelectionRange2, SemanticTokenTypes2, SemanticTokenModifiers2, SemanticTokens2, InlineValueText2, InlineValueVariableLookup2, InlineValueEvaluatableExpression2, InlineValueContext2, InlayHintKind2, InlayHintLabelPart2, InlayHint2, StringValue2, InlineCompletionItem2, InlineCompletionList2, InlineCompletionTriggerKind2, SelectedCompletionInfo2, InlineCompletionContext2, WorkspaceFolder2, EOL2, TextDocument3, FullTextDocument3, Is2;
  var init_main2 = __esm({
    "server/node_modules/vscode-languageserver-types/lib/esm/main.js"() {
      "use strict";
      (function(DocumentUri3) {
        function is(value) {
          return typeof value === "string";
        }
        DocumentUri3.is = is;
      })(DocumentUri2 || (DocumentUri2 = {}));
      (function(URI3) {
        function is(value) {
          return typeof value === "string";
        }
        URI3.is = is;
      })(URI2 || (URI2 = {}));
      (function(integer3) {
        integer3.MIN_VALUE = -2147483648;
        integer3.MAX_VALUE = 2147483647;
        function is(value) {
          return typeof value === "number" && integer3.MIN_VALUE <= value && value <= integer3.MAX_VALUE;
        }
        integer3.is = is;
      })(integer2 || (integer2 = {}));
      (function(uinteger3) {
        uinteger3.MIN_VALUE = 0;
        uinteger3.MAX_VALUE = 2147483647;
        function is(value) {
          return typeof value === "number" && uinteger3.MIN_VALUE <= value && value <= uinteger3.MAX_VALUE;
        }
        uinteger3.is = is;
      })(uinteger2 || (uinteger2 = {}));
      (function(Position4) {
        function create(line, character) {
          if (line === Number.MAX_VALUE) {
            line = uinteger2.MAX_VALUE;
          }
          if (character === Number.MAX_VALUE) {
            character = uinteger2.MAX_VALUE;
          }
          return { line, character };
        }
        Position4.create = create;
        function is(value) {
          let candidate = value;
          return Is2.objectLiteral(candidate) && Is2.uinteger(candidate.line) && Is2.uinteger(candidate.character);
        }
        Position4.is = is;
      })(Position2 || (Position2 = {}));
      (function(Range4) {
        function create(one, two, three, four) {
          if (Is2.uinteger(one) && Is2.uinteger(two) && Is2.uinteger(three) && Is2.uinteger(four)) {
            return { start: Position2.create(one, two), end: Position2.create(three, four) };
          } else if (Position2.is(one) && Position2.is(two)) {
            return { start: one, end: two };
          } else {
            throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
          }
        }
        Range4.create = create;
        function is(value) {
          let candidate = value;
          return Is2.objectLiteral(candidate) && Position2.is(candidate.start) && Position2.is(candidate.end);
        }
        Range4.is = is;
      })(Range2 || (Range2 = {}));
      (function(Location4) {
        function create(uri, range) {
          return { uri, range };
        }
        Location4.create = create;
        function is(value) {
          let candidate = value;
          return Is2.objectLiteral(candidate) && Range2.is(candidate.range) && (Is2.string(candidate.uri) || Is2.undefined(candidate.uri));
        }
        Location4.is = is;
      })(Location2 || (Location2 = {}));
      (function(LocationLink3) {
        function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
          return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
        }
        LocationLink3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.objectLiteral(candidate) && Range2.is(candidate.targetRange) && Is2.string(candidate.targetUri) && Range2.is(candidate.targetSelectionRange) && (Range2.is(candidate.originSelectionRange) || Is2.undefined(candidate.originSelectionRange));
        }
        LocationLink3.is = is;
      })(LocationLink2 || (LocationLink2 = {}));
      (function(Color3) {
        function create(red, green, blue, alpha) {
          return {
            red,
            green,
            blue,
            alpha
          };
        }
        Color3.create = create;
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && Is2.numberRange(candidate.red, 0, 1) && Is2.numberRange(candidate.green, 0, 1) && Is2.numberRange(candidate.blue, 0, 1) && Is2.numberRange(candidate.alpha, 0, 1);
        }
        Color3.is = is;
      })(Color2 || (Color2 = {}));
      (function(ColorInformation3) {
        function create(range, color) {
          return {
            range,
            color
          };
        }
        ColorInformation3.create = create;
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && Range2.is(candidate.range) && Color2.is(candidate.color);
        }
        ColorInformation3.is = is;
      })(ColorInformation2 || (ColorInformation2 = {}));
      (function(ColorPresentation3) {
        function create(label, textEdit, additionalTextEdits) {
          return {
            label,
            textEdit,
            additionalTextEdits
          };
        }
        ColorPresentation3.create = create;
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && Is2.string(candidate.label) && (Is2.undefined(candidate.textEdit) || TextEdit2.is(candidate)) && (Is2.undefined(candidate.additionalTextEdits) || Is2.typedArray(candidate.additionalTextEdits, TextEdit2.is));
        }
        ColorPresentation3.is = is;
      })(ColorPresentation2 || (ColorPresentation2 = {}));
      (function(FoldingRangeKind4) {
        FoldingRangeKind4.Comment = "comment";
        FoldingRangeKind4.Imports = "imports";
        FoldingRangeKind4.Region = "region";
      })(FoldingRangeKind2 || (FoldingRangeKind2 = {}));
      (function(FoldingRange5) {
        function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
          const result = {
            startLine,
            endLine
          };
          if (Is2.defined(startCharacter)) {
            result.startCharacter = startCharacter;
          }
          if (Is2.defined(endCharacter)) {
            result.endCharacter = endCharacter;
          }
          if (Is2.defined(kind)) {
            result.kind = kind;
          }
          if (Is2.defined(collapsedText)) {
            result.collapsedText = collapsedText;
          }
          return result;
        }
        FoldingRange5.create = create;
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && Is2.uinteger(candidate.startLine) && Is2.uinteger(candidate.startLine) && (Is2.undefined(candidate.startCharacter) || Is2.uinteger(candidate.startCharacter)) && (Is2.undefined(candidate.endCharacter) || Is2.uinteger(candidate.endCharacter)) && (Is2.undefined(candidate.kind) || Is2.string(candidate.kind));
        }
        FoldingRange5.is = is;
      })(FoldingRange2 || (FoldingRange2 = {}));
      (function(DiagnosticRelatedInformation3) {
        function create(location, message) {
          return {
            location,
            message
          };
        }
        DiagnosticRelatedInformation3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Location2.is(candidate.location) && Is2.string(candidate.message);
        }
        DiagnosticRelatedInformation3.is = is;
      })(DiagnosticRelatedInformation2 || (DiagnosticRelatedInformation2 = {}));
      (function(DiagnosticSeverity7) {
        DiagnosticSeverity7.Error = 1;
        DiagnosticSeverity7.Warning = 2;
        DiagnosticSeverity7.Information = 3;
        DiagnosticSeverity7.Hint = 4;
      })(DiagnosticSeverity2 || (DiagnosticSeverity2 = {}));
      (function(DiagnosticTag3) {
        DiagnosticTag3.Unnecessary = 1;
        DiagnosticTag3.Deprecated = 2;
      })(DiagnosticTag2 || (DiagnosticTag2 = {}));
      (function(CodeDescription3) {
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && Is2.string(candidate.href);
        }
        CodeDescription3.is = is;
      })(CodeDescription2 || (CodeDescription2 = {}));
      (function(Diagnostic7) {
        function create(range, message, severity, code, source, relatedInformation) {
          let result = { range, message };
          if (Is2.defined(severity)) {
            result.severity = severity;
          }
          if (Is2.defined(code)) {
            result.code = code;
          }
          if (Is2.defined(source)) {
            result.source = source;
          }
          if (Is2.defined(relatedInformation)) {
            result.relatedInformation = relatedInformation;
          }
          return result;
        }
        Diagnostic7.create = create;
        function is(value) {
          var _a;
          let candidate = value;
          return Is2.defined(candidate) && Range2.is(candidate.range) && Is2.string(candidate.message) && (Is2.number(candidate.severity) || Is2.undefined(candidate.severity)) && (Is2.integer(candidate.code) || Is2.string(candidate.code) || Is2.undefined(candidate.code)) && (Is2.undefined(candidate.codeDescription) || Is2.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is2.string(candidate.source) || Is2.undefined(candidate.source)) && (Is2.undefined(candidate.relatedInformation) || Is2.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation2.is));
        }
        Diagnostic7.is = is;
      })(Diagnostic2 || (Diagnostic2 = {}));
      (function(Command3) {
        function create(title, command, ...args) {
          let result = { title, command };
          if (Is2.defined(args) && args.length > 0) {
            result.arguments = args;
          }
          return result;
        }
        Command3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Is2.string(candidate.title) && Is2.string(candidate.command);
        }
        Command3.is = is;
      })(Command2 || (Command2 = {}));
      (function(TextEdit6) {
        function replace(range, newText) {
          return { range, newText };
        }
        TextEdit6.replace = replace;
        function insert(position, newText) {
          return { range: { start: position, end: position }, newText };
        }
        TextEdit6.insert = insert;
        function del(range) {
          return { range, newText: "" };
        }
        TextEdit6.del = del;
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && Is2.string(candidate.newText) && Range2.is(candidate.range);
        }
        TextEdit6.is = is;
      })(TextEdit2 || (TextEdit2 = {}));
      (function(ChangeAnnotation3) {
        function create(label, needsConfirmation, description) {
          const result = { label };
          if (needsConfirmation !== void 0) {
            result.needsConfirmation = needsConfirmation;
          }
          if (description !== void 0) {
            result.description = description;
          }
          return result;
        }
        ChangeAnnotation3.create = create;
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && Is2.string(candidate.label) && (Is2.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is2.string(candidate.description) || candidate.description === void 0);
        }
        ChangeAnnotation3.is = is;
      })(ChangeAnnotation2 || (ChangeAnnotation2 = {}));
      (function(ChangeAnnotationIdentifier3) {
        function is(value) {
          const candidate = value;
          return Is2.string(candidate);
        }
        ChangeAnnotationIdentifier3.is = is;
      })(ChangeAnnotationIdentifier2 || (ChangeAnnotationIdentifier2 = {}));
      (function(AnnotatedTextEdit3) {
        function replace(range, newText, annotation) {
          return { range, newText, annotationId: annotation };
        }
        AnnotatedTextEdit3.replace = replace;
        function insert(position, newText, annotation) {
          return { range: { start: position, end: position }, newText, annotationId: annotation };
        }
        AnnotatedTextEdit3.insert = insert;
        function del(range, annotation) {
          return { range, newText: "", annotationId: annotation };
        }
        AnnotatedTextEdit3.del = del;
        function is(value) {
          const candidate = value;
          return TextEdit2.is(candidate) && (ChangeAnnotation2.is(candidate.annotationId) || ChangeAnnotationIdentifier2.is(candidate.annotationId));
        }
        AnnotatedTextEdit3.is = is;
      })(AnnotatedTextEdit2 || (AnnotatedTextEdit2 = {}));
      (function(TextDocumentEdit3) {
        function create(textDocument, edits) {
          return { textDocument, edits };
        }
        TextDocumentEdit3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && OptionalVersionedTextDocumentIdentifier2.is(candidate.textDocument) && Array.isArray(candidate.edits);
        }
        TextDocumentEdit3.is = is;
      })(TextDocumentEdit2 || (TextDocumentEdit2 = {}));
      (function(CreateFile3) {
        function create(uri, options, annotation) {
          let result = {
            kind: "create",
            uri
          };
          if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
            result.options = options;
          }
          if (annotation !== void 0) {
            result.annotationId = annotation;
          }
          return result;
        }
        CreateFile3.create = create;
        function is(value) {
          let candidate = value;
          return candidate && candidate.kind === "create" && Is2.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is2.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is2.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier2.is(candidate.annotationId));
        }
        CreateFile3.is = is;
      })(CreateFile2 || (CreateFile2 = {}));
      (function(RenameFile3) {
        function create(oldUri, newUri, options, annotation) {
          let result = {
            kind: "rename",
            oldUri,
            newUri
          };
          if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
            result.options = options;
          }
          if (annotation !== void 0) {
            result.annotationId = annotation;
          }
          return result;
        }
        RenameFile3.create = create;
        function is(value) {
          let candidate = value;
          return candidate && candidate.kind === "rename" && Is2.string(candidate.oldUri) && Is2.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is2.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is2.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier2.is(candidate.annotationId));
        }
        RenameFile3.is = is;
      })(RenameFile2 || (RenameFile2 = {}));
      (function(DeleteFile3) {
        function create(uri, options, annotation) {
          let result = {
            kind: "delete",
            uri
          };
          if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
            result.options = options;
          }
          if (annotation !== void 0) {
            result.annotationId = annotation;
          }
          return result;
        }
        DeleteFile3.create = create;
        function is(value) {
          let candidate = value;
          return candidate && candidate.kind === "delete" && Is2.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is2.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is2.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier2.is(candidate.annotationId));
        }
        DeleteFile3.is = is;
      })(DeleteFile2 || (DeleteFile2 = {}));
      (function(WorkspaceEdit5) {
        function is(value) {
          let candidate = value;
          return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every((change) => {
            if (Is2.string(change.kind)) {
              return CreateFile2.is(change) || RenameFile2.is(change) || DeleteFile2.is(change);
            } else {
              return TextDocumentEdit2.is(change);
            }
          }));
        }
        WorkspaceEdit5.is = is;
      })(WorkspaceEdit2 || (WorkspaceEdit2 = {}));
      TextEditChangeImpl2 = class {
        constructor(edits, changeAnnotations) {
          this.edits = edits;
          this.changeAnnotations = changeAnnotations;
        }
        insert(position, newText, annotation) {
          let edit;
          let id;
          if (annotation === void 0) {
            edit = TextEdit2.insert(position, newText);
          } else if (ChangeAnnotationIdentifier2.is(annotation)) {
            id = annotation;
            edit = AnnotatedTextEdit2.insert(position, newText, annotation);
          } else {
            this.assertChangeAnnotations(this.changeAnnotations);
            id = this.changeAnnotations.manage(annotation);
            edit = AnnotatedTextEdit2.insert(position, newText, id);
          }
          this.edits.push(edit);
          if (id !== void 0) {
            return id;
          }
        }
        replace(range, newText, annotation) {
          let edit;
          let id;
          if (annotation === void 0) {
            edit = TextEdit2.replace(range, newText);
          } else if (ChangeAnnotationIdentifier2.is(annotation)) {
            id = annotation;
            edit = AnnotatedTextEdit2.replace(range, newText, annotation);
          } else {
            this.assertChangeAnnotations(this.changeAnnotations);
            id = this.changeAnnotations.manage(annotation);
            edit = AnnotatedTextEdit2.replace(range, newText, id);
          }
          this.edits.push(edit);
          if (id !== void 0) {
            return id;
          }
        }
        delete(range, annotation) {
          let edit;
          let id;
          if (annotation === void 0) {
            edit = TextEdit2.del(range);
          } else if (ChangeAnnotationIdentifier2.is(annotation)) {
            id = annotation;
            edit = AnnotatedTextEdit2.del(range, annotation);
          } else {
            this.assertChangeAnnotations(this.changeAnnotations);
            id = this.changeAnnotations.manage(annotation);
            edit = AnnotatedTextEdit2.del(range, id);
          }
          this.edits.push(edit);
          if (id !== void 0) {
            return id;
          }
        }
        add(edit) {
          this.edits.push(edit);
        }
        all() {
          return this.edits;
        }
        clear() {
          this.edits.splice(0, this.edits.length);
        }
        assertChangeAnnotations(value) {
          if (value === void 0) {
            throw new Error(`Text edit change is not configured to manage change annotations.`);
          }
        }
      };
      ChangeAnnotations2 = class {
        constructor(annotations) {
          this._annotations = annotations === void 0 ? /* @__PURE__ */ Object.create(null) : annotations;
          this._counter = 0;
          this._size = 0;
        }
        all() {
          return this._annotations;
        }
        get size() {
          return this._size;
        }
        manage(idOrAnnotation, annotation) {
          let id;
          if (ChangeAnnotationIdentifier2.is(idOrAnnotation)) {
            id = idOrAnnotation;
          } else {
            id = this.nextId();
            annotation = idOrAnnotation;
          }
          if (this._annotations[id] !== void 0) {
            throw new Error(`Id ${id} is already in use.`);
          }
          if (annotation === void 0) {
            throw new Error(`No annotation provided for id ${id}`);
          }
          this._annotations[id] = annotation;
          this._size++;
          return id;
        }
        nextId() {
          this._counter++;
          return this._counter.toString();
        }
      };
      WorkspaceChange2 = class {
        constructor(workspaceEdit) {
          this._textEditChanges = /* @__PURE__ */ Object.create(null);
          if (workspaceEdit !== void 0) {
            this._workspaceEdit = workspaceEdit;
            if (workspaceEdit.documentChanges) {
              this._changeAnnotations = new ChangeAnnotations2(workspaceEdit.changeAnnotations);
              workspaceEdit.changeAnnotations = this._changeAnnotations.all();
              workspaceEdit.documentChanges.forEach((change) => {
                if (TextDocumentEdit2.is(change)) {
                  const textEditChange = new TextEditChangeImpl2(change.edits, this._changeAnnotations);
                  this._textEditChanges[change.textDocument.uri] = textEditChange;
                }
              });
            } else if (workspaceEdit.changes) {
              Object.keys(workspaceEdit.changes).forEach((key) => {
                const textEditChange = new TextEditChangeImpl2(workspaceEdit.changes[key]);
                this._textEditChanges[key] = textEditChange;
              });
            }
          } else {
            this._workspaceEdit = {};
          }
        }
        /**
         * Returns the underlying {@link WorkspaceEdit} literal
         * use to be returned from a workspace edit operation like rename.
         */
        get edit() {
          this.initDocumentChanges();
          if (this._changeAnnotations !== void 0) {
            if (this._changeAnnotations.size === 0) {
              this._workspaceEdit.changeAnnotations = void 0;
            } else {
              this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
            }
          }
          return this._workspaceEdit;
        }
        getTextEditChange(key) {
          if (OptionalVersionedTextDocumentIdentifier2.is(key)) {
            this.initDocumentChanges();
            if (this._workspaceEdit.documentChanges === void 0) {
              throw new Error("Workspace edit is not configured for document changes.");
            }
            const textDocument = { uri: key.uri, version: key.version };
            let result = this._textEditChanges[textDocument.uri];
            if (!result) {
              const edits = [];
              const textDocumentEdit = {
                textDocument,
                edits
              };
              this._workspaceEdit.documentChanges.push(textDocumentEdit);
              result = new TextEditChangeImpl2(edits, this._changeAnnotations);
              this._textEditChanges[textDocument.uri] = result;
            }
            return result;
          } else {
            this.initChanges();
            if (this._workspaceEdit.changes === void 0) {
              throw new Error("Workspace edit is not configured for normal text edit changes.");
            }
            let result = this._textEditChanges[key];
            if (!result) {
              let edits = [];
              this._workspaceEdit.changes[key] = edits;
              result = new TextEditChangeImpl2(edits);
              this._textEditChanges[key] = result;
            }
            return result;
          }
        }
        initDocumentChanges() {
          if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
            this._changeAnnotations = new ChangeAnnotations2();
            this._workspaceEdit.documentChanges = [];
            this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();
          }
        }
        initChanges() {
          if (this._workspaceEdit.documentChanges === void 0 && this._workspaceEdit.changes === void 0) {
            this._workspaceEdit.changes = /* @__PURE__ */ Object.create(null);
          }
        }
        createFile(uri, optionsOrAnnotation, options) {
          this.initDocumentChanges();
          if (this._workspaceEdit.documentChanges === void 0) {
            throw new Error("Workspace edit is not configured for document changes.");
          }
          let annotation;
          if (ChangeAnnotation2.is(optionsOrAnnotation) || ChangeAnnotationIdentifier2.is(optionsOrAnnotation)) {
            annotation = optionsOrAnnotation;
          } else {
            options = optionsOrAnnotation;
          }
          let operation;
          let id;
          if (annotation === void 0) {
            operation = CreateFile2.create(uri, options);
          } else {
            id = ChangeAnnotationIdentifier2.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
            operation = CreateFile2.create(uri, options, id);
          }
          this._workspaceEdit.documentChanges.push(operation);
          if (id !== void 0) {
            return id;
          }
        }
        renameFile(oldUri, newUri, optionsOrAnnotation, options) {
          this.initDocumentChanges();
          if (this._workspaceEdit.documentChanges === void 0) {
            throw new Error("Workspace edit is not configured for document changes.");
          }
          let annotation;
          if (ChangeAnnotation2.is(optionsOrAnnotation) || ChangeAnnotationIdentifier2.is(optionsOrAnnotation)) {
            annotation = optionsOrAnnotation;
          } else {
            options = optionsOrAnnotation;
          }
          let operation;
          let id;
          if (annotation === void 0) {
            operation = RenameFile2.create(oldUri, newUri, options);
          } else {
            id = ChangeAnnotationIdentifier2.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
            operation = RenameFile2.create(oldUri, newUri, options, id);
          }
          this._workspaceEdit.documentChanges.push(operation);
          if (id !== void 0) {
            return id;
          }
        }
        deleteFile(uri, optionsOrAnnotation, options) {
          this.initDocumentChanges();
          if (this._workspaceEdit.documentChanges === void 0) {
            throw new Error("Workspace edit is not configured for document changes.");
          }
          let annotation;
          if (ChangeAnnotation2.is(optionsOrAnnotation) || ChangeAnnotationIdentifier2.is(optionsOrAnnotation)) {
            annotation = optionsOrAnnotation;
          } else {
            options = optionsOrAnnotation;
          }
          let operation;
          let id;
          if (annotation === void 0) {
            operation = DeleteFile2.create(uri, options);
          } else {
            id = ChangeAnnotationIdentifier2.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);
            operation = DeleteFile2.create(uri, options, id);
          }
          this._workspaceEdit.documentChanges.push(operation);
          if (id !== void 0) {
            return id;
          }
        }
      };
      (function(TextDocumentIdentifier3) {
        function create(uri) {
          return { uri };
        }
        TextDocumentIdentifier3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Is2.string(candidate.uri);
        }
        TextDocumentIdentifier3.is = is;
      })(TextDocumentIdentifier2 || (TextDocumentIdentifier2 = {}));
      (function(VersionedTextDocumentIdentifier3) {
        function create(uri, version) {
          return { uri, version };
        }
        VersionedTextDocumentIdentifier3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Is2.string(candidate.uri) && Is2.integer(candidate.version);
        }
        VersionedTextDocumentIdentifier3.is = is;
      })(VersionedTextDocumentIdentifier2 || (VersionedTextDocumentIdentifier2 = {}));
      (function(OptionalVersionedTextDocumentIdentifier3) {
        function create(uri, version) {
          return { uri, version };
        }
        OptionalVersionedTextDocumentIdentifier3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Is2.string(candidate.uri) && (candidate.version === null || Is2.integer(candidate.version));
        }
        OptionalVersionedTextDocumentIdentifier3.is = is;
      })(OptionalVersionedTextDocumentIdentifier2 || (OptionalVersionedTextDocumentIdentifier2 = {}));
      (function(TextDocumentItem3) {
        function create(uri, languageId, version, text) {
          return { uri, languageId, version, text };
        }
        TextDocumentItem3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Is2.string(candidate.uri) && Is2.string(candidate.languageId) && Is2.integer(candidate.version) && Is2.string(candidate.text);
        }
        TextDocumentItem3.is = is;
      })(TextDocumentItem2 || (TextDocumentItem2 = {}));
      (function(MarkupKind4) {
        MarkupKind4.PlainText = "plaintext";
        MarkupKind4.Markdown = "markdown";
        function is(value) {
          const candidate = value;
          return candidate === MarkupKind4.PlainText || candidate === MarkupKind4.Markdown;
        }
        MarkupKind4.is = is;
      })(MarkupKind2 || (MarkupKind2 = {}));
      (function(MarkupContent4) {
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(value) && MarkupKind2.is(candidate.kind) && Is2.string(candidate.value);
        }
        MarkupContent4.is = is;
      })(MarkupContent2 || (MarkupContent2 = {}));
      (function(CompletionItemKind4) {
        CompletionItemKind4.Text = 1;
        CompletionItemKind4.Method = 2;
        CompletionItemKind4.Function = 3;
        CompletionItemKind4.Constructor = 4;
        CompletionItemKind4.Field = 5;
        CompletionItemKind4.Variable = 6;
        CompletionItemKind4.Class = 7;
        CompletionItemKind4.Interface = 8;
        CompletionItemKind4.Module = 9;
        CompletionItemKind4.Property = 10;
        CompletionItemKind4.Unit = 11;
        CompletionItemKind4.Value = 12;
        CompletionItemKind4.Enum = 13;
        CompletionItemKind4.Keyword = 14;
        CompletionItemKind4.Snippet = 15;
        CompletionItemKind4.Color = 16;
        CompletionItemKind4.File = 17;
        CompletionItemKind4.Reference = 18;
        CompletionItemKind4.Folder = 19;
        CompletionItemKind4.EnumMember = 20;
        CompletionItemKind4.Constant = 21;
        CompletionItemKind4.Struct = 22;
        CompletionItemKind4.Event = 23;
        CompletionItemKind4.Operator = 24;
        CompletionItemKind4.TypeParameter = 25;
      })(CompletionItemKind2 || (CompletionItemKind2 = {}));
      (function(InsertTextFormat4) {
        InsertTextFormat4.PlainText = 1;
        InsertTextFormat4.Snippet = 2;
      })(InsertTextFormat2 || (InsertTextFormat2 = {}));
      (function(CompletionItemTag3) {
        CompletionItemTag3.Deprecated = 1;
      })(CompletionItemTag2 || (CompletionItemTag2 = {}));
      (function(InsertReplaceEdit3) {
        function create(newText, insert, replace) {
          return { newText, insert, replace };
        }
        InsertReplaceEdit3.create = create;
        function is(value) {
          const candidate = value;
          return candidate && Is2.string(candidate.newText) && Range2.is(candidate.insert) && Range2.is(candidate.replace);
        }
        InsertReplaceEdit3.is = is;
      })(InsertReplaceEdit2 || (InsertReplaceEdit2 = {}));
      (function(InsertTextMode3) {
        InsertTextMode3.asIs = 1;
        InsertTextMode3.adjustIndentation = 2;
      })(InsertTextMode2 || (InsertTextMode2 = {}));
      (function(CompletionItemLabelDetails3) {
        function is(value) {
          const candidate = value;
          return candidate && (Is2.string(candidate.detail) || candidate.detail === void 0) && (Is2.string(candidate.description) || candidate.description === void 0);
        }
        CompletionItemLabelDetails3.is = is;
      })(CompletionItemLabelDetails2 || (CompletionItemLabelDetails2 = {}));
      (function(CompletionItem5) {
        function create(label) {
          return { label };
        }
        CompletionItem5.create = create;
      })(CompletionItem2 || (CompletionItem2 = {}));
      (function(CompletionList3) {
        function create(items, isIncomplete) {
          return { items: items ? items : [], isIncomplete: !!isIncomplete };
        }
        CompletionList3.create = create;
      })(CompletionList2 || (CompletionList2 = {}));
      (function(MarkedString3) {
        function fromPlainText(plainText) {
          return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
        }
        MarkedString3.fromPlainText = fromPlainText;
        function is(value) {
          const candidate = value;
          return Is2.string(candidate) || Is2.objectLiteral(candidate) && Is2.string(candidate.language) && Is2.string(candidate.value);
        }
        MarkedString3.is = is;
      })(MarkedString2 || (MarkedString2 = {}));
      (function(Hover5) {
        function is(value) {
          let candidate = value;
          return !!candidate && Is2.objectLiteral(candidate) && (MarkupContent2.is(candidate.contents) || MarkedString2.is(candidate.contents) || Is2.typedArray(candidate.contents, MarkedString2.is)) && (value.range === void 0 || Range2.is(value.range));
        }
        Hover5.is = is;
      })(Hover2 || (Hover2 = {}));
      (function(ParameterInformation3) {
        function create(label, documentation) {
          return documentation ? { label, documentation } : { label };
        }
        ParameterInformation3.create = create;
      })(ParameterInformation2 || (ParameterInformation2 = {}));
      (function(SignatureInformation3) {
        function create(label, documentation, ...parameters) {
          let result = { label };
          if (Is2.defined(documentation)) {
            result.documentation = documentation;
          }
          if (Is2.defined(parameters)) {
            result.parameters = parameters;
          } else {
            result.parameters = [];
          }
          return result;
        }
        SignatureInformation3.create = create;
      })(SignatureInformation2 || (SignatureInformation2 = {}));
      (function(DocumentHighlightKind3) {
        DocumentHighlightKind3.Text = 1;
        DocumentHighlightKind3.Read = 2;
        DocumentHighlightKind3.Write = 3;
      })(DocumentHighlightKind2 || (DocumentHighlightKind2 = {}));
      (function(DocumentHighlight3) {
        function create(range, kind) {
          let result = { range };
          if (Is2.number(kind)) {
            result.kind = kind;
          }
          return result;
        }
        DocumentHighlight3.create = create;
      })(DocumentHighlight2 || (DocumentHighlight2 = {}));
      (function(SymbolKind4) {
        SymbolKind4.File = 1;
        SymbolKind4.Module = 2;
        SymbolKind4.Namespace = 3;
        SymbolKind4.Package = 4;
        SymbolKind4.Class = 5;
        SymbolKind4.Method = 6;
        SymbolKind4.Property = 7;
        SymbolKind4.Field = 8;
        SymbolKind4.Constructor = 9;
        SymbolKind4.Enum = 10;
        SymbolKind4.Interface = 11;
        SymbolKind4.Function = 12;
        SymbolKind4.Variable = 13;
        SymbolKind4.Constant = 14;
        SymbolKind4.String = 15;
        SymbolKind4.Number = 16;
        SymbolKind4.Boolean = 17;
        SymbolKind4.Array = 18;
        SymbolKind4.Object = 19;
        SymbolKind4.Key = 20;
        SymbolKind4.Null = 21;
        SymbolKind4.EnumMember = 22;
        SymbolKind4.Struct = 23;
        SymbolKind4.Event = 24;
        SymbolKind4.Operator = 25;
        SymbolKind4.TypeParameter = 26;
      })(SymbolKind2 || (SymbolKind2 = {}));
      (function(SymbolTag3) {
        SymbolTag3.Deprecated = 1;
      })(SymbolTag2 || (SymbolTag2 = {}));
      (function(SymbolInformation3) {
        function create(name, kind, range, uri, containerName) {
          let result = {
            name,
            kind,
            location: { uri, range }
          };
          if (containerName) {
            result.containerName = containerName;
          }
          return result;
        }
        SymbolInformation3.create = create;
      })(SymbolInformation2 || (SymbolInformation2 = {}));
      (function(WorkspaceSymbol3) {
        function create(name, kind, uri, range) {
          return range !== void 0 ? { name, kind, location: { uri, range } } : { name, kind, location: { uri } };
        }
        WorkspaceSymbol3.create = create;
      })(WorkspaceSymbol2 || (WorkspaceSymbol2 = {}));
      (function(DocumentSymbol4) {
        function create(name, detail, kind, range, selectionRange, children) {
          let result = {
            name,
            detail,
            kind,
            range,
            selectionRange
          };
          if (children !== void 0) {
            result.children = children;
          }
          return result;
        }
        DocumentSymbol4.create = create;
        function is(value) {
          let candidate = value;
          return candidate && Is2.string(candidate.name) && Is2.number(candidate.kind) && Range2.is(candidate.range) && Range2.is(candidate.selectionRange) && (candidate.detail === void 0 || Is2.string(candidate.detail)) && (candidate.deprecated === void 0 || Is2.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
        }
        DocumentSymbol4.is = is;
      })(DocumentSymbol2 || (DocumentSymbol2 = {}));
      (function(CodeActionKind5) {
        CodeActionKind5.Empty = "";
        CodeActionKind5.QuickFix = "quickfix";
        CodeActionKind5.Refactor = "refactor";
        CodeActionKind5.RefactorExtract = "refactor.extract";
        CodeActionKind5.RefactorInline = "refactor.inline";
        CodeActionKind5.RefactorRewrite = "refactor.rewrite";
        CodeActionKind5.Source = "source";
        CodeActionKind5.SourceOrganizeImports = "source.organizeImports";
        CodeActionKind5.SourceFixAll = "source.fixAll";
      })(CodeActionKind2 || (CodeActionKind2 = {}));
      (function(CodeActionTriggerKind3) {
        CodeActionTriggerKind3.Invoked = 1;
        CodeActionTriggerKind3.Automatic = 2;
      })(CodeActionTriggerKind2 || (CodeActionTriggerKind2 = {}));
      (function(CodeActionContext3) {
        function create(diagnostics, only, triggerKind) {
          let result = { diagnostics };
          if (only !== void 0 && only !== null) {
            result.only = only;
          }
          if (triggerKind !== void 0 && triggerKind !== null) {
            result.triggerKind = triggerKind;
          }
          return result;
        }
        CodeActionContext3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Is2.typedArray(candidate.diagnostics, Diagnostic2.is) && (candidate.only === void 0 || Is2.typedArray(candidate.only, Is2.string)) && (candidate.triggerKind === void 0 || candidate.triggerKind === CodeActionTriggerKind2.Invoked || candidate.triggerKind === CodeActionTriggerKind2.Automatic);
        }
        CodeActionContext3.is = is;
      })(CodeActionContext2 || (CodeActionContext2 = {}));
      (function(CodeAction4) {
        function create(title, kindOrCommandOrEdit, kind) {
          let result = { title };
          let checkKind = true;
          if (typeof kindOrCommandOrEdit === "string") {
            checkKind = false;
            result.kind = kindOrCommandOrEdit;
          } else if (Command2.is(kindOrCommandOrEdit)) {
            result.command = kindOrCommandOrEdit;
          } else {
            result.edit = kindOrCommandOrEdit;
          }
          if (checkKind && kind !== void 0) {
            result.kind = kind;
          }
          return result;
        }
        CodeAction4.create = create;
        function is(value) {
          let candidate = value;
          return candidate && Is2.string(candidate.title) && (candidate.diagnostics === void 0 || Is2.typedArray(candidate.diagnostics, Diagnostic2.is)) && (candidate.kind === void 0 || Is2.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command2.is(candidate.command)) && (candidate.isPreferred === void 0 || Is2.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit2.is(candidate.edit));
        }
        CodeAction4.is = is;
      })(CodeAction2 || (CodeAction2 = {}));
      (function(CodeLens3) {
        function create(range, data) {
          let result = { range };
          if (Is2.defined(data)) {
            result.data = data;
          }
          return result;
        }
        CodeLens3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Range2.is(candidate.range) && (Is2.undefined(candidate.command) || Command2.is(candidate.command));
        }
        CodeLens3.is = is;
      })(CodeLens2 || (CodeLens2 = {}));
      (function(FormattingOptions3) {
        function create(tabSize, insertSpaces) {
          return { tabSize, insertSpaces };
        }
        FormattingOptions3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Is2.uinteger(candidate.tabSize) && Is2.boolean(candidate.insertSpaces);
        }
        FormattingOptions3.is = is;
      })(FormattingOptions2 || (FormattingOptions2 = {}));
      (function(DocumentLink3) {
        function create(range, target, data) {
          return { range, target, data };
        }
        DocumentLink3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Range2.is(candidate.range) && (Is2.undefined(candidate.target) || Is2.string(candidate.target));
        }
        DocumentLink3.is = is;
      })(DocumentLink2 || (DocumentLink2 = {}));
      (function(SelectionRange3) {
        function create(range, parent) {
          return { range, parent };
        }
        SelectionRange3.create = create;
        function is(value) {
          let candidate = value;
          return Is2.objectLiteral(candidate) && Range2.is(candidate.range) && (candidate.parent === void 0 || SelectionRange3.is(candidate.parent));
        }
        SelectionRange3.is = is;
      })(SelectionRange2 || (SelectionRange2 = {}));
      (function(SemanticTokenTypes3) {
        SemanticTokenTypes3["namespace"] = "namespace";
        SemanticTokenTypes3["type"] = "type";
        SemanticTokenTypes3["class"] = "class";
        SemanticTokenTypes3["enum"] = "enum";
        SemanticTokenTypes3["interface"] = "interface";
        SemanticTokenTypes3["struct"] = "struct";
        SemanticTokenTypes3["typeParameter"] = "typeParameter";
        SemanticTokenTypes3["parameter"] = "parameter";
        SemanticTokenTypes3["variable"] = "variable";
        SemanticTokenTypes3["property"] = "property";
        SemanticTokenTypes3["enumMember"] = "enumMember";
        SemanticTokenTypes3["event"] = "event";
        SemanticTokenTypes3["function"] = "function";
        SemanticTokenTypes3["method"] = "method";
        SemanticTokenTypes3["macro"] = "macro";
        SemanticTokenTypes3["keyword"] = "keyword";
        SemanticTokenTypes3["modifier"] = "modifier";
        SemanticTokenTypes3["comment"] = "comment";
        SemanticTokenTypes3["string"] = "string";
        SemanticTokenTypes3["number"] = "number";
        SemanticTokenTypes3["regexp"] = "regexp";
        SemanticTokenTypes3["operator"] = "operator";
        SemanticTokenTypes3["decorator"] = "decorator";
      })(SemanticTokenTypes2 || (SemanticTokenTypes2 = {}));
      (function(SemanticTokenModifiers3) {
        SemanticTokenModifiers3["declaration"] = "declaration";
        SemanticTokenModifiers3["definition"] = "definition";
        SemanticTokenModifiers3["readonly"] = "readonly";
        SemanticTokenModifiers3["static"] = "static";
        SemanticTokenModifiers3["deprecated"] = "deprecated";
        SemanticTokenModifiers3["abstract"] = "abstract";
        SemanticTokenModifiers3["async"] = "async";
        SemanticTokenModifiers3["modification"] = "modification";
        SemanticTokenModifiers3["documentation"] = "documentation";
        SemanticTokenModifiers3["defaultLibrary"] = "defaultLibrary";
      })(SemanticTokenModifiers2 || (SemanticTokenModifiers2 = {}));
      (function(SemanticTokens5) {
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
        }
        SemanticTokens5.is = is;
      })(SemanticTokens2 || (SemanticTokens2 = {}));
      (function(InlineValueText3) {
        function create(range, text) {
          return { range, text };
        }
        InlineValueText3.create = create;
        function is(value) {
          const candidate = value;
          return candidate !== void 0 && candidate !== null && Range2.is(candidate.range) && Is2.string(candidate.text);
        }
        InlineValueText3.is = is;
      })(InlineValueText2 || (InlineValueText2 = {}));
      (function(InlineValueVariableLookup3) {
        function create(range, variableName, caseSensitiveLookup) {
          return { range, variableName, caseSensitiveLookup };
        }
        InlineValueVariableLookup3.create = create;
        function is(value) {
          const candidate = value;
          return candidate !== void 0 && candidate !== null && Range2.is(candidate.range) && Is2.boolean(candidate.caseSensitiveLookup) && (Is2.string(candidate.variableName) || candidate.variableName === void 0);
        }
        InlineValueVariableLookup3.is = is;
      })(InlineValueVariableLookup2 || (InlineValueVariableLookup2 = {}));
      (function(InlineValueEvaluatableExpression3) {
        function create(range, expression) {
          return { range, expression };
        }
        InlineValueEvaluatableExpression3.create = create;
        function is(value) {
          const candidate = value;
          return candidate !== void 0 && candidate !== null && Range2.is(candidate.range) && (Is2.string(candidate.expression) || candidate.expression === void 0);
        }
        InlineValueEvaluatableExpression3.is = is;
      })(InlineValueEvaluatableExpression2 || (InlineValueEvaluatableExpression2 = {}));
      (function(InlineValueContext3) {
        function create(frameId, stoppedLocation) {
          return { frameId, stoppedLocation };
        }
        InlineValueContext3.create = create;
        function is(value) {
          const candidate = value;
          return Is2.defined(candidate) && Range2.is(value.stoppedLocation);
        }
        InlineValueContext3.is = is;
      })(InlineValueContext2 || (InlineValueContext2 = {}));
      (function(InlayHintKind3) {
        InlayHintKind3.Type = 1;
        InlayHintKind3.Parameter = 2;
        function is(value) {
          return value === 1 || value === 2;
        }
        InlayHintKind3.is = is;
      })(InlayHintKind2 || (InlayHintKind2 = {}));
      (function(InlayHintLabelPart3) {
        function create(value) {
          return { value };
        }
        InlayHintLabelPart3.create = create;
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && (candidate.tooltip === void 0 || Is2.string(candidate.tooltip) || MarkupContent2.is(candidate.tooltip)) && (candidate.location === void 0 || Location2.is(candidate.location)) && (candidate.command === void 0 || Command2.is(candidate.command));
        }
        InlayHintLabelPart3.is = is;
      })(InlayHintLabelPart2 || (InlayHintLabelPart2 = {}));
      (function(InlayHint3) {
        function create(position, label, kind) {
          const result = { position, label };
          if (kind !== void 0) {
            result.kind = kind;
          }
          return result;
        }
        InlayHint3.create = create;
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && Position2.is(candidate.position) && (Is2.string(candidate.label) || Is2.typedArray(candidate.label, InlayHintLabelPart2.is)) && (candidate.kind === void 0 || InlayHintKind2.is(candidate.kind)) && candidate.textEdits === void 0 || Is2.typedArray(candidate.textEdits, TextEdit2.is) && (candidate.tooltip === void 0 || Is2.string(candidate.tooltip) || MarkupContent2.is(candidate.tooltip)) && (candidate.paddingLeft === void 0 || Is2.boolean(candidate.paddingLeft)) && (candidate.paddingRight === void 0 || Is2.boolean(candidate.paddingRight));
        }
        InlayHint3.is = is;
      })(InlayHint2 || (InlayHint2 = {}));
      (function(StringValue3) {
        function createSnippet(value) {
          return { kind: "snippet", value };
        }
        StringValue3.createSnippet = createSnippet;
      })(StringValue2 || (StringValue2 = {}));
      (function(InlineCompletionItem3) {
        function create(insertText, filterText, range, command) {
          return { insertText, filterText, range, command };
        }
        InlineCompletionItem3.create = create;
      })(InlineCompletionItem2 || (InlineCompletionItem2 = {}));
      (function(InlineCompletionList3) {
        function create(items) {
          return { items };
        }
        InlineCompletionList3.create = create;
      })(InlineCompletionList2 || (InlineCompletionList2 = {}));
      (function(InlineCompletionTriggerKind3) {
        InlineCompletionTriggerKind3.Invoked = 0;
        InlineCompletionTriggerKind3.Automatic = 1;
      })(InlineCompletionTriggerKind2 || (InlineCompletionTriggerKind2 = {}));
      (function(SelectedCompletionInfo3) {
        function create(range, text) {
          return { range, text };
        }
        SelectedCompletionInfo3.create = create;
      })(SelectedCompletionInfo2 || (SelectedCompletionInfo2 = {}));
      (function(InlineCompletionContext3) {
        function create(triggerKind, selectedCompletionInfo) {
          return { triggerKind, selectedCompletionInfo };
        }
        InlineCompletionContext3.create = create;
      })(InlineCompletionContext2 || (InlineCompletionContext2 = {}));
      (function(WorkspaceFolder3) {
        function is(value) {
          const candidate = value;
          return Is2.objectLiteral(candidate) && URI2.is(candidate.uri) && Is2.string(candidate.name);
        }
        WorkspaceFolder3.is = is;
      })(WorkspaceFolder2 || (WorkspaceFolder2 = {}));
      EOL2 = ["\n", "\r\n", "\r"];
      (function(TextDocument4) {
        function create(uri, languageId, version, content) {
          return new FullTextDocument3(uri, languageId, version, content);
        }
        TextDocument4.create = create;
        function is(value) {
          let candidate = value;
          return Is2.defined(candidate) && Is2.string(candidate.uri) && (Is2.undefined(candidate.languageId) || Is2.string(candidate.languageId)) && Is2.uinteger(candidate.lineCount) && Is2.func(candidate.getText) && Is2.func(candidate.positionAt) && Is2.func(candidate.offsetAt) ? true : false;
        }
        TextDocument4.is = is;
        function applyEdits(document, edits) {
          let text = document.getText();
          let sortedEdits = mergeSort2(edits, (a, b) => {
            let diff = a.range.start.line - b.range.start.line;
            if (diff === 0) {
              return a.range.start.character - b.range.start.character;
            }
            return diff;
          });
          let lastModifiedOffset = text.length;
          for (let i = sortedEdits.length - 1; i >= 0; i--) {
            let e = sortedEdits[i];
            let startOffset = document.offsetAt(e.range.start);
            let endOffset = document.offsetAt(e.range.end);
            if (endOffset <= lastModifiedOffset) {
              text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
            } else {
              throw new Error("Overlapping edit");
            }
            lastModifiedOffset = startOffset;
          }
          return text;
        }
        TextDocument4.applyEdits = applyEdits;
        function mergeSort2(data, compare) {
          if (data.length <= 1) {
            return data;
          }
          const p = data.length / 2 | 0;
          const left = data.slice(0, p);
          const right = data.slice(p);
          mergeSort2(left, compare);
          mergeSort2(right, compare);
          let leftIdx = 0;
          let rightIdx = 0;
          let i = 0;
          while (leftIdx < left.length && rightIdx < right.length) {
            let ret = compare(left[leftIdx], right[rightIdx]);
            if (ret <= 0) {
              data[i++] = left[leftIdx++];
            } else {
              data[i++] = right[rightIdx++];
            }
          }
          while (leftIdx < left.length) {
            data[i++] = left[leftIdx++];
          }
          while (rightIdx < right.length) {
            data[i++] = right[rightIdx++];
          }
          return data;
        }
      })(TextDocument3 || (TextDocument3 = {}));
      FullTextDocument3 = class {
        constructor(uri, languageId, version, content) {
          this._uri = uri;
          this._languageId = languageId;
          this._version = version;
          this._content = content;
          this._lineOffsets = void 0;
        }
        get uri() {
          return this._uri;
        }
        get languageId() {
          return this._languageId;
        }
        get version() {
          return this._version;
        }
        getText(range) {
          if (range) {
            let start = this.offsetAt(range.start);
            let end = this.offsetAt(range.end);
            return this._content.substring(start, end);
          }
          return this._content;
        }
        update(event, version) {
          this._content = event.text;
          this._version = version;
          this._lineOffsets = void 0;
        }
        getLineOffsets() {
          if (this._lineOffsets === void 0) {
            let lineOffsets = [];
            let text = this._content;
            let isLineStart = true;
            for (let i = 0; i < text.length; i++) {
              if (isLineStart) {
                lineOffsets.push(i);
                isLineStart = false;
              }
              let ch = text.charAt(i);
              isLineStart = ch === "\r" || ch === "\n";
              if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
                i++;
              }
            }
            if (isLineStart && text.length > 0) {
              lineOffsets.push(text.length);
            }
            this._lineOffsets = lineOffsets;
          }
          return this._lineOffsets;
        }
        positionAt(offset) {
          offset = Math.max(Math.min(offset, this._content.length), 0);
          let lineOffsets = this.getLineOffsets();
          let low = 0, high = lineOffsets.length;
          if (high === 0) {
            return Position2.create(0, offset);
          }
          while (low < high) {
            let mid = Math.floor((low + high) / 2);
            if (lineOffsets[mid] > offset) {
              high = mid;
            } else {
              low = mid + 1;
            }
          }
          let line = low - 1;
          return Position2.create(line, offset - lineOffsets[line]);
        }
        offsetAt(position) {
          let lineOffsets = this.getLineOffsets();
          if (position.line >= lineOffsets.length) {
            return this._content.length;
          } else if (position.line < 0) {
            return 0;
          }
          let lineOffset = lineOffsets[position.line];
          let nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
          return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
        }
        get lineCount() {
          return this.getLineOffsets().length;
        }
      };
      (function(Is3) {
        const toString = Object.prototype.toString;
        function defined(value) {
          return typeof value !== "undefined";
        }
        Is3.defined = defined;
        function undefined2(value) {
          return typeof value === "undefined";
        }
        Is3.undefined = undefined2;
        function boolean(value) {
          return value === true || value === false;
        }
        Is3.boolean = boolean;
        function string(value) {
          return toString.call(value) === "[object String]";
        }
        Is3.string = string;
        function number(value) {
          return toString.call(value) === "[object Number]";
        }
        Is3.number = number;
        function numberRange(value, min, max) {
          return toString.call(value) === "[object Number]" && min <= value && value <= max;
        }
        Is3.numberRange = numberRange;
        function integer3(value) {
          return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
        }
        Is3.integer = integer3;
        function uinteger3(value) {
          return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
        }
        Is3.uinteger = uinteger3;
        function func(value) {
          return toString.call(value) === "[object Function]";
        }
        Is3.func = func;
        function objectLiteral(value) {
          return value !== null && typeof value === "object";
        }
        Is3.objectLiteral = objectLiteral;
        function typedArray(value, check) {
          return Array.isArray(value) && value.every(check);
        }
        Is3.typedArray = typedArray;
      })(Is2 || (Is2 = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/messages.js
  var require_messages4 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/messages.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ProtocolNotificationType = exports.ProtocolNotificationType0 = exports.ProtocolRequestType = exports.ProtocolRequestType0 = exports.RegistrationType = exports.MessageDirection = void 0;
      var vscode_jsonrpc_1 = require_main4();
      var MessageDirection;
      (function(MessageDirection2) {
        MessageDirection2["clientToServer"] = "clientToServer";
        MessageDirection2["serverToClient"] = "serverToClient";
        MessageDirection2["both"] = "both";
      })(MessageDirection || (exports.MessageDirection = MessageDirection = {}));
      var RegistrationType = class {
        constructor(method) {
          this.method = method;
        }
      };
      exports.RegistrationType = RegistrationType;
      var ProtocolRequestType0 = class extends vscode_jsonrpc_1.RequestType0 {
        constructor(method) {
          super(method);
        }
      };
      exports.ProtocolRequestType0 = ProtocolRequestType0;
      var ProtocolRequestType = class extends vscode_jsonrpc_1.RequestType {
        constructor(method) {
          super(method, vscode_jsonrpc_1.ParameterStructures.byName);
        }
      };
      exports.ProtocolRequestType = ProtocolRequestType;
      var ProtocolNotificationType0 = class extends vscode_jsonrpc_1.NotificationType0 {
        constructor(method) {
          super(method);
        }
      };
      exports.ProtocolNotificationType0 = ProtocolNotificationType0;
      var ProtocolNotificationType = class extends vscode_jsonrpc_1.NotificationType {
        constructor(method) {
          super(method, vscode_jsonrpc_1.ParameterStructures.byName);
        }
      };
      exports.ProtocolNotificationType = ProtocolNotificationType;
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js
  var require_is5 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/utils/is.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.objectLiteral = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
      function boolean(value) {
        return value === true || value === false;
      }
      exports.boolean = boolean;
      function string(value) {
        return typeof value === "string" || value instanceof String;
      }
      exports.string = string;
      function number(value) {
        return typeof value === "number" || value instanceof Number;
      }
      exports.number = number;
      function error(value) {
        return value instanceof Error;
      }
      exports.error = error;
      function func(value) {
        return typeof value === "function";
      }
      exports.func = func;
      function array(value) {
        return Array.isArray(value);
      }
      exports.array = array;
      function stringArray(value) {
        return array(value) && value.every((elem) => string(elem));
      }
      exports.stringArray = stringArray;
      function typedArray(value, check) {
        return Array.isArray(value) && value.every(check);
      }
      exports.typedArray = typedArray;
      function objectLiteral(value) {
        return value !== null && typeof value === "object";
      }
      exports.objectLiteral = objectLiteral;
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js
  var require_protocol_implementation2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.implementation.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ImplementationRequest = void 0;
      var messages_1 = require_messages4();
      var ImplementationRequest;
      (function(ImplementationRequest2) {
        ImplementationRequest2.method = "textDocument/implementation";
        ImplementationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ImplementationRequest2.type = new messages_1.ProtocolRequestType(ImplementationRequest2.method);
      })(ImplementationRequest || (exports.ImplementationRequest = ImplementationRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js
  var require_protocol_typeDefinition2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeDefinition.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TypeDefinitionRequest = void 0;
      var messages_1 = require_messages4();
      var TypeDefinitionRequest;
      (function(TypeDefinitionRequest2) {
        TypeDefinitionRequest2.method = "textDocument/typeDefinition";
        TypeDefinitionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TypeDefinitionRequest2.type = new messages_1.ProtocolRequestType(TypeDefinitionRequest2.method);
      })(TypeDefinitionRequest || (exports.TypeDefinitionRequest = TypeDefinitionRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolder.js
  var require_protocol_workspaceFolder2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.workspaceFolder.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = void 0;
      var messages_1 = require_messages4();
      var WorkspaceFoldersRequest;
      (function(WorkspaceFoldersRequest2) {
        WorkspaceFoldersRequest2.method = "workspace/workspaceFolders";
        WorkspaceFoldersRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        WorkspaceFoldersRequest2.type = new messages_1.ProtocolRequestType0(WorkspaceFoldersRequest2.method);
      })(WorkspaceFoldersRequest || (exports.WorkspaceFoldersRequest = WorkspaceFoldersRequest = {}));
      var DidChangeWorkspaceFoldersNotification;
      (function(DidChangeWorkspaceFoldersNotification2) {
        DidChangeWorkspaceFoldersNotification2.method = "workspace/didChangeWorkspaceFolders";
        DidChangeWorkspaceFoldersNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeWorkspaceFoldersNotification2.type = new messages_1.ProtocolNotificationType(DidChangeWorkspaceFoldersNotification2.method);
      })(DidChangeWorkspaceFoldersNotification || (exports.DidChangeWorkspaceFoldersNotification = DidChangeWorkspaceFoldersNotification = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js
  var require_protocol_configuration2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.configuration.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ConfigurationRequest = void 0;
      var messages_1 = require_messages4();
      var ConfigurationRequest;
      (function(ConfigurationRequest2) {
        ConfigurationRequest2.method = "workspace/configuration";
        ConfigurationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        ConfigurationRequest2.type = new messages_1.ProtocolRequestType(ConfigurationRequest2.method);
      })(ConfigurationRequest || (exports.ConfigurationRequest = ConfigurationRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js
  var require_protocol_colorProvider2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.colorProvider.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ColorPresentationRequest = exports.DocumentColorRequest = void 0;
      var messages_1 = require_messages4();
      var DocumentColorRequest;
      (function(DocumentColorRequest2) {
        DocumentColorRequest2.method = "textDocument/documentColor";
        DocumentColorRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentColorRequest2.type = new messages_1.ProtocolRequestType(DocumentColorRequest2.method);
      })(DocumentColorRequest || (exports.DocumentColorRequest = DocumentColorRequest = {}));
      var ColorPresentationRequest;
      (function(ColorPresentationRequest2) {
        ColorPresentationRequest2.method = "textDocument/colorPresentation";
        ColorPresentationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ColorPresentationRequest2.type = new messages_1.ProtocolRequestType(ColorPresentationRequest2.method);
      })(ColorPresentationRequest || (exports.ColorPresentationRequest = ColorPresentationRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js
  var require_protocol_foldingRange2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.foldingRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.FoldingRangeRefreshRequest = exports.FoldingRangeRequest = void 0;
      var messages_1 = require_messages4();
      var FoldingRangeRequest;
      (function(FoldingRangeRequest2) {
        FoldingRangeRequest2.method = "textDocument/foldingRange";
        FoldingRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        FoldingRangeRequest2.type = new messages_1.ProtocolRequestType(FoldingRangeRequest2.method);
      })(FoldingRangeRequest || (exports.FoldingRangeRequest = FoldingRangeRequest = {}));
      var FoldingRangeRefreshRequest;
      (function(FoldingRangeRefreshRequest2) {
        FoldingRangeRefreshRequest2.method = `workspace/foldingRange/refresh`;
        FoldingRangeRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        FoldingRangeRefreshRequest2.type = new messages_1.ProtocolRequestType0(FoldingRangeRefreshRequest2.method);
      })(FoldingRangeRefreshRequest || (exports.FoldingRangeRefreshRequest = FoldingRangeRefreshRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js
  var require_protocol_declaration2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.declaration.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DeclarationRequest = void 0;
      var messages_1 = require_messages4();
      var DeclarationRequest;
      (function(DeclarationRequest2) {
        DeclarationRequest2.method = "textDocument/declaration";
        DeclarationRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DeclarationRequest2.type = new messages_1.ProtocolRequestType(DeclarationRequest2.method);
      })(DeclarationRequest || (exports.DeclarationRequest = DeclarationRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js
  var require_protocol_selectionRange2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.selectionRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SelectionRangeRequest = void 0;
      var messages_1 = require_messages4();
      var SelectionRangeRequest;
      (function(SelectionRangeRequest2) {
        SelectionRangeRequest2.method = "textDocument/selectionRange";
        SelectionRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SelectionRangeRequest2.type = new messages_1.ProtocolRequestType(SelectionRangeRequest2.method);
      })(SelectionRangeRequest || (exports.SelectionRangeRequest = SelectionRangeRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js
  var require_protocol_progress2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.progress.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = void 0;
      var vscode_jsonrpc_1 = require_main4();
      var messages_1 = require_messages4();
      var WorkDoneProgress;
      (function(WorkDoneProgress2) {
        WorkDoneProgress2.type = new vscode_jsonrpc_1.ProgressType();
        function is(value) {
          return value === WorkDoneProgress2.type;
        }
        WorkDoneProgress2.is = is;
      })(WorkDoneProgress || (exports.WorkDoneProgress = WorkDoneProgress = {}));
      var WorkDoneProgressCreateRequest;
      (function(WorkDoneProgressCreateRequest2) {
        WorkDoneProgressCreateRequest2.method = "window/workDoneProgress/create";
        WorkDoneProgressCreateRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        WorkDoneProgressCreateRequest2.type = new messages_1.ProtocolRequestType(WorkDoneProgressCreateRequest2.method);
      })(WorkDoneProgressCreateRequest || (exports.WorkDoneProgressCreateRequest = WorkDoneProgressCreateRequest = {}));
      var WorkDoneProgressCancelNotification;
      (function(WorkDoneProgressCancelNotification2) {
        WorkDoneProgressCancelNotification2.method = "window/workDoneProgress/cancel";
        WorkDoneProgressCancelNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        WorkDoneProgressCancelNotification2.type = new messages_1.ProtocolNotificationType(WorkDoneProgressCancelNotification2.method);
      })(WorkDoneProgressCancelNotification || (exports.WorkDoneProgressCancelNotification = WorkDoneProgressCancelNotification = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js
  var require_protocol_callHierarchy2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.callHierarchy.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.CallHierarchyPrepareRequest = void 0;
      var messages_1 = require_messages4();
      var CallHierarchyPrepareRequest;
      (function(CallHierarchyPrepareRequest2) {
        CallHierarchyPrepareRequest2.method = "textDocument/prepareCallHierarchy";
        CallHierarchyPrepareRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CallHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyPrepareRequest2.method);
      })(CallHierarchyPrepareRequest || (exports.CallHierarchyPrepareRequest = CallHierarchyPrepareRequest = {}));
      var CallHierarchyIncomingCallsRequest;
      (function(CallHierarchyIncomingCallsRequest2) {
        CallHierarchyIncomingCallsRequest2.method = "callHierarchy/incomingCalls";
        CallHierarchyIncomingCallsRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CallHierarchyIncomingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyIncomingCallsRequest2.method);
      })(CallHierarchyIncomingCallsRequest || (exports.CallHierarchyIncomingCallsRequest = CallHierarchyIncomingCallsRequest = {}));
      var CallHierarchyOutgoingCallsRequest;
      (function(CallHierarchyOutgoingCallsRequest2) {
        CallHierarchyOutgoingCallsRequest2.method = "callHierarchy/outgoingCalls";
        CallHierarchyOutgoingCallsRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CallHierarchyOutgoingCallsRequest2.type = new messages_1.ProtocolRequestType(CallHierarchyOutgoingCallsRequest2.method);
      })(CallHierarchyOutgoingCallsRequest || (exports.CallHierarchyOutgoingCallsRequest = CallHierarchyOutgoingCallsRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js
  var require_protocol_semanticTokens2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.semanticTokens.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.SemanticTokensRegistrationType = exports.TokenFormat = void 0;
      var messages_1 = require_messages4();
      var TokenFormat;
      (function(TokenFormat2) {
        TokenFormat2.Relative = "relative";
      })(TokenFormat || (exports.TokenFormat = TokenFormat = {}));
      var SemanticTokensRegistrationType;
      (function(SemanticTokensRegistrationType2) {
        SemanticTokensRegistrationType2.method = "textDocument/semanticTokens";
        SemanticTokensRegistrationType2.type = new messages_1.RegistrationType(SemanticTokensRegistrationType2.method);
      })(SemanticTokensRegistrationType || (exports.SemanticTokensRegistrationType = SemanticTokensRegistrationType = {}));
      var SemanticTokensRequest;
      (function(SemanticTokensRequest2) {
        SemanticTokensRequest2.method = "textDocument/semanticTokens/full";
        SemanticTokensRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SemanticTokensRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRequest2.method);
        SemanticTokensRequest2.registrationMethod = SemanticTokensRegistrationType.method;
      })(SemanticTokensRequest || (exports.SemanticTokensRequest = SemanticTokensRequest = {}));
      var SemanticTokensDeltaRequest;
      (function(SemanticTokensDeltaRequest2) {
        SemanticTokensDeltaRequest2.method = "textDocument/semanticTokens/full/delta";
        SemanticTokensDeltaRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SemanticTokensDeltaRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensDeltaRequest2.method);
        SemanticTokensDeltaRequest2.registrationMethod = SemanticTokensRegistrationType.method;
      })(SemanticTokensDeltaRequest || (exports.SemanticTokensDeltaRequest = SemanticTokensDeltaRequest = {}));
      var SemanticTokensRangeRequest;
      (function(SemanticTokensRangeRequest2) {
        SemanticTokensRangeRequest2.method = "textDocument/semanticTokens/range";
        SemanticTokensRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SemanticTokensRangeRequest2.type = new messages_1.ProtocolRequestType(SemanticTokensRangeRequest2.method);
        SemanticTokensRangeRequest2.registrationMethod = SemanticTokensRegistrationType.method;
      })(SemanticTokensRangeRequest || (exports.SemanticTokensRangeRequest = SemanticTokensRangeRequest = {}));
      var SemanticTokensRefreshRequest;
      (function(SemanticTokensRefreshRequest2) {
        SemanticTokensRefreshRequest2.method = `workspace/semanticTokens/refresh`;
        SemanticTokensRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        SemanticTokensRefreshRequest2.type = new messages_1.ProtocolRequestType0(SemanticTokensRefreshRequest2.method);
      })(SemanticTokensRefreshRequest || (exports.SemanticTokensRefreshRequest = SemanticTokensRefreshRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js
  var require_protocol_showDocument2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.showDocument.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ShowDocumentRequest = void 0;
      var messages_1 = require_messages4();
      var ShowDocumentRequest;
      (function(ShowDocumentRequest2) {
        ShowDocumentRequest2.method = "window/showDocument";
        ShowDocumentRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        ShowDocumentRequest2.type = new messages_1.ProtocolRequestType(ShowDocumentRequest2.method);
      })(ShowDocumentRequest || (exports.ShowDocumentRequest = ShowDocumentRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js
  var require_protocol_linkedEditingRange2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.linkedEditingRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LinkedEditingRangeRequest = void 0;
      var messages_1 = require_messages4();
      var LinkedEditingRangeRequest;
      (function(LinkedEditingRangeRequest2) {
        LinkedEditingRangeRequest2.method = "textDocument/linkedEditingRange";
        LinkedEditingRangeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        LinkedEditingRangeRequest2.type = new messages_1.ProtocolRequestType(LinkedEditingRangeRequest2.method);
      })(LinkedEditingRangeRequest || (exports.LinkedEditingRangeRequest = LinkedEditingRangeRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js
  var require_protocol_fileOperations2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.fileOperations.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.DidRenameFilesNotification = exports.WillRenameFilesRequest = exports.DidCreateFilesNotification = exports.WillCreateFilesRequest = exports.FileOperationPatternKind = void 0;
      var messages_1 = require_messages4();
      var FileOperationPatternKind;
      (function(FileOperationPatternKind2) {
        FileOperationPatternKind2.file = "file";
        FileOperationPatternKind2.folder = "folder";
      })(FileOperationPatternKind || (exports.FileOperationPatternKind = FileOperationPatternKind = {}));
      var WillCreateFilesRequest;
      (function(WillCreateFilesRequest2) {
        WillCreateFilesRequest2.method = "workspace/willCreateFiles";
        WillCreateFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillCreateFilesRequest2.type = new messages_1.ProtocolRequestType(WillCreateFilesRequest2.method);
      })(WillCreateFilesRequest || (exports.WillCreateFilesRequest = WillCreateFilesRequest = {}));
      var DidCreateFilesNotification;
      (function(DidCreateFilesNotification2) {
        DidCreateFilesNotification2.method = "workspace/didCreateFiles";
        DidCreateFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidCreateFilesNotification2.type = new messages_1.ProtocolNotificationType(DidCreateFilesNotification2.method);
      })(DidCreateFilesNotification || (exports.DidCreateFilesNotification = DidCreateFilesNotification = {}));
      var WillRenameFilesRequest;
      (function(WillRenameFilesRequest2) {
        WillRenameFilesRequest2.method = "workspace/willRenameFiles";
        WillRenameFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillRenameFilesRequest2.type = new messages_1.ProtocolRequestType(WillRenameFilesRequest2.method);
      })(WillRenameFilesRequest || (exports.WillRenameFilesRequest = WillRenameFilesRequest = {}));
      var DidRenameFilesNotification;
      (function(DidRenameFilesNotification2) {
        DidRenameFilesNotification2.method = "workspace/didRenameFiles";
        DidRenameFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidRenameFilesNotification2.type = new messages_1.ProtocolNotificationType(DidRenameFilesNotification2.method);
      })(DidRenameFilesNotification || (exports.DidRenameFilesNotification = DidRenameFilesNotification = {}));
      var DidDeleteFilesNotification;
      (function(DidDeleteFilesNotification2) {
        DidDeleteFilesNotification2.method = "workspace/didDeleteFiles";
        DidDeleteFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidDeleteFilesNotification2.type = new messages_1.ProtocolNotificationType(DidDeleteFilesNotification2.method);
      })(DidDeleteFilesNotification || (exports.DidDeleteFilesNotification = DidDeleteFilesNotification = {}));
      var WillDeleteFilesRequest;
      (function(WillDeleteFilesRequest2) {
        WillDeleteFilesRequest2.method = "workspace/willDeleteFiles";
        WillDeleteFilesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillDeleteFilesRequest2.type = new messages_1.ProtocolRequestType(WillDeleteFilesRequest2.method);
      })(WillDeleteFilesRequest || (exports.WillDeleteFilesRequest = WillDeleteFilesRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js
  var require_protocol_moniker2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.moniker.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = void 0;
      var messages_1 = require_messages4();
      var UniquenessLevel;
      (function(UniquenessLevel2) {
        UniquenessLevel2.document = "document";
        UniquenessLevel2.project = "project";
        UniquenessLevel2.group = "group";
        UniquenessLevel2.scheme = "scheme";
        UniquenessLevel2.global = "global";
      })(UniquenessLevel || (exports.UniquenessLevel = UniquenessLevel = {}));
      var MonikerKind;
      (function(MonikerKind2) {
        MonikerKind2.$import = "import";
        MonikerKind2.$export = "export";
        MonikerKind2.local = "local";
      })(MonikerKind || (exports.MonikerKind = MonikerKind = {}));
      var MonikerRequest;
      (function(MonikerRequest2) {
        MonikerRequest2.method = "textDocument/moniker";
        MonikerRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        MonikerRequest2.type = new messages_1.ProtocolRequestType(MonikerRequest2.method);
      })(MonikerRequest || (exports.MonikerRequest = MonikerRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeHierarchy.js
  var require_protocol_typeHierarchy2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.typeHierarchy.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TypeHierarchySubtypesRequest = exports.TypeHierarchySupertypesRequest = exports.TypeHierarchyPrepareRequest = void 0;
      var messages_1 = require_messages4();
      var TypeHierarchyPrepareRequest;
      (function(TypeHierarchyPrepareRequest2) {
        TypeHierarchyPrepareRequest2.method = "textDocument/prepareTypeHierarchy";
        TypeHierarchyPrepareRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TypeHierarchyPrepareRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchyPrepareRequest2.method);
      })(TypeHierarchyPrepareRequest || (exports.TypeHierarchyPrepareRequest = TypeHierarchyPrepareRequest = {}));
      var TypeHierarchySupertypesRequest;
      (function(TypeHierarchySupertypesRequest2) {
        TypeHierarchySupertypesRequest2.method = "typeHierarchy/supertypes";
        TypeHierarchySupertypesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TypeHierarchySupertypesRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchySupertypesRequest2.method);
      })(TypeHierarchySupertypesRequest || (exports.TypeHierarchySupertypesRequest = TypeHierarchySupertypesRequest = {}));
      var TypeHierarchySubtypesRequest;
      (function(TypeHierarchySubtypesRequest2) {
        TypeHierarchySubtypesRequest2.method = "typeHierarchy/subtypes";
        TypeHierarchySubtypesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        TypeHierarchySubtypesRequest2.type = new messages_1.ProtocolRequestType(TypeHierarchySubtypesRequest2.method);
      })(TypeHierarchySubtypesRequest || (exports.TypeHierarchySubtypesRequest = TypeHierarchySubtypesRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.js
  var require_protocol_inlineValue2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineValue.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlineValueRefreshRequest = exports.InlineValueRequest = void 0;
      var messages_1 = require_messages4();
      var InlineValueRequest;
      (function(InlineValueRequest2) {
        InlineValueRequest2.method = "textDocument/inlineValue";
        InlineValueRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InlineValueRequest2.type = new messages_1.ProtocolRequestType(InlineValueRequest2.method);
      })(InlineValueRequest || (exports.InlineValueRequest = InlineValueRequest = {}));
      var InlineValueRefreshRequest;
      (function(InlineValueRefreshRequest2) {
        InlineValueRefreshRequest2.method = `workspace/inlineValue/refresh`;
        InlineValueRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        InlineValueRefreshRequest2.type = new messages_1.ProtocolRequestType0(InlineValueRefreshRequest2.method);
      })(InlineValueRefreshRequest || (exports.InlineValueRefreshRequest = InlineValueRefreshRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.js
  var require_protocol_inlayHint2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlayHint.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlayHintRefreshRequest = exports.InlayHintResolveRequest = exports.InlayHintRequest = void 0;
      var messages_1 = require_messages4();
      var InlayHintRequest;
      (function(InlayHintRequest2) {
        InlayHintRequest2.method = "textDocument/inlayHint";
        InlayHintRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InlayHintRequest2.type = new messages_1.ProtocolRequestType(InlayHintRequest2.method);
      })(InlayHintRequest || (exports.InlayHintRequest = InlayHintRequest = {}));
      var InlayHintResolveRequest;
      (function(InlayHintResolveRequest2) {
        InlayHintResolveRequest2.method = "inlayHint/resolve";
        InlayHintResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InlayHintResolveRequest2.type = new messages_1.ProtocolRequestType(InlayHintResolveRequest2.method);
      })(InlayHintResolveRequest || (exports.InlayHintResolveRequest = InlayHintResolveRequest = {}));
      var InlayHintRefreshRequest;
      (function(InlayHintRefreshRequest2) {
        InlayHintRefreshRequest2.method = `workspace/inlayHint/refresh`;
        InlayHintRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        InlayHintRefreshRequest2.type = new messages_1.ProtocolRequestType0(InlayHintRefreshRequest2.method);
      })(InlayHintRefreshRequest || (exports.InlayHintRefreshRequest = InlayHintRefreshRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.diagnostic.js
  var require_protocol_diagnostic2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.diagnostic.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = void 0;
      var vscode_jsonrpc_1 = require_main4();
      var Is3 = require_is5();
      var messages_1 = require_messages4();
      var DiagnosticServerCancellationData;
      (function(DiagnosticServerCancellationData2) {
        function is(value) {
          const candidate = value;
          return candidate && Is3.boolean(candidate.retriggerRequest);
        }
        DiagnosticServerCancellationData2.is = is;
      })(DiagnosticServerCancellationData || (exports.DiagnosticServerCancellationData = DiagnosticServerCancellationData = {}));
      var DocumentDiagnosticReportKind;
      (function(DocumentDiagnosticReportKind2) {
        DocumentDiagnosticReportKind2.Full = "full";
        DocumentDiagnosticReportKind2.Unchanged = "unchanged";
      })(DocumentDiagnosticReportKind || (exports.DocumentDiagnosticReportKind = DocumentDiagnosticReportKind = {}));
      var DocumentDiagnosticRequest;
      (function(DocumentDiagnosticRequest2) {
        DocumentDiagnosticRequest2.method = "textDocument/diagnostic";
        DocumentDiagnosticRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentDiagnosticRequest2.type = new messages_1.ProtocolRequestType(DocumentDiagnosticRequest2.method);
        DocumentDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType();
      })(DocumentDiagnosticRequest || (exports.DocumentDiagnosticRequest = DocumentDiagnosticRequest = {}));
      var WorkspaceDiagnosticRequest;
      (function(WorkspaceDiagnosticRequest2) {
        WorkspaceDiagnosticRequest2.method = "workspace/diagnostic";
        WorkspaceDiagnosticRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WorkspaceDiagnosticRequest2.type = new messages_1.ProtocolRequestType(WorkspaceDiagnosticRequest2.method);
        WorkspaceDiagnosticRequest2.partialResult = new vscode_jsonrpc_1.ProgressType();
      })(WorkspaceDiagnosticRequest || (exports.WorkspaceDiagnosticRequest = WorkspaceDiagnosticRequest = {}));
      var DiagnosticRefreshRequest;
      (function(DiagnosticRefreshRequest2) {
        DiagnosticRefreshRequest2.method = `workspace/diagnostic/refresh`;
        DiagnosticRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        DiagnosticRefreshRequest2.type = new messages_1.ProtocolRequestType0(DiagnosticRefreshRequest2.method);
      })(DiagnosticRefreshRequest || (exports.DiagnosticRefreshRequest = DiagnosticRefreshRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.js
  var require_protocol_notebook2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.notebook.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DidCloseNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification = exports.NotebookCellArrayChange = exports.DidOpenNotebookDocumentNotification = exports.NotebookDocumentSyncRegistrationType = exports.NotebookDocument = exports.NotebookCell = exports.ExecutionSummary = exports.NotebookCellKind = void 0;
      var vscode_languageserver_types_1 = (init_main2(), __toCommonJS(main_exports2));
      var Is3 = require_is5();
      var messages_1 = require_messages4();
      var NotebookCellKind;
      (function(NotebookCellKind2) {
        NotebookCellKind2.Markup = 1;
        NotebookCellKind2.Code = 2;
        function is(value) {
          return value === 1 || value === 2;
        }
        NotebookCellKind2.is = is;
      })(NotebookCellKind || (exports.NotebookCellKind = NotebookCellKind = {}));
      var ExecutionSummary;
      (function(ExecutionSummary2) {
        function create(executionOrder, success) {
          const result = { executionOrder };
          if (success === true || success === false) {
            result.success = success;
          }
          return result;
        }
        ExecutionSummary2.create = create;
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.executionOrder) && (candidate.success === void 0 || Is3.boolean(candidate.success));
        }
        ExecutionSummary2.is = is;
        function equals(one, other) {
          if (one === other) {
            return true;
          }
          if (one === null || one === void 0 || other === null || other === void 0) {
            return false;
          }
          return one.executionOrder === other.executionOrder && one.success === other.success;
        }
        ExecutionSummary2.equals = equals;
      })(ExecutionSummary || (exports.ExecutionSummary = ExecutionSummary = {}));
      var NotebookCell;
      (function(NotebookCell2) {
        function create(kind, document) {
          return { kind, document };
        }
        NotebookCell2.create = create;
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && NotebookCellKind.is(candidate.kind) && vscode_languageserver_types_1.DocumentUri.is(candidate.document) && (candidate.metadata === void 0 || Is3.objectLiteral(candidate.metadata));
        }
        NotebookCell2.is = is;
        function diff(one, two) {
          const result = /* @__PURE__ */ new Set();
          if (one.document !== two.document) {
            result.add("document");
          }
          if (one.kind !== two.kind) {
            result.add("kind");
          }
          if (one.executionSummary !== two.executionSummary) {
            result.add("executionSummary");
          }
          if ((one.metadata !== void 0 || two.metadata !== void 0) && !equalsMetadata(one.metadata, two.metadata)) {
            result.add("metadata");
          }
          if ((one.executionSummary !== void 0 || two.executionSummary !== void 0) && !ExecutionSummary.equals(one.executionSummary, two.executionSummary)) {
            result.add("executionSummary");
          }
          return result;
        }
        NotebookCell2.diff = diff;
        function equalsMetadata(one, other) {
          if (one === other) {
            return true;
          }
          if (one === null || one === void 0 || other === null || other === void 0) {
            return false;
          }
          if (typeof one !== typeof other) {
            return false;
          }
          if (typeof one !== "object") {
            return false;
          }
          const oneArray = Array.isArray(one);
          const otherArray = Array.isArray(other);
          if (oneArray !== otherArray) {
            return false;
          }
          if (oneArray && otherArray) {
            if (one.length !== other.length) {
              return false;
            }
            for (let i = 0; i < one.length; i++) {
              if (!equalsMetadata(one[i], other[i])) {
                return false;
              }
            }
          }
          if (Is3.objectLiteral(one) && Is3.objectLiteral(other)) {
            const oneKeys = Object.keys(one);
            const otherKeys = Object.keys(other);
            if (oneKeys.length !== otherKeys.length) {
              return false;
            }
            oneKeys.sort();
            otherKeys.sort();
            if (!equalsMetadata(oneKeys, otherKeys)) {
              return false;
            }
            for (let i = 0; i < oneKeys.length; i++) {
              const prop = oneKeys[i];
              if (!equalsMetadata(one[prop], other[prop])) {
                return false;
              }
            }
          }
          return true;
        }
      })(NotebookCell || (exports.NotebookCell = NotebookCell = {}));
      var NotebookDocument;
      (function(NotebookDocument2) {
        function create(uri, notebookType, version, cells) {
          return { uri, notebookType, version, cells };
        }
        NotebookDocument2.create = create;
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && Is3.string(candidate.uri) && vscode_languageserver_types_1.integer.is(candidate.version) && Is3.typedArray(candidate.cells, NotebookCell.is);
        }
        NotebookDocument2.is = is;
      })(NotebookDocument || (exports.NotebookDocument = NotebookDocument = {}));
      var NotebookDocumentSyncRegistrationType;
      (function(NotebookDocumentSyncRegistrationType2) {
        NotebookDocumentSyncRegistrationType2.method = "notebookDocument/sync";
        NotebookDocumentSyncRegistrationType2.messageDirection = messages_1.MessageDirection.clientToServer;
        NotebookDocumentSyncRegistrationType2.type = new messages_1.RegistrationType(NotebookDocumentSyncRegistrationType2.method);
      })(NotebookDocumentSyncRegistrationType || (exports.NotebookDocumentSyncRegistrationType = NotebookDocumentSyncRegistrationType = {}));
      var DidOpenNotebookDocumentNotification;
      (function(DidOpenNotebookDocumentNotification2) {
        DidOpenNotebookDocumentNotification2.method = "notebookDocument/didOpen";
        DidOpenNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidOpenNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenNotebookDocumentNotification2.method);
        DidOpenNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
      })(DidOpenNotebookDocumentNotification || (exports.DidOpenNotebookDocumentNotification = DidOpenNotebookDocumentNotification = {}));
      var NotebookCellArrayChange;
      (function(NotebookCellArrayChange2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && vscode_languageserver_types_1.uinteger.is(candidate.start) && vscode_languageserver_types_1.uinteger.is(candidate.deleteCount) && (candidate.cells === void 0 || Is3.typedArray(candidate.cells, NotebookCell.is));
        }
        NotebookCellArrayChange2.is = is;
        function create(start, deleteCount, cells) {
          const result = { start, deleteCount };
          if (cells !== void 0) {
            result.cells = cells;
          }
          return result;
        }
        NotebookCellArrayChange2.create = create;
      })(NotebookCellArrayChange || (exports.NotebookCellArrayChange = NotebookCellArrayChange = {}));
      var DidChangeNotebookDocumentNotification;
      (function(DidChangeNotebookDocumentNotification2) {
        DidChangeNotebookDocumentNotification2.method = "notebookDocument/didChange";
        DidChangeNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidChangeNotebookDocumentNotification2.method);
        DidChangeNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
      })(DidChangeNotebookDocumentNotification || (exports.DidChangeNotebookDocumentNotification = DidChangeNotebookDocumentNotification = {}));
      var DidSaveNotebookDocumentNotification;
      (function(DidSaveNotebookDocumentNotification2) {
        DidSaveNotebookDocumentNotification2.method = "notebookDocument/didSave";
        DidSaveNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidSaveNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidSaveNotebookDocumentNotification2.method);
        DidSaveNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
      })(DidSaveNotebookDocumentNotification || (exports.DidSaveNotebookDocumentNotification = DidSaveNotebookDocumentNotification = {}));
      var DidCloseNotebookDocumentNotification;
      (function(DidCloseNotebookDocumentNotification2) {
        DidCloseNotebookDocumentNotification2.method = "notebookDocument/didClose";
        DidCloseNotebookDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidCloseNotebookDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidCloseNotebookDocumentNotification2.method);
        DidCloseNotebookDocumentNotification2.registrationMethod = NotebookDocumentSyncRegistrationType.method;
      })(DidCloseNotebookDocumentNotification || (exports.DidCloseNotebookDocumentNotification = DidCloseNotebookDocumentNotification = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineCompletion.js
  var require_protocol_inlineCompletion2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.inlineCompletion.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlineCompletionRequest = void 0;
      var messages_1 = require_messages4();
      var InlineCompletionRequest;
      (function(InlineCompletionRequest2) {
        InlineCompletionRequest2.method = "textDocument/inlineCompletion";
        InlineCompletionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InlineCompletionRequest2.type = new messages_1.ProtocolRequestType(InlineCompletionRequest2.method);
      })(InlineCompletionRequest || (exports.InlineCompletionRequest = InlineCompletionRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/protocol.js
  var require_protocol2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/protocol.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WorkspaceSymbolRequest = exports.CodeActionResolveRequest = exports.CodeActionRequest = exports.DocumentSymbolRequest = exports.DocumentHighlightRequest = exports.ReferencesRequest = exports.DefinitionRequest = exports.SignatureHelpRequest = exports.SignatureHelpTriggerKind = exports.HoverRequest = exports.CompletionResolveRequest = exports.CompletionRequest = exports.CompletionTriggerKind = exports.PublishDiagnosticsNotification = exports.WatchKind = exports.RelativePattern = exports.FileChangeType = exports.DidChangeWatchedFilesNotification = exports.WillSaveTextDocumentWaitUntilRequest = exports.WillSaveTextDocumentNotification = exports.TextDocumentSaveReason = exports.DidSaveTextDocumentNotification = exports.DidCloseTextDocumentNotification = exports.DidChangeTextDocumentNotification = exports.TextDocumentContentChangeEvent = exports.DidOpenTextDocumentNotification = exports.TextDocumentSyncKind = exports.TelemetryEventNotification = exports.LogMessageNotification = exports.ShowMessageRequest = exports.ShowMessageNotification = exports.MessageType = exports.DidChangeConfigurationNotification = exports.ExitNotification = exports.ShutdownRequest = exports.InitializedNotification = exports.InitializeErrorCodes = exports.InitializeRequest = exports.WorkDoneProgressOptions = exports.TextDocumentRegistrationOptions = exports.StaticRegistrationOptions = exports.PositionEncodingKind = exports.FailureHandlingKind = exports.ResourceOperationKind = exports.UnregistrationRequest = exports.RegistrationRequest = exports.DocumentSelector = exports.NotebookCellTextDocumentFilter = exports.NotebookDocumentFilter = exports.TextDocumentFilter = void 0;
      exports.MonikerRequest = exports.MonikerKind = exports.UniquenessLevel = exports.WillDeleteFilesRequest = exports.DidDeleteFilesNotification = exports.WillRenameFilesRequest = exports.DidRenameFilesNotification = exports.WillCreateFilesRequest = exports.DidCreateFilesNotification = exports.FileOperationPatternKind = exports.LinkedEditingRangeRequest = exports.ShowDocumentRequest = exports.SemanticTokensRegistrationType = exports.SemanticTokensRefreshRequest = exports.SemanticTokensRangeRequest = exports.SemanticTokensDeltaRequest = exports.SemanticTokensRequest = exports.TokenFormat = exports.CallHierarchyPrepareRequest = exports.CallHierarchyOutgoingCallsRequest = exports.CallHierarchyIncomingCallsRequest = exports.WorkDoneProgressCancelNotification = exports.WorkDoneProgressCreateRequest = exports.WorkDoneProgress = exports.SelectionRangeRequest = exports.DeclarationRequest = exports.FoldingRangeRefreshRequest = exports.FoldingRangeRequest = exports.ColorPresentationRequest = exports.DocumentColorRequest = exports.ConfigurationRequest = exports.DidChangeWorkspaceFoldersNotification = exports.WorkspaceFoldersRequest = exports.TypeDefinitionRequest = exports.ImplementationRequest = exports.ApplyWorkspaceEditRequest = exports.ExecuteCommandRequest = exports.PrepareRenameRequest = exports.RenameRequest = exports.PrepareSupportDefaultBehavior = exports.DocumentOnTypeFormattingRequest = exports.DocumentRangesFormattingRequest = exports.DocumentRangeFormattingRequest = exports.DocumentFormattingRequest = exports.DocumentLinkResolveRequest = exports.DocumentLinkRequest = exports.CodeLensRefreshRequest = exports.CodeLensResolveRequest = exports.CodeLensRequest = exports.WorkspaceSymbolResolveRequest = void 0;
      exports.InlineCompletionRequest = exports.DidCloseNotebookDocumentNotification = exports.DidSaveNotebookDocumentNotification = exports.DidChangeNotebookDocumentNotification = exports.NotebookCellArrayChange = exports.DidOpenNotebookDocumentNotification = exports.NotebookDocumentSyncRegistrationType = exports.NotebookDocument = exports.NotebookCell = exports.ExecutionSummary = exports.NotebookCellKind = exports.DiagnosticRefreshRequest = exports.WorkspaceDiagnosticRequest = exports.DocumentDiagnosticRequest = exports.DocumentDiagnosticReportKind = exports.DiagnosticServerCancellationData = exports.InlayHintRefreshRequest = exports.InlayHintResolveRequest = exports.InlayHintRequest = exports.InlineValueRefreshRequest = exports.InlineValueRequest = exports.TypeHierarchySupertypesRequest = exports.TypeHierarchySubtypesRequest = exports.TypeHierarchyPrepareRequest = void 0;
      var messages_1 = require_messages4();
      var vscode_languageserver_types_1 = (init_main2(), __toCommonJS(main_exports2));
      var Is3 = require_is5();
      var protocol_implementation_1 = require_protocol_implementation2();
      Object.defineProperty(exports, "ImplementationRequest", { enumerable: true, get: function() {
        return protocol_implementation_1.ImplementationRequest;
      } });
      var protocol_typeDefinition_1 = require_protocol_typeDefinition2();
      Object.defineProperty(exports, "TypeDefinitionRequest", { enumerable: true, get: function() {
        return protocol_typeDefinition_1.TypeDefinitionRequest;
      } });
      var protocol_workspaceFolder_1 = require_protocol_workspaceFolder2();
      Object.defineProperty(exports, "WorkspaceFoldersRequest", { enumerable: true, get: function() {
        return protocol_workspaceFolder_1.WorkspaceFoldersRequest;
      } });
      Object.defineProperty(exports, "DidChangeWorkspaceFoldersNotification", { enumerable: true, get: function() {
        return protocol_workspaceFolder_1.DidChangeWorkspaceFoldersNotification;
      } });
      var protocol_configuration_1 = require_protocol_configuration2();
      Object.defineProperty(exports, "ConfigurationRequest", { enumerable: true, get: function() {
        return protocol_configuration_1.ConfigurationRequest;
      } });
      var protocol_colorProvider_1 = require_protocol_colorProvider2();
      Object.defineProperty(exports, "DocumentColorRequest", { enumerable: true, get: function() {
        return protocol_colorProvider_1.DocumentColorRequest;
      } });
      Object.defineProperty(exports, "ColorPresentationRequest", { enumerable: true, get: function() {
        return protocol_colorProvider_1.ColorPresentationRequest;
      } });
      var protocol_foldingRange_1 = require_protocol_foldingRange2();
      Object.defineProperty(exports, "FoldingRangeRequest", { enumerable: true, get: function() {
        return protocol_foldingRange_1.FoldingRangeRequest;
      } });
      Object.defineProperty(exports, "FoldingRangeRefreshRequest", { enumerable: true, get: function() {
        return protocol_foldingRange_1.FoldingRangeRefreshRequest;
      } });
      var protocol_declaration_1 = require_protocol_declaration2();
      Object.defineProperty(exports, "DeclarationRequest", { enumerable: true, get: function() {
        return protocol_declaration_1.DeclarationRequest;
      } });
      var protocol_selectionRange_1 = require_protocol_selectionRange2();
      Object.defineProperty(exports, "SelectionRangeRequest", { enumerable: true, get: function() {
        return protocol_selectionRange_1.SelectionRangeRequest;
      } });
      var protocol_progress_1 = require_protocol_progress2();
      Object.defineProperty(exports, "WorkDoneProgress", { enumerable: true, get: function() {
        return protocol_progress_1.WorkDoneProgress;
      } });
      Object.defineProperty(exports, "WorkDoneProgressCreateRequest", { enumerable: true, get: function() {
        return protocol_progress_1.WorkDoneProgressCreateRequest;
      } });
      Object.defineProperty(exports, "WorkDoneProgressCancelNotification", { enumerable: true, get: function() {
        return protocol_progress_1.WorkDoneProgressCancelNotification;
      } });
      var protocol_callHierarchy_1 = require_protocol_callHierarchy2();
      Object.defineProperty(exports, "CallHierarchyIncomingCallsRequest", { enumerable: true, get: function() {
        return protocol_callHierarchy_1.CallHierarchyIncomingCallsRequest;
      } });
      Object.defineProperty(exports, "CallHierarchyOutgoingCallsRequest", { enumerable: true, get: function() {
        return protocol_callHierarchy_1.CallHierarchyOutgoingCallsRequest;
      } });
      Object.defineProperty(exports, "CallHierarchyPrepareRequest", { enumerable: true, get: function() {
        return protocol_callHierarchy_1.CallHierarchyPrepareRequest;
      } });
      var protocol_semanticTokens_1 = require_protocol_semanticTokens2();
      Object.defineProperty(exports, "TokenFormat", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.TokenFormat;
      } });
      Object.defineProperty(exports, "SemanticTokensRequest", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensRequest;
      } });
      Object.defineProperty(exports, "SemanticTokensDeltaRequest", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensDeltaRequest;
      } });
      Object.defineProperty(exports, "SemanticTokensRangeRequest", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensRangeRequest;
      } });
      Object.defineProperty(exports, "SemanticTokensRefreshRequest", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensRefreshRequest;
      } });
      Object.defineProperty(exports, "SemanticTokensRegistrationType", { enumerable: true, get: function() {
        return protocol_semanticTokens_1.SemanticTokensRegistrationType;
      } });
      var protocol_showDocument_1 = require_protocol_showDocument2();
      Object.defineProperty(exports, "ShowDocumentRequest", { enumerable: true, get: function() {
        return protocol_showDocument_1.ShowDocumentRequest;
      } });
      var protocol_linkedEditingRange_1 = require_protocol_linkedEditingRange2();
      Object.defineProperty(exports, "LinkedEditingRangeRequest", { enumerable: true, get: function() {
        return protocol_linkedEditingRange_1.LinkedEditingRangeRequest;
      } });
      var protocol_fileOperations_1 = require_protocol_fileOperations2();
      Object.defineProperty(exports, "FileOperationPatternKind", { enumerable: true, get: function() {
        return protocol_fileOperations_1.FileOperationPatternKind;
      } });
      Object.defineProperty(exports, "DidCreateFilesNotification", { enumerable: true, get: function() {
        return protocol_fileOperations_1.DidCreateFilesNotification;
      } });
      Object.defineProperty(exports, "WillCreateFilesRequest", { enumerable: true, get: function() {
        return protocol_fileOperations_1.WillCreateFilesRequest;
      } });
      Object.defineProperty(exports, "DidRenameFilesNotification", { enumerable: true, get: function() {
        return protocol_fileOperations_1.DidRenameFilesNotification;
      } });
      Object.defineProperty(exports, "WillRenameFilesRequest", { enumerable: true, get: function() {
        return protocol_fileOperations_1.WillRenameFilesRequest;
      } });
      Object.defineProperty(exports, "DidDeleteFilesNotification", { enumerable: true, get: function() {
        return protocol_fileOperations_1.DidDeleteFilesNotification;
      } });
      Object.defineProperty(exports, "WillDeleteFilesRequest", { enumerable: true, get: function() {
        return protocol_fileOperations_1.WillDeleteFilesRequest;
      } });
      var protocol_moniker_1 = require_protocol_moniker2();
      Object.defineProperty(exports, "UniquenessLevel", { enumerable: true, get: function() {
        return protocol_moniker_1.UniquenessLevel;
      } });
      Object.defineProperty(exports, "MonikerKind", { enumerable: true, get: function() {
        return protocol_moniker_1.MonikerKind;
      } });
      Object.defineProperty(exports, "MonikerRequest", { enumerable: true, get: function() {
        return protocol_moniker_1.MonikerRequest;
      } });
      var protocol_typeHierarchy_1 = require_protocol_typeHierarchy2();
      Object.defineProperty(exports, "TypeHierarchyPrepareRequest", { enumerable: true, get: function() {
        return protocol_typeHierarchy_1.TypeHierarchyPrepareRequest;
      } });
      Object.defineProperty(exports, "TypeHierarchySubtypesRequest", { enumerable: true, get: function() {
        return protocol_typeHierarchy_1.TypeHierarchySubtypesRequest;
      } });
      Object.defineProperty(exports, "TypeHierarchySupertypesRequest", { enumerable: true, get: function() {
        return protocol_typeHierarchy_1.TypeHierarchySupertypesRequest;
      } });
      var protocol_inlineValue_1 = require_protocol_inlineValue2();
      Object.defineProperty(exports, "InlineValueRequest", { enumerable: true, get: function() {
        return protocol_inlineValue_1.InlineValueRequest;
      } });
      Object.defineProperty(exports, "InlineValueRefreshRequest", { enumerable: true, get: function() {
        return protocol_inlineValue_1.InlineValueRefreshRequest;
      } });
      var protocol_inlayHint_1 = require_protocol_inlayHint2();
      Object.defineProperty(exports, "InlayHintRequest", { enumerable: true, get: function() {
        return protocol_inlayHint_1.InlayHintRequest;
      } });
      Object.defineProperty(exports, "InlayHintResolveRequest", { enumerable: true, get: function() {
        return protocol_inlayHint_1.InlayHintResolveRequest;
      } });
      Object.defineProperty(exports, "InlayHintRefreshRequest", { enumerable: true, get: function() {
        return protocol_inlayHint_1.InlayHintRefreshRequest;
      } });
      var protocol_diagnostic_1 = require_protocol_diagnostic2();
      Object.defineProperty(exports, "DiagnosticServerCancellationData", { enumerable: true, get: function() {
        return protocol_diagnostic_1.DiagnosticServerCancellationData;
      } });
      Object.defineProperty(exports, "DocumentDiagnosticReportKind", { enumerable: true, get: function() {
        return protocol_diagnostic_1.DocumentDiagnosticReportKind;
      } });
      Object.defineProperty(exports, "DocumentDiagnosticRequest", { enumerable: true, get: function() {
        return protocol_diagnostic_1.DocumentDiagnosticRequest;
      } });
      Object.defineProperty(exports, "WorkspaceDiagnosticRequest", { enumerable: true, get: function() {
        return protocol_diagnostic_1.WorkspaceDiagnosticRequest;
      } });
      Object.defineProperty(exports, "DiagnosticRefreshRequest", { enumerable: true, get: function() {
        return protocol_diagnostic_1.DiagnosticRefreshRequest;
      } });
      var protocol_notebook_1 = require_protocol_notebook2();
      Object.defineProperty(exports, "NotebookCellKind", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookCellKind;
      } });
      Object.defineProperty(exports, "ExecutionSummary", { enumerable: true, get: function() {
        return protocol_notebook_1.ExecutionSummary;
      } });
      Object.defineProperty(exports, "NotebookCell", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookCell;
      } });
      Object.defineProperty(exports, "NotebookDocument", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookDocument;
      } });
      Object.defineProperty(exports, "NotebookDocumentSyncRegistrationType", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookDocumentSyncRegistrationType;
      } });
      Object.defineProperty(exports, "DidOpenNotebookDocumentNotification", { enumerable: true, get: function() {
        return protocol_notebook_1.DidOpenNotebookDocumentNotification;
      } });
      Object.defineProperty(exports, "NotebookCellArrayChange", { enumerable: true, get: function() {
        return protocol_notebook_1.NotebookCellArrayChange;
      } });
      Object.defineProperty(exports, "DidChangeNotebookDocumentNotification", { enumerable: true, get: function() {
        return protocol_notebook_1.DidChangeNotebookDocumentNotification;
      } });
      Object.defineProperty(exports, "DidSaveNotebookDocumentNotification", { enumerable: true, get: function() {
        return protocol_notebook_1.DidSaveNotebookDocumentNotification;
      } });
      Object.defineProperty(exports, "DidCloseNotebookDocumentNotification", { enumerable: true, get: function() {
        return protocol_notebook_1.DidCloseNotebookDocumentNotification;
      } });
      var protocol_inlineCompletion_1 = require_protocol_inlineCompletion2();
      Object.defineProperty(exports, "InlineCompletionRequest", { enumerable: true, get: function() {
        return protocol_inlineCompletion_1.InlineCompletionRequest;
      } });
      var TextDocumentFilter;
      (function(TextDocumentFilter2) {
        function is(value) {
          const candidate = value;
          return Is3.string(candidate) || (Is3.string(candidate.language) || Is3.string(candidate.scheme) || Is3.string(candidate.pattern));
        }
        TextDocumentFilter2.is = is;
      })(TextDocumentFilter || (exports.TextDocumentFilter = TextDocumentFilter = {}));
      var NotebookDocumentFilter;
      (function(NotebookDocumentFilter2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && (Is3.string(candidate.notebookType) || Is3.string(candidate.scheme) || Is3.string(candidate.pattern));
        }
        NotebookDocumentFilter2.is = is;
      })(NotebookDocumentFilter || (exports.NotebookDocumentFilter = NotebookDocumentFilter = {}));
      var NotebookCellTextDocumentFilter;
      (function(NotebookCellTextDocumentFilter2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && (Is3.string(candidate.notebook) || NotebookDocumentFilter.is(candidate.notebook)) && (candidate.language === void 0 || Is3.string(candidate.language));
        }
        NotebookCellTextDocumentFilter2.is = is;
      })(NotebookCellTextDocumentFilter || (exports.NotebookCellTextDocumentFilter = NotebookCellTextDocumentFilter = {}));
      var DocumentSelector;
      (function(DocumentSelector2) {
        function is(value) {
          if (!Array.isArray(value)) {
            return false;
          }
          for (let elem of value) {
            if (!Is3.string(elem) && !TextDocumentFilter.is(elem) && !NotebookCellTextDocumentFilter.is(elem)) {
              return false;
            }
          }
          return true;
        }
        DocumentSelector2.is = is;
      })(DocumentSelector || (exports.DocumentSelector = DocumentSelector = {}));
      var RegistrationRequest;
      (function(RegistrationRequest2) {
        RegistrationRequest2.method = "client/registerCapability";
        RegistrationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        RegistrationRequest2.type = new messages_1.ProtocolRequestType(RegistrationRequest2.method);
      })(RegistrationRequest || (exports.RegistrationRequest = RegistrationRequest = {}));
      var UnregistrationRequest;
      (function(UnregistrationRequest2) {
        UnregistrationRequest2.method = "client/unregisterCapability";
        UnregistrationRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        UnregistrationRequest2.type = new messages_1.ProtocolRequestType(UnregistrationRequest2.method);
      })(UnregistrationRequest || (exports.UnregistrationRequest = UnregistrationRequest = {}));
      var ResourceOperationKind;
      (function(ResourceOperationKind2) {
        ResourceOperationKind2.Create = "create";
        ResourceOperationKind2.Rename = "rename";
        ResourceOperationKind2.Delete = "delete";
      })(ResourceOperationKind || (exports.ResourceOperationKind = ResourceOperationKind = {}));
      var FailureHandlingKind;
      (function(FailureHandlingKind2) {
        FailureHandlingKind2.Abort = "abort";
        FailureHandlingKind2.Transactional = "transactional";
        FailureHandlingKind2.TextOnlyTransactional = "textOnlyTransactional";
        FailureHandlingKind2.Undo = "undo";
      })(FailureHandlingKind || (exports.FailureHandlingKind = FailureHandlingKind = {}));
      var PositionEncodingKind;
      (function(PositionEncodingKind2) {
        PositionEncodingKind2.UTF8 = "utf-8";
        PositionEncodingKind2.UTF16 = "utf-16";
        PositionEncodingKind2.UTF32 = "utf-32";
      })(PositionEncodingKind || (exports.PositionEncodingKind = PositionEncodingKind = {}));
      var StaticRegistrationOptions;
      (function(StaticRegistrationOptions2) {
        function hasId(value) {
          const candidate = value;
          return candidate && Is3.string(candidate.id) && candidate.id.length > 0;
        }
        StaticRegistrationOptions2.hasId = hasId;
      })(StaticRegistrationOptions || (exports.StaticRegistrationOptions = StaticRegistrationOptions = {}));
      var TextDocumentRegistrationOptions;
      (function(TextDocumentRegistrationOptions2) {
        function is(value) {
          const candidate = value;
          return candidate && (candidate.documentSelector === null || DocumentSelector.is(candidate.documentSelector));
        }
        TextDocumentRegistrationOptions2.is = is;
      })(TextDocumentRegistrationOptions || (exports.TextDocumentRegistrationOptions = TextDocumentRegistrationOptions = {}));
      var WorkDoneProgressOptions;
      (function(WorkDoneProgressOptions2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && (candidate.workDoneProgress === void 0 || Is3.boolean(candidate.workDoneProgress));
        }
        WorkDoneProgressOptions2.is = is;
        function hasWorkDoneProgress(value) {
          const candidate = value;
          return candidate && Is3.boolean(candidate.workDoneProgress);
        }
        WorkDoneProgressOptions2.hasWorkDoneProgress = hasWorkDoneProgress;
      })(WorkDoneProgressOptions || (exports.WorkDoneProgressOptions = WorkDoneProgressOptions = {}));
      var InitializeRequest;
      (function(InitializeRequest2) {
        InitializeRequest2.method = "initialize";
        InitializeRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        InitializeRequest2.type = new messages_1.ProtocolRequestType(InitializeRequest2.method);
      })(InitializeRequest || (exports.InitializeRequest = InitializeRequest = {}));
      var InitializeErrorCodes;
      (function(InitializeErrorCodes2) {
        InitializeErrorCodes2.unknownProtocolVersion = 1;
      })(InitializeErrorCodes || (exports.InitializeErrorCodes = InitializeErrorCodes = {}));
      var InitializedNotification;
      (function(InitializedNotification2) {
        InitializedNotification2.method = "initialized";
        InitializedNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        InitializedNotification2.type = new messages_1.ProtocolNotificationType(InitializedNotification2.method);
      })(InitializedNotification || (exports.InitializedNotification = InitializedNotification = {}));
      var ShutdownRequest;
      (function(ShutdownRequest2) {
        ShutdownRequest2.method = "shutdown";
        ShutdownRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ShutdownRequest2.type = new messages_1.ProtocolRequestType0(ShutdownRequest2.method);
      })(ShutdownRequest || (exports.ShutdownRequest = ShutdownRequest = {}));
      var ExitNotification;
      (function(ExitNotification2) {
        ExitNotification2.method = "exit";
        ExitNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        ExitNotification2.type = new messages_1.ProtocolNotificationType0(ExitNotification2.method);
      })(ExitNotification || (exports.ExitNotification = ExitNotification = {}));
      var DidChangeConfigurationNotification2;
      (function(DidChangeConfigurationNotification3) {
        DidChangeConfigurationNotification3.method = "workspace/didChangeConfiguration";
        DidChangeConfigurationNotification3.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeConfigurationNotification3.type = new messages_1.ProtocolNotificationType(DidChangeConfigurationNotification3.method);
      })(DidChangeConfigurationNotification2 || (exports.DidChangeConfigurationNotification = DidChangeConfigurationNotification2 = {}));
      var MessageType;
      (function(MessageType2) {
        MessageType2.Error = 1;
        MessageType2.Warning = 2;
        MessageType2.Info = 3;
        MessageType2.Log = 4;
        MessageType2.Debug = 5;
      })(MessageType || (exports.MessageType = MessageType = {}));
      var ShowMessageNotification;
      (function(ShowMessageNotification2) {
        ShowMessageNotification2.method = "window/showMessage";
        ShowMessageNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
        ShowMessageNotification2.type = new messages_1.ProtocolNotificationType(ShowMessageNotification2.method);
      })(ShowMessageNotification || (exports.ShowMessageNotification = ShowMessageNotification = {}));
      var ShowMessageRequest;
      (function(ShowMessageRequest2) {
        ShowMessageRequest2.method = "window/showMessageRequest";
        ShowMessageRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        ShowMessageRequest2.type = new messages_1.ProtocolRequestType(ShowMessageRequest2.method);
      })(ShowMessageRequest || (exports.ShowMessageRequest = ShowMessageRequest = {}));
      var LogMessageNotification;
      (function(LogMessageNotification2) {
        LogMessageNotification2.method = "window/logMessage";
        LogMessageNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
        LogMessageNotification2.type = new messages_1.ProtocolNotificationType(LogMessageNotification2.method);
      })(LogMessageNotification || (exports.LogMessageNotification = LogMessageNotification = {}));
      var TelemetryEventNotification;
      (function(TelemetryEventNotification2) {
        TelemetryEventNotification2.method = "telemetry/event";
        TelemetryEventNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
        TelemetryEventNotification2.type = new messages_1.ProtocolNotificationType(TelemetryEventNotification2.method);
      })(TelemetryEventNotification || (exports.TelemetryEventNotification = TelemetryEventNotification = {}));
      var TextDocumentSyncKind2;
      (function(TextDocumentSyncKind3) {
        TextDocumentSyncKind3.None = 0;
        TextDocumentSyncKind3.Full = 1;
        TextDocumentSyncKind3.Incremental = 2;
      })(TextDocumentSyncKind2 || (exports.TextDocumentSyncKind = TextDocumentSyncKind2 = {}));
      var DidOpenTextDocumentNotification;
      (function(DidOpenTextDocumentNotification2) {
        DidOpenTextDocumentNotification2.method = "textDocument/didOpen";
        DidOpenTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidOpenTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidOpenTextDocumentNotification2.method);
      })(DidOpenTextDocumentNotification || (exports.DidOpenTextDocumentNotification = DidOpenTextDocumentNotification = {}));
      var TextDocumentContentChangeEvent;
      (function(TextDocumentContentChangeEvent2) {
        function isIncremental(event) {
          let candidate = event;
          return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
        }
        TextDocumentContentChangeEvent2.isIncremental = isIncremental;
        function isFull(event) {
          let candidate = event;
          return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
        }
        TextDocumentContentChangeEvent2.isFull = isFull;
      })(TextDocumentContentChangeEvent || (exports.TextDocumentContentChangeEvent = TextDocumentContentChangeEvent = {}));
      var DidChangeTextDocumentNotification;
      (function(DidChangeTextDocumentNotification2) {
        DidChangeTextDocumentNotification2.method = "textDocument/didChange";
        DidChangeTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidChangeTextDocumentNotification2.method);
      })(DidChangeTextDocumentNotification || (exports.DidChangeTextDocumentNotification = DidChangeTextDocumentNotification = {}));
      var DidCloseTextDocumentNotification;
      (function(DidCloseTextDocumentNotification2) {
        DidCloseTextDocumentNotification2.method = "textDocument/didClose";
        DidCloseTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidCloseTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidCloseTextDocumentNotification2.method);
      })(DidCloseTextDocumentNotification || (exports.DidCloseTextDocumentNotification = DidCloseTextDocumentNotification = {}));
      var DidSaveTextDocumentNotification;
      (function(DidSaveTextDocumentNotification2) {
        DidSaveTextDocumentNotification2.method = "textDocument/didSave";
        DidSaveTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(DidSaveTextDocumentNotification2.method);
      })(DidSaveTextDocumentNotification || (exports.DidSaveTextDocumentNotification = DidSaveTextDocumentNotification = {}));
      var TextDocumentSaveReason;
      (function(TextDocumentSaveReason2) {
        TextDocumentSaveReason2.Manual = 1;
        TextDocumentSaveReason2.AfterDelay = 2;
        TextDocumentSaveReason2.FocusOut = 3;
      })(TextDocumentSaveReason || (exports.TextDocumentSaveReason = TextDocumentSaveReason = {}));
      var WillSaveTextDocumentNotification;
      (function(WillSaveTextDocumentNotification2) {
        WillSaveTextDocumentNotification2.method = "textDocument/willSave";
        WillSaveTextDocumentNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillSaveTextDocumentNotification2.type = new messages_1.ProtocolNotificationType(WillSaveTextDocumentNotification2.method);
      })(WillSaveTextDocumentNotification || (exports.WillSaveTextDocumentNotification = WillSaveTextDocumentNotification = {}));
      var WillSaveTextDocumentWaitUntilRequest;
      (function(WillSaveTextDocumentWaitUntilRequest2) {
        WillSaveTextDocumentWaitUntilRequest2.method = "textDocument/willSaveWaitUntil";
        WillSaveTextDocumentWaitUntilRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WillSaveTextDocumentWaitUntilRequest2.type = new messages_1.ProtocolRequestType(WillSaveTextDocumentWaitUntilRequest2.method);
      })(WillSaveTextDocumentWaitUntilRequest || (exports.WillSaveTextDocumentWaitUntilRequest = WillSaveTextDocumentWaitUntilRequest = {}));
      var DidChangeWatchedFilesNotification;
      (function(DidChangeWatchedFilesNotification2) {
        DidChangeWatchedFilesNotification2.method = "workspace/didChangeWatchedFiles";
        DidChangeWatchedFilesNotification2.messageDirection = messages_1.MessageDirection.clientToServer;
        DidChangeWatchedFilesNotification2.type = new messages_1.ProtocolNotificationType(DidChangeWatchedFilesNotification2.method);
      })(DidChangeWatchedFilesNotification || (exports.DidChangeWatchedFilesNotification = DidChangeWatchedFilesNotification = {}));
      var FileChangeType;
      (function(FileChangeType2) {
        FileChangeType2.Created = 1;
        FileChangeType2.Changed = 2;
        FileChangeType2.Deleted = 3;
      })(FileChangeType || (exports.FileChangeType = FileChangeType = {}));
      var RelativePattern;
      (function(RelativePattern2) {
        function is(value) {
          const candidate = value;
          return Is3.objectLiteral(candidate) && (vscode_languageserver_types_1.URI.is(candidate.baseUri) || vscode_languageserver_types_1.WorkspaceFolder.is(candidate.baseUri)) && Is3.string(candidate.pattern);
        }
        RelativePattern2.is = is;
      })(RelativePattern || (exports.RelativePattern = RelativePattern = {}));
      var WatchKind;
      (function(WatchKind2) {
        WatchKind2.Create = 1;
        WatchKind2.Change = 2;
        WatchKind2.Delete = 4;
      })(WatchKind || (exports.WatchKind = WatchKind = {}));
      var PublishDiagnosticsNotification;
      (function(PublishDiagnosticsNotification2) {
        PublishDiagnosticsNotification2.method = "textDocument/publishDiagnostics";
        PublishDiagnosticsNotification2.messageDirection = messages_1.MessageDirection.serverToClient;
        PublishDiagnosticsNotification2.type = new messages_1.ProtocolNotificationType(PublishDiagnosticsNotification2.method);
      })(PublishDiagnosticsNotification || (exports.PublishDiagnosticsNotification = PublishDiagnosticsNotification = {}));
      var CompletionTriggerKind;
      (function(CompletionTriggerKind2) {
        CompletionTriggerKind2.Invoked = 1;
        CompletionTriggerKind2.TriggerCharacter = 2;
        CompletionTriggerKind2.TriggerForIncompleteCompletions = 3;
      })(CompletionTriggerKind || (exports.CompletionTriggerKind = CompletionTriggerKind = {}));
      var CompletionRequest;
      (function(CompletionRequest2) {
        CompletionRequest2.method = "textDocument/completion";
        CompletionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CompletionRequest2.type = new messages_1.ProtocolRequestType(CompletionRequest2.method);
      })(CompletionRequest || (exports.CompletionRequest = CompletionRequest = {}));
      var CompletionResolveRequest;
      (function(CompletionResolveRequest2) {
        CompletionResolveRequest2.method = "completionItem/resolve";
        CompletionResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CompletionResolveRequest2.type = new messages_1.ProtocolRequestType(CompletionResolveRequest2.method);
      })(CompletionResolveRequest || (exports.CompletionResolveRequest = CompletionResolveRequest = {}));
      var HoverRequest;
      (function(HoverRequest2) {
        HoverRequest2.method = "textDocument/hover";
        HoverRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        HoverRequest2.type = new messages_1.ProtocolRequestType(HoverRequest2.method);
      })(HoverRequest || (exports.HoverRequest = HoverRequest = {}));
      var SignatureHelpTriggerKind;
      (function(SignatureHelpTriggerKind2) {
        SignatureHelpTriggerKind2.Invoked = 1;
        SignatureHelpTriggerKind2.TriggerCharacter = 2;
        SignatureHelpTriggerKind2.ContentChange = 3;
      })(SignatureHelpTriggerKind || (exports.SignatureHelpTriggerKind = SignatureHelpTriggerKind = {}));
      var SignatureHelpRequest;
      (function(SignatureHelpRequest2) {
        SignatureHelpRequest2.method = "textDocument/signatureHelp";
        SignatureHelpRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        SignatureHelpRequest2.type = new messages_1.ProtocolRequestType(SignatureHelpRequest2.method);
      })(SignatureHelpRequest || (exports.SignatureHelpRequest = SignatureHelpRequest = {}));
      var DefinitionRequest;
      (function(DefinitionRequest2) {
        DefinitionRequest2.method = "textDocument/definition";
        DefinitionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DefinitionRequest2.type = new messages_1.ProtocolRequestType(DefinitionRequest2.method);
      })(DefinitionRequest || (exports.DefinitionRequest = DefinitionRequest = {}));
      var ReferencesRequest;
      (function(ReferencesRequest2) {
        ReferencesRequest2.method = "textDocument/references";
        ReferencesRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ReferencesRequest2.type = new messages_1.ProtocolRequestType(ReferencesRequest2.method);
      })(ReferencesRequest || (exports.ReferencesRequest = ReferencesRequest = {}));
      var DocumentHighlightRequest;
      (function(DocumentHighlightRequest2) {
        DocumentHighlightRequest2.method = "textDocument/documentHighlight";
        DocumentHighlightRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentHighlightRequest2.type = new messages_1.ProtocolRequestType(DocumentHighlightRequest2.method);
      })(DocumentHighlightRequest || (exports.DocumentHighlightRequest = DocumentHighlightRequest = {}));
      var DocumentSymbolRequest;
      (function(DocumentSymbolRequest2) {
        DocumentSymbolRequest2.method = "textDocument/documentSymbol";
        DocumentSymbolRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentSymbolRequest2.type = new messages_1.ProtocolRequestType(DocumentSymbolRequest2.method);
      })(DocumentSymbolRequest || (exports.DocumentSymbolRequest = DocumentSymbolRequest = {}));
      var CodeActionRequest;
      (function(CodeActionRequest2) {
        CodeActionRequest2.method = "textDocument/codeAction";
        CodeActionRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CodeActionRequest2.type = new messages_1.ProtocolRequestType(CodeActionRequest2.method);
      })(CodeActionRequest || (exports.CodeActionRequest = CodeActionRequest = {}));
      var CodeActionResolveRequest;
      (function(CodeActionResolveRequest2) {
        CodeActionResolveRequest2.method = "codeAction/resolve";
        CodeActionResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CodeActionResolveRequest2.type = new messages_1.ProtocolRequestType(CodeActionResolveRequest2.method);
      })(CodeActionResolveRequest || (exports.CodeActionResolveRequest = CodeActionResolveRequest = {}));
      var WorkspaceSymbolRequest;
      (function(WorkspaceSymbolRequest2) {
        WorkspaceSymbolRequest2.method = "workspace/symbol";
        WorkspaceSymbolRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WorkspaceSymbolRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolRequest2.method);
      })(WorkspaceSymbolRequest || (exports.WorkspaceSymbolRequest = WorkspaceSymbolRequest = {}));
      var WorkspaceSymbolResolveRequest;
      (function(WorkspaceSymbolResolveRequest2) {
        WorkspaceSymbolResolveRequest2.method = "workspaceSymbol/resolve";
        WorkspaceSymbolResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        WorkspaceSymbolResolveRequest2.type = new messages_1.ProtocolRequestType(WorkspaceSymbolResolveRequest2.method);
      })(WorkspaceSymbolResolveRequest || (exports.WorkspaceSymbolResolveRequest = WorkspaceSymbolResolveRequest = {}));
      var CodeLensRequest;
      (function(CodeLensRequest2) {
        CodeLensRequest2.method = "textDocument/codeLens";
        CodeLensRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CodeLensRequest2.type = new messages_1.ProtocolRequestType(CodeLensRequest2.method);
      })(CodeLensRequest || (exports.CodeLensRequest = CodeLensRequest = {}));
      var CodeLensResolveRequest;
      (function(CodeLensResolveRequest2) {
        CodeLensResolveRequest2.method = "codeLens/resolve";
        CodeLensResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        CodeLensResolveRequest2.type = new messages_1.ProtocolRequestType(CodeLensResolveRequest2.method);
      })(CodeLensResolveRequest || (exports.CodeLensResolveRequest = CodeLensResolveRequest = {}));
      var CodeLensRefreshRequest;
      (function(CodeLensRefreshRequest2) {
        CodeLensRefreshRequest2.method = `workspace/codeLens/refresh`;
        CodeLensRefreshRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        CodeLensRefreshRequest2.type = new messages_1.ProtocolRequestType0(CodeLensRefreshRequest2.method);
      })(CodeLensRefreshRequest || (exports.CodeLensRefreshRequest = CodeLensRefreshRequest = {}));
      var DocumentLinkRequest;
      (function(DocumentLinkRequest2) {
        DocumentLinkRequest2.method = "textDocument/documentLink";
        DocumentLinkRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentLinkRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkRequest2.method);
      })(DocumentLinkRequest || (exports.DocumentLinkRequest = DocumentLinkRequest = {}));
      var DocumentLinkResolveRequest;
      (function(DocumentLinkResolveRequest2) {
        DocumentLinkResolveRequest2.method = "documentLink/resolve";
        DocumentLinkResolveRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentLinkResolveRequest2.type = new messages_1.ProtocolRequestType(DocumentLinkResolveRequest2.method);
      })(DocumentLinkResolveRequest || (exports.DocumentLinkResolveRequest = DocumentLinkResolveRequest = {}));
      var DocumentFormattingRequest;
      (function(DocumentFormattingRequest2) {
        DocumentFormattingRequest2.method = "textDocument/formatting";
        DocumentFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentFormattingRequest2.method);
      })(DocumentFormattingRequest || (exports.DocumentFormattingRequest = DocumentFormattingRequest = {}));
      var DocumentRangeFormattingRequest;
      (function(DocumentRangeFormattingRequest2) {
        DocumentRangeFormattingRequest2.method = "textDocument/rangeFormatting";
        DocumentRangeFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentRangeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentRangeFormattingRequest2.method);
      })(DocumentRangeFormattingRequest || (exports.DocumentRangeFormattingRequest = DocumentRangeFormattingRequest = {}));
      var DocumentRangesFormattingRequest;
      (function(DocumentRangesFormattingRequest2) {
        DocumentRangesFormattingRequest2.method = "textDocument/rangesFormatting";
        DocumentRangesFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentRangesFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentRangesFormattingRequest2.method);
      })(DocumentRangesFormattingRequest || (exports.DocumentRangesFormattingRequest = DocumentRangesFormattingRequest = {}));
      var DocumentOnTypeFormattingRequest;
      (function(DocumentOnTypeFormattingRequest2) {
        DocumentOnTypeFormattingRequest2.method = "textDocument/onTypeFormatting";
        DocumentOnTypeFormattingRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        DocumentOnTypeFormattingRequest2.type = new messages_1.ProtocolRequestType(DocumentOnTypeFormattingRequest2.method);
      })(DocumentOnTypeFormattingRequest || (exports.DocumentOnTypeFormattingRequest = DocumentOnTypeFormattingRequest = {}));
      var PrepareSupportDefaultBehavior;
      (function(PrepareSupportDefaultBehavior2) {
        PrepareSupportDefaultBehavior2.Identifier = 1;
      })(PrepareSupportDefaultBehavior || (exports.PrepareSupportDefaultBehavior = PrepareSupportDefaultBehavior = {}));
      var RenameRequest;
      (function(RenameRequest2) {
        RenameRequest2.method = "textDocument/rename";
        RenameRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        RenameRequest2.type = new messages_1.ProtocolRequestType(RenameRequest2.method);
      })(RenameRequest || (exports.RenameRequest = RenameRequest = {}));
      var PrepareRenameRequest;
      (function(PrepareRenameRequest2) {
        PrepareRenameRequest2.method = "textDocument/prepareRename";
        PrepareRenameRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        PrepareRenameRequest2.type = new messages_1.ProtocolRequestType(PrepareRenameRequest2.method);
      })(PrepareRenameRequest || (exports.PrepareRenameRequest = PrepareRenameRequest = {}));
      var ExecuteCommandRequest;
      (function(ExecuteCommandRequest2) {
        ExecuteCommandRequest2.method = "workspace/executeCommand";
        ExecuteCommandRequest2.messageDirection = messages_1.MessageDirection.clientToServer;
        ExecuteCommandRequest2.type = new messages_1.ProtocolRequestType(ExecuteCommandRequest2.method);
      })(ExecuteCommandRequest || (exports.ExecuteCommandRequest = ExecuteCommandRequest = {}));
      var ApplyWorkspaceEditRequest;
      (function(ApplyWorkspaceEditRequest2) {
        ApplyWorkspaceEditRequest2.method = "workspace/applyEdit";
        ApplyWorkspaceEditRequest2.messageDirection = messages_1.MessageDirection.serverToClient;
        ApplyWorkspaceEditRequest2.type = new messages_1.ProtocolRequestType("workspace/applyEdit");
      })(ApplyWorkspaceEditRequest || (exports.ApplyWorkspaceEditRequest = ApplyWorkspaceEditRequest = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/connection.js
  var require_connection4 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/connection.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createProtocolConnection = void 0;
      var vscode_jsonrpc_1 = require_main4();
      function createProtocolConnection(input, output, logger, options) {
        if (vscode_jsonrpc_1.ConnectionStrategy.is(options)) {
          options = { connectionStrategy: options };
        }
        return (0, vscode_jsonrpc_1.createMessageConnection)(input, output, logger, options);
      }
      exports.createProtocolConnection = createProtocolConnection;
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/common/api.js
  var require_api5 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/common/api.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LSPErrorCodes = exports.createProtocolConnection = void 0;
      __exportStar(require_main4(), exports);
      __exportStar((init_main2(), __toCommonJS(main_exports2)), exports);
      __exportStar(require_messages4(), exports);
      __exportStar(require_protocol2(), exports);
      var connection_1 = require_connection4();
      Object.defineProperty(exports, "createProtocolConnection", { enumerable: true, get: function() {
        return connection_1.createProtocolConnection;
      } });
      var LSPErrorCodes;
      (function(LSPErrorCodes2) {
        LSPErrorCodes2.lspReservedErrorRangeStart = -32899;
        LSPErrorCodes2.RequestFailed = -32803;
        LSPErrorCodes2.ServerCancelled = -32802;
        LSPErrorCodes2.ContentModified = -32801;
        LSPErrorCodes2.RequestCancelled = -32800;
        LSPErrorCodes2.lspReservedErrorRangeEnd = -32800;
      })(LSPErrorCodes || (exports.LSPErrorCodes = LSPErrorCodes = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/lib/browser/main.js
  var require_main5 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/lib/browser/main.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createProtocolConnection = void 0;
      var browser_1 = require_browser();
      __exportStar(require_browser(), exports);
      __exportStar(require_api5(), exports);
      function createProtocolConnection(reader, writer, logger, options) {
        return (0, browser_1.createMessageConnection)(reader, writer, logger, options);
      }
      exports.createProtocolConnection = createProtocolConnection;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/semanticTokens.js
  var require_semanticTokens2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/semanticTokens.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SemanticTokensBuilder = exports.SemanticTokensDiff = exports.SemanticTokensFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var SemanticTokensFeature = (Base) => {
        return class extends Base {
          get semanticTokens() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.SemanticTokensRefreshRequest.type);
              },
              on: (handler) => {
                const type = vscode_languageserver_protocol_1.SemanticTokensRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              },
              onDelta: (handler) => {
                const type = vscode_languageserver_protocol_1.SemanticTokensDeltaRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              },
              onRange: (handler) => {
                const type = vscode_languageserver_protocol_1.SemanticTokensRangeRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.SemanticTokensFeature = SemanticTokensFeature;
      var SemanticTokensDiff = class {
        constructor(originalSequence, modifiedSequence) {
          this.originalSequence = originalSequence;
          this.modifiedSequence = modifiedSequence;
        }
        computeDiff() {
          const originalLength = this.originalSequence.length;
          const modifiedLength = this.modifiedSequence.length;
          let startIndex = 0;
          while (startIndex < modifiedLength && startIndex < originalLength && this.originalSequence[startIndex] === this.modifiedSequence[startIndex]) {
            startIndex++;
          }
          if (startIndex < modifiedLength && startIndex < originalLength) {
            let originalEndIndex = originalLength - 1;
            let modifiedEndIndex = modifiedLength - 1;
            while (originalEndIndex >= startIndex && modifiedEndIndex >= startIndex && this.originalSequence[originalEndIndex] === this.modifiedSequence[modifiedEndIndex]) {
              originalEndIndex--;
              modifiedEndIndex--;
            }
            if (originalEndIndex < startIndex || modifiedEndIndex < startIndex) {
              originalEndIndex++;
              modifiedEndIndex++;
            }
            const deleteCount = originalEndIndex - startIndex + 1;
            const newData = this.modifiedSequence.slice(startIndex, modifiedEndIndex + 1);
            if (newData.length === 1 && newData[0] === this.originalSequence[originalEndIndex]) {
              return [
                { start: startIndex, deleteCount: deleteCount - 1 }
              ];
            } else {
              return [
                { start: startIndex, deleteCount, data: newData }
              ];
            }
          } else if (startIndex < modifiedLength) {
            return [
              { start: startIndex, deleteCount: 0, data: this.modifiedSequence.slice(startIndex) }
            ];
          } else if (startIndex < originalLength) {
            return [
              { start: startIndex, deleteCount: originalLength - startIndex }
            ];
          } else {
            return [];
          }
        }
      };
      exports.SemanticTokensDiff = SemanticTokensDiff;
      var SemanticTokensBuilder2 = class {
        constructor() {
          this._prevData = void 0;
          this.initialize();
        }
        initialize() {
          this._id = Date.now();
          this._prevLine = 0;
          this._prevChar = 0;
          this._data = [];
          this._dataLen = 0;
        }
        push(line, char, length, tokenType, tokenModifiers2) {
          let pushLine = line;
          let pushChar = char;
          if (this._dataLen > 0) {
            pushLine -= this._prevLine;
            if (pushLine === 0) {
              pushChar -= this._prevChar;
            }
          }
          this._data[this._dataLen++] = pushLine;
          this._data[this._dataLen++] = pushChar;
          this._data[this._dataLen++] = length;
          this._data[this._dataLen++] = tokenType;
          this._data[this._dataLen++] = tokenModifiers2;
          this._prevLine = line;
          this._prevChar = char;
        }
        get id() {
          return this._id.toString();
        }
        previousResult(id) {
          if (this.id === id) {
            this._prevData = this._data;
          }
          this.initialize();
        }
        build() {
          this._prevData = void 0;
          return {
            resultId: this.id,
            data: this._data
          };
        }
        canBuildEdits() {
          return this._prevData !== void 0;
        }
        buildEdits() {
          if (this._prevData !== void 0) {
            return {
              resultId: this.id,
              edits: new SemanticTokensDiff(this._prevData, this._data).computeDiff()
            };
          } else {
            return this.build();
          }
        }
      };
      exports.SemanticTokensBuilder = SemanticTokensBuilder2;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/inlineCompletion.proposed.js
  var require_inlineCompletion_proposed2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/inlineCompletion.proposed.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlineCompletionFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var InlineCompletionFeature = (Base) => {
        return class extends Base {
          get inlineCompletion() {
            return {
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.InlineCompletionRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params));
                });
              }
            };
          }
        };
      };
      exports.InlineCompletionFeature = InlineCompletionFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/textDocuments.js
  var require_textDocuments2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/textDocuments.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TextDocuments = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var TextDocuments2 = class {
        /**
         * Create a new text document manager.
         */
        constructor(configuration) {
          this._configuration = configuration;
          this._syncedDocuments = /* @__PURE__ */ new Map();
          this._onDidChangeContent = new vscode_languageserver_protocol_1.Emitter();
          this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
          this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
          this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
          this._onWillSave = new vscode_languageserver_protocol_1.Emitter();
        }
        /**
         * An event that fires when a text document managed by this manager
         * has been opened.
         */
        get onDidOpen() {
          return this._onDidOpen.event;
        }
        /**
         * An event that fires when a text document managed by this manager
         * has been opened or the content changes.
         */
        get onDidChangeContent() {
          return this._onDidChangeContent.event;
        }
        /**
         * An event that fires when a text document managed by this manager
         * will be saved.
         */
        get onWillSave() {
          return this._onWillSave.event;
        }
        /**
         * Sets a handler that will be called if a participant wants to provide
         * edits during a text document save.
         */
        onWillSaveWaitUntil(handler) {
          this._willSaveWaitUntil = handler;
        }
        /**
         * An event that fires when a text document managed by this manager
         * has been saved.
         */
        get onDidSave() {
          return this._onDidSave.event;
        }
        /**
         * An event that fires when a text document managed by this manager
         * has been closed.
         */
        get onDidClose() {
          return this._onDidClose.event;
        }
        /**
         * Returns the document for the given URI. Returns undefined if
         * the document is not managed by this instance.
         *
         * @param uri The text document's URI to retrieve.
         * @return the text document or `undefined`.
         */
        get(uri) {
          return this._syncedDocuments.get(uri);
        }
        /**
         * Returns all text documents managed by this instance.
         *
         * @return all text documents.
         */
        all() {
          return Array.from(this._syncedDocuments.values());
        }
        /**
         * Returns the URIs of all text documents managed by this instance.
         *
         * @return the URI's of all text documents.
         */
        keys() {
          return Array.from(this._syncedDocuments.keys());
        }
        /**
         * Listens for `low level` notification on the given connection to
         * update the text documents managed by this instance.
         *
         * Please note that the connection only provides handlers not an event model. Therefore
         * listening on a connection will overwrite the following handlers on a connection:
         * `onDidOpenTextDocument`, `onDidChangeTextDocument`, `onDidCloseTextDocument`,
         * `onWillSaveTextDocument`, `onWillSaveTextDocumentWaitUntil` and `onDidSaveTextDocument`.
         *
         * Use the corresponding events on the TextDocuments instance instead.
         *
         * @param connection The connection to listen on.
         */
        listen(connection2) {
          connection2.__textDocumentSync = vscode_languageserver_protocol_1.TextDocumentSyncKind.Incremental;
          const disposables = [];
          disposables.push(connection2.onDidOpenTextDocument((event) => {
            const td = event.textDocument;
            const document = this._configuration.create(td.uri, td.languageId, td.version, td.text);
            this._syncedDocuments.set(td.uri, document);
            const toFire = Object.freeze({ document });
            this._onDidOpen.fire(toFire);
            this._onDidChangeContent.fire(toFire);
          }));
          disposables.push(connection2.onDidChangeTextDocument((event) => {
            const td = event.textDocument;
            const changes = event.contentChanges;
            if (changes.length === 0) {
              return;
            }
            const { version } = td;
            if (version === null || version === void 0) {
              throw new Error(`Received document change event for ${td.uri} without valid version identifier`);
            }
            let syncedDocument = this._syncedDocuments.get(td.uri);
            if (syncedDocument !== void 0) {
              syncedDocument = this._configuration.update(syncedDocument, changes, version);
              this._syncedDocuments.set(td.uri, syncedDocument);
              this._onDidChangeContent.fire(Object.freeze({ document: syncedDocument }));
            }
          }));
          disposables.push(connection2.onDidCloseTextDocument((event) => {
            let syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
            if (syncedDocument !== void 0) {
              this._syncedDocuments.delete(event.textDocument.uri);
              this._onDidClose.fire(Object.freeze({ document: syncedDocument }));
            }
          }));
          disposables.push(connection2.onWillSaveTextDocument((event) => {
            let syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
            if (syncedDocument !== void 0) {
              this._onWillSave.fire(Object.freeze({ document: syncedDocument, reason: event.reason }));
            }
          }));
          disposables.push(connection2.onWillSaveTextDocumentWaitUntil((event, token) => {
            let syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
            if (syncedDocument !== void 0 && this._willSaveWaitUntil) {
              return this._willSaveWaitUntil(Object.freeze({ document: syncedDocument, reason: event.reason }), token);
            } else {
              return [];
            }
          }));
          disposables.push(connection2.onDidSaveTextDocument((event) => {
            let syncedDocument = this._syncedDocuments.get(event.textDocument.uri);
            if (syncedDocument !== void 0) {
              this._onDidSave.fire(Object.freeze({ document: syncedDocument }));
            }
          }));
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            disposables.forEach((disposable) => disposable.dispose());
          });
        }
      };
      exports.TextDocuments = TextDocuments2;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/notebook.js
  var require_notebook2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/notebook.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.NotebookDocuments = exports.NotebookSyncFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var textDocuments_1 = require_textDocuments2();
      var NotebookSyncFeature = (Base) => {
        return class extends Base {
          get synchronization() {
            return {
              onDidOpenNotebookDocument: (handler) => {
                return this.connection.onNotification(vscode_languageserver_protocol_1.DidOpenNotebookDocumentNotification.type, (params) => {
                  handler(params);
                });
              },
              onDidChangeNotebookDocument: (handler) => {
                return this.connection.onNotification(vscode_languageserver_protocol_1.DidChangeNotebookDocumentNotification.type, (params) => {
                  handler(params);
                });
              },
              onDidSaveNotebookDocument: (handler) => {
                return this.connection.onNotification(vscode_languageserver_protocol_1.DidSaveNotebookDocumentNotification.type, (params) => {
                  handler(params);
                });
              },
              onDidCloseNotebookDocument: (handler) => {
                return this.connection.onNotification(vscode_languageserver_protocol_1.DidCloseNotebookDocumentNotification.type, (params) => {
                  handler(params);
                });
              }
            };
          }
        };
      };
      exports.NotebookSyncFeature = NotebookSyncFeature;
      var CellTextDocumentConnection = class _CellTextDocumentConnection {
        onDidOpenTextDocument(handler) {
          this.openHandler = handler;
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            this.openHandler = void 0;
          });
        }
        openTextDocument(params) {
          this.openHandler && this.openHandler(params);
        }
        onDidChangeTextDocument(handler) {
          this.changeHandler = handler;
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            this.changeHandler = handler;
          });
        }
        changeTextDocument(params) {
          this.changeHandler && this.changeHandler(params);
        }
        onDidCloseTextDocument(handler) {
          this.closeHandler = handler;
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            this.closeHandler = void 0;
          });
        }
        closeTextDocument(params) {
          this.closeHandler && this.closeHandler(params);
        }
        onWillSaveTextDocument() {
          return _CellTextDocumentConnection.NULL_DISPOSE;
        }
        onWillSaveTextDocumentWaitUntil() {
          return _CellTextDocumentConnection.NULL_DISPOSE;
        }
        onDidSaveTextDocument() {
          return _CellTextDocumentConnection.NULL_DISPOSE;
        }
      };
      CellTextDocumentConnection.NULL_DISPOSE = Object.freeze({ dispose: () => {
      } });
      var NotebookDocuments = class {
        constructor(configurationOrTextDocuments) {
          if (configurationOrTextDocuments instanceof textDocuments_1.TextDocuments) {
            this._cellTextDocuments = configurationOrTextDocuments;
          } else {
            this._cellTextDocuments = new textDocuments_1.TextDocuments(configurationOrTextDocuments);
          }
          this.notebookDocuments = /* @__PURE__ */ new Map();
          this.notebookCellMap = /* @__PURE__ */ new Map();
          this._onDidOpen = new vscode_languageserver_protocol_1.Emitter();
          this._onDidChange = new vscode_languageserver_protocol_1.Emitter();
          this._onDidSave = new vscode_languageserver_protocol_1.Emitter();
          this._onDidClose = new vscode_languageserver_protocol_1.Emitter();
        }
        get cellTextDocuments() {
          return this._cellTextDocuments;
        }
        getCellTextDocument(cell) {
          return this._cellTextDocuments.get(cell.document);
        }
        getNotebookDocument(uri) {
          return this.notebookDocuments.get(uri);
        }
        getNotebookCell(uri) {
          const value = this.notebookCellMap.get(uri);
          return value && value[0];
        }
        findNotebookDocumentForCell(cell) {
          const key = typeof cell === "string" ? cell : cell.document;
          const value = this.notebookCellMap.get(key);
          return value && value[1];
        }
        get onDidOpen() {
          return this._onDidOpen.event;
        }
        get onDidSave() {
          return this._onDidSave.event;
        }
        get onDidChange() {
          return this._onDidChange.event;
        }
        get onDidClose() {
          return this._onDidClose.event;
        }
        /**
         * Listens for `low level` notification on the given connection to
         * update the notebook documents managed by this instance.
         *
         * Please note that the connection only provides handlers not an event model. Therefore
         * listening on a connection will overwrite the following handlers on a connection:
         * `onDidOpenNotebookDocument`, `onDidChangeNotebookDocument`, `onDidSaveNotebookDocument`,
         *  and `onDidCloseNotebookDocument`.
         *
         * @param connection The connection to listen on.
         */
        listen(connection2) {
          const cellTextDocumentConnection = new CellTextDocumentConnection();
          const disposables = [];
          disposables.push(this.cellTextDocuments.listen(cellTextDocumentConnection));
          disposables.push(connection2.notebooks.synchronization.onDidOpenNotebookDocument((params) => {
            this.notebookDocuments.set(params.notebookDocument.uri, params.notebookDocument);
            for (const cellTextDocument of params.cellTextDocuments) {
              cellTextDocumentConnection.openTextDocument({ textDocument: cellTextDocument });
            }
            this.updateCellMap(params.notebookDocument);
            this._onDidOpen.fire(params.notebookDocument);
          }));
          disposables.push(connection2.notebooks.synchronization.onDidChangeNotebookDocument((params) => {
            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
            if (notebookDocument === void 0) {
              return;
            }
            notebookDocument.version = params.notebookDocument.version;
            const oldMetadata = notebookDocument.metadata;
            let metadataChanged = false;
            const change = params.change;
            if (change.metadata !== void 0) {
              metadataChanged = true;
              notebookDocument.metadata = change.metadata;
            }
            const opened = [];
            const closed = [];
            const data = [];
            const text = [];
            if (change.cells !== void 0) {
              const changedCells = change.cells;
              if (changedCells.structure !== void 0) {
                const array = changedCells.structure.array;
                notebookDocument.cells.splice(array.start, array.deleteCount, ...array.cells !== void 0 ? array.cells : []);
                if (changedCells.structure.didOpen !== void 0) {
                  for (const open of changedCells.structure.didOpen) {
                    cellTextDocumentConnection.openTextDocument({ textDocument: open });
                    opened.push(open.uri);
                  }
                }
                if (changedCells.structure.didClose) {
                  for (const close of changedCells.structure.didClose) {
                    cellTextDocumentConnection.closeTextDocument({ textDocument: close });
                    closed.push(close.uri);
                  }
                }
              }
              if (changedCells.data !== void 0) {
                const cellUpdates = new Map(changedCells.data.map((cell) => [cell.document, cell]));
                for (let i = 0; i <= notebookDocument.cells.length; i++) {
                  const change2 = cellUpdates.get(notebookDocument.cells[i].document);
                  if (change2 !== void 0) {
                    const old = notebookDocument.cells.splice(i, 1, change2);
                    data.push({ old: old[0], new: change2 });
                    cellUpdates.delete(change2.document);
                    if (cellUpdates.size === 0) {
                      break;
                    }
                  }
                }
              }
              if (changedCells.textContent !== void 0) {
                for (const cellTextDocument of changedCells.textContent) {
                  cellTextDocumentConnection.changeTextDocument({ textDocument: cellTextDocument.document, contentChanges: cellTextDocument.changes });
                  text.push(cellTextDocument.document.uri);
                }
              }
            }
            this.updateCellMap(notebookDocument);
            const changeEvent = { notebookDocument };
            if (metadataChanged) {
              changeEvent.metadata = { old: oldMetadata, new: notebookDocument.metadata };
            }
            const added = [];
            for (const open of opened) {
              added.push(this.getNotebookCell(open));
            }
            const removed = [];
            for (const close of closed) {
              removed.push(this.getNotebookCell(close));
            }
            const textContent = [];
            for (const change2 of text) {
              textContent.push(this.getNotebookCell(change2));
            }
            if (added.length > 0 || removed.length > 0 || data.length > 0 || textContent.length > 0) {
              changeEvent.cells = { added, removed, changed: { data, textContent } };
            }
            if (changeEvent.metadata !== void 0 || changeEvent.cells !== void 0) {
              this._onDidChange.fire(changeEvent);
            }
          }));
          disposables.push(connection2.notebooks.synchronization.onDidSaveNotebookDocument((params) => {
            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
            if (notebookDocument === void 0) {
              return;
            }
            this._onDidSave.fire(notebookDocument);
          }));
          disposables.push(connection2.notebooks.synchronization.onDidCloseNotebookDocument((params) => {
            const notebookDocument = this.notebookDocuments.get(params.notebookDocument.uri);
            if (notebookDocument === void 0) {
              return;
            }
            this._onDidClose.fire(notebookDocument);
            for (const cellTextDocument of params.cellTextDocuments) {
              cellTextDocumentConnection.closeTextDocument({ textDocument: cellTextDocument });
            }
            this.notebookDocuments.delete(params.notebookDocument.uri);
            for (const cell of notebookDocument.cells) {
              this.notebookCellMap.delete(cell.document);
            }
          }));
          return vscode_languageserver_protocol_1.Disposable.create(() => {
            disposables.forEach((disposable) => disposable.dispose());
          });
        }
        updateCellMap(notebookDocument) {
          for (const cell of notebookDocument.cells) {
            this.notebookCellMap.set(cell.document, [cell, notebookDocument]);
          }
        }
      };
      exports.NotebookDocuments = NotebookDocuments;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/utils/is.js
  var require_is6 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/utils/is.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.thenable = exports.typedArray = exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
      function boolean(value) {
        return value === true || value === false;
      }
      exports.boolean = boolean;
      function string(value) {
        return typeof value === "string" || value instanceof String;
      }
      exports.string = string;
      function number(value) {
        return typeof value === "number" || value instanceof Number;
      }
      exports.number = number;
      function error(value) {
        return value instanceof Error;
      }
      exports.error = error;
      function func(value) {
        return typeof value === "function";
      }
      exports.func = func;
      function array(value) {
        return Array.isArray(value);
      }
      exports.array = array;
      function stringArray(value) {
        return array(value) && value.every((elem) => string(elem));
      }
      exports.stringArray = stringArray;
      function typedArray(value, check) {
        return Array.isArray(value) && value.every(check);
      }
      exports.typedArray = typedArray;
      function thenable(value) {
        return value && func(value.then);
      }
      exports.thenable = thenable;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/utils/uuid.js
  var require_uuid2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/utils/uuid.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.generateUuid = exports.parse = exports.isUUID = exports.v4 = exports.empty = void 0;
      var ValueUUID = class {
        constructor(_value) {
          this._value = _value;
        }
        asHex() {
          return this._value;
        }
        equals(other) {
          return this.asHex() === other.asHex();
        }
      };
      var V4UUID = class _V4UUID extends ValueUUID {
        static _oneOf(array) {
          return array[Math.floor(array.length * Math.random())];
        }
        static _randomHex() {
          return _V4UUID._oneOf(_V4UUID._chars);
        }
        constructor() {
          super([
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            "-",
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            "-",
            "4",
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            "-",
            _V4UUID._oneOf(_V4UUID._timeHighBits),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            "-",
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex(),
            _V4UUID._randomHex()
          ].join(""));
        }
      };
      V4UUID._chars = ["0", "1", "2", "3", "4", "5", "6", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
      V4UUID._timeHighBits = ["8", "9", "a", "b"];
      exports.empty = new ValueUUID("00000000-0000-0000-0000-000000000000");
      function v4() {
        return new V4UUID();
      }
      exports.v4 = v4;
      var _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
      function isUUID(value) {
        return _UUIDPattern.test(value);
      }
      exports.isUUID = isUUID;
      function parse(value) {
        if (!isUUID(value)) {
          throw new Error("invalid uuid");
        }
        return new ValueUUID(value);
      }
      exports.parse = parse;
      function generateUuid() {
        return v4().asHex();
      }
      exports.generateUuid = generateUuid;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/progress.js
  var require_progress2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/progress.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.attachPartialResult = exports.ProgressFeature = exports.attachWorkDone = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var uuid_1 = require_uuid2();
      var WorkDoneProgressReporterImpl = class _WorkDoneProgressReporterImpl {
        constructor(_connection, _token) {
          this._connection = _connection;
          this._token = _token;
          _WorkDoneProgressReporterImpl.Instances.set(this._token, this);
        }
        begin(title, percentage, message, cancellable) {
          let param = {
            kind: "begin",
            title,
            percentage,
            message,
            cancellable
          };
          this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, param);
        }
        report(arg0, arg1) {
          let param = {
            kind: "report"
          };
          if (typeof arg0 === "number") {
            param.percentage = arg0;
            if (arg1 !== void 0) {
              param.message = arg1;
            }
          } else {
            param.message = arg0;
          }
          this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, param);
        }
        done() {
          _WorkDoneProgressReporterImpl.Instances.delete(this._token);
          this._connection.sendProgress(vscode_languageserver_protocol_1.WorkDoneProgress.type, this._token, { kind: "end" });
        }
      };
      WorkDoneProgressReporterImpl.Instances = /* @__PURE__ */ new Map();
      var WorkDoneProgressServerReporterImpl = class extends WorkDoneProgressReporterImpl {
        constructor(connection2, token) {
          super(connection2, token);
          this._source = new vscode_languageserver_protocol_1.CancellationTokenSource();
        }
        get token() {
          return this._source.token;
        }
        done() {
          this._source.dispose();
          super.done();
        }
        cancel() {
          this._source.cancel();
        }
      };
      var NullProgressReporter = class {
        constructor() {
        }
        begin() {
        }
        report() {
        }
        done() {
        }
      };
      var NullProgressServerReporter = class extends NullProgressReporter {
        constructor() {
          super();
          this._source = new vscode_languageserver_protocol_1.CancellationTokenSource();
        }
        get token() {
          return this._source.token;
        }
        done() {
          this._source.dispose();
        }
        cancel() {
          this._source.cancel();
        }
      };
      function attachWorkDone(connection2, params) {
        if (params === void 0 || params.workDoneToken === void 0) {
          return new NullProgressReporter();
        }
        const token = params.workDoneToken;
        delete params.workDoneToken;
        return new WorkDoneProgressReporterImpl(connection2, token);
      }
      exports.attachWorkDone = attachWorkDone;
      var ProgressFeature = (Base) => {
        return class extends Base {
          constructor() {
            super();
            this._progressSupported = false;
          }
          initialize(capabilities) {
            super.initialize(capabilities);
            if (capabilities?.window?.workDoneProgress === true) {
              this._progressSupported = true;
              this.connection.onNotification(vscode_languageserver_protocol_1.WorkDoneProgressCancelNotification.type, (params) => {
                let progress = WorkDoneProgressReporterImpl.Instances.get(params.token);
                if (progress instanceof WorkDoneProgressServerReporterImpl || progress instanceof NullProgressServerReporter) {
                  progress.cancel();
                }
              });
            }
          }
          attachWorkDoneProgress(token) {
            if (token === void 0) {
              return new NullProgressReporter();
            } else {
              return new WorkDoneProgressReporterImpl(this.connection, token);
            }
          }
          createWorkDoneProgress() {
            if (this._progressSupported) {
              const token = (0, uuid_1.generateUuid)();
              return this.connection.sendRequest(vscode_languageserver_protocol_1.WorkDoneProgressCreateRequest.type, { token }).then(() => {
                const result = new WorkDoneProgressServerReporterImpl(this.connection, token);
                return result;
              });
            } else {
              return Promise.resolve(new NullProgressServerReporter());
            }
          }
        };
      };
      exports.ProgressFeature = ProgressFeature;
      var ResultProgress;
      (function(ResultProgress2) {
        ResultProgress2.type = new vscode_languageserver_protocol_1.ProgressType();
      })(ResultProgress || (ResultProgress = {}));
      var ResultProgressReporterImpl = class {
        constructor(_connection, _token) {
          this._connection = _connection;
          this._token = _token;
        }
        report(data) {
          this._connection.sendProgress(ResultProgress.type, this._token, data);
        }
      };
      function attachPartialResult(connection2, params) {
        if (params === void 0 || params.partialResultToken === void 0) {
          return void 0;
        }
        const token = params.partialResultToken;
        delete params.partialResultToken;
        return new ResultProgressReporterImpl(connection2, token);
      }
      exports.attachPartialResult = attachPartialResult;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/configuration.js
  var require_configuration2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/configuration.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ConfigurationFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var Is3 = require_is6();
      var ConfigurationFeature = (Base) => {
        return class extends Base {
          getConfiguration(arg) {
            if (!arg) {
              return this._getConfiguration({});
            } else if (Is3.string(arg)) {
              return this._getConfiguration({ section: arg });
            } else {
              return this._getConfiguration(arg);
            }
          }
          _getConfiguration(arg) {
            let params = {
              items: Array.isArray(arg) ? arg : [arg]
            };
            return this.connection.sendRequest(vscode_languageserver_protocol_1.ConfigurationRequest.type, params).then((result) => {
              if (Array.isArray(result)) {
                return Array.isArray(arg) ? result : result[0];
              } else {
                return Array.isArray(arg) ? [] : null;
              }
            });
          }
        };
      };
      exports.ConfigurationFeature = ConfigurationFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/workspaceFolder.js
  var require_workspaceFolder2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/workspaceFolder.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.WorkspaceFoldersFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var WorkspaceFoldersFeature = (Base) => {
        return class extends Base {
          constructor() {
            super();
            this._notificationIsAutoRegistered = false;
          }
          initialize(capabilities) {
            super.initialize(capabilities);
            let workspaceCapabilities = capabilities.workspace;
            if (workspaceCapabilities && workspaceCapabilities.workspaceFolders) {
              this._onDidChangeWorkspaceFolders = new vscode_languageserver_protocol_1.Emitter();
              this.connection.onNotification(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type, (params) => {
                this._onDidChangeWorkspaceFolders.fire(params.event);
              });
            }
          }
          fillServerCapabilities(capabilities) {
            super.fillServerCapabilities(capabilities);
            const changeNotifications = capabilities.workspace?.workspaceFolders?.changeNotifications;
            this._notificationIsAutoRegistered = changeNotifications === true || typeof changeNotifications === "string";
          }
          getWorkspaceFolders() {
            return this.connection.sendRequest(vscode_languageserver_protocol_1.WorkspaceFoldersRequest.type);
          }
          get onDidChangeWorkspaceFolders() {
            if (!this._onDidChangeWorkspaceFolders) {
              throw new Error("Client doesn't support sending workspace folder change events.");
            }
            if (!this._notificationIsAutoRegistered && !this._unregistration) {
              this._unregistration = this.connection.client.register(vscode_languageserver_protocol_1.DidChangeWorkspaceFoldersNotification.type);
            }
            return this._onDidChangeWorkspaceFolders.event;
          }
        };
      };
      exports.WorkspaceFoldersFeature = WorkspaceFoldersFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/callHierarchy.js
  var require_callHierarchy2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/callHierarchy.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CallHierarchyFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var CallHierarchyFeature = (Base) => {
        return class extends Base {
          get callHierarchy() {
            return {
              onPrepare: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.CallHierarchyPrepareRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), void 0);
                });
              },
              onIncomingCalls: (handler) => {
                const type = vscode_languageserver_protocol_1.CallHierarchyIncomingCallsRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              },
              onOutgoingCalls: (handler) => {
                const type = vscode_languageserver_protocol_1.CallHierarchyOutgoingCallsRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.CallHierarchyFeature = CallHierarchyFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/showDocument.js
  var require_showDocument2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/showDocument.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ShowDocumentFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var ShowDocumentFeature = (Base) => {
        return class extends Base {
          showDocument(params) {
            return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowDocumentRequest.type, params);
          }
        };
      };
      exports.ShowDocumentFeature = ShowDocumentFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/fileOperations.js
  var require_fileOperations2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/fileOperations.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.FileOperationsFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var FileOperationsFeature = (Base) => {
        return class extends Base {
          onDidCreateFiles(handler) {
            return this.connection.onNotification(vscode_languageserver_protocol_1.DidCreateFilesNotification.type, (params) => {
              handler(params);
            });
          }
          onDidRenameFiles(handler) {
            return this.connection.onNotification(vscode_languageserver_protocol_1.DidRenameFilesNotification.type, (params) => {
              handler(params);
            });
          }
          onDidDeleteFiles(handler) {
            return this.connection.onNotification(vscode_languageserver_protocol_1.DidDeleteFilesNotification.type, (params) => {
              handler(params);
            });
          }
          onWillCreateFiles(handler) {
            return this.connection.onRequest(vscode_languageserver_protocol_1.WillCreateFilesRequest.type, (params, cancel) => {
              return handler(params, cancel);
            });
          }
          onWillRenameFiles(handler) {
            return this.connection.onRequest(vscode_languageserver_protocol_1.WillRenameFilesRequest.type, (params, cancel) => {
              return handler(params, cancel);
            });
          }
          onWillDeleteFiles(handler) {
            return this.connection.onRequest(vscode_languageserver_protocol_1.WillDeleteFilesRequest.type, (params, cancel) => {
              return handler(params, cancel);
            });
          }
        };
      };
      exports.FileOperationsFeature = FileOperationsFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/linkedEditingRange.js
  var require_linkedEditingRange2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/linkedEditingRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.LinkedEditingRangeFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var LinkedEditingRangeFeature = (Base) => {
        return class extends Base {
          onLinkedEditingRange(handler) {
            return this.connection.onRequest(vscode_languageserver_protocol_1.LinkedEditingRangeRequest.type, (params, cancel) => {
              return handler(params, cancel, this.attachWorkDoneProgress(params), void 0);
            });
          }
        };
      };
      exports.LinkedEditingRangeFeature = LinkedEditingRangeFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/typeHierarchy.js
  var require_typeHierarchy2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/typeHierarchy.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.TypeHierarchyFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var TypeHierarchyFeature = (Base) => {
        return class extends Base {
          get typeHierarchy() {
            return {
              onPrepare: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.TypeHierarchyPrepareRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), void 0);
                });
              },
              onSupertypes: (handler) => {
                const type = vscode_languageserver_protocol_1.TypeHierarchySupertypesRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              },
              onSubtypes: (handler) => {
                const type = vscode_languageserver_protocol_1.TypeHierarchySubtypesRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.TypeHierarchyFeature = TypeHierarchyFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/inlineValue.js
  var require_inlineValue2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/inlineValue.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlineValueFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var InlineValueFeature = (Base) => {
        return class extends Base {
          get inlineValue() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.InlineValueRefreshRequest.type);
              },
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.InlineValueRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params));
                });
              }
            };
          }
        };
      };
      exports.InlineValueFeature = InlineValueFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/foldingRange.js
  var require_foldingRange2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/foldingRange.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.FoldingRangeFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var FoldingRangeFeature = (Base) => {
        return class extends Base {
          get foldingRange() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.FoldingRangeRefreshRequest.type);
              },
              on: (handler) => {
                const type = vscode_languageserver_protocol_1.FoldingRangeRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.FoldingRangeFeature = FoldingRangeFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/inlayHint.js
  var require_inlayHint2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/inlayHint.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.InlayHintFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var InlayHintFeature = (Base) => {
        return class extends Base {
          get inlayHint() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.InlayHintRefreshRequest.type);
              },
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.InlayHintRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params));
                });
              },
              resolve: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.InlayHintResolveRequest.type, (params, cancel) => {
                  return handler(params, cancel);
                });
              }
            };
          }
        };
      };
      exports.InlayHintFeature = InlayHintFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/diagnostic.js
  var require_diagnostic2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/diagnostic.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.DiagnosticFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var DiagnosticFeature = (Base) => {
        return class extends Base {
          get diagnostics() {
            return {
              refresh: () => {
                return this.connection.sendRequest(vscode_languageserver_protocol_1.DiagnosticRefreshRequest.type);
              },
              on: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(vscode_languageserver_protocol_1.DocumentDiagnosticRequest.partialResult, params));
                });
              },
              onWorkspace: (handler) => {
                return this.connection.onRequest(vscode_languageserver_protocol_1.WorkspaceDiagnosticRequest.type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(vscode_languageserver_protocol_1.WorkspaceDiagnosticRequest.partialResult, params));
                });
              }
            };
          }
        };
      };
      exports.DiagnosticFeature = DiagnosticFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/moniker.js
  var require_moniker2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/moniker.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.MonikerFeature = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var MonikerFeature = (Base) => {
        return class extends Base {
          get moniker() {
            return {
              on: (handler) => {
                const type = vscode_languageserver_protocol_1.MonikerRequest.type;
                return this.connection.onRequest(type, (params, cancel) => {
                  return handler(params, cancel, this.attachWorkDoneProgress(params), this.attachPartialResultProgress(type, params));
                });
              }
            };
          }
        };
      };
      exports.MonikerFeature = MonikerFeature;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/server.js
  var require_server2 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/server.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createConnection = exports.combineFeatures = exports.combineNotebooksFeatures = exports.combineLanguagesFeatures = exports.combineWorkspaceFeatures = exports.combineWindowFeatures = exports.combineClientFeatures = exports.combineTracerFeatures = exports.combineTelemetryFeatures = exports.combineConsoleFeatures = exports._NotebooksImpl = exports._LanguagesImpl = exports.BulkUnregistration = exports.BulkRegistration = exports.ErrorMessageTracker = void 0;
      var vscode_languageserver_protocol_1 = require_main5();
      var Is3 = require_is6();
      var UUID = require_uuid2();
      var progress_1 = require_progress2();
      var configuration_1 = require_configuration2();
      var workspaceFolder_1 = require_workspaceFolder2();
      var callHierarchy_1 = require_callHierarchy2();
      var semanticTokens_1 = require_semanticTokens2();
      var showDocument_1 = require_showDocument2();
      var fileOperations_1 = require_fileOperations2();
      var linkedEditingRange_1 = require_linkedEditingRange2();
      var typeHierarchy_1 = require_typeHierarchy2();
      var inlineValue_1 = require_inlineValue2();
      var foldingRange_1 = require_foldingRange2();
      var inlayHint_1 = require_inlayHint2();
      var diagnostic_1 = require_diagnostic2();
      var notebook_1 = require_notebook2();
      var moniker_1 = require_moniker2();
      function null2Undefined(value) {
        if (value === null) {
          return void 0;
        }
        return value;
      }
      var ErrorMessageTracker = class {
        constructor() {
          this._messages = /* @__PURE__ */ Object.create(null);
        }
        /**
         * Add a message to the tracker.
         *
         * @param message The message to add.
         */
        add(message) {
          let count = this._messages[message];
          if (!count) {
            count = 0;
          }
          count++;
          this._messages[message] = count;
        }
        /**
         * Send all tracked messages to the connection's window.
         *
         * @param connection The connection established between client and server.
         */
        sendErrors(connection2) {
          Object.keys(this._messages).forEach((message) => {
            connection2.window.showErrorMessage(message);
          });
        }
      };
      exports.ErrorMessageTracker = ErrorMessageTracker;
      var RemoteConsoleImpl = class {
        constructor() {
        }
        rawAttach(connection2) {
          this._rawConnection = connection2;
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        fillServerCapabilities(_capabilities) {
        }
        initialize(_capabilities) {
        }
        error(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Error, message);
        }
        warn(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Warning, message);
        }
        info(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Info, message);
        }
        log(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Log, message);
        }
        debug(message) {
          this.send(vscode_languageserver_protocol_1.MessageType.Debug, message);
        }
        send(type, message) {
          if (this._rawConnection) {
            this._rawConnection.sendNotification(vscode_languageserver_protocol_1.LogMessageNotification.type, { type, message }).catch(() => {
              (0, vscode_languageserver_protocol_1.RAL)().console.error(`Sending log message failed`);
            });
          }
        }
      };
      var _RemoteWindowImpl = class {
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        showErrorMessage(message, ...actions) {
          let params = { type: vscode_languageserver_protocol_1.MessageType.Error, message, actions };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
        }
        showWarningMessage(message, ...actions) {
          let params = { type: vscode_languageserver_protocol_1.MessageType.Warning, message, actions };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
        }
        showInformationMessage(message, ...actions) {
          let params = { type: vscode_languageserver_protocol_1.MessageType.Info, message, actions };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.ShowMessageRequest.type, params).then(null2Undefined);
        }
      };
      var RemoteWindowImpl = (0, showDocument_1.ShowDocumentFeature)((0, progress_1.ProgressFeature)(_RemoteWindowImpl));
      var BulkRegistration;
      (function(BulkRegistration2) {
        function create() {
          return new BulkRegistrationImpl();
        }
        BulkRegistration2.create = create;
      })(BulkRegistration || (exports.BulkRegistration = BulkRegistration = {}));
      var BulkRegistrationImpl = class {
        constructor() {
          this._registrations = [];
          this._registered = /* @__PURE__ */ new Set();
        }
        add(type, registerOptions) {
          const method = Is3.string(type) ? type : type.method;
          if (this._registered.has(method)) {
            throw new Error(`${method} is already added to this registration`);
          }
          const id = UUID.generateUuid();
          this._registrations.push({
            id,
            method,
            registerOptions: registerOptions || {}
          });
          this._registered.add(method);
        }
        asRegistrationParams() {
          return {
            registrations: this._registrations
          };
        }
      };
      var BulkUnregistration;
      (function(BulkUnregistration2) {
        function create() {
          return new BulkUnregistrationImpl(void 0, []);
        }
        BulkUnregistration2.create = create;
      })(BulkUnregistration || (exports.BulkUnregistration = BulkUnregistration = {}));
      var BulkUnregistrationImpl = class {
        constructor(_connection, unregistrations) {
          this._connection = _connection;
          this._unregistrations = /* @__PURE__ */ new Map();
          unregistrations.forEach((unregistration) => {
            this._unregistrations.set(unregistration.method, unregistration);
          });
        }
        get isAttached() {
          return !!this._connection;
        }
        attach(connection2) {
          this._connection = connection2;
        }
        add(unregistration) {
          this._unregistrations.set(unregistration.method, unregistration);
        }
        dispose() {
          let unregistrations = [];
          for (let unregistration of this._unregistrations.values()) {
            unregistrations.push(unregistration);
          }
          let params = {
            unregisterations: unregistrations
          };
          this._connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).catch(() => {
            this._connection.console.info(`Bulk unregistration failed.`);
          });
        }
        disposeSingle(arg) {
          const method = Is3.string(arg) ? arg : arg.method;
          const unregistration = this._unregistrations.get(method);
          if (!unregistration) {
            return false;
          }
          let params = {
            unregisterations: [unregistration]
          };
          this._connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).then(() => {
            this._unregistrations.delete(method);
          }, (_error) => {
            this._connection.console.info(`Un-registering request handler for ${unregistration.id} failed.`);
          });
          return true;
        }
      };
      var RemoteClientImpl = class {
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        register(typeOrRegistrations, registerOptionsOrType, registerOptions) {
          if (typeOrRegistrations instanceof BulkRegistrationImpl) {
            return this.registerMany(typeOrRegistrations);
          } else if (typeOrRegistrations instanceof BulkUnregistrationImpl) {
            return this.registerSingle1(typeOrRegistrations, registerOptionsOrType, registerOptions);
          } else {
            return this.registerSingle2(typeOrRegistrations, registerOptionsOrType);
          }
        }
        registerSingle1(unregistration, type, registerOptions) {
          const method = Is3.string(type) ? type : type.method;
          const id = UUID.generateUuid();
          let params = {
            registrations: [{ id, method, registerOptions: registerOptions || {} }]
          };
          if (!unregistration.isAttached) {
            unregistration.attach(this.connection);
          }
          return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then((_result) => {
            unregistration.add({ id, method });
            return unregistration;
          }, (_error) => {
            this.connection.console.info(`Registering request handler for ${method} failed.`);
            return Promise.reject(_error);
          });
        }
        registerSingle2(type, registerOptions) {
          const method = Is3.string(type) ? type : type.method;
          const id = UUID.generateUuid();
          let params = {
            registrations: [{ id, method, registerOptions: registerOptions || {} }]
          };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then((_result) => {
            return vscode_languageserver_protocol_1.Disposable.create(() => {
              this.unregisterSingle(id, method).catch(() => {
                this.connection.console.info(`Un-registering capability with id ${id} failed.`);
              });
            });
          }, (_error) => {
            this.connection.console.info(`Registering request handler for ${method} failed.`);
            return Promise.reject(_error);
          });
        }
        unregisterSingle(id, method) {
          let params = {
            unregisterations: [{ id, method }]
          };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.UnregistrationRequest.type, params).catch(() => {
            this.connection.console.info(`Un-registering request handler for ${id} failed.`);
          });
        }
        registerMany(registrations) {
          let params = registrations.asRegistrationParams();
          return this.connection.sendRequest(vscode_languageserver_protocol_1.RegistrationRequest.type, params).then(() => {
            return new BulkUnregistrationImpl(this._connection, params.registrations.map((registration) => {
              return { id: registration.id, method: registration.method };
            }));
          }, (_error) => {
            this.connection.console.info(`Bulk registration failed.`);
            return Promise.reject(_error);
          });
        }
      };
      var _RemoteWorkspaceImpl = class {
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        applyEdit(paramOrEdit) {
          function isApplyWorkspaceEditParams(value) {
            return value && !!value.edit;
          }
          let params = isApplyWorkspaceEditParams(paramOrEdit) ? paramOrEdit : { edit: paramOrEdit };
          return this.connection.sendRequest(vscode_languageserver_protocol_1.ApplyWorkspaceEditRequest.type, params);
        }
      };
      var RemoteWorkspaceImpl = (0, fileOperations_1.FileOperationsFeature)((0, workspaceFolder_1.WorkspaceFoldersFeature)((0, configuration_1.ConfigurationFeature)(_RemoteWorkspaceImpl)));
      var TracerImpl = class {
        constructor() {
          this._trace = vscode_languageserver_protocol_1.Trace.Off;
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        set trace(value) {
          this._trace = value;
        }
        log(message, verbose) {
          if (this._trace === vscode_languageserver_protocol_1.Trace.Off) {
            return;
          }
          this.connection.sendNotification(vscode_languageserver_protocol_1.LogTraceNotification.type, {
            message,
            verbose: this._trace === vscode_languageserver_protocol_1.Trace.Verbose ? verbose : void 0
          }).catch(() => {
          });
        }
      };
      var TelemetryImpl = class {
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        logEvent(data) {
          this.connection.sendNotification(vscode_languageserver_protocol_1.TelemetryEventNotification.type, data).catch(() => {
            this.connection.console.log(`Sending TelemetryEventNotification failed`);
          });
        }
      };
      var _LanguagesImpl = class {
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        attachWorkDoneProgress(params) {
          return (0, progress_1.attachWorkDone)(this.connection, params);
        }
        attachPartialResultProgress(_type, params) {
          return (0, progress_1.attachPartialResult)(this.connection, params);
        }
      };
      exports._LanguagesImpl = _LanguagesImpl;
      var LanguagesImpl = (0, foldingRange_1.FoldingRangeFeature)((0, moniker_1.MonikerFeature)((0, diagnostic_1.DiagnosticFeature)((0, inlayHint_1.InlayHintFeature)((0, inlineValue_1.InlineValueFeature)((0, typeHierarchy_1.TypeHierarchyFeature)((0, linkedEditingRange_1.LinkedEditingRangeFeature)((0, semanticTokens_1.SemanticTokensFeature)((0, callHierarchy_1.CallHierarchyFeature)(_LanguagesImpl)))))))));
      var _NotebooksImpl = class {
        constructor() {
        }
        attach(connection2) {
          this._connection = connection2;
        }
        get connection() {
          if (!this._connection) {
            throw new Error("Remote is not attached to a connection yet.");
          }
          return this._connection;
        }
        initialize(_capabilities) {
        }
        fillServerCapabilities(_capabilities) {
        }
        attachWorkDoneProgress(params) {
          return (0, progress_1.attachWorkDone)(this.connection, params);
        }
        attachPartialResultProgress(_type, params) {
          return (0, progress_1.attachPartialResult)(this.connection, params);
        }
      };
      exports._NotebooksImpl = _NotebooksImpl;
      var NotebooksImpl = (0, notebook_1.NotebookSyncFeature)(_NotebooksImpl);
      function combineConsoleFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      exports.combineConsoleFeatures = combineConsoleFeatures;
      function combineTelemetryFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      exports.combineTelemetryFeatures = combineTelemetryFeatures;
      function combineTracerFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      exports.combineTracerFeatures = combineTracerFeatures;
      function combineClientFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      exports.combineClientFeatures = combineClientFeatures;
      function combineWindowFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      exports.combineWindowFeatures = combineWindowFeatures;
      function combineWorkspaceFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      exports.combineWorkspaceFeatures = combineWorkspaceFeatures;
      function combineLanguagesFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      exports.combineLanguagesFeatures = combineLanguagesFeatures;
      function combineNotebooksFeatures(one, two) {
        return function(Base) {
          return two(one(Base));
        };
      }
      exports.combineNotebooksFeatures = combineNotebooksFeatures;
      function combineFeatures(one, two) {
        function combine(one2, two2, func) {
          if (one2 && two2) {
            return func(one2, two2);
          } else if (one2) {
            return one2;
          } else {
            return two2;
          }
        }
        let result = {
          __brand: "features",
          console: combine(one.console, two.console, combineConsoleFeatures),
          tracer: combine(one.tracer, two.tracer, combineTracerFeatures),
          telemetry: combine(one.telemetry, two.telemetry, combineTelemetryFeatures),
          client: combine(one.client, two.client, combineClientFeatures),
          window: combine(one.window, two.window, combineWindowFeatures),
          workspace: combine(one.workspace, two.workspace, combineWorkspaceFeatures),
          languages: combine(one.languages, two.languages, combineLanguagesFeatures),
          notebooks: combine(one.notebooks, two.notebooks, combineNotebooksFeatures)
        };
        return result;
      }
      exports.combineFeatures = combineFeatures;
      function createConnection2(connectionFactory, watchDog, factories) {
        const logger = factories && factories.console ? new (factories.console(RemoteConsoleImpl))() : new RemoteConsoleImpl();
        const connection2 = connectionFactory(logger);
        logger.rawAttach(connection2);
        const tracer = factories && factories.tracer ? new (factories.tracer(TracerImpl))() : new TracerImpl();
        const telemetry = factories && factories.telemetry ? new (factories.telemetry(TelemetryImpl))() : new TelemetryImpl();
        const client = factories && factories.client ? new (factories.client(RemoteClientImpl))() : new RemoteClientImpl();
        const remoteWindow = factories && factories.window ? new (factories.window(RemoteWindowImpl))() : new RemoteWindowImpl();
        const workspace = factories && factories.workspace ? new (factories.workspace(RemoteWorkspaceImpl))() : new RemoteWorkspaceImpl();
        const languages = factories && factories.languages ? new (factories.languages(LanguagesImpl))() : new LanguagesImpl();
        const notebooks = factories && factories.notebooks ? new (factories.notebooks(NotebooksImpl))() : new NotebooksImpl();
        const allRemotes = [logger, tracer, telemetry, client, remoteWindow, workspace, languages, notebooks];
        function asPromise(value) {
          if (value instanceof Promise) {
            return value;
          } else if (Is3.thenable(value)) {
            return new Promise((resolve, reject) => {
              value.then((resolved) => resolve(resolved), (error) => reject(error));
            });
          } else {
            return Promise.resolve(value);
          }
        }
        let shutdownHandler = void 0;
        let initializeHandler = void 0;
        let exitHandler = void 0;
        let protocolConnection = {
          listen: () => connection2.listen(),
          sendRequest: (type, ...params) => connection2.sendRequest(Is3.string(type) ? type : type.method, ...params),
          onRequest: (type, handler) => connection2.onRequest(type, handler),
          sendNotification: (type, param) => {
            const method = Is3.string(type) ? type : type.method;
            return connection2.sendNotification(method, param);
          },
          onNotification: (type, handler) => connection2.onNotification(type, handler),
          onProgress: connection2.onProgress,
          sendProgress: connection2.sendProgress,
          onInitialize: (handler) => {
            initializeHandler = handler;
            return {
              dispose: () => {
                initializeHandler = void 0;
              }
            };
          },
          onInitialized: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.InitializedNotification.type, handler),
          onShutdown: (handler) => {
            shutdownHandler = handler;
            return {
              dispose: () => {
                shutdownHandler = void 0;
              }
            };
          },
          onExit: (handler) => {
            exitHandler = handler;
            return {
              dispose: () => {
                exitHandler = void 0;
              }
            };
          },
          get console() {
            return logger;
          },
          get telemetry() {
            return telemetry;
          },
          get tracer() {
            return tracer;
          },
          get client() {
            return client;
          },
          get window() {
            return remoteWindow;
          },
          get workspace() {
            return workspace;
          },
          get languages() {
            return languages;
          },
          get notebooks() {
            return notebooks;
          },
          onDidChangeConfiguration: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidChangeConfigurationNotification.type, handler),
          onDidChangeWatchedFiles: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidChangeWatchedFilesNotification.type, handler),
          __textDocumentSync: void 0,
          onDidOpenTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidOpenTextDocumentNotification.type, handler),
          onDidChangeTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidChangeTextDocumentNotification.type, handler),
          onDidCloseTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidCloseTextDocumentNotification.type, handler),
          onWillSaveTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.WillSaveTextDocumentNotification.type, handler),
          onWillSaveTextDocumentWaitUntil: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.WillSaveTextDocumentWaitUntilRequest.type, handler),
          onDidSaveTextDocument: (handler) => connection2.onNotification(vscode_languageserver_protocol_1.DidSaveTextDocumentNotification.type, handler),
          sendDiagnostics: (params) => connection2.sendNotification(vscode_languageserver_protocol_1.PublishDiagnosticsNotification.type, params),
          onHover: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.HoverRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onCompletion: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CompletionRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onCompletionResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CompletionResolveRequest.type, handler),
          onSignatureHelp: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.SignatureHelpRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onDeclaration: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DeclarationRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onDefinition: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DefinitionRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onTypeDefinition: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.TypeDefinitionRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onImplementation: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.ImplementationRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onReferences: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.ReferencesRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onDocumentHighlight: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentHighlightRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onDocumentSymbol: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentSymbolRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onWorkspaceSymbol: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.WorkspaceSymbolRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onWorkspaceSymbolResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.WorkspaceSymbolResolveRequest.type, handler),
          onCodeAction: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CodeActionRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onCodeActionResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CodeActionResolveRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onCodeLens: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CodeLensRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onCodeLensResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.CodeLensResolveRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onDocumentFormatting: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentFormattingRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onDocumentRangeFormatting: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentRangeFormattingRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onDocumentOnTypeFormatting: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentOnTypeFormattingRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onRenameRequest: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.RenameRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          onPrepareRename: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.PrepareRenameRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onDocumentLinks: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentLinkRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onDocumentLinkResolve: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentLinkResolveRequest.type, (params, cancel) => {
            return handler(params, cancel);
          }),
          onDocumentColor: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.DocumentColorRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onColorPresentation: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.ColorPresentationRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onFoldingRanges: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.FoldingRangeRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onSelectionRanges: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.SelectionRangeRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), (0, progress_1.attachPartialResult)(connection2, params));
          }),
          onExecuteCommand: (handler) => connection2.onRequest(vscode_languageserver_protocol_1.ExecuteCommandRequest.type, (params, cancel) => {
            return handler(params, cancel, (0, progress_1.attachWorkDone)(connection2, params), void 0);
          }),
          dispose: () => connection2.dispose()
        };
        for (let remote of allRemotes) {
          remote.attach(protocolConnection);
        }
        connection2.onRequest(vscode_languageserver_protocol_1.InitializeRequest.type, (params) => {
          watchDog.initialize(params);
          if (Is3.string(params.trace)) {
            tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.trace);
          }
          for (let remote of allRemotes) {
            remote.initialize(params.capabilities);
          }
          if (initializeHandler) {
            let result = initializeHandler(params, new vscode_languageserver_protocol_1.CancellationTokenSource().token, (0, progress_1.attachWorkDone)(connection2, params), void 0);
            return asPromise(result).then((value) => {
              if (value instanceof vscode_languageserver_protocol_1.ResponseError) {
                return value;
              }
              let result2 = value;
              if (!result2) {
                result2 = { capabilities: {} };
              }
              let capabilities = result2.capabilities;
              if (!capabilities) {
                capabilities = {};
                result2.capabilities = capabilities;
              }
              if (capabilities.textDocumentSync === void 0 || capabilities.textDocumentSync === null) {
                capabilities.textDocumentSync = Is3.number(protocolConnection.__textDocumentSync) ? protocolConnection.__textDocumentSync : vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
              } else if (!Is3.number(capabilities.textDocumentSync) && !Is3.number(capabilities.textDocumentSync.change)) {
                capabilities.textDocumentSync.change = Is3.number(protocolConnection.__textDocumentSync) ? protocolConnection.__textDocumentSync : vscode_languageserver_protocol_1.TextDocumentSyncKind.None;
              }
              for (let remote of allRemotes) {
                remote.fillServerCapabilities(capabilities);
              }
              return result2;
            });
          } else {
            let result = { capabilities: { textDocumentSync: vscode_languageserver_protocol_1.TextDocumentSyncKind.None } };
            for (let remote of allRemotes) {
              remote.fillServerCapabilities(result.capabilities);
            }
            return result;
          }
        });
        connection2.onRequest(vscode_languageserver_protocol_1.ShutdownRequest.type, () => {
          watchDog.shutdownReceived = true;
          if (shutdownHandler) {
            return shutdownHandler(new vscode_languageserver_protocol_1.CancellationTokenSource().token);
          } else {
            return void 0;
          }
        });
        connection2.onNotification(vscode_languageserver_protocol_1.ExitNotification.type, () => {
          try {
            if (exitHandler) {
              exitHandler();
            }
          } finally {
            if (watchDog.shutdownReceived) {
              watchDog.exit(0);
            } else {
              watchDog.exit(1);
            }
          }
        });
        connection2.onNotification(vscode_languageserver_protocol_1.SetTraceNotification.type, (params) => {
          tracer.trace = vscode_languageserver_protocol_1.Trace.fromString(params.value);
        });
        return protocolConnection;
      }
      exports.createConnection = createConnection2;
    }
  });

  // server/node_modules/vscode-languageserver/lib/common/api.js
  var require_api6 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/common/api.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.ProposedFeatures = exports.NotebookDocuments = exports.TextDocuments = exports.SemanticTokensBuilder = void 0;
      var semanticTokens_1 = require_semanticTokens2();
      Object.defineProperty(exports, "SemanticTokensBuilder", { enumerable: true, get: function() {
        return semanticTokens_1.SemanticTokensBuilder;
      } });
      var ic = require_inlineCompletion_proposed2();
      __exportStar(require_main5(), exports);
      var textDocuments_1 = require_textDocuments2();
      Object.defineProperty(exports, "TextDocuments", { enumerable: true, get: function() {
        return textDocuments_1.TextDocuments;
      } });
      var notebook_1 = require_notebook2();
      Object.defineProperty(exports, "NotebookDocuments", { enumerable: true, get: function() {
        return notebook_1.NotebookDocuments;
      } });
      __exportStar(require_server2(), exports);
      var ProposedFeatures2;
      (function(ProposedFeatures3) {
        ProposedFeatures3.all = {
          __brand: "features",
          languages: ic.InlineCompletionFeature
        };
      })(ProposedFeatures2 || (exports.ProposedFeatures = ProposedFeatures2 = {}));
    }
  });

  // server/node_modules/vscode-languageserver-protocol/browser.js
  var require_browser2 = __commonJS({
    "server/node_modules/vscode-languageserver-protocol/browser.js"(exports, module) {
      "use strict";
      module.exports = require_main5();
    }
  });

  // server/node_modules/vscode-languageserver/lib/browser/main.js
  var require_main6 = __commonJS({
    "server/node_modules/vscode-languageserver/lib/browser/main.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m2, k);
        if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m2[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      }) : (function(o, m2, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m2[k];
      }));
      var __exportStar = exports && exports.__exportStar || function(m2, exports2) {
        for (var p in m2) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m2, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.createConnection = void 0;
      var api_1 = require_api6();
      __exportStar(require_browser2(), exports);
      __exportStar(require_api6(), exports);
      var _shutdownReceived = false;
      var watchDog = {
        initialize: (_params) => {
        },
        get shutdownReceived() {
          return _shutdownReceived;
        },
        set shutdownReceived(value) {
          _shutdownReceived = value;
        },
        exit: (_code) => {
        }
      };
      function createConnection2(arg1, arg2, arg3, arg4) {
        let factories;
        let reader;
        let writer;
        let options;
        if (arg1 !== void 0 && arg1.__brand === "features") {
          factories = arg1;
          arg1 = arg2;
          arg2 = arg3;
          arg3 = arg4;
        }
        if (api_1.ConnectionStrategy.is(arg1) || api_1.ConnectionOptions.is(arg1)) {
          options = arg1;
        } else {
          reader = arg1;
          writer = arg2;
          options = arg3;
        }
        const connectionFactory = (logger) => {
          return (0, api_1.createProtocolConnection)(reader, writer, logger, options);
        };
        return (0, api_1.createConnection)(connectionFactory, watchDog, factories);
      }
      exports.createConnection = createConnection2;
    }
  });

  // server/node_modules/vscode-languageserver/browser.js
  var require_browser3 = __commonJS({
    "server/node_modules/vscode-languageserver/browser.js"(exports, module) {
      "use strict";
      module.exports = require_main6();
    }
  });

  // server/src/server.ts
  var import_node11 = __toESM(require_main3());

  // server/src/platform/shims/fs.ts
  function readFileSync(_path, _enc) {
    throw new Error("fs.readFileSync is not available in the browser");
  }

  // server/src/platform/shims/path.ts
  function normalizeArray(parts, allowAboveRoot) {
    const res = [];
    for (const p of parts) {
      if (!p || p === ".") continue;
      if (p === "..") {
        if (res.length && res[res.length - 1] !== "..") {
          res.pop();
        } else if (allowAboveRoot) {
          res.push("..");
        }
      } else {
        res.push(p);
      }
    }
    return res;
  }
  function join(...parts) {
    const joined = parts.filter(Boolean).join("/");
    const isAbsolute = joined.startsWith("/");
    const normalized = normalizeArray(joined.split("/"), !isAbsolute).join("/");
    return (isAbsolute ? "/" : "") + (normalized || (isAbsolute ? "" : "."));
  }

  // server/src/platform/shims/url.ts
  function fileURLToPath(url) {
    const href = typeof url === "string" ? url : url.href;
    if (href.startsWith("file://")) {
      const withoutScheme = href.slice("file://".length);
      const path = withoutScheme.startsWith("/") ? withoutScheme : `/${withoutScheme}`;
      return decodeURIComponent(path);
    }
    return decodeURIComponent(href);
  }
  function pathToFileURL(path) {
    const normalized = path.replace(/\\/g, "/");
    const withSlash = normalized.startsWith("/") ? normalized : `/${normalized}`;
    const encoded = withSlash.split("/").map(encodeURIComponent).join("/");
    return new URL(`file://${encoded}`);
  }

  // server/src/platform/shims/worker_threads.ts
  var Worker = class {
    constructor(_path, _opts) {
      throw new Error("worker_threads is not available in the browser; using inline parsing");
    }
    on(_event, _cb) {
      return this;
    }
    postMessage(_value) {
    }
    terminate() {
      return Promise.resolve(0);
    }
  };

  // server/node_modules/vscode-languageserver-textdocument/lib/esm/main.js
  var FullTextDocument2 = class _FullTextDocument {
    constructor(uri, languageId, version, content) {
      this._uri = uri;
      this._languageId = languageId;
      this._version = version;
      this._content = content;
      this._lineOffsets = void 0;
    }
    get uri() {
      return this._uri;
    }
    get languageId() {
      return this._languageId;
    }
    get version() {
      return this._version;
    }
    getText(range) {
      if (range) {
        const start = this.offsetAt(range.start);
        const end = this.offsetAt(range.end);
        return this._content.substring(start, end);
      }
      return this._content;
    }
    update(changes, version) {
      for (const change of changes) {
        if (_FullTextDocument.isIncremental(change)) {
          const range = getWellformedRange(change.range);
          const startOffset = this.offsetAt(range.start);
          const endOffset = this.offsetAt(range.end);
          this._content = this._content.substring(0, startOffset) + change.text + this._content.substring(endOffset, this._content.length);
          const startLine = Math.max(range.start.line, 0);
          const endLine = Math.max(range.end.line, 0);
          let lineOffsets = this._lineOffsets;
          const addedLineOffsets = computeLineOffsets(change.text, false, startOffset);
          if (endLine - startLine === addedLineOffsets.length) {
            for (let i = 0, len = addedLineOffsets.length; i < len; i++) {
              lineOffsets[i + startLine + 1] = addedLineOffsets[i];
            }
          } else {
            if (addedLineOffsets.length < 1e4) {
              lineOffsets.splice(startLine + 1, endLine - startLine, ...addedLineOffsets);
            } else {
              this._lineOffsets = lineOffsets = lineOffsets.slice(0, startLine + 1).concat(addedLineOffsets, lineOffsets.slice(endLine + 1));
            }
          }
          const diff = change.text.length - (endOffset - startOffset);
          if (diff !== 0) {
            for (let i = startLine + 1 + addedLineOffsets.length, len = lineOffsets.length; i < len; i++) {
              lineOffsets[i] = lineOffsets[i] + diff;
            }
          }
        } else if (_FullTextDocument.isFull(change)) {
          this._content = change.text;
          this._lineOffsets = void 0;
        } else {
          throw new Error("Unknown change event received");
        }
      }
      this._version = version;
    }
    getLineOffsets() {
      if (this._lineOffsets === void 0) {
        this._lineOffsets = computeLineOffsets(this._content, true);
      }
      return this._lineOffsets;
    }
    positionAt(offset) {
      offset = Math.max(Math.min(offset, this._content.length), 0);
      const lineOffsets = this.getLineOffsets();
      let low = 0, high = lineOffsets.length;
      if (high === 0) {
        return { line: 0, character: offset };
      }
      while (low < high) {
        const mid = Math.floor((low + high) / 2);
        if (lineOffsets[mid] > offset) {
          high = mid;
        } else {
          low = mid + 1;
        }
      }
      const line = low - 1;
      offset = this.ensureBeforeEOL(offset, lineOffsets[line]);
      return { line, character: offset - lineOffsets[line] };
    }
    offsetAt(position) {
      const lineOffsets = this.getLineOffsets();
      if (position.line >= lineOffsets.length) {
        return this._content.length;
      } else if (position.line < 0) {
        return 0;
      }
      const lineOffset = lineOffsets[position.line];
      if (position.character <= 0) {
        return lineOffset;
      }
      const nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
      const offset = Math.min(lineOffset + position.character, nextLineOffset);
      return this.ensureBeforeEOL(offset, lineOffset);
    }
    ensureBeforeEOL(offset, lineOffset) {
      while (offset > lineOffset && isEOL(this._content.charCodeAt(offset - 1))) {
        offset--;
      }
      return offset;
    }
    get lineCount() {
      return this.getLineOffsets().length;
    }
    static isIncremental(event) {
      const candidate = event;
      return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range !== void 0 && (candidate.rangeLength === void 0 || typeof candidate.rangeLength === "number");
    }
    static isFull(event) {
      const candidate = event;
      return candidate !== void 0 && candidate !== null && typeof candidate.text === "string" && candidate.range === void 0 && candidate.rangeLength === void 0;
    }
  };
  var TextDocument2;
  (function(TextDocument4) {
    function create(uri, languageId, version, content) {
      return new FullTextDocument2(uri, languageId, version, content);
    }
    TextDocument4.create = create;
    function update(document, changes, version) {
      if (document instanceof FullTextDocument2) {
        document.update(changes, version);
        return document;
      } else {
        throw new Error("TextDocument.update: document must be created by TextDocument.create");
      }
    }
    TextDocument4.update = update;
    function applyEdits(document, edits) {
      const text = document.getText();
      const sortedEdits = mergeSort(edits.map(getWellformedEdit), (a, b) => {
        const diff = a.range.start.line - b.range.start.line;
        if (diff === 0) {
          return a.range.start.character - b.range.start.character;
        }
        return diff;
      });
      let lastModifiedOffset = 0;
      const spans = [];
      for (const e of sortedEdits) {
        const startOffset = document.offsetAt(e.range.start);
        if (startOffset < lastModifiedOffset) {
          throw new Error("Overlapping edit");
        } else if (startOffset > lastModifiedOffset) {
          spans.push(text.substring(lastModifiedOffset, startOffset));
        }
        if (e.newText.length) {
          spans.push(e.newText);
        }
        lastModifiedOffset = document.offsetAt(e.range.end);
      }
      spans.push(text.substr(lastModifiedOffset));
      return spans.join("");
    }
    TextDocument4.applyEdits = applyEdits;
  })(TextDocument2 || (TextDocument2 = {}));
  function mergeSort(data, compare) {
    if (data.length <= 1) {
      return data;
    }
    const p = data.length / 2 | 0;
    const left = data.slice(0, p);
    const right = data.slice(p);
    mergeSort(left, compare);
    mergeSort(right, compare);
    let leftIdx = 0;
    let rightIdx = 0;
    let i = 0;
    while (leftIdx < left.length && rightIdx < right.length) {
      const ret = compare(left[leftIdx], right[rightIdx]);
      if (ret <= 0) {
        data[i++] = left[leftIdx++];
      } else {
        data[i++] = right[rightIdx++];
      }
    }
    while (leftIdx < left.length) {
      data[i++] = left[leftIdx++];
    }
    while (rightIdx < right.length) {
      data[i++] = right[rightIdx++];
    }
    return data;
  }
  function computeLineOffsets(text, isAtLineStart, textOffset = 0) {
    const result = isAtLineStart ? [textOffset] : [];
    for (let i = 0; i < text.length; i++) {
      const ch = text.charCodeAt(i);
      if (isEOL(ch)) {
        if (ch === 13 && i + 1 < text.length && text.charCodeAt(i + 1) === 10) {
          i++;
        }
        result.push(textOffset + i + 1);
      }
    }
    return result;
  }
  function isEOL(char) {
    return char === 13 || char === 10;
  }
  function getWellformedRange(range) {
    const start = range.start;
    const end = range.end;
    if (start.line > end.line || start.line === end.line && start.character > end.character) {
      return { start: end, end: start };
    }
    return range;
  }
  function getWellformedEdit(textEdit) {
    const range = getWellformedRange(textEdit.range);
    if (range !== textEdit.range) {
      return { newText: textEdit.newText, range };
    }
    return textEdit;
  }

  // server/node_modules/antlr4ng/dist/index.mjs
  var __defProp2 = Object.defineProperty;
  var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
  var IntStream;
  ((IntStream2) => {
    IntStream2.EOF = -1;
    IntStream2.UNKNOWN_SOURCE_NAME = "<unknown>";
  })(IntStream || (IntStream = {}));
  var Token;
  ((Token22) => {
    Token22.INVALID_TYPE = 0;
    Token22.EPSILON = -2;
    Token22.MIN_USER_TOKEN_TYPE = 1;
    Token22.EOF = IntStream.EOF;
    Token22.DEFAULT_CHANNEL = 0;
    Token22.HIDDEN_CHANNEL = 1;
    Token22.MIN_USER_CHANNEL_VALUE = 2;
  })(Token || (Token = {}));
  var isToken = /* @__PURE__ */ __name((candidate) => {
    const token = candidate;
    return token.tokenSource !== void 0 && token.channel !== void 0;
  }, "isToken");
  var BitSet = class {
    static {
      __name(this, "BitSet");
    }
    data;
    /**
     * Creates a new bit set. All bits are initially `false`.
     *
     * @param data Optional initial data.
     */
    constructor(data) {
      if (data) {
        this.data = new Uint32Array(data.map((value) => {
          return value >>> 0;
        }));
      } else {
        this.data = new Uint32Array(1);
      }
    }
    /**
     * @returns an iterator over all set bits.
     */
    [Symbol.iterator]() {
      const length = this.data.length;
      let currentIndex = 0;
      let currentWord = this.data[currentIndex];
      const words = this.data;
      return {
        [Symbol.iterator]() {
          return this;
        },
        next: /* @__PURE__ */ __name(() => {
          while (currentIndex < length) {
            if (currentWord !== 0) {
              const t = currentWord & -currentWord;
              const value = (currentIndex << 5) + this.bitCount(t - 1);
              currentWord ^= t;
              return { done: false, value };
            } else {
              currentIndex++;
              if (currentIndex < length) {
                currentWord = words[currentIndex];
              }
            }
          }
          return { done: true, value: void 0 };
        }, "next")
      };
    }
    /**
     * Sets a single bit or all of the bits in this `BitSet` to `false`.
     *
     * @param index the index of the bit to be cleared, or undefined to clear all bits.
     */
    clear(index2) {
      if (index2 === void 0) {
        this.data = new Uint32Array();
      } else {
        this.resize(index2);
        this.data[index2 >>> 5] &= ~(1 << index2);
      }
    }
    /**
     * Performs a logical **OR** of this bit set with the bit set argument. This bit set is modified so that a bit in it
     * has the value `true` if and only if it either already had the value `true` or the corresponding bit in the bit
     * set argument has the value `true`.
     *
     * @param set the bit set to be ORed with.
     */
    or(set) {
      const minCount = Math.min(this.data.length, set.data.length);
      for (let k = 0; k < minCount; ++k) {
        this.data[k] |= set.data[k];
      }
      if (this.data.length < set.data.length) {
        this.resize((set.data.length << 5) - 1);
        const c = set.data.length;
        for (let k = minCount; k < c; ++k) {
          this.data[k] = set.data[k];
        }
      }
    }
    /**
     * Returns the value of the bit with the specified index. The value is `true` if the bit with the index `bitIndex`
     * is currently set in this `BitSet`; otherwise, the result is `false`.
     *
     * @param index the bit index
     *
     * @returns the value of the bit with the specified index.
     */
    get(index2) {
      if (index2 < 0) {
        throw new RangeError("index cannot be negative");
      }
      const slot = index2 >>> 5;
      if (slot >= this.data.length) {
        return false;
      }
      return (this.data[slot] & 1 << index2 % 32) !== 0;
    }
    /**
     * @returns the number of set bits.
     */
    get length() {
      let result = 0;
      const c = this.data.length;
      const w = this.data;
      for (let i = 0; i < c; i++) {
        result += this.bitCount(w[i]);
      }
      return result;
    }
    /**
     * @returns an array with indices of set bits.
     */
    values() {
      const result = new Array(this.length);
      let pos = 0;
      const length = this.data.length;
      for (let k = 0; k < length; ++k) {
        let w = this.data[k];
        while (w !== 0) {
          const t = w & -w;
          result[pos++] = (k << 5) + this.bitCount(t - 1);
          w ^= t;
        }
      }
      return result;
    }
    /**
     * @returns the index of the first bit that is set to `true` that occurs on or after the specified starting index.
     * If no such bit exists then undefined is returned.
     *
     * @param fromIndex the index to start checking from (inclusive)
     */
    nextSetBit(fromIndex) {
      if (fromIndex < 0) {
        throw new RangeError("index cannot be negative");
      }
      for (const index2 of this) {
        if (index2 >= fromIndex) {
          return index2;
        }
      }
      return void 0;
    }
    /**
     * Sets the bit at the specified index to `true`.
     *
     * @param index a bit index
     */
    set(index2) {
      if (index2 < 0) {
        throw new RangeError("index cannot be negative");
      }
      this.resize(index2);
      this.data[index2 >>> 5] |= 1 << index2 % 32;
    }
    /**
     * @returns a string representation of this bit set.
     */
    toString() {
      return "{" + this.values().join(", ") + "}";
    }
    resize(index2) {
      const count = index2 + 32 >>> 5;
      if (count <= this.data.length) {
        return;
      }
      const data = new Uint32Array(count);
      data.set(this.data);
      data.fill(0, this.data.length);
      this.data = data;
    }
    bitCount(v) {
      v = v - (v >> 1 & 1431655765);
      v = (v & 858993459) + (v >> 2 & 858993459);
      v = v + (v >> 4) & 252645135;
      v = v + (v >> 8);
      v = v + (v >> 16);
      return v & 63;
    }
  };
  var c1 = 3432918353;
  var c2 = 461845907;
  var r1 = 15;
  var r2 = 13;
  var m = 5;
  var n = 3864292196;
  var MurmurHash = class _MurmurHash {
    static {
      __name(this, "MurmurHash");
    }
    static defaultSeed = 701;
    constructor() {
    }
    /**
     * Initialize the hash using the specified {@code seed}.
     *
     * @param seed the seed
     *
     * @returns the intermediate hash value
     */
    static initialize(seed = _MurmurHash.defaultSeed) {
      return seed;
    }
    static updateFromComparable(hash, value) {
      return this.update(hash, value?.hashCode() ?? 0);
    }
    /**
     * Update the intermediate hash value for the next input {@code value}.
     *
     * @param hash The intermediate hash value.
     * @param value the value to add to the current hash.
     *
     * @returns the updated intermediate hash value
     */
    static update(hash, value) {
      value = Math.imul(value, c1);
      value = value << r1 | value >>> 32 - r1;
      value = Math.imul(value, c2);
      hash = hash ^ value;
      hash = hash << r2 | hash >>> 32 - r2;
      hash = Math.imul(hash, m) + n;
      return hash;
    }
    /**
     * Apply the final computation steps to the intermediate value {@code hash}
     * to form the final result of the MurmurHash 3 hash function.
     *
     * @param hash The intermediate hash value.
     * @param entryCount The number of values added to the hash.
     *
     * @returns the final hash result
     */
    static finish(hash, entryCount) {
      hash ^= entryCount * 4;
      hash ^= hash >>> 16;
      hash = Math.imul(hash, 2246822507);
      hash ^= hash >>> 13;
      hash = Math.imul(hash, 3266489909);
      hash ^= hash >>> 16;
      return hash;
    }
    /**
     * An all-in-one convenience method to compute a hash for a single value.
     *
     * @param value The value to hash.
     * @param seed The seed for the hash value.
     *
     * @returns The computed hash.
     */
    static hashCode(value, seed) {
      return _MurmurHash.finish(_MurmurHash.update(seed ?? _MurmurHash.defaultSeed, value), 1);
    }
  };
  var ObjectEqualityComparator = class _ObjectEqualityComparator {
    static {
      __name(this, "ObjectEqualityComparator");
    }
    static instance = new _ObjectEqualityComparator();
    hashCode(obj) {
      if (obj == null) {
        return 0;
      }
      return obj.hashCode();
    }
    equals(a, b) {
      if (a == null) {
        return b == null;
      }
      return a.equals(b);
    }
  };
  var DefaultEqualityComparator = class _DefaultEqualityComparator {
    static {
      __name(this, "DefaultEqualityComparator");
    }
    static instance = new _DefaultEqualityComparator();
    hashCode(obj) {
      if (obj == null) {
        return 0;
      }
      return ObjectEqualityComparator.instance.hashCode(obj);
    }
    equals(a, b) {
      if (a == null) {
        return b == null;
      }
      if (typeof a === "string" || typeof a === "number") {
        return a === b;
      }
      return ObjectEqualityComparator.instance.equals(a, b);
    }
  };
  var HashSet = class _HashSet {
    static {
      __name(this, "HashSet");
    }
    static defaultLoadFactor = 0.75;
    static initialCapacity = 16;
    // must be power of 2
    comparator;
    buckets;
    threshold;
    /** How many elements in set */
    itemCount = 0;
    constructor(comparatorOrSet, initialCapacity = _HashSet.initialCapacity) {
      if (comparatorOrSet instanceof _HashSet) {
        this.comparator = comparatorOrSet.comparator;
        this.buckets = comparatorOrSet.buckets.slice(0);
        for (let i = 0; i < this.buckets.length; i++) {
          const bucket = this.buckets[i];
          if (bucket) {
            this.buckets[i] = bucket.slice(0);
          }
        }
        this.itemCount = comparatorOrSet.itemCount;
        this.threshold = comparatorOrSet.threshold;
      } else {
        this.comparator = comparatorOrSet ?? DefaultEqualityComparator.instance;
        this.buckets = this.createBuckets(initialCapacity);
        this.threshold = Math.floor(_HashSet.initialCapacity * _HashSet.defaultLoadFactor);
      }
    }
    /**
     * Add `o` to set if not there; return existing value if already
     * there. This method performs the same operation as {@link #add} aside from
     * the return value.
     *
     * @param o the object to add to the set.
     *
     * @returns An existing element that equals to `o` if already in set, otherwise `o`.
     */
    getOrAdd(o) {
      if (this.itemCount > this.threshold) {
        this.expand();
      }
      const b = this.getBucket(o);
      let bucket = this.buckets[b];
      if (!bucket) {
        bucket = [o];
        this.buckets[b] = bucket;
        ++this.itemCount;
        return o;
      }
      for (const existing of bucket) {
        if (this.comparator.equals(existing, o)) {
          return existing;
        }
      }
      bucket.push(o);
      ++this.itemCount;
      return o;
    }
    get(o) {
      if (o == null) {
        return o;
      }
      const b = this.getBucket(o);
      const bucket = this.buckets[b];
      if (!bucket) {
        return void 0;
      }
      for (const e of bucket) {
        if (this.comparator.equals(e, o)) {
          return e;
        }
      }
      return void 0;
    }
    /**
     * Removes the specified element from this set if it is present.
     *
     * @param o object to be removed from this set, if present.
     *
     * @returns `true` if the set contained the specified element.
     */
    remove(o) {
      if (o == null) {
        return false;
      }
      const b = this.getBucket(o);
      const bucket = this.buckets[b];
      if (!bucket) {
        return false;
      }
      for (let i = 0; i < bucket.length; i++) {
        const existing = bucket[i];
        if (this.comparator.equals(existing, o)) {
          bucket.splice(i, 1);
          --this.itemCount;
          return true;
        }
      }
      return false;
    }
    hashCode() {
      let hash = MurmurHash.initialize();
      for (const bucket of this.buckets) {
        if (bucket == null) {
          continue;
        }
        for (const o of bucket) {
          if (o == null) {
            break;
          }
          hash = MurmurHash.update(hash, this.comparator.hashCode(o));
        }
      }
      hash = MurmurHash.finish(hash, this.size);
      return hash;
    }
    equals(o) {
      if (o === this) {
        return true;
      }
      if (!(o instanceof _HashSet)) {
        return false;
      }
      if (o.size !== this.size) {
        return false;
      }
      return this.containsAll(o);
    }
    add(t) {
      const existing = this.getOrAdd(t);
      return existing === t;
    }
    contains(o) {
      return this.containsFast(o);
    }
    containsFast(obj) {
      if (obj == null) {
        return false;
      }
      return this.get(obj) !== void 0;
    }
    *[Symbol.iterator]() {
      yield* this.toArray();
    }
    toArray() {
      const a = new Array(this.size);
      let i = 0;
      for (const bucket of this.buckets) {
        if (bucket == null) {
          continue;
        }
        for (const o of bucket) {
          if (o == null) {
            break;
          }
          a[i++] = o;
        }
      }
      return a;
    }
    containsAll(collection) {
      if (collection instanceof _HashSet) {
        for (const bucket of collection.buckets) {
          if (bucket == null) {
            continue;
          }
          for (const o of bucket) {
            if (o == null) {
              break;
            }
            if (!this.containsFast(o)) {
              return false;
            }
          }
        }
      } else {
        for (const o of collection) {
          if (!this.containsFast(o)) {
            return false;
          }
        }
      }
      return true;
    }
    addAll(c) {
      let changed = false;
      for (const o of c) {
        const existing = this.getOrAdd(o);
        if (existing !== o) {
          changed = true;
        }
      }
      return changed;
    }
    clear() {
      this.buckets = this.createBuckets(_HashSet.initialCapacity);
      this.itemCount = 0;
      this.threshold = Math.floor(_HashSet.initialCapacity * _HashSet.defaultLoadFactor);
    }
    toString() {
      if (this.size === 0) {
        return "{}";
      }
      let buf = "{";
      let first = true;
      for (const bucket of this.buckets) {
        if (bucket == null) {
          continue;
        }
        for (const o of bucket) {
          if (o == null) {
            break;
          }
          if (first) {
            first = false;
          } else {
            buf += ", ";
          }
          buf += o.toString();
        }
      }
      buf += "}";
      return buf;
    }
    toTableString() {
      let buf = "";
      for (const bucket of this.buckets) {
        if (bucket == null) {
          buf += "null\n";
          continue;
        }
        buf += "[";
        let first = true;
        for (const o of bucket) {
          if (first) {
            first = false;
          } else {
            buf += " ";
          }
          if (o == null) {
            buf += "_";
          } else {
            buf += o.toString();
          }
        }
        buf += "]\n";
      }
      return buf;
    }
    getBucket(o) {
      const hash = this.comparator.hashCode(o);
      const b = hash & this.buckets.length - 1;
      return b;
    }
    expand() {
      const old = this.buckets;
      const newCapacity = this.buckets.length * 2;
      const newTable = this.createBuckets(newCapacity);
      this.buckets = newTable;
      this.threshold = Math.floor(newCapacity * _HashSet.defaultLoadFactor);
      for (const bucket of old) {
        if (!bucket) {
          continue;
        }
        for (const o of bucket) {
          const b = this.getBucket(o);
          let newBucket = this.buckets[b];
          if (!newBucket) {
            newBucket = [];
            this.buckets[b] = newBucket;
          }
          newBucket.push(o);
        }
      }
    }
    get size() {
      return this.itemCount;
    }
    get isEmpty() {
      return this.itemCount === 0;
    }
    /**
     * Return an array of `T[]` with length `capacity`.
     *
     * @param capacity the length of the array to return
     * @returns the newly constructed array
     */
    createBuckets(capacity) {
      return new Array(capacity);
    }
  };
  var Interval = class _Interval {
    static {
      __name(this, "Interval");
    }
    static INVALID_INTERVAL = new _Interval(-1, -2);
    static INTERVAL_POOL_MAX_VALUE = 1e3;
    static cache = [];
    start;
    stop;
    cachedHashCode;
    constructor(start, stop) {
      this.start = start;
      this.stop = stop;
      this.cachedHashCode = Math.imul(651 + start, 31) + stop;
    }
    /**
     * Creates a new interval from the given values.
     *
     * Interval objects are used readonly so share all with the
     * same single value a==b up to some max size. Use an array as a perfect hash.
     * Return shared object for 0..INTERVAL_POOL_MAX_VALUE or a new
     * Interval object with a..a in it.  On Java.g4, 218623 IntervalSets
     * have a..a (set with 1 element).
     *
     * @param a The start of the interval.
     * @param b The end of the interval (inclusive).
     *
     * @returns A cached or new interval.
     */
    static of(a, b) {
      if (a !== b || a < 0 || a > _Interval.INTERVAL_POOL_MAX_VALUE) {
        return new _Interval(a, b);
      }
      if (!_Interval.cache[a]) {
        _Interval.cache[a] = new _Interval(a, a);
      }
      return _Interval.cache[a];
    }
    equals(o) {
      return this.start === o.start && this.stop === o.stop;
    }
    hashCode() {
      return this.cachedHashCode;
    }
    /** Does this start completely before other? Disjoint */
    startsBeforeDisjoint(other) {
      return this.start < other.start && this.stop < other.start;
    }
    /** Does this start at or before other? Nondisjoint */
    startsBeforeNonDisjoint(other) {
      return this.start <= other.start && this.stop >= other.start;
    }
    /** Does this.start start after other.stop? May or may not be disjoint */
    startsAfter(other) {
      return this.start > other.start;
    }
    /** Does this start completely after other? Disjoint */
    startsAfterDisjoint(other) {
      return this.start > other.stop;
    }
    /** Does this start after other? NonDisjoint */
    startsAfterNonDisjoint(other) {
      return this.start > other.start && this.start <= other.stop;
    }
    /** Are both ranges disjoint? I.e., no overlap? */
    disjoint(other) {
      return this.startsBeforeDisjoint(other) || this.startsAfterDisjoint(other);
    }
    /** Are two intervals adjacent such as 0..41 and 42..42? */
    adjacent(other) {
      return this.start === other.stop + 1 || this.stop === other.start - 1;
    }
    properlyContains(other) {
      return other.start >= this.start && other.stop <= this.stop;
    }
    /** Return the interval computed from combining this and other */
    union(other) {
      return _Interval.of(Math.min(this.start, other.start), Math.max(this.stop, other.stop));
    }
    /** Return the interval in common between this and o */
    intersection(other) {
      return _Interval.of(Math.max(this.start, other.start), Math.min(this.stop, other.stop));
    }
    /**
     * Return the interval with elements from this not in other;
     *  other must not be totally enclosed (properly contained)
     *  within this, which would result in two disjoint intervals
     *  instead of the single one returned by this method.
     */
    differenceNotProperlyContained(other) {
      let diff = null;
      if (other.startsBeforeNonDisjoint(this)) {
        diff = _Interval.of(Math.max(this.start, other.stop + 1), this.stop);
      } else if (other.startsAfterNonDisjoint(this)) {
        diff = _Interval.of(this.start, other.start - 1);
      }
      return diff;
    }
    toString() {
      return `${this.start}..${this.stop}`;
    }
    get length() {
      if (this.stop < this.start) {
        return 0;
      }
      return this.stop - this.start + 1;
    }
  };
  var Vocabulary = class _Vocabulary {
    static {
      __name(this, "Vocabulary");
    }
    static EMPTY_NAMES = [];
    /**
     * Gets an empty {@link Vocabulary} instance.
     *
     *
     * No literal or symbol names are assigned to token types, so
     * {@link #getDisplayName(int)} returns the numeric value for all tokens
     * except {@link Token#EOF}.
     */
    static EMPTY_VOCABULARY = new _Vocabulary(_Vocabulary.EMPTY_NAMES, _Vocabulary.EMPTY_NAMES, _Vocabulary.EMPTY_NAMES);
    maxTokenType;
    literalNames;
    symbolicNames;
    displayNames;
    /**
     * Constructs a new instance of {@link Vocabulary} from the specified
     * literal, symbolic, and display token names.
     *
     * @param literalNames The literal names assigned to tokens, or `null`
     * if no literal names are assigned.
     * @param symbolicNames The symbolic names assigned to tokens, or
     * `null` if no symbolic names are assigned.
     * @param displayNames The display names assigned to tokens, or `null`
     * to use the values in `literalNames` and `symbolicNames` as
     * the source of display names, as described in
     * {@link #getDisplayName(int)}.
     */
    constructor(literalNames, symbolicNames, displayNames) {
      this.literalNames = literalNames ?? _Vocabulary.EMPTY_NAMES;
      this.symbolicNames = symbolicNames ?? _Vocabulary.EMPTY_NAMES;
      this.displayNames = displayNames ?? _Vocabulary.EMPTY_NAMES;
      this.maxTokenType = Math.max(this.displayNames.length, Math.max(
        this.literalNames.length,
        this.symbolicNames.length
      )) - 1;
    }
    /**
     * Returns a {@link Vocabulary} instance from the specified set of token
     * names. This method acts as a compatibility layer for the single
     * `tokenNames` array generated by previous releases of ANTLR.
     *
     * The resulting vocabulary instance returns `null` for
     * {@link getLiteralName getLiteralName(int)} and {@link getSymbolicName getSymbolicName(int)}, and the
     * value from `tokenNames` for the display names.
     *
     * @param tokenNames The token names, or `null` if no token names are
     * available.
     * @returns A {@link Vocabulary} instance which uses `tokenNames` for
     * the display names of tokens.
     */
    static fromTokenNames(tokenNames) {
      if (tokenNames == null || tokenNames.length === 0) {
        return _Vocabulary.EMPTY_VOCABULARY;
      }
      const literalNames = [...tokenNames];
      const symbolicNames = [...tokenNames];
      for (let i = 0; i < tokenNames.length; i++) {
        const tokenName = tokenNames[i];
        if (tokenName == null) {
          continue;
        }
        if (tokenName.length > 0) {
          const firstChar = tokenName.codePointAt(0);
          if (firstChar === 39) {
            symbolicNames[i] = null;
            continue;
          } else if (firstChar >= 65 && firstChar <= 90) {
            literalNames[i] = null;
            continue;
          }
        }
        literalNames[i] = null;
        symbolicNames[i] = null;
      }
      return new _Vocabulary(literalNames, symbolicNames, tokenNames);
    }
    getMaxTokenType() {
      return this.maxTokenType;
    }
    getLiteralName(tokenType) {
      if (tokenType >= 0 && tokenType < this.literalNames.length) {
        return this.literalNames[tokenType];
      }
      return null;
    }
    getSymbolicName(tokenType) {
      if (tokenType >= 0 && tokenType < this.symbolicNames.length) {
        return this.symbolicNames[tokenType];
      }
      if (tokenType === Token.EOF) {
        return "EOF";
      }
      return null;
    }
    getDisplayName(tokenType) {
      if (tokenType >= 0 && tokenType < this.displayNames.length) {
        const displayName = this.displayNames[tokenType];
        if (displayName != null) {
          return displayName;
        }
      }
      const literalName = this.getLiteralName(tokenType);
      if (literalName != null) {
        return literalName;
      }
      const symbolicName = this.getSymbolicName(tokenType);
      if (symbolicName != null) {
        return symbolicName;
      }
      return `${tokenType}`;
    }
    getLiteralNames() {
      return this.literalNames;
    }
    getSymbolicNames() {
      return this.symbolicNames;
    }
    getDisplayNames() {
      return this.displayNames;
    }
  };
  var IntervalSet = class _IntervalSet {
    static {
      __name(this, "IntervalSet");
    }
    /** The list of sorted, disjoint intervals. */
    intervals = [];
    cachedHashCode;
    constructor(set) {
      if (set) {
        if (Array.isArray(set)) {
          for (const el of set) {
            this.addOne(el);
          }
        } else {
          this.addSet(set);
        }
      }
    }
    /** Create a set with all ints within range [a..b] (inclusive) */
    static of(a, b) {
      const s = new _IntervalSet();
      s.addRange(a, b);
      return s;
    }
    /** Combine all sets in the array and return the union of them */
    static or(sets) {
      const result = new _IntervalSet();
      for (const set of sets) {
        result.addSet(set);
      }
      return result;
    }
    [Symbol.iterator]() {
      return this.intervals[Symbol.iterator]();
    }
    get(index2) {
      return this.intervals[index2];
    }
    /**
     * Returns the minimum value contained in the set if not isNil().
     *
     * @returns the minimum value contained in the set.
     */
    get minElement() {
      if (this.intervals.length === 0) {
        return Token.INVALID_TYPE;
      }
      return this.intervals[0].start;
    }
    /**
     * Returns the maximum value contained in the set if not isNil().
     *
     * @returns the maximum value contained in the set.
     */
    get maxElement() {
      if (this.intervals.length === 0) {
        return Token.INVALID_TYPE;
      }
      return this.intervals[this.intervals.length - 1].stop;
    }
    clear() {
      this.cachedHashCode = void 0;
      this.intervals = [];
    }
    /**
     * Add a single element to the set.  An isolated element is stored
     *  as a range el..el.
     */
    addOne(v) {
      this.addInterval(new Interval(v, v));
    }
    /**
     * Add interval; i.e., add all integers from a to b to set.
     *  If b < a, do nothing.
     *  Keep list in sorted order (by left range value).
     *  If overlap, combine ranges. For example,
     *  If this is {1..5, 10..20}, adding 6..7 yields
     *  {1..5, 6..7, 10..20}. Adding 4..8 yields {1..8, 10..20}.
     */
    addRange(l, h) {
      this.addInterval(new Interval(l, h));
    }
    addInterval(addition) {
      this.cachedHashCode = void 0;
      if (this.intervals.length === 0) {
        this.intervals.push(addition);
      } else {
        for (let pos = 0; pos < this.intervals.length; pos++) {
          const existing = this.intervals[pos];
          if (addition.equals(existing)) {
            return;
          }
          if (addition.adjacent(existing) || !addition.disjoint(existing)) {
            const bigger = addition.union(existing);
            this.intervals[pos] = bigger;
            for (let sub = pos + 1; sub < this.intervals.length; ) {
              const next = this.intervals[sub];
              if (!bigger.adjacent(next) && bigger.disjoint(next)) {
                break;
              }
              this.intervals.splice(sub, 1);
              this.intervals[pos] = bigger.union(next);
            }
            return;
          }
          if (addition.startsBeforeDisjoint(existing)) {
            this.intervals.splice(pos, 0, addition);
            return;
          }
        }
        this.intervals.push(addition);
      }
    }
    addSet(other) {
      other.intervals.forEach((toAdd) => {
        return this.addInterval(toAdd);
      }, this);
      return this;
    }
    complementWithVocabulary(vocabulary) {
      const result = new _IntervalSet();
      if (!vocabulary) {
        return result;
      }
      if (vocabulary.length === 0) {
        return result;
      }
      result.addSet(vocabulary);
      return result.subtract(this);
    }
    complement(minElement, maxElement) {
      const result = new _IntervalSet();
      result.addInterval(new Interval(minElement, maxElement));
      return result.subtract(this);
    }
    /** combine all sets in the array returned the or'd value */
    or(sets) {
      const result = new _IntervalSet();
      result.addSet(this);
      sets.forEach((set) => {
        return result.addSet(set);
      });
      return result;
    }
    and(other) {
      if (other.length === 0) {
        return new _IntervalSet();
      }
      const myIntervals = this.intervals;
      const theirIntervals = other.intervals;
      let intersection;
      const mySize = myIntervals.length;
      const theirSize = theirIntervals.length;
      let i = 0;
      let j = 0;
      while (i < mySize && j < theirSize) {
        const mine = myIntervals[i];
        const theirs = theirIntervals[j];
        if (mine.startsBeforeDisjoint(theirs)) {
          i++;
        } else if (theirs.startsBeforeDisjoint(mine)) {
          j++;
        } else if (mine.properlyContains(theirs)) {
          if (!intersection) {
            intersection = new _IntervalSet();
          }
          intersection.addInterval(mine.intersection(theirs));
          j++;
        } else if (theirs.properlyContains(mine)) {
          if (!intersection) {
            intersection = new _IntervalSet();
          }
          intersection.addInterval(mine.intersection(theirs));
          i++;
        } else if (!mine.disjoint(theirs)) {
          if (!intersection) {
            intersection = new _IntervalSet();
          }
          intersection.addInterval(mine.intersection(theirs));
          if (mine.startsAfterNonDisjoint(theirs)) {
            j++;
          } else if (theirs.startsAfterNonDisjoint(mine)) {
            i++;
          }
        }
      }
      if (!intersection) {
        return new _IntervalSet();
      }
      return intersection;
    }
    /**
     * Compute the set difference between two interval sets. The specific
     * operation is `left - right`. If either of the input sets is
     * `null`, it is treated as though it was an empty set.
     */
    subtract(other) {
      if (this.length === 0) {
        return new _IntervalSet();
      }
      const result = new _IntervalSet(this);
      if (other.length === 0) {
        return result;
      }
      let resultI = 0;
      let rightI = 0;
      while (resultI < result.intervals.length && rightI < other.intervals.length) {
        const resultInterval = result.intervals[resultI];
        const rightInterval = other.intervals[rightI];
        if (rightInterval.stop < resultInterval.start) {
          rightI++;
          continue;
        }
        if (rightInterval.start > resultInterval.stop) {
          resultI++;
          continue;
        }
        let beforeCurrent;
        let afterCurrent;
        if (rightInterval.start > resultInterval.start) {
          beforeCurrent = new Interval(resultInterval.start, rightInterval.start - 1);
        }
        if (rightInterval.stop < resultInterval.stop) {
          afterCurrent = new Interval(rightInterval.stop + 1, resultInterval.stop);
        }
        if (beforeCurrent) {
          if (afterCurrent) {
            result.intervals[resultI] = beforeCurrent;
            result.intervals.splice(resultI + 1, 0, afterCurrent);
            resultI++;
            rightI++;
          } else {
            result.intervals[resultI] = beforeCurrent;
            resultI++;
          }
        } else {
          if (afterCurrent) {
            result.intervals[resultI] = afterCurrent;
            rightI++;
          } else {
            result.intervals.splice(resultI, 1);
          }
        }
      }
      return result;
    }
    contains(el) {
      const n2 = this.intervals.length;
      let l = 0;
      let r = n2 - 1;
      while (l <= r) {
        const m2 = Math.floor((l + r) / 2);
        const interval = this.intervals[m2];
        if (interval.stop < el) {
          l = m2 + 1;
        } else if (interval.start > el) {
          r = m2 - 1;
        } else {
          return true;
        }
      }
      return false;
    }
    removeRange(toRemove) {
      this.cachedHashCode = void 0;
      if (toRemove.start === toRemove.stop) {
        this.removeOne(toRemove.start);
      } else if (this.intervals !== null) {
        let pos = 0;
        for (const existing of this.intervals) {
          if (toRemove.stop <= existing.start) {
            return;
          } else if (toRemove.start > existing.start && toRemove.stop < existing.stop) {
            this.intervals[pos] = new Interval(existing.start, toRemove.start);
            const x = new Interval(toRemove.stop, existing.stop);
            this.intervals.splice(pos, 0, x);
            return;
          } else if (toRemove.start <= existing.start && toRemove.stop >= existing.stop) {
            this.intervals.splice(pos, 1);
            pos = pos - 1;
          } else if (toRemove.start < existing.stop) {
            this.intervals[pos] = new Interval(existing.start, toRemove.start);
          } else if (toRemove.stop < existing.stop) {
            this.intervals[pos] = new Interval(toRemove.stop, existing.stop);
          }
          pos += 1;
        }
      }
    }
    removeOne(value) {
      this.cachedHashCode = void 0;
      for (let i = 0; i < this.intervals.length; i++) {
        const existing = this.intervals[i];
        if (value < existing.start) {
          return;
        } else if (value === existing.start && value === existing.stop) {
          this.intervals.splice(i, 1);
          return;
        } else if (value === existing.start) {
          this.intervals[i] = new Interval(existing.start + 1, existing.stop);
          return;
        } else if (value === existing.stop) {
          this.intervals[i] = new Interval(existing.start, existing.stop - 1);
          return;
        } else if (value < existing.stop) {
          const replace = new Interval(existing.start, value - 1);
          this.intervals[i] = new Interval(value + 1, existing.stop);
          this.intervals.splice(i, 0, replace);
          return;
        }
      }
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        for (const interval of this.intervals) {
          hash = MurmurHash.update(hash, interval.start);
          hash = MurmurHash.update(hash, interval.stop);
        }
        this.cachedHashCode = MurmurHash.finish(hash, this.intervals.length * 2);
      }
      return this.cachedHashCode;
    }
    /**
     * Are two IntervalSets equal? Because all intervals are sorted and disjoint, equals is a simple linear walk over
     * both lists to make sure they are the same. Interval.equals() is used by the List.equals() method to check
     * the ranges.
     */
    equals(other) {
      if (this === other) {
        return true;
      }
      if (this.intervals.length !== other.intervals.length) {
        return false;
      }
      for (let i = 0; i < this.intervals.length; i++) {
        if (!this.intervals[i].equals(other.intervals[i])) {
          return false;
        }
      }
      return true;
    }
    toString(elementsAreChar) {
      if (this.intervals.length === 0) {
        return "{}";
      }
      let result = "";
      if (this.length > 1) {
        result += "{";
      }
      for (let i = 0; i < this.intervals.length; ++i) {
        const interval = this.intervals[i];
        const start = interval.start;
        const stop = interval.stop;
        if (start === stop) {
          if (start === Token.EOF) {
            result += "<EOF>";
          } else if (elementsAreChar) {
            result += "'" + String.fromCodePoint(start) + "'";
          } else {
            result += start;
          }
        } else {
          if (elementsAreChar) {
            result += "'" + String.fromCodePoint(start) + "'..'" + String.fromCodePoint(stop) + "'";
          } else {
            result += start + ".." + stop;
          }
        }
        if (i < this.intervals.length - 1) {
          result += ", ";
        }
      }
      if (this.length > 1) {
        result += "}";
      }
      return result;
    }
    toStringWithVocabulary(vocabulary) {
      if (this.intervals.length === 0) {
        return "{}";
      }
      let result = "";
      if (this.length > 1) {
        result += "{";
      }
      for (let i = 0; i < this.intervals.length; ++i) {
        const interval = this.intervals[i];
        const start = interval.start;
        const stop = interval.stop;
        if (start === stop) {
          if (start === Token.EOF) {
            result += "<EOF>";
          } else {
            result += this.elementName(vocabulary, start);
          }
        } else {
          for (let i2 = start; i2 <= stop; ++i2) {
            if (i2 > start) {
              result += ", ";
            }
            result += this.elementName(vocabulary, i2);
          }
        }
        if (i < this.intervals.length - 1) {
          result += ", ";
        }
      }
      if (this.length > 1) {
        result += "}";
      }
      return result;
    }
    toStringWithRuleNames(ruleNames) {
      if (this.intervals.length === 0) {
        return "{}";
      }
      let result = "";
      if (this.length > 1) {
        result += "{";
      }
      const vocabulary = Vocabulary.fromTokenNames(ruleNames);
      for (let i = 0; i < this.intervals.length; ++i) {
        const interval = this.intervals[i];
        const start = interval.start;
        const stop = interval.stop;
        if (start === stop) {
          if (start === Token.EOF) {
            result += "<EOF>";
          } else {
            result += this.elementName(vocabulary, start);
          }
        } else {
          for (let i2 = start; i2 <= stop; ++i2) {
            if (i2 > start) {
              result += ", ";
            }
            result += this.elementName(vocabulary, i2);
          }
        }
        if (i < this.intervals.length - 1) {
          result += ", ";
        }
      }
      if (this.length > 1) {
        result += "}";
      }
      return result;
    }
    toArray() {
      const data = [];
      for (const interval of this.intervals) {
        for (let j = interval.start; j <= interval.stop; j++) {
          data.push(j);
        }
      }
      return data;
    }
    /** @returns the number of elements in this set. */
    get length() {
      let result = 0;
      for (const interval of this.intervals) {
        result += interval.length;
      }
      return result;
    }
    elementName(vocabulary, token) {
      if (token === Token.EOF) {
        return "<EOF>";
      }
      if (token === Token.EPSILON) {
        return "<EPSILON>";
      }
      return vocabulary.getDisplayName(token);
    }
  };
  var valueToString = /* @__PURE__ */ __name((v) => {
    return v === null ? "null" : v;
  }, "valueToString");
  var arrayToString = /* @__PURE__ */ __name((value) => {
    return Array.isArray(value) ? "[" + value.map(valueToString).join(", ") + "]" : "null";
  }, "arrayToString");
  var equalArrays = /* @__PURE__ */ __name((a, b) => {
    if (a === b) {
      return true;
    }
    if (a.length !== b.length) {
      return false;
    }
    for (let i = 0; i < a.length; i++) {
      const left = a[i];
      const right = b[i];
      if (left === right) {
        continue;
      }
      if (!left || !left.equals(right)) {
        return false;
      }
    }
    return true;
  }, "equalArrays");
  var equalNumberArrays = /* @__PURE__ */ __name((a, b) => {
    if (a === b) {
      return true;
    }
    if (a.length !== b.length) {
      return false;
    }
    for (let i = 0; i < a.length; i++) {
      if (a[i] !== b[i]) {
        return false;
      }
    }
    return true;
  }, "equalNumberArrays");
  var escapeWhitespace = /* @__PURE__ */ __name((s, escapeSpaces = false) => {
    s = s.replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
    if (escapeSpaces) {
      s = s.replace(/ /g, "\xB7");
    }
    return s;
  }, "escapeWhitespace");
  var SemanticContext = class _SemanticContext {
    static {
      __name(this, "SemanticContext");
    }
    cachedHashCode;
    static andContext(a, b) {
      if (a === null || a === _SemanticContext.NONE) {
        return b;
      }
      if (b === null || b === _SemanticContext.NONE) {
        return a;
      }
      const result = new AND(a, b);
      if (result.operands.length === 1) {
        return result.operands[0];
      }
      return result;
    }
    static orContext(a, b) {
      if (a === null) {
        return b;
      }
      if (b === null) {
        return a;
      }
      if (a === _SemanticContext.NONE || b === _SemanticContext.NONE) {
        return _SemanticContext.NONE;
      }
      const result = new OR(a, b);
      if (result.operands.length === 1) {
        return result.operands[0];
      } else {
        return result;
      }
    }
    static filterPrecedencePredicates(set) {
      const result = [];
      for (const context of set) {
        if (context instanceof _SemanticContext.PrecedencePredicate) {
          result.push(context);
        }
      }
      return result;
    }
    /**
     * Evaluate the precedence predicates for the context and reduce the result.
     *
     * @param _parser The parser instance.
     * @param _parserCallStack The current parser context object.
     * @returns The simplified semantic context after precedence predicates are
     * evaluated, which will be one of the following values.
     * - {@link NONE}: if the predicate simplifies to `true` after
     * precedence predicates are evaluated.
     * - `null`: if the predicate simplifies to `false` after
     * precedence predicates are evaluated.
     * - `this`: if the semantic context is not changed as a result of
     * precedence predicate evaluation.
     * - A non-`null` {@link SemanticContext}: the new simplified
     * semantic context after precedence predicates are evaluated.
     */
    evalPrecedence(_parser, _parserCallStack) {
      return this;
    }
  };
  var AND = class _AND extends SemanticContext {
    static {
      __name(this, "AND");
    }
    operands;
    /**
     * A semantic context which is true whenever none of the contained contexts
     * is false
     */
    constructor(a, b) {
      super();
      const operands = new HashSet();
      if (a instanceof _AND) {
        a.operands.forEach((o) => {
          operands.add(o);
        });
      } else {
        operands.add(a);
      }
      if (b instanceof _AND) {
        b.operands.forEach((o) => {
          operands.add(o);
        });
      } else {
        operands.add(b);
      }
      const precedencePredicates = SemanticContext.filterPrecedencePredicates(operands);
      if (precedencePredicates.length > 0) {
        let reduced = null;
        precedencePredicates.forEach((p) => {
          if (reduced === null || p.precedence < reduced.precedence) {
            reduced = p;
          }
        });
        if (reduced) {
          operands.add(reduced);
        }
      }
      this.operands = operands.toArray();
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _AND)) {
        return false;
      }
      return equalArrays(this.operands, other.operands);
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        for (const operand of this.operands) {
          hash = MurmurHash.updateFromComparable(hash, operand);
        }
        hash = MurmurHash.update(hash, 3813686060);
        this.cachedHashCode = MurmurHash.finish(hash, this.operands.length + 1);
      }
      return this.cachedHashCode;
    }
    /**
     * {@inheritDoc}
     *
     *
     * The evaluation of predicates by this context is short-circuiting, but
     * unordered.
     */
    evaluate(parser, parserCallStack) {
      for (const operand of this.operands) {
        if (!operand.evaluate(parser, parserCallStack)) {
          return false;
        }
      }
      return true;
    }
    evalPrecedence(parser, parserCallStack) {
      let differs = false;
      const operands = [];
      for (const context of this.operands) {
        const evaluated = context.evalPrecedence(parser, parserCallStack);
        differs ||= evaluated !== context;
        if (evaluated === null) {
          return null;
        } else if (evaluated !== SemanticContext.NONE) {
          operands.push(evaluated);
        }
      }
      if (!differs) {
        return this;
      }
      if (operands.length === 0) {
        return SemanticContext.NONE;
      }
      let result = null;
      operands.forEach((o) => {
        result = result === null ? o : SemanticContext.andContext(result, o);
      });
      return result;
    }
    toString() {
      const s = this.operands.map((o) => {
        return o.toString();
      });
      return (s.length > 3 ? s.slice(3) : s).join("&&");
    }
  };
  var OR = class _OR extends SemanticContext {
    static {
      __name(this, "OR");
    }
    operands;
    /**
     * A semantic context which is true whenever at least one of the contained
     * contexts is true
     */
    constructor(a, b) {
      super();
      const operands = new HashSet();
      if (a instanceof _OR) {
        a.operands.forEach((o) => {
          operands.add(o);
        });
      } else {
        operands.add(a);
      }
      if (b instanceof _OR) {
        b.operands.forEach((o) => {
          operands.add(o);
        });
      } else {
        operands.add(b);
      }
      const precedencePredicates = SemanticContext.filterPrecedencePredicates(operands);
      if (precedencePredicates.length > 0) {
        const s = precedencePredicates.sort((a2, b2) => {
          return a2.compareTo(b2);
        });
        const reduced = s[s.length - 1];
        operands.add(reduced);
      }
      this.operands = operands.toArray();
    }
    equals(other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof _OR)) {
        return false;
      } else {
        return equalArrays(this.operands, other.operands);
      }
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        for (const operand of this.operands) {
          hash = MurmurHash.updateFromComparable(hash, operand);
        }
        hash = MurmurHash.update(hash, 3383313031);
        this.cachedHashCode = MurmurHash.finish(hash, this.operands.length + 1);
      }
      return this.cachedHashCode;
    }
    /**
     * The evaluation of predicates by this context is short-circuiting, but unordered.
     */
    evaluate(parser, parserCallStack) {
      for (const operand of this.operands) {
        if (operand.evaluate(parser, parserCallStack)) {
          return true;
        }
      }
      return false;
    }
    evalPrecedence(parser, parserCallStack) {
      let differs = false;
      const operands = [];
      for (const context of this.operands) {
        const evaluated = context.evalPrecedence(parser, parserCallStack);
        differs ||= evaluated !== context;
        if (evaluated === SemanticContext.NONE) {
          return SemanticContext.NONE;
        } else if (evaluated !== null) {
          operands.push(evaluated);
        }
      }
      if (!differs) {
        return this;
      }
      if (operands.length === 0) {
        return null;
      }
      let result = null;
      operands.forEach((o) => {
        result = result === null ? o : SemanticContext.orContext(result, o);
      });
      return result;
    }
    toString() {
      const s = this.operands.map((o) => {
        return o.toString();
      });
      return (s.length > 3 ? s.slice(3) : s).join("||");
    }
  };
  ((SemanticContext2) => {
    class Predicate extends SemanticContext2 {
      static {
        __name(this, "Predicate");
      }
      ruleIndex;
      predIndex;
      isCtxDependent;
      // e.g., $i ref in pred
      constructor(ruleIndex, predIndex, isCtxDependent) {
        super();
        this.ruleIndex = ruleIndex ?? -1;
        this.predIndex = predIndex ?? -1;
        this.isCtxDependent = isCtxDependent ?? false;
      }
      evaluate(parser, outerContext) {
        const localctx = this.isCtxDependent ? outerContext : null;
        return parser.sempred(localctx, this.ruleIndex, this.predIndex);
      }
      hashCode() {
        if (this.cachedHashCode === void 0) {
          let hashCode = MurmurHash.initialize();
          hashCode = MurmurHash.update(hashCode, this.ruleIndex);
          hashCode = MurmurHash.update(hashCode, this.predIndex);
          hashCode = MurmurHash.update(hashCode, this.isCtxDependent ? 1 : 0);
          hashCode = MurmurHash.finish(hashCode, 3);
          this.cachedHashCode = hashCode;
        }
        return this.cachedHashCode;
      }
      equals(other) {
        if (this === other) {
          return true;
        }
        return this.ruleIndex === other.ruleIndex && this.predIndex === other.predIndex && this.isCtxDependent === other.isCtxDependent;
      }
      toString() {
        return "{" + this.ruleIndex + ":" + this.predIndex + "}?";
      }
    }
    SemanticContext2.Predicate = Predicate;
    class PrecedencePredicate extends SemanticContext2 {
      static {
        __name(this, "PrecedencePredicate");
      }
      precedence;
      constructor(precedence) {
        super();
        this.precedence = precedence ?? 0;
      }
      evaluate(parser, outerContext) {
        return parser.precpred(outerContext, this.precedence);
      }
      evalPrecedence(parser, outerContext) {
        if (parser.precpred(outerContext ?? null, this.precedence)) {
          return SemanticContext2.NONE;
        }
        return null;
      }
      compareTo(other) {
        return this.precedence - other.precedence;
      }
      hashCode() {
        return 31 + this.precedence;
      }
      equals(other) {
        if (this === other) {
          return true;
        }
        return this.precedence === other.precedence;
      }
      toString() {
        return "{" + this.precedence + ">=prec}?";
      }
    }
    SemanticContext2.PrecedencePredicate = PrecedencePredicate;
    SemanticContext2.NONE = new Predicate();
  })(SemanticContext || (SemanticContext = {}));
  var ATNConfig = class _ATNConfig {
    static {
      __name(this, "ATNConfig");
    }
    /** The ATN state associated with this configuration */
    state;
    /** What alt (or lexer rule) is predicted by this configuration */
    alt;
    /**
     * We cannot execute predicates dependent upon local context unless
     * we know for sure we are in the correct context. Because there is
     * no way to do this efficiently, we simply cannot evaluate
     * dependent predicates unless we are in the rule that initially
     * invokes the ATN simulator.
     *
     * closure() tracks the depth of how far we dip into the outer context:
     * depth > 0.
     */
    reachesIntoOuterContext = false;
    // Not used in hash code.
    precedenceFilterSuppressed = false;
    // Not used in hash code.
    get semanticContext() {
      return this.#semanticContext;
    }
    cachedHashCode;
    // Shared with LexerATNConfig.
    /**
     * The syntactic context is a graph-structured stack node whose
     * path(s) to the root is the rule invocation(s)
     * chain used to arrive at the state.  The semantic context is
     * the tree of semantic predicates encountered before reaching
     * an ATN state
     */
    #context = null;
    #semanticContext;
    /** Never create config classes directly. Use the factory methods below. */
    constructor(c, state, context, semanticContext) {
      this.state = state;
      this.alt = c.alt;
      this.context = context;
      this.#semanticContext = semanticContext ?? SemanticContext.NONE;
      this.reachesIntoOuterContext = c.reachesIntoOuterContext;
      if (c.precedenceFilterSuppressed !== void 0) {
        this.precedenceFilterSuppressed = c.precedenceFilterSuppressed;
      }
    }
    static duplicate(old, semanticContext) {
      return new _ATNConfig(old, old.state, old.context, semanticContext ?? old.semanticContext);
    }
    static createWithContext(state, alt, context, semanticContext) {
      return new _ATNConfig({ alt }, state, context, semanticContext);
    }
    static createWithConfig(state, config, context) {
      return new _ATNConfig(config, state, context ?? config.context, config.semanticContext);
    }
    static createWithSemanticContext(state, c, semanticContext) {
      return new _ATNConfig(c, state ?? c.state, c.context, semanticContext);
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hashCode = MurmurHash.initialize(7);
        hashCode = MurmurHash.update(hashCode, this.state.stateNumber);
        hashCode = MurmurHash.update(hashCode, this.alt);
        hashCode = MurmurHash.updateFromComparable(hashCode, this.#context);
        hashCode = MurmurHash.updateFromComparable(hashCode, this.semanticContext);
        hashCode = MurmurHash.finish(hashCode, 4);
        this.cachedHashCode = hashCode;
      }
      return this.cachedHashCode;
    }
    /**
     * The stack of invoking states leading to the rule/states associated
     * with this config.  We track only those contexts pushed during
     * execution of the ATN simulator.
     */
    get context() {
      return this.#context;
    }
    set context(context) {
      this.#context = context;
      this.cachedHashCode = void 0;
    }
    /**
     * An ATN configuration is equal to another if both have
     * the same state, they predict the same alternative, and
     * syntactic/semantic contexts are the same.
     */
    equals(other) {
      if (this === other) {
        return true;
      }
      return this.state.stateNumber === other.state.stateNumber && this.alt === other.alt && (this.context === null ? other.context === null : this.context.equals(other.context)) && this.semanticContext.equals(other.semanticContext) && this.precedenceFilterSuppressed === other.precedenceFilterSuppressed;
    }
    toString(_recog, showAlt = true) {
      let alt = "";
      if (showAlt) {
        alt = "," + this.alt;
      }
      return "(" + this.state + alt + (this.context !== null ? ",[" + this.context.toString() + "]" : "") + (this.semanticContext !== SemanticContext.NONE ? "," + this.semanticContext.toString() : "") + (this.reachesIntoOuterContext ? ",up=" + this.reachesIntoOuterContext : "") + ")";
    }
  };
  var ATNState = class _ATNState {
    static {
      __name(this, "ATNState");
    }
    static INVALID_STATE_NUMBER = -1;
    static INVALID_TYPE = 0;
    static BASIC = 1;
    static RULE_START = 2;
    static BLOCK_START = 3;
    static PLUS_BLOCK_START = 4;
    static STAR_BLOCK_START = 5;
    static TOKEN_START = 6;
    static RULE_STOP = 7;
    static BLOCK_END = 8;
    static STAR_LOOP_BACK = 9;
    static STAR_LOOP_ENTRY = 10;
    static PLUS_LOOP_BACK = 11;
    static LOOP_END = 12;
    static stateType = _ATNState.INVALID_STATE_NUMBER;
    stateNumber = 0;
    ruleIndex = 0;
    // at runtime, we don't have Rule objects
    epsilonOnlyTransitions = false;
    /** Used to cache lookahead during parsing, not used during construction */
    nextTokenWithinRule;
    /** Track the transitions emanating from this ATN state. */
    transitions = [];
    hashCode() {
      return this.stateNumber;
    }
    equals(other) {
      return this.stateNumber === other.stateNumber;
    }
    toString() {
      return `${this.stateNumber}`;
    }
    addTransitionAtIndex(index2, transition) {
      if (this.transitions.length === 0) {
        this.epsilonOnlyTransitions = transition.isEpsilon;
      } else if (this.epsilonOnlyTransitions !== transition.isEpsilon) {
        this.epsilonOnlyTransitions = false;
      }
      this.transitions.splice(index2, 0, transition);
    }
    addTransition(transition) {
      if (this.transitions.length === 0) {
        this.epsilonOnlyTransitions = transition.isEpsilon;
      } else if (this.epsilonOnlyTransitions !== transition.isEpsilon) {
        this.epsilonOnlyTransitions = false;
      }
      this.transitions.push(transition);
    }
    setTransition(i, e) {
      this.transitions.splice(i, 1, e);
    }
    removeTransition(index2) {
      const t = this.transitions.splice(index2, 1);
      return t[0];
    }
  };
  var PredictionContext = class _PredictionContext {
    static {
      __name(this, "PredictionContext");
    }
    /**
     * Represents `$` in an array in full context mode, when `$`
     * doesn't mean wildcard: `$ + x = [$,x]`. Here,
     * `$` = {@link EMPTY_RETURN_STATE}.
     */
    static EMPTY_RETURN_STATE = 2147483647;
    static traceATNSimulator = false;
    cachedHashCode;
    constructor(cachedHashCode) {
      this.cachedHashCode = cachedHashCode;
    }
    static calculateEmptyHashCode() {
      let hash = MurmurHash.initialize(31);
      hash = MurmurHash.finish(hash, 0);
      return hash;
    }
    static calculateHashCodeSingle(parent, returnState) {
      let hash = MurmurHash.initialize(31);
      hash = MurmurHash.updateFromComparable(hash, parent);
      hash = MurmurHash.update(hash, returnState);
      hash = MurmurHash.finish(hash, 2);
      return hash;
    }
    static calculateHashCodeList(parents, returnStates) {
      let hash = MurmurHash.initialize(31);
      for (const parent of parents) {
        hash = MurmurHash.updateFromComparable(hash, parent);
      }
      for (const returnState of returnStates) {
        hash = MurmurHash.update(hash, returnState);
      }
      hash = MurmurHash.finish(hash, 2 * parents.length);
      return hash;
    }
    isEmpty() {
      return false;
    }
    hasEmptyPath() {
      return this.getReturnState(this.length - 1) === _PredictionContext.EMPTY_RETURN_STATE;
    }
    hashCode() {
      return this.cachedHashCode;
    }
    toString(_recog) {
      return "";
    }
  };
  var SingletonPredictionContext = class _SingletonPredictionContext extends PredictionContext {
    static {
      __name(this, "SingletonPredictionContext");
    }
    parent;
    returnState;
    constructor(parent, returnState) {
      super(
        parent ? PredictionContext.calculateHashCodeSingle(parent, returnState) : PredictionContext.calculateEmptyHashCode()
      );
      this.parent = parent ?? null;
      this.returnState = returnState;
    }
    getParent(_index) {
      return this.parent;
    }
    getReturnState(_index) {
      return this.returnState;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _SingletonPredictionContext)) {
        return false;
      }
      if (this.hashCode() !== other.hashCode()) {
        return false;
      }
      if (this.returnState !== other.returnState) {
        return false;
      }
      if (this.parent == null) {
        return other.parent == null;
      }
      return this.parent.equals(other.parent);
    }
    toString() {
      const up = this.parent === null ? "" : this.parent.toString();
      if (up.length === 0) {
        if (this.returnState === PredictionContext.EMPTY_RETURN_STATE) {
          return "$";
        }
        return "" + this.returnState;
      } else {
        return "" + this.returnState + " " + up;
      }
    }
    get length() {
      return 1;
    }
  };
  var EmptyPredictionContext = class _EmptyPredictionContext extends SingletonPredictionContext {
    static {
      __name(this, "EmptyPredictionContext");
    }
    /**
     * Represents `$` in local context prediction, which means wildcard.
     * `*+x = *`.
     */
    static instance = new _EmptyPredictionContext();
    constructor() {
      super(void 0, PredictionContext.EMPTY_RETURN_STATE);
    }
    isEmpty() {
      return true;
    }
    getParent() {
      return null;
    }
    getReturnState() {
      return this.returnState;
    }
    equals(other) {
      return this === other;
    }
    toString() {
      return "$";
    }
  };
  var Transition = class {
    static {
      __name(this, "Transition");
    }
    static INVALID = 0;
    static EPSILON = 1;
    static RANGE = 2;
    static RULE = 3;
    static PREDICATE = 4;
    // e.g., {isType(input.LT(1))}
    static ATOM = 5;
    static ACTION = 6;
    static SET = 7;
    // ~(A|B) or ~atom, wildcard, which convert to next
    static NOT_SET = 8;
    static WILDCARD = 9;
    static PRECEDENCE = 10;
    /** The target of this transition. */
    target;
    constructor(target) {
      this.target = target;
    }
    /**
     * Determines if the transition is an "epsilon" transition.
     *
     * The default implementation returns `false`.
     *
     * @returns `true` if traversing this transition in the ATN does not
     * consume an input symbol; otherwise, `false` if traversing this
     * transition consumes (matches) an input symbol.
     */
    get isEpsilon() {
      return false;
    }
    get label() {
      return null;
    }
    toString() {
      return "";
    }
  };
  var SetTransition = class extends Transition {
    static {
      __name(this, "SetTransition");
    }
    set;
    constructor(target, set) {
      super(target);
      if (set) {
        this.set = set;
      } else {
        this.set = IntervalSet.of(Token.INVALID_TYPE, Token.INVALID_TYPE);
      }
    }
    get transitionType() {
      return Transition.SET;
    }
    get label() {
      return this.set;
    }
    matches(symbol, _minVocabSymbol, _maxVocabSymbol) {
      return this.set.contains(symbol);
    }
    toString() {
      return this.set.toString();
    }
  };
  var NotSetTransition = class extends SetTransition {
    static {
      __name(this, "NotSetTransition");
    }
    get transitionType() {
      return Transition.NOT_SET;
    }
    matches(symbol, minVocabSymbol, maxVocabSymbol) {
      return symbol >= minVocabSymbol && symbol <= maxVocabSymbol && !super.matches(symbol, minVocabSymbol, maxVocabSymbol);
    }
    toString() {
      return "~" + super.toString();
    }
  };
  var MapKeyEqualityComparator = class {
    static {
      __name(this, "MapKeyEqualityComparator");
    }
    keyComparator;
    constructor(keyComparator) {
      this.keyComparator = keyComparator;
    }
    hashCode(obj) {
      return this.keyComparator.hashCode(obj.key);
    }
    equals(a, b) {
      return this.keyComparator.equals(a.key, b.key);
    }
  };
  var HashMap = class _HashMap {
    static {
      __name(this, "HashMap");
    }
    backingStore;
    constructor(keyComparer) {
      if (keyComparer instanceof _HashMap) {
        this.backingStore = new HashSet(keyComparer.backingStore);
      } else {
        keyComparer = keyComparer ?? DefaultEqualityComparator.instance;
        this.backingStore = new HashSet(new MapKeyEqualityComparator(keyComparer));
      }
    }
    clear() {
      this.backingStore.clear();
    }
    containsKey(key) {
      return this.backingStore.contains({ key });
    }
    get(key) {
      const bucket = this.backingStore.get({ key });
      if (!bucket) {
        return void 0;
      }
      return bucket.value;
    }
    get isEmpty() {
      return this.backingStore.isEmpty;
    }
    /**
     * Sets the value for a key in the map. If the key is not present in the map, it is added.
     * If the key is present, the value is updated and the old value is returned.
     *
     * @param key The key to set.
     * @param value The value to set.
     *
     * @returns The old value for the key, if present.
     */
    set(key, value) {
      const element = this.backingStore.get({ key, value });
      let result;
      if (!element) {
        this.backingStore.add({ key, value });
      } else {
        result = element.value;
        element.value = value;
      }
      return result;
    }
    /**
     * Sets the value for a key in the map if the key is not already present. Otherwise the value is not changed and
     * the old value is returned.
     *
     * @param key The key to set.
     * @param value The value to set.
     *
     * @returns The current value for the key, if present.
     */
    setIfAbsent(key, value) {
      const element = this.backingStore.get({ key, value });
      let result;
      if (!element) {
        this.backingStore.add({ key, value });
      } else {
        result = element.value;
      }
      return result;
    }
    keys() {
      return this.backingStore.toArray().map((bucket) => {
        return bucket.key;
      });
    }
    values() {
      return this.backingStore.toArray().map((bucket) => {
        return bucket.value;
      });
    }
    get size() {
      return this.backingStore.size;
    }
    hashCode() {
      return this.backingStore.hashCode();
    }
    equals(o) {
      return this.backingStore.equals(o.backingStore);
    }
  };
  var TerminalNode = class {
    static {
      __name(this, "TerminalNode");
    }
    parent = null;
    symbol;
    constructor(symbol) {
      this.symbol = symbol;
    }
    getChild(_i) {
      return null;
    }
    getSymbol() {
      return this.symbol;
    }
    getPayload() {
      return this.symbol;
    }
    getSourceInterval() {
      if (this.symbol === null) {
        return Interval.INVALID_INTERVAL;
      }
      const tokenIndex = this.symbol.tokenIndex;
      return new Interval(tokenIndex, tokenIndex);
    }
    getChildCount() {
      return 0;
    }
    accept(visitor) {
      return visitor.visitTerminal(this);
    }
    getText() {
      return this.symbol?.text ?? "";
    }
    toString() {
      if (this.symbol?.type === Token.EOF) {
        return "<EOF>";
      } else {
        return this.symbol?.text ?? "";
      }
    }
    toStringTree() {
      return this.toString();
    }
  };
  var ErrorNode = class extends TerminalNode {
    static {
      __name(this, "ErrorNode");
    }
    accept(visitor) {
      return visitor.visitErrorNode(this);
    }
  };
  var CommonToken = class _CommonToken {
    static {
      __name(this, "CommonToken");
    }
    /**
     * An empty tuple which is used as the default value of
     * {@link source} for tokens that do not have a source.
     */
    // eslint-disable-next-line @typescript-eslint/naming-convention
    static EMPTY_SOURCE = [null, null];
    /**
     * These properties share a field to reduce the memory footprint of
     * {@link CommonToken}. Tokens created by a {@link CommonTokenFactory} from
     * the same source and input stream share a reference to the same
     * {@link Pair} containing these values.
     */
    source;
    tokenIndex;
    start;
    stop;
    /**
     * This is the backing field for {@link #getType} and {@link #setType}.
     */
    type;
    /**
     * The (one-based) line number on which the 1st character of this token was.
     */
    line;
    /**
     * The zero-based index of the first character position in its line.
     */
    column;
    /**
     * The token's channel.
     */
    channel;
    /**
     * This is the backing field for {@link getText} when the token text is
     * explicitly set in the constructor or via {@link setText}.
     */
    #text;
    constructor(details) {
      this.type = details.type;
      this.source = details.source;
      this.tokenIndex = details.tokenIndex ?? -1;
      this.line = details.line ?? 0;
      this.column = details.column ?? -1;
      this.channel = details.channel ?? Token.DEFAULT_CHANNEL;
      this.start = details.start ?? 0;
      this.stop = details.stop ?? 0;
      this.#text = details.text;
      if (details.line === void 0 && details.source[0] !== null) {
        this.line = details.source[0].line;
      }
      if (details.column === void 0 && details.source[0] !== null) {
        this.column = details.source[0].column;
      }
    }
    /**
     * Constructs a new {@link CommonToken} as a copy of another {@link Token}.
     *
     * If `token` is also a {@link CommonToken} instance, the newly
     * constructed token will share a reference to the {@link #text} field and
     * the {@link Pair} stored in {@link source}. Otherwise, {@link text} will
     * be assigned the result of calling {@link getText}, and {@link source}
     * will be constructed from the result of {@link Token.getTokenSource} and
     * {@link Token#getInputStream}.
     *
     * @param token The token to copy.
     */
    static fromToken(token) {
      const source = [token.tokenSource, token.inputStream];
      return new _CommonToken({
        type: token.type,
        line: token.line,
        tokenIndex: token.tokenIndex,
        column: token.column,
        channel: token.channel,
        start: token.start,
        stop: token.stop,
        text: token.text,
        source
      });
    }
    /**
     * Constructs a new {@link CommonToken} with the specified token type and text.
     *
     * @param type The token type.
     * @param text The text of the token.
     */
    static fromType(type, text) {
      return new _CommonToken({ type, text, source: _CommonToken.EMPTY_SOURCE });
    }
    static fromSource(source, type, channel, start, stop) {
      return new _CommonToken({ type, channel, start, stop, source });
    }
    get tokenSource() {
      return this.source[0];
    }
    get inputStream() {
      return this.source[1];
    }
    set inputStream(input) {
      this.source[1] = input;
    }
    /**
     * Constructs a new {@link CommonToken} as a copy of another {@link Token}.
     *
     * If `oldToken` is also a {@link CommonToken} instance, the newly
     * constructed token will share a reference to the {@link text} field and
     * the {@link Pair} stored in {@link source}. Otherwise, {@link text} will
     * be assigned the result of calling {@link getText}, and {@link source}
     * will be constructed from the result of {@link Token.getTokenSource} and
     * {@link Token.getInputStream}.
     */
    clone() {
      const t = new _CommonToken({
        source: this.source,
        type: this.type,
        channel: this.channel,
        start: this.start,
        stop: this.stop,
        tokenIndex: this.tokenIndex,
        line: this.line,
        column: this.column,
        text: this.#text
      });
      return t;
    }
    toString(recognizer) {
      let channelStr = "";
      if (this.channel > 0) {
        channelStr = ",channel=" + this.channel;
      }
      let text = this.text;
      if (text) {
        text = text.replace(/\n/g, "\\n");
        text = text.replace(/\r/g, "\\r");
        text = text.replace(/\t/g, "\\t");
      } else {
        text = "<no text>";
      }
      let typeString = String(this.type);
      if (recognizer) {
        typeString = recognizer.vocabulary.getDisplayName(this.type) ?? "<unknown>";
      }
      return "[@" + this.tokenIndex + "," + this.start + ":" + this.stop + "='" + text + "',<" + typeString + ">" + channelStr + "," + this.line + ":" + this.column + "]";
    }
    get text() {
      if (this.#text !== void 0) {
        return this.#text;
      }
      const input = this.inputStream;
      if (!input) {
        return void 0;
      }
      const n2 = input.size;
      if (this.start < n2 && this.stop < n2) {
        return input.getTextFromRange(this.start, this.stop);
      }
      return "<EOF>";
    }
    set text(text) {
      this.#text = text;
    }
    // WritableToken implementation
    setText(text) {
      this.#text = text;
    }
    setType(ttype) {
      this.type = ttype;
    }
    setLine(line) {
      this.line = line;
    }
    setCharPositionInLine(pos) {
      this.column = pos;
    }
    setChannel(channel) {
      this.channel = channel;
    }
    setTokenIndex(index2) {
      this.tokenIndex = index2;
    }
  };
  var Trees = class _Trees {
    static {
      __name(this, "Trees");
    }
    /**
     * Print out a whole tree in LISP form. {@link getNodeText} is used on the
     * node payloads to get the text for the nodes.  Detect
     * parse trees and extract data appropriately.
     */
    static toStringTree(tree, ruleNames, recog) {
      ruleNames = ruleNames ?? null;
      if (recog) {
        ruleNames = recog.ruleNames;
      }
      let s = _Trees.getNodeText(tree, ruleNames);
      s = escapeWhitespace(s, false);
      const c = tree.getChildCount();
      if (c === 0) {
        return s;
      }
      let res = "(" + s + " ";
      if (c > 0) {
        s = _Trees.toStringTree(tree.getChild(0), ruleNames);
        res = res.concat(s);
      }
      for (let i = 1; i < c; i++) {
        s = _Trees.toStringTree(tree.getChild(i), ruleNames);
        res = res.concat(" " + s);
      }
      res = res.concat(")");
      return res;
    }
    static getNodeText(t, ruleNames, recog) {
      ruleNames = ruleNames ?? null;
      if (recog) {
        ruleNames = recog.ruleNames;
      }
      if (ruleNames !== null) {
        if (t instanceof ParserRuleContext) {
          const context = t.ruleContext;
          const altNumber = context.getAltNumber();
          if (altNumber !== 0) {
            return ruleNames[t.ruleIndex] + ":" + altNumber;
          }
          return ruleNames[t.ruleIndex];
        } else if (t instanceof ErrorNode) {
          return t.toString();
        } else if (t instanceof TerminalNode) {
          return t.symbol.text;
        }
      }
      const payload = t.getPayload();
      if (isToken(payload)) {
        return payload.text;
      }
      return String(t.getPayload());
    }
    /**
     * Return ordered list of all children of this node
     */
    static getChildren(t) {
      const list = [];
      for (let i = 0; i < t.getChildCount(); i++) {
        list.push(t.getChild(i));
      }
      return list;
    }
    /**
     * Return a list of all ancestors of this node.  The first node of
     * list is the root and the last is the parent of this node.
     */
    static getAncestors(t) {
      if (t.parent === null) {
        return [];
      }
      let ancestors = [];
      let p = t.parent;
      while (p !== null) {
        ancestors = [p].concat(ancestors);
        p = p.parent;
      }
      return ancestors;
    }
    /**
     * Return true if t is u's parent or a node on path to root from u.
     */
    static isAncestorOf(t, u) {
      if (t === null || u === null || t.parent === null) {
        return false;
      }
      let p = u.parent;
      while (p !== null) {
        if (t === p) {
          return true;
        }
        p = p.parent;
      }
      return false;
    }
    static findAllTokenNodes(t, ttype) {
      return _Trees.findAllNodes(t, ttype, true);
    }
    static findAllRuleNodes(t, ruleIndex) {
      return _Trees.findAllNodes(t, ruleIndex, false);
    }
    static findAllNodes(t, index2, findTokens) {
      const nodes = [];
      _Trees.doFindAllNodes(t, index2, findTokens, nodes);
      return nodes;
    }
    static descendants(t) {
      let nodes = [t];
      for (let i = 0; i < t.getChildCount(); i++) {
        nodes = nodes.concat(_Trees.descendants(t.getChild(i)));
      }
      return nodes;
    }
    /**
     * Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex
     * inclusively using post order traversal. Recursive depth-first-search.
     */
    static getRootOfSubtreeEnclosingRegion(t, startTokenIndex, stopTokenIndex) {
      const n2 = t.getChildCount();
      for (let i = 0; i < n2; i++) {
        const child = t.getChild(i);
        const r = this.getRootOfSubtreeEnclosingRegion(child, startTokenIndex, stopTokenIndex);
        if (r !== null) {
          return r;
        }
      }
      if (t instanceof ParserRuleContext) {
        if (startTokenIndex >= t.start.tokenIndex && // is range fully contained in t?
        (t.stop === null || stopTokenIndex <= t.stop.tokenIndex)) {
          return t;
        }
      }
      return null;
    }
    /**
     * Replace any subtree siblings of root that are completely to left
     * or right of lookahead range with a CommonToken(Token.INVALID_TYPE,"...")
     * node. The source interval for t is not altered to suit smaller range!
     *
     * WARNING: destructive to t.
     */
    static stripChildrenOutOfRange(t, root, startIndex, stopIndex) {
      if (t === null) {
        return;
      }
      for (let i = 0; i < t.getChildCount(); i++) {
        const child = t.getChild(i);
        const range = child.getSourceInterval();
        if (t instanceof ParserRuleContext && (range.stop < startIndex || range.start > stopIndex)) {
          if (this.isAncestorOf(child, root)) {
            const abbrev = CommonToken.fromType(Token.INVALID_TYPE, "...");
            t.children[i] = new TerminalNode(abbrev);
          }
        }
      }
    }
    static doFindAllNodes(t, index2, findTokens, nodes) {
      if (findTokens && t instanceof TerminalNode) {
        if (t.symbol?.type === index2) {
          nodes.push(t);
        }
      } else if (!findTokens && t instanceof ParserRuleContext) {
        if (t.ruleIndex === index2) {
          nodes.push(t);
        }
      }
      for (let i = 0; i < t.getChildCount(); i++) {
        _Trees.doFindAllNodes(t.getChild(i), index2, findTokens, nodes);
      }
    }
  };
  var ParserRuleContext = class _ParserRuleContext {
    static {
      __name(this, "ParserRuleContext");
    }
    static empty = new _ParserRuleContext(null);
    start = null;
    stop = null;
    children = [];
    /**
     * What state invoked the rule associated with this context?
     *  The "return address" is the followState of invokingState
     *  If parent is null, this should be -1 this context object represents
     *  the start rule.
     */
    invokingState;
    parent;
    /**
     * A rule context is a record of a single rule invocation. It knows
     * which context invoked it, if any. If there is no parent context, then
     * naturally the invoking state is not valid.  The parent link
     * provides a chain upwards from the current rule invocation to the root
     * of the invocation tree, forming a stack. We actually carry no
     * information about the rule associated with this context (except
     * when parsing). We keep only the state number of the invoking state from
     * the ATN submachine that invoked this. Contrast this with the s
     * pointer inside ParserRuleContext that tracks the current state
     * being "executed" for the current rule.
     *
     * The parent contexts are useful for computing lookahead sets and
     * getting error information.
     *
     * These objects are used during parsing and prediction.
     * For the special case of parsers, we use the subclass
     * ParserRuleContext.
     */
    constructor(parent, invokingStateNumber = -1) {
      this.parent = parent;
      this.invokingState = invokingStateNumber;
    }
    /** Copy a context */
    copyFrom(ctx) {
      this.parent = ctx.parent;
      this.invokingState = ctx.invokingState;
      this.children.slice(0, this.children.length);
      this.start = ctx.start;
      this.stop = ctx.stop;
      if (ctx.children) {
        ctx.children.forEach((child) => {
          if (child instanceof ErrorNode) {
            this.children.push(child);
            child.parent = this;
          }
        });
      }
    }
    // Double dispatch methods for listeners
    enterRule(_listener) {
    }
    exitRule(_listener) {
    }
    addChild(child) {
      this.children.push(child);
      return child;
    }
    /**
     * Used by enterOuterAlt to toss out a RuleContext previously added as
     * we entered a rule. If we have label, we will need to remove
     * generic ruleContext object.
     */
    removeLastChild() {
      this.children.pop();
    }
    addTokenNode(token) {
      const node = new TerminalNode(token);
      this.children.push(node);
      node.parent = this;
      return node;
    }
    addErrorNode(errorNode) {
      errorNode.parent = this;
      this.children.push(errorNode);
      return errorNode;
    }
    getChild(i, type) {
      if (i < 0 || i >= this.children.length) {
        return null;
      }
      if (!type) {
        return this.children[i];
      }
      for (const child of this.children) {
        if (child instanceof type) {
          if (i === 0) {
            return child;
          } else {
            i -= 1;
          }
        }
      }
      return null;
    }
    getToken(ttype, i) {
      if (i < 0 || i >= this.children.length) {
        return null;
      }
      for (const child of this.children) {
        if ("symbol" in child) {
          if (child.symbol?.type === ttype) {
            if (i === 0) {
              return child;
            } else {
              i -= 1;
            }
          }
        }
      }
      return null;
    }
    getTokens(ttype) {
      const tokens = [];
      for (const child of this.children) {
        if ("symbol" in child) {
          if (child.symbol?.type === ttype) {
            tokens.push(child);
          }
        }
      }
      return tokens;
    }
    // XXX: base the child type selection on the rule index, not the class.
    getRuleContext(index2, ctxType) {
      return this.getChild(index2, ctxType);
    }
    // XXX: base the child type selection on the rule index, not the class.
    getRuleContexts(ctxType) {
      const contexts = [];
      for (const child of this.children) {
        if (child instanceof ctxType) {
          contexts.push(child);
        }
      }
      return contexts;
    }
    getChildCount() {
      return this.children.length;
    }
    getSourceInterval() {
      if (this.start === null) {
        return Interval.INVALID_INTERVAL;
      }
      if (this.stop === null || this.stop.tokenIndex < this.start.tokenIndex) {
        return new Interval(this.start.tokenIndex, this.start.tokenIndex - 1);
      }
      return new Interval(this.start.tokenIndex, this.stop.tokenIndex);
    }
    depth() {
      let n2 = 0;
      let p = this;
      while (p !== null) {
        p = p.parent;
        n2 += 1;
      }
      return n2;
    }
    /**
     * A context is empty if there is no invoking state; meaning nobody call
     * current context.
     */
    isEmpty() {
      return this.invokingState === -1;
    }
    get ruleContext() {
      return this;
    }
    get ruleIndex() {
      return -1;
    }
    getPayload() {
      return this;
    }
    getText() {
      if (this.children.length === 0) {
        return "";
      }
      return this.children.map((child) => {
        return child.getText();
      }).join("");
    }
    /**
     * For rule associated with this parse tree internal node, return
     * the outer alternative number used to match the input. Default
     * implementation does not compute nor store this alt num. Create
     * a subclass of ParserRuleContext with backing field and set
     * option contextSuperClass.
     * to set it.
     */
    getAltNumber() {
      return ATN.INVALID_ALT_NUMBER;
    }
    /**
     * Set the outer alternative number for this context node. Default
     * implementation does nothing to avoid backing field overhead for
     * trees that don't need it.  Create
     * a subclass of ParserRuleContext with backing field and set
     * option contextSuperClass.
     */
    setAltNumber(_altNumber) {
    }
    accept(visitor) {
      return visitor.visitChildren(this);
    }
    toStringTree(...args) {
      if (args.length < 2) {
        return Trees.toStringTree(this, null, args[0]);
      }
      return Trees.toStringTree(this, args[0], args[1]);
    }
    toString(ruleNames, stop) {
      ruleNames = ruleNames ?? null;
      stop = stop ?? null;
      let p = this;
      let s = "[";
      while (p !== null && p !== stop) {
        if (ruleNames === null) {
          if (!p.isEmpty()) {
            s += p.invokingState;
          }
        } else {
          const ri = p.ruleIndex;
          const ruleName = ri >= 0 && ri < ruleNames.length ? ruleNames[ri] : "" + ri;
          s += ruleName;
        }
        if (p.parent !== null && (ruleNames !== null || !p.parent.isEmpty())) {
          s += " ";
        }
        p = p.parent;
      }
      s += "]";
      return s;
    }
  };
  var ArrayPredictionContext = class _ArrayPredictionContext extends PredictionContext {
    static {
      __name(this, "ArrayPredictionContext");
    }
    parents = [];
    returnStates = [];
    constructor(parents, returnStates) {
      super(PredictionContext.calculateHashCodeList(parents, returnStates));
      this.parents = parents;
      this.returnStates = returnStates;
      return this;
    }
    isEmpty() {
      return this.returnStates[0] === PredictionContext.EMPTY_RETURN_STATE;
    }
    get length() {
      return this.returnStates.length;
    }
    getParent(index2) {
      return this.parents[index2];
    }
    getReturnState(index2) {
      return this.returnStates[index2];
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _ArrayPredictionContext) || this.hashCode() !== other.hashCode()) {
        return false;
      }
      return equalNumberArrays(this.returnStates, other.returnStates) && equalArrays(this.parents, other.parents);
    }
    toString() {
      if (this.isEmpty()) {
        return "[]";
      }
      const entries = [];
      for (let i = 0; i < this.returnStates.length; i++) {
        if (this.returnStates[i] === PredictionContext.EMPTY_RETURN_STATE) {
          entries.push("$");
          continue;
        }
        entries.push(this.returnStates[i].toString());
        if (this.parents[i]) {
          entries.push(this.parents[i].toString());
        } else {
          entries.push("null");
        }
      }
      return `[${entries.join(", ")}]`;
    }
  };
  var createSingletonPredictionContext = /* @__PURE__ */ __name((parent, returnState) => {
    if (returnState === PredictionContext.EMPTY_RETURN_STATE && parent === null) {
      return EmptyPredictionContext.instance;
    } else {
      return new SingletonPredictionContext(parent, returnState);
    }
  }, "createSingletonPredictionContext");
  var predictionContextFromRuleContext = /* @__PURE__ */ __name((atn, outerContext) => {
    if (!outerContext) {
      outerContext = ParserRuleContext.empty;
    }
    if (!outerContext.parent || outerContext === ParserRuleContext.empty) {
      return EmptyPredictionContext.instance;
    }
    const parent = predictionContextFromRuleContext(atn, outerContext.parent);
    const state = atn.states[outerContext.invokingState];
    const transition = state.transitions[0];
    return createSingletonPredictionContext(parent, transition.followState.stateNumber);
  }, "predictionContextFromRuleContext");
  var getCachedPredictionContext = /* @__PURE__ */ __name((context, contextCache, visited) => {
    if (context.isEmpty()) {
      return context;
    }
    let existing = visited.get(context);
    if (existing) {
      return existing;
    }
    existing = contextCache.get(context);
    if (existing) {
      visited.set(context, existing);
      return existing;
    }
    let changed = false;
    let parents = [];
    for (let i = 0; i < parents.length; i++) {
      const parent = getCachedPredictionContext(context.getParent(i), contextCache, visited);
      if (changed || parent !== context.getParent(i)) {
        if (!changed) {
          parents = [];
          for (let j = 0; j < context.length; j++) {
            parents[j] = context.getParent(j);
          }
          changed = true;
        }
        parents[i] = parent;
      }
    }
    if (!changed) {
      contextCache.add(context);
      visited.set(context, context);
      return context;
    }
    let updated;
    if (parents.length === 0) {
      updated = EmptyPredictionContext.instance;
    } else if (parents.length === 1) {
      updated = createSingletonPredictionContext(parents[0] ?? void 0, context.getReturnState(0));
    } else {
      updated = new ArrayPredictionContext(parents, context.returnStates);
    }
    contextCache.add(updated);
    visited.set(updated, updated);
    visited.set(context, updated);
    return updated;
  }, "getCachedPredictionContext");
  var merge = /* @__PURE__ */ __name((a, b, rootIsWildcard, mergeCache) => {
    if (a === b || a.equals(b)) {
      return a;
    }
    if (a instanceof SingletonPredictionContext && b instanceof SingletonPredictionContext) {
      return mergeSingletons(a, b, rootIsWildcard, mergeCache);
    }
    if (rootIsWildcard) {
      if (a instanceof EmptyPredictionContext) {
        return a;
      }
      if (b instanceof EmptyPredictionContext) {
        return b;
      }
    }
    if (a instanceof SingletonPredictionContext) {
      a = new ArrayPredictionContext([a.parent], [a.returnState]);
    }
    if (b instanceof SingletonPredictionContext) {
      b = new ArrayPredictionContext([b.parent], [b.returnState]);
    }
    return mergeArrays(a, b, rootIsWildcard, mergeCache);
  }, "merge");
  var mergeArrays = /* @__PURE__ */ __name((a, b, rootIsWildcard, mergeCache) => {
    if (mergeCache) {
      let previous = mergeCache.get(a, b);
      if (previous) {
        return previous;
      }
      previous = mergeCache.get(b, a);
      if (previous) {
        return previous;
      }
    }
    let i = 0;
    let j = 0;
    let k = 0;
    let mergedReturnStates = new Array(a.returnStates.length + b.returnStates.length).fill(0);
    let mergedParents = new Array(a.returnStates.length + b.returnStates.length).fill(null);
    while (i < a.returnStates.length && j < b.returnStates.length) {
      const aParent = a.parents[i];
      const bParent = b.parents[j];
      if (a.returnStates[i] === b.returnStates[j]) {
        const payload = a.returnStates[i];
        const bothDollars = payload === PredictionContext.EMPTY_RETURN_STATE && aParent === null && bParent === null;
        const axAx = aParent !== null && bParent !== null && aParent === bParent;
        if (bothDollars || axAx) {
          mergedParents[k] = aParent;
          mergedReturnStates[k] = payload;
        } else {
          mergedParents[k] = merge(aParent, bParent, rootIsWildcard, mergeCache);
          mergedReturnStates[k] = payload;
        }
        i += 1;
        j += 1;
      } else if (a.returnStates[i] < b.returnStates[j]) {
        mergedParents[k] = aParent;
        mergedReturnStates[k] = a.returnStates[i];
        i += 1;
      } else {
        mergedParents[k] = bParent;
        mergedReturnStates[k] = b.returnStates[j];
        j += 1;
      }
      k += 1;
    }
    if (i < a.returnStates.length) {
      for (let p = i; p < a.returnStates.length; p++) {
        mergedParents[k] = a.parents[p];
        mergedReturnStates[k] = a.returnStates[p];
        k += 1;
      }
    } else {
      for (let p = j; p < b.returnStates.length; p++) {
        mergedParents[k] = b.parents[p];
        mergedReturnStates[k] = b.returnStates[p];
        k += 1;
      }
    }
    if (k < mergedParents.length) {
      if (k === 1) {
        const aNew = createSingletonPredictionContext(mergedParents[0] ?? void 0, mergedReturnStates[0]);
        if (mergeCache !== null) {
          mergeCache.set(a, b, aNew);
        }
        return aNew;
      }
      mergedParents = mergedParents.slice(0, k);
      mergedReturnStates = mergedReturnStates.slice(0, k);
    }
    const merged = new ArrayPredictionContext(mergedParents, mergedReturnStates);
    if (merged.equals(a)) {
      if (mergeCache !== null) {
        mergeCache.set(a, b, a);
      }
      if (PredictionContext.traceATNSimulator) {
        console.log("mergeArrays a=" + a + ",b=" + b + " -> a");
      }
      return a;
    }
    if (merged.equals(b)) {
      if (mergeCache !== null) {
        mergeCache.set(a, b, b);
      }
      return b;
    }
    combineCommonParents(mergedParents);
    if (mergeCache !== null) {
      mergeCache.set(a, b, merged);
    }
    if (PredictionContext.traceATNSimulator) {
      console.log("mergeArrays a=" + a + ",b=" + b + " -> " + merged);
    }
    return merged;
  }, "mergeArrays");
  var combineCommonParents = /* @__PURE__ */ __name((parents) => {
    const uniqueParents = new HashMap(ObjectEqualityComparator.instance);
    for (const parent of parents) {
      if (parent) {
        if (!uniqueParents.containsKey(parent)) {
          uniqueParents.set(parent, parent);
        }
      }
    }
    for (let q = 0; q < parents.length; q++) {
      if (parents[q]) {
        parents[q] = uniqueParents.get(parents[q]) ?? null;
      }
    }
  }, "combineCommonParents");
  var mergeSingletons = /* @__PURE__ */ __name((a, b, rootIsWildcard, mergeCache) => {
    if (mergeCache !== null) {
      let previous = mergeCache.get(a, b);
      if (previous !== null) {
        return previous;
      }
      previous = mergeCache.get(b, a);
      if (previous !== null) {
        return previous;
      }
    }
    const rootMerge = mergeRoot(a, b, rootIsWildcard);
    if (rootMerge !== null) {
      if (mergeCache !== null) {
        mergeCache.set(a, b, rootMerge);
      }
      return rootMerge;
    }
    if (a.returnState === b.returnState) {
      const parent = merge(a.parent, b.parent, rootIsWildcard, mergeCache);
      if (parent === a.parent) {
        return a;
      }
      if (parent === b.parent) {
        return b;
      }
      const spc = createSingletonPredictionContext(parent, a.returnState);
      if (mergeCache !== null) {
        mergeCache.set(a, b, spc);
      }
      return spc;
    } else {
      let singleParent = null;
      if (a === b || a.parent !== null && a.parent.equals(b.parent)) {
        singleParent = a.parent;
      }
      if (singleParent !== null) {
        const payloads2 = [a.returnState, b.returnState];
        if (a.returnState > b.returnState) {
          payloads2[0] = b.returnState;
          payloads2[1] = a.returnState;
        }
        const parents2 = [singleParent, singleParent];
        const apc = new ArrayPredictionContext(parents2, payloads2);
        if (mergeCache !== null) {
          mergeCache.set(a, b, apc);
        }
        return apc;
      }
      const payloads = [a.returnState, b.returnState];
      let parents = [a.parent, b.parent];
      if (a.returnState > b.returnState) {
        payloads[0] = b.returnState;
        payloads[1] = a.returnState;
        parents = [b.parent, a.parent];
      }
      const aNew = new ArrayPredictionContext(parents, payloads);
      if (mergeCache !== null) {
        mergeCache.set(a, b, aNew);
      }
      return aNew;
    }
  }, "mergeSingletons");
  var mergeRoot = /* @__PURE__ */ __name((a, b, rootIsWildcard) => {
    if (rootIsWildcard) {
      if (a === EmptyPredictionContext.instance || b === EmptyPredictionContext.instance) {
        return EmptyPredictionContext.instance;
      }
    } else {
      if (a === EmptyPredictionContext.instance && b === EmptyPredictionContext.instance) {
        return EmptyPredictionContext.instance;
      }
      if (a === EmptyPredictionContext.instance) {
        const payloads = [
          b.returnState,
          PredictionContext.EMPTY_RETURN_STATE
        ];
        const parents = [b.parent, null];
        return new ArrayPredictionContext(parents, payloads);
      }
      if (b === EmptyPredictionContext.instance) {
        const payloads = [a.returnState, PredictionContext.EMPTY_RETURN_STATE];
        const parents = [a.parent, null];
        return new ArrayPredictionContext(parents, payloads);
      }
    }
    return null;
  }, "mergeRoot");
  var LL1Analyzer = class _LL1Analyzer {
    constructor(atn) {
      this.atn = atn;
    }
    static {
      __name(this, "LL1Analyzer");
    }
    /**
     * Special value added to the lookahead sets to indicate that we hit
     * a predicate during analysis if `seeThruPreds==false`.
     */
    static hitPredicate = Token.INVALID_TYPE;
    /**
     * Calculates the SLL(1) expected lookahead set for each outgoing transition
     * of an {@link ATNState}. The returned array has one element for each
     * outgoing transition in `s`. If the closure from transition
     * _i_ leads to a semantic predicate before matching a symbol, the
     * element at index *i* of the result will be `undefined`.
     *
     * @param s the ATN state
     * @returns the expected symbols for each outgoing transition of `s`.
     */
    getDecisionLookahead(s) {
      const count = s.transitions.length;
      const look = new Array(count);
      for (let alt = 0; alt < count; alt++) {
        const set = new IntervalSet();
        const lookBusy = new HashSet();
        this.doLook(
          s.transitions[alt].target,
          void 0,
          EmptyPredictionContext.instance,
          set,
          lookBusy,
          new BitSet(),
          false,
          false
        );
        if (set.length > 0 && !set.contains(_LL1Analyzer.hitPredicate)) {
          look[alt] = set;
        }
      }
      return look;
    }
    /**
     * Compute set of tokens that can follow `s` in the ATN in the
     * specified `ctx`.
     *
     * If `ctx` is `null` and the end of the rule containing
     * `s` is reached, {@link Token//EPSILON} is added to the result set.
     * If `ctx` is not `null` and the end of the outermost rule is
     * reached, {@link Token//EOF} is added to the result set.
     *
     * @param s the ATN state
     * @param stopState the ATN state to stop at. This can be a
     * {@link BlockEndState} to detect epsilon paths through a closure.
     * @param ctx the complete parser context, or `null` if the context
     * should be ignored
     *
     * @returns The set of tokens that can follow `s` in the ATN in the
     * specified `ctx`.
     */
    look(s, stopState, ctx) {
      const r = new IntervalSet();
      const lookContext = ctx ? predictionContextFromRuleContext(this.atn, ctx) : null;
      this.doLook(s, stopState, lookContext, r, new HashSet(), new BitSet(), true, true);
      return r;
    }
    /**
     * Compute set of tokens that can follow `s` in the ATN in the
     * specified `ctx`.
     *
     * If `ctx` is `null` and `stopState` or the end of the
     * rule containing `s` is reached, {@link Token//EPSILON} is added to
     * the result set. If `ctx` is not `null` and `addEOF` is
     * `true` and `stopState` or the end of the outermost rule is
     * reached, {@link Token//EOF} is added to the result set.
     *
     * @param s the ATN state.
     * @param stopState the ATN state to stop at. This can be a
     * {@link BlockEndState} to detect epsilon paths through a closure.
     * @param ctx The outer context, or `null` if the outer context should
     * not be used.
     * @param look The result lookahead set.
     * @param lookBusy A set used for preventing epsilon closures in the ATN
     * from causing a stack overflow. Outside code should pass
     * `new CustomizedSet<ATNConfig>` for this argument.
     * @param calledRuleStack A set used for preventing left recursion in the
     * ATN from causing a stack overflow. Outside code should pass
     * `new BitSet()` for this argument.
     * @param seeThruPreds `true` to true semantic predicates as
     * implicitly `true` and "see through them", otherwise `false`
     * to treat semantic predicates as opaque and add {@link hitPredicate} to the
     * result if one is encountered.
     * @param addEOF Add {@link Token//EOF} to the result if the end of the
     * outermost context is reached. This parameter has no effect if `ctx`
     * is `null`.
     */
    doLook(s, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) {
      const c = ATNConfig.createWithContext(s, 0, ctx);
      if (lookBusy.get(c)) {
        return;
      }
      lookBusy.add(c);
      if (s === stopState) {
        if (!ctx) {
          look.addOne(Token.EPSILON);
          return;
        } else if (ctx.isEmpty() && addEOF) {
          look.addOne(Token.EOF);
          return;
        }
      }
      if (s.constructor.stateType === ATNState.RULE_STOP) {
        if (!ctx) {
          look.addOne(Token.EPSILON);
          return;
        } else if (ctx.isEmpty() && addEOF) {
          look.addOne(Token.EOF);
          return;
        }
        if (ctx !== EmptyPredictionContext.instance) {
          const removed = calledRuleStack.get(s.ruleIndex);
          try {
            calledRuleStack.clear(s.ruleIndex);
            for (let i = 0; i < ctx.length; i++) {
              const returnState = this.atn.states[ctx.getReturnState(i)];
              this.doLook(
                returnState,
                stopState,
                ctx.getParent(i),
                look,
                lookBusy,
                calledRuleStack,
                seeThruPreds,
                addEOF
              );
            }
          } finally {
            if (removed) {
              calledRuleStack.set(s.ruleIndex);
            }
          }
          return;
        }
      }
      for (const t of s.transitions) {
        switch (t.transitionType) {
          case Transition.RULE: {
            if (calledRuleStack.get(t.target.ruleIndex)) {
              continue;
            }
            const newContext = createSingletonPredictionContext(
              ctx ?? void 0,
              t.followState.stateNumber
            );
            try {
              calledRuleStack.set(t.target.ruleIndex);
              this.doLook(
                t.target,
                stopState,
                newContext,
                look,
                lookBusy,
                calledRuleStack,
                seeThruPreds,
                addEOF
              );
            } finally {
              calledRuleStack.clear(t.target.ruleIndex);
            }
            break;
          }
          case Transition.PREDICATE:
          case Transition.PRECEDENCE: {
            if (seeThruPreds) {
              this.doLook(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
            } else {
              look.addOne(_LL1Analyzer.hitPredicate);
            }
            break;
          }
          case Transition.WILDCARD: {
            look.addRange(Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
            break;
          }
          default: {
            if (t.isEpsilon) {
              this.doLook(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
            } else {
              let set = t.label;
              if (set) {
                if (t instanceof NotSetTransition) {
                  set = set.complement(Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
                }
                look.addSet(set);
              }
            }
            break;
          }
        }
      }
    }
  };
  var ATN = class {
    static {
      __name(this, "ATN");
    }
    static INVALID_ALT_NUMBER = 0;
    /** Represents the type of recognizer an ATN applies to */
    static LEXER = 0;
    static PARSER = 1;
    /**
     * Used for runtime deserialization of ATNs from strings
     * The type of the ATN.
     */
    grammarType;
    /** The maximum value for any symbol recognized by a transition in the ATN. */
    maxTokenType;
    states = [];
    /**
     * Each subrule/rule is a decision point and we must track them so we
     * can go back later and build DFA predictors for them.  This includes
     * all the rules, subrules, optional blocks, ()+, ()* etc...
     */
    decisionToState = [];
    /** Maps from rule index to starting state number. */
    ruleToStartState = [];
    // Initialized by the ATN deserializer.
    /** Maps from rule index to stop state number. */
    ruleToStopState = [];
    // Initialized by the ATN deserializer.
    modeNameToStartState = /* @__PURE__ */ new Map();
    /**
     * For lexer ATNs, this maps the rule index to the resulting token type.
     * For parser ATNs, this maps the rule index to the generated bypass token
     * type if the {@link ATNDeserializationOptions//isGenerateRuleBypassTransitions}
     * deserialization option was specified; otherwise, this is `null`
     */
    ruleToTokenType = [];
    // Initialized by the ATN deserializer.
    /**
     * For lexer ATNs, this is an array of {@link LexerAction} objects which may
     * be referenced by action transitions in the ATN
     */
    lexerActions = [];
    modeToStartState = [];
    analyzer;
    constructor(grammarType, maxTokenType) {
      this.grammarType = grammarType;
      this.maxTokenType = maxTokenType;
      this.analyzer = new LL1Analyzer(this);
    }
    /**
     * Compute the set of valid tokens that can occur starting in state `s`.
     * If `ctx` is null, the set of tokens will not include what can follow
     * the rule surrounding `s`. In other words, the set will be
     * restricted to tokens reachable staying within `s`'s rule.
     */
    nextTokens(atnState, ctx) {
      if (!ctx && atnState.nextTokenWithinRule) {
        return atnState.nextTokenWithinRule;
      }
      const next = this.analyzer.look(atnState, void 0, ctx);
      if (!ctx) {
        atnState.nextTokenWithinRule = next;
      }
      return next;
    }
    addState(state) {
      if (state) {
        state.stateNumber = this.states.length;
      }
      this.states.push(state);
    }
    removeState(state) {
      this.states[state.stateNumber] = null;
    }
    defineDecisionState(s) {
      this.decisionToState.push(s);
      s.decision = this.decisionToState.length - 1;
      return s.decision;
    }
    getDecisionState(decision) {
      if (this.decisionToState.length === 0) {
        return null;
      } else {
        return this.decisionToState[decision];
      }
    }
    getNumberOfDecisions() {
      return this.decisionToState.length;
    }
    /**
     * Computes the set of input symbols which could follow ATN state number
     * `stateNumber` in the specified full `context`. This method
     * considers the complete parser context, but does not evaluate semantic
     * predicates (i.e. all predicates encountered during the calculation are
     * assumed true). If a path in the ATN exists from the starting state to the
     * {@link RuleStopState} of the outermost context without matching any
     * symbols, {@link Token//EOF} is added to the returned set.
     *
     * If `context` is `null`, it is treated as
     * {@link ParserRuleContext//EMPTY}.
     *
     * @param stateNumber the ATN state number
     * @param context the full parse context
     *
     * @returns {IntervalSet} The set of potentially valid input symbols which could follow the
     * specified state in the specified context.
     *
     * @throws IllegalArgumentException if the ATN does not contain a state with
     * number `stateNumber`
     */
    getExpectedTokens(stateNumber, context) {
      if (stateNumber < 0 || stateNumber >= this.states.length) {
        throw new Error("Invalid state number.");
      }
      const s = this.states[stateNumber];
      let following = this.nextTokens(s);
      if (!following.contains(Token.EPSILON)) {
        return following;
      }
      let ctx = context;
      const expected = new IntervalSet();
      expected.addSet(following);
      expected.removeOne(Token.EPSILON);
      while (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) {
        const invokingState = this.states[ctx.invokingState];
        const rt = invokingState.transitions[0];
        following = this.nextTokens(rt.followState);
        expected.addSet(following);
        expected.removeOne(Token.EPSILON);
        ctx = ctx.parent;
      }
      if (following.contains(Token.EPSILON)) {
        expected.addOne(Token.EOF);
      }
      return expected;
    }
  };
  var KeyTypeEqualityComparer = class _KeyTypeEqualityComparer {
    static {
      __name(this, "KeyTypeEqualityComparer");
    }
    static instance = new _KeyTypeEqualityComparer();
    hashCode(config) {
      let hashCode = 7;
      hashCode = 31 * hashCode + config.state.stateNumber;
      hashCode = 31 * hashCode + config.alt;
      hashCode = 31 * hashCode + config.semanticContext.hashCode();
      return hashCode;
    }
    equals(a, b) {
      if (a === b) {
        return true;
      }
      return a.state.stateNumber === b.state.stateNumber && a.alt === b.alt && a.semanticContext.equals(b.semanticContext);
    }
  };
  var ATNConfigSet = class {
    static {
      __name(this, "ATNConfigSet");
    }
    /**
     * The reason that we need this is because we don't want the hash map to use
     * the standard hash code and equals. We need all configurations with the
     * same
     * `(s,i,_,semctx)` to be equal. Unfortunately, this key effectively
     * doubles
     * the number of objects associated with ATNConfigs. The other solution is
     * to
     * use a hash table that lets us specify the equals/hashCode operation.
     * All configs but hashed by (s, i, _, pi) not including context. Wiped out
     * when we go readonly as this set becomes a DFA state
     */
    configLookup = new HashSet(KeyTypeEqualityComparer.instance);
    // Track the elements as they are added to the set; supports get(i).
    configs = [];
    uniqueAlt = 0;
    /**
     * Used in parser and lexer. In lexer, it indicates we hit a pred
     * while computing a closure operation. Don't make a DFA state from this
     */
    hasSemanticContext = false;
    dipsIntoOuterContext = false;
    /**
     * Indicates that this configuration set is part of a full context
     * LL prediction. It will be used to determine how to merge $. With SLL
     * it's a wildcard whereas it is not for LL context merge
     */
    fullCtx = false;
    /**
     * Indicates that the set of configurations is read-only. Do not
     * allow any code to manipulate the set; DFA states will point at
     * the sets and they must not change. This does not protect the other
     * fields; in particular, conflictingAlts is set after
     * we've made this readonly
     */
    readOnly = false;
    conflictingAlts = null;
    /**
     * Tracks the first config that has a rule stop state. Avoids frequent linear search for that, when adding
     * a DFA state in the lexer ATN simulator.
     */
    firstStopState;
    #cachedHashCode = -1;
    constructor(fullCtxOrOldSet) {
      if (fullCtxOrOldSet !== void 0) {
        if (typeof fullCtxOrOldSet === "boolean") {
          this.fullCtx = fullCtxOrOldSet ?? true;
        } else {
          const old = fullCtxOrOldSet;
          this.addAll(old.configs);
          this.uniqueAlt = old.uniqueAlt;
          this.conflictingAlts = old.conflictingAlts;
          this.hasSemanticContext = old.hasSemanticContext;
          this.dipsIntoOuterContext = old.dipsIntoOuterContext;
        }
      }
    }
    [Symbol.iterator]() {
      return this.configs[Symbol.iterator]();
    }
    /**
     * Adding a new config means merging contexts with existing configs for
     * `(s, i, pi, _)`, where `s` is the {@link ATNConfig.state}, `i` is the {@link ATNConfig.alt}, and
     * `pi` is the {@link ATNConfig.semanticContext}. We use `(s,i,pi)` as key.
     *
     * This method updates {@link dipsIntoOuterContext} and
     * {@link hasSemanticContext} when necessary.
     */
    add(config, mergeCache = null) {
      if (this.readOnly) {
        throw new Error("This set is readonly");
      }
      if (!this.firstStopState && config.state.constructor.stateType === ATNState.RULE_STOP) {
        this.firstStopState = config;
      }
      this.hasSemanticContext ||= config.semanticContext !== SemanticContext.NONE;
      this.dipsIntoOuterContext ||= config.reachesIntoOuterContext;
      const existing = this.configLookup.getOrAdd(config);
      if (existing === config) {
        this.#cachedHashCode = -1;
        this.configs.push(config);
        return;
      }
      const rootIsWildcard = !this.fullCtx;
      const merged = merge(existing.context, config.context, rootIsWildcard, mergeCache);
      existing.reachesIntoOuterContext ||= config.reachesIntoOuterContext;
      existing.precedenceFilterSuppressed ||= config.precedenceFilterSuppressed;
      existing.context = merged;
    }
    /** Return a List holding list of configs */
    get elements() {
      return this.configs;
    }
    /**
     * Gets the complete set of represented alternatives for the configuration set.
     *
     * @returns the set of represented alternatives in this configuration set
     */
    getAlts() {
      const alts = new BitSet();
      for (const config of this.configs) {
        alts.set(config.alt);
      }
      return alts;
    }
    getPredicates() {
      const preds = [];
      for (const config of this.configs) {
        if (config.semanticContext !== SemanticContext.NONE) {
          preds.push(config.semanticContext);
        }
      }
      return preds;
    }
    getStates() {
      const states = new HashSet();
      for (const config of this.configs) {
        states.add(config.state);
      }
      return states;
    }
    optimizeConfigs(interpreter) {
      if (this.readOnly) {
        throw new Error("This set is readonly");
      }
      if (this.configLookup.size === 0) {
        return;
      }
      for (const config of this.configs) {
        config.context = interpreter.getCachedContext(config.context);
      }
    }
    addAll(coll) {
      for (const config of coll) {
        this.add(config);
      }
      return false;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (this.fullCtx === other.fullCtx && this.uniqueAlt === other.uniqueAlt && this.conflictingAlts === other.conflictingAlts && this.hasSemanticContext === other.hasSemanticContext && this.dipsIntoOuterContext === other.dipsIntoOuterContext && equalArrays(this.configs, other.configs)) {
        return true;
      }
      return false;
    }
    hashCode() {
      if (this.#cachedHashCode === -1) {
        this.#cachedHashCode = this.computeHashCode();
      }
      return this.#cachedHashCode;
    }
    get length() {
      return this.configs.length;
    }
    isEmpty() {
      return this.configs.length === 0;
    }
    contains(item) {
      if (this.configLookup === null) {
        throw new Error("This method is not implemented for readonly sets.");
      }
      return this.configLookup.contains(item);
    }
    containsFast(item) {
      if (this.configLookup === null) {
        throw new Error("This method is not implemented for readonly sets.");
      }
      return this.configLookup.contains(item);
    }
    clear() {
      if (this.readOnly) {
        throw new Error("This set is readonly");
      }
      this.configs = [];
      this.#cachedHashCode = -1;
      this.configLookup = new HashSet(KeyTypeEqualityComparer.instance);
    }
    setReadonly(readOnly) {
      this.readOnly = readOnly;
      if (readOnly) {
        this.configLookup = null;
      }
    }
    toString() {
      return arrayToString(this.configs) + (this.hasSemanticContext ? ",hasSemanticContext=" + this.hasSemanticContext : "") + (this.uniqueAlt !== ATN.INVALID_ALT_NUMBER ? ",uniqueAlt=" + this.uniqueAlt : "") + (this.conflictingAlts !== null ? ",conflictingAlts=" + this.conflictingAlts : "") + (this.dipsIntoOuterContext ? ",dipsIntoOuterContext" : "");
    }
    computeHashCode() {
      let hash = MurmurHash.initialize();
      this.configs.forEach((config) => {
        hash = MurmurHash.update(hash, config.hashCode());
      });
      hash = MurmurHash.finish(hash, this.configs.length);
      return hash;
    }
  };
  var BasicState = class extends ATNState {
    static {
      __name(this, "BasicState");
    }
    static stateType = ATNState.BASIC;
  };
  var DecisionState = class extends ATNState {
    static {
      __name(this, "DecisionState");
    }
    decision = -1;
    nonGreedy = false;
  };
  var BlockStartState = class extends DecisionState {
    static {
      __name(this, "BlockStartState");
    }
    endState;
  };
  var BlockEndState = class extends ATNState {
    static {
      __name(this, "BlockEndState");
    }
    static stateType = ATNState.BLOCK_END;
    startState;
  };
  var LoopEndState = class extends ATNState {
    static {
      __name(this, "LoopEndState");
    }
    static stateType = ATNState.LOOP_END;
    loopBackState;
  };
  var RuleStartState = class extends ATNState {
    static {
      __name(this, "RuleStartState");
    }
    static stateType = ATNState.RULE_START;
    stopState;
    isLeftRecursiveRule = false;
  };
  var RuleStopState = class extends ATNState {
    static {
      __name(this, "RuleStopState");
    }
    static stateType = ATNState.RULE_STOP;
  };
  var TokensStartState = class extends DecisionState {
    static {
      __name(this, "TokensStartState");
    }
    static stateType = ATNState.TOKEN_START;
  };
  var PlusLoopbackState = class extends DecisionState {
    static {
      __name(this, "PlusLoopbackState");
    }
    static stateType = ATNState.PLUS_LOOP_BACK;
  };
  var StarLoopbackState = class extends ATNState {
    static {
      __name(this, "StarLoopbackState");
    }
    static stateType = ATNState.STAR_LOOP_BACK;
  };
  var StarLoopEntryState = class extends DecisionState {
    static {
      __name(this, "StarLoopEntryState");
    }
    static stateType = ATNState.STAR_LOOP_ENTRY;
    // This is always set during ATN deserialization
    loopBackState;
    /**
     * Indicates whether this state can benefit from a precedence DFA during SLL
     * decision making.
     *
     * This is a computed property that is calculated during ATN deserialization
     * and stored for use in {@link ParserATNSimulator} and
     * {@link ParserInterpreter}.
     *
     * @see `DFA.isPrecedenceDfa`
     */
    precedenceRuleDecision = false;
  };
  var PlusBlockStartState = class extends BlockStartState {
    static {
      __name(this, "PlusBlockStartState");
    }
    static stateType = ATNState.PLUS_BLOCK_START;
    loopBackState;
  };
  var StarBlockStartState = class extends BlockStartState {
    static {
      __name(this, "StarBlockStartState");
    }
    static stateType = ATNState.STAR_BLOCK_START;
  };
  var BasicBlockStartState = class extends BlockStartState {
    static {
      __name(this, "BasicBlockStartState");
    }
    static stateType = ATNState.BLOCK_START;
  };
  var AtomTransition = class extends Transition {
    static {
      __name(this, "AtomTransition");
    }
    /** The token type or character value; or, signifies special label. */
    labelValue;
    #label;
    constructor(target, label) {
      super(target);
      this.labelValue = label;
      this.#label = IntervalSet.of(label, label);
    }
    get label() {
      return this.#label;
    }
    get transitionType() {
      return Transition.ATOM;
    }
    matches(symbol) {
      return this.labelValue === symbol;
    }
    toString() {
      return this.labelValue.toString();
    }
  };
  var RuleTransition = class extends Transition {
    static {
      __name(this, "RuleTransition");
    }
    ruleIndex;
    precedence;
    followState;
    constructor(ruleStart, ruleIndex, precedence, followState) {
      super(ruleStart);
      this.ruleIndex = ruleIndex;
      this.precedence = precedence;
      this.followState = followState;
    }
    get isEpsilon() {
      return true;
    }
    get transitionType() {
      return Transition.RULE;
    }
    matches(_symbol, _minVocabSymbol, _maxVocabSymbol) {
      return false;
    }
  };
  var RangeTransition = class extends Transition {
    static {
      __name(this, "RangeTransition");
    }
    start;
    stop;
    #label = new IntervalSet();
    constructor(target, start, stop) {
      super(target);
      this.start = start;
      this.stop = stop;
      this.#label.addRange(start, stop);
    }
    get label() {
      return this.#label;
    }
    get transitionType() {
      return Transition.RANGE;
    }
    matches(symbol, _minVocabSymbol, _maxVocabSymbol) {
      return symbol >= this.start && symbol <= this.stop;
    }
    toString() {
      return "'" + String.fromCharCode(this.start) + "'..'" + String.fromCharCode(this.stop) + "'";
    }
  };
  var ActionTransition = class extends Transition {
    static {
      __name(this, "ActionTransition");
    }
    ruleIndex;
    actionIndex;
    isCtxDependent;
    constructor(target, ruleIndex, actionIndex, isCtxDependent) {
      super(target);
      this.ruleIndex = ruleIndex;
      this.actionIndex = actionIndex ?? -1;
      this.isCtxDependent = isCtxDependent ?? false;
    }
    get isEpsilon() {
      return true;
    }
    get transitionType() {
      return Transition.ACTION;
    }
    matches(_symbol, _minVocabSymbol, _maxVocabSymbol) {
      return false;
    }
    toString() {
      return "action_" + this.ruleIndex + ":" + this.actionIndex;
    }
  };
  var EpsilonTransition = class extends Transition {
    static {
      __name(this, "EpsilonTransition");
    }
    #outermostPrecedenceReturn;
    constructor(target, outermostPrecedenceReturn = -1) {
      super(target);
      this.#outermostPrecedenceReturn = outermostPrecedenceReturn;
    }
    /**
     * @returns the rule index of a precedence rule for which this transition is
     * returning from, where the precedence value is 0; otherwise, -1.
     *
     * @see ATNConfig.isPrecedenceFilterSuppressed()
     * @see ParserATNSimulator.applyPrecedenceFilter(ATNConfigSet)
     * @since 4.4.1
     */
    get outermostPrecedenceReturn() {
      return this.#outermostPrecedenceReturn;
    }
    get isEpsilon() {
      return true;
    }
    get transitionType() {
      return Transition.EPSILON;
    }
    matches() {
      return false;
    }
    toString() {
      return "epsilon";
    }
  };
  var WildcardTransition = class extends Transition {
    static {
      __name(this, "WildcardTransition");
    }
    get transitionType() {
      return Transition.WILDCARD;
    }
    matches(symbol, minVocabSymbol, maxVocabSymbol) {
      return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;
    }
    toString() {
      return ".";
    }
  };
  var AbstractPredicateTransition = class extends Transition {
    static {
      __name(this, "AbstractPredicateTransition");
    }
    constructor(target) {
      super(target);
    }
  };
  var PredicateTransition = class extends AbstractPredicateTransition {
    static {
      __name(this, "PredicateTransition");
    }
    ruleIndex;
    predIndex;
    isCtxDependent;
    // e.g., $i ref in pred
    constructor(target, ruleIndex, predIndex, isCtxDependent) {
      super(target);
      this.ruleIndex = ruleIndex;
      this.predIndex = predIndex;
      this.isCtxDependent = isCtxDependent;
    }
    get isEpsilon() {
      return true;
    }
    matches(_symbol, _minVocabSymbol, _maxVocabSymbol) {
      return false;
    }
    get transitionType() {
      return Transition.PREDICATE;
    }
    getPredicate() {
      return new SemanticContext.Predicate(this.ruleIndex, this.predIndex, this.isCtxDependent);
    }
    toString() {
      return "pred_" + this.ruleIndex + ":" + this.predIndex;
    }
  };
  var PrecedencePredicateTransition = class extends AbstractPredicateTransition {
    static {
      __name(this, "PrecedencePredicateTransition");
    }
    precedence;
    constructor(target, precedence) {
      super(target);
      this.precedence = precedence;
    }
    get isEpsilon() {
      return true;
    }
    matches(_symbol, _minVocabSymbol, _maxVocabSymbol) {
      return false;
    }
    getPredicate() {
      return new SemanticContext.PrecedencePredicate(this.precedence);
    }
    get transitionType() {
      return Transition.PRECEDENCE;
    }
    toString() {
      return this.precedence + " >= _p";
    }
  };
  var LexerActionType = {
    /** The type of a {@link LexerChannelAction} action. */
    CHANNEL: 0,
    /** The type of a {@link LexerCustomAction} action */
    CUSTOM: 1,
    /** The type of a {@link LexerModeAction} action. */
    MODE: 2,
    /** The type of a {@link LexerMoreAction} action. */
    MORE: 3,
    /** The type of a {@link LexerPopModeAction} action. */
    POP_MODE: 4,
    /** The type of a {@link LexerPushModeAction} action. */
    PUSH_MODE: 5,
    /** The type of a {@link LexerSkipAction} action. */
    SKIP: 6,
    /** The type of a {@link LexerTypeAction} action. */
    TYPE: 7
  };
  var LexerSkipAction = class _LexerSkipAction {
    static {
      __name(this, "LexerSkipAction");
    }
    /** Provides a singleton instance of this parameter-less lexer action. */
    static instance = new _LexerSkipAction();
    actionType;
    isPositionDependent = false;
    constructor() {
      this.actionType = LexerActionType.SKIP;
    }
    equals(obj) {
      return obj === this;
    }
    hashCode() {
      return LexerActionType.SKIP;
    }
    execute(lexer) {
      lexer.skip();
    }
    toString() {
      return "skip";
    }
  };
  var LexerChannelAction = class _LexerChannelAction {
    static {
      __name(this, "LexerChannelAction");
    }
    channel;
    actionType;
    isPositionDependent = false;
    cachedHashCode;
    constructor(channel) {
      this.actionType = LexerActionType.CHANNEL;
      this.channel = channel;
    }
    /**
     * This action is implemented by calling {@link Lexer.setChannel} with the
     * value provided by {@link getChannel}.
     */
    execute(lexer) {
      lexer.channel = this.channel;
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        hash = MurmurHash.update(hash, this.actionType);
        hash = MurmurHash.update(hash, this.channel);
        this.cachedHashCode = MurmurHash.finish(hash, 2);
      }
      return this.cachedHashCode;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _LexerChannelAction)) {
        return false;
      }
      return this.channel === other.channel;
    }
    toString() {
      return "channel(" + this.channel + ")";
    }
  };
  var LexerCustomAction = class _LexerCustomAction {
    static {
      __name(this, "LexerCustomAction");
    }
    ruleIndex;
    actionIndex;
    actionType;
    isPositionDependent = true;
    cachedHashCode;
    /**
     * Constructs a custom lexer action with the specified rule and action indexes.
     *
     * @param ruleIndex The rule index to use for calls to {@link Recognizer.action}.
     * @param actionIndex The action index to use for calls to {@link Recognizer.action}.
     */
    constructor(ruleIndex, actionIndex) {
      this.actionType = LexerActionType.CUSTOM;
      this.ruleIndex = ruleIndex;
      this.actionIndex = actionIndex;
    }
    /**
     * Custom actions are implemented by calling {@link Lexer.action} with the
     * appropriate rule and action indexes.
     */
    execute(lexer) {
      lexer.action(null, this.ruleIndex, this.actionIndex);
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        hash = MurmurHash.update(hash, this.actionType);
        hash = MurmurHash.update(hash, this.ruleIndex);
        hash = MurmurHash.update(hash, this.actionIndex);
        this.cachedHashCode = MurmurHash.finish(hash, 3);
      }
      return this.cachedHashCode;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _LexerCustomAction)) {
        return false;
      }
      return this.ruleIndex === other.ruleIndex && this.actionIndex === other.actionIndex;
    }
  };
  var LexerMoreAction = class _LexerMoreAction {
    static {
      __name(this, "LexerMoreAction");
    }
    static instance = new _LexerMoreAction();
    actionType;
    isPositionDependent = false;
    constructor() {
      this.actionType = LexerActionType.MORE;
    }
    equals(obj) {
      return obj === this;
    }
    hashCode() {
      return LexerActionType.MORE;
    }
    /**
     * This action is implemented by calling {@link Lexer.popMode}.
     */
    execute(lexer) {
      lexer.more();
    }
    toString() {
      return "more";
    }
  };
  var LexerTypeAction = class _LexerTypeAction {
    static {
      __name(this, "LexerTypeAction");
    }
    type;
    actionType;
    isPositionDependent = false;
    cachedHashCode;
    constructor(type) {
      this.actionType = LexerActionType.TYPE;
      this.type = type;
    }
    execute(lexer) {
      lexer.type = this.type;
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        hash = MurmurHash.update(hash, this.actionType);
        hash = MurmurHash.update(hash, this.type);
        this.cachedHashCode = MurmurHash.finish(hash, 2);
      }
      return this.cachedHashCode;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _LexerTypeAction)) {
        return false;
      }
      return this.type === other.type;
    }
    toString() {
      return "type(" + this.type + ")";
    }
  };
  var LexerPushModeAction = class _LexerPushModeAction {
    static {
      __name(this, "LexerPushModeAction");
    }
    mode;
    actionType;
    isPositionDependent = false;
    cachedHashCode;
    constructor(mode) {
      this.actionType = LexerActionType.PUSH_MODE;
      this.mode = mode;
    }
    /**
     * This action is implemented by calling {@link Lexer.pushMode} with the
     * value provided by {@link getMode}.
     */
    execute(lexer) {
      lexer.pushMode(this.mode);
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        hash = MurmurHash.update(hash, this.actionType);
        hash = MurmurHash.update(hash, this.mode);
        this.cachedHashCode = MurmurHash.finish(hash, 2);
      }
      return this.cachedHashCode;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _LexerPushModeAction)) {
        return false;
      }
      return this.mode === other.mode;
    }
    toString() {
      return "pushMode(" + this.mode + ")";
    }
  };
  var LexerPopModeAction = class _LexerPopModeAction {
    static {
      __name(this, "LexerPopModeAction");
    }
    static instance = new _LexerPopModeAction();
    actionType;
    isPositionDependent = false;
    constructor() {
      this.actionType = LexerActionType.POP_MODE;
    }
    equals(obj) {
      return obj === this;
    }
    hashCode() {
      return LexerActionType.POP_MODE;
    }
    /**
     * This action is implemented by calling {@link Lexer//popMode}.
     */
    execute(lexer) {
      lexer.popMode();
    }
    toString() {
      return "popMode";
    }
  };
  var LexerModeAction = class _LexerModeAction {
    static {
      __name(this, "LexerModeAction");
    }
    mode;
    actionType;
    isPositionDependent = false;
    cachedHashCode;
    constructor(mode) {
      this.actionType = LexerActionType.MODE;
      this.mode = mode;
    }
    /**
     * This action is implemented by calling {@link Lexer.mode} with the
     * value provided by {@link getMode}.
     */
    execute(lexer) {
      lexer.mode = this.mode;
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        hash = MurmurHash.update(hash, this.actionType);
        hash = MurmurHash.update(hash, this.mode);
        this.cachedHashCode = MurmurHash.finish(hash, 2);
      }
      return this.cachedHashCode;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _LexerModeAction)) {
        return false;
      }
      return this.mode === other.mode;
    }
    toString() {
      return "mode(" + this.mode + ")";
    }
  };
  var ATNDeserializer = class _ATNDeserializer {
    static {
      __name(this, "ATNDeserializer");
    }
    static SERIALIZED_VERSION = 4;
    static stateTypeMapper = /* @__PURE__ */ new Map([
      [ATNState.INVALID_TYPE, void 0],
      [ATNState.BASIC, BasicState],
      [ATNState.RULE_START, RuleStartState],
      [ATNState.BLOCK_START, BasicBlockStartState],
      [ATNState.PLUS_BLOCK_START, PlusBlockStartState],
      [ATNState.STAR_BLOCK_START, StarBlockStartState],
      [ATNState.TOKEN_START, TokensStartState],
      [ATNState.RULE_STOP, RuleStopState],
      [ATNState.BLOCK_END, BlockEndState],
      [ATNState.STAR_LOOP_BACK, StarLoopbackState],
      [ATNState.STAR_LOOP_ENTRY, StarLoopEntryState],
      [ATNState.PLUS_LOOP_BACK, PlusLoopbackState],
      [ATNState.LOOP_END, LoopEndState]
    ]);
    static lexerActionFactoryMapper = /* @__PURE__ */ new Map([
      [LexerActionType.CHANNEL, (data1) => {
        return new LexerChannelAction(data1);
      }],
      [LexerActionType.CUSTOM, (data1, data2) => {
        return new LexerCustomAction(data1, data2);
      }],
      [LexerActionType.MODE, (data1) => {
        return new LexerModeAction(data1);
      }],
      [LexerActionType.MORE, () => {
        return LexerMoreAction.instance;
      }],
      [LexerActionType.POP_MODE, () => {
        return LexerPopModeAction.instance;
      }],
      [LexerActionType.PUSH_MODE, (data1) => {
        return new LexerPushModeAction(data1);
      }],
      [LexerActionType.SKIP, () => {
        return LexerSkipAction.instance;
      }],
      [LexerActionType.TYPE, (data1) => {
        return new LexerTypeAction(data1);
      }]
    ]);
    data = [];
    pos = 0;
    deserializationOptions;
    actionFactories;
    constructor(options) {
      if (!options) {
        options = { readOnly: false, verifyATN: true, generateRuleBypassTransitions: false };
      }
      this.deserializationOptions = options;
    }
    deserialize(data) {
      this.data = data;
      this.checkVersion();
      const atn = this.readATN();
      this.readStates(atn);
      this.readRules(atn);
      this.readModes(atn);
      const sets = [];
      this.readSets(atn, sets);
      this.readEdges(atn, sets);
      this.readDecisions(atn);
      this.readLexerActions(atn);
      this.markPrecedenceDecisions(atn);
      this.verifyATN(atn);
      if (this.deserializationOptions.generateRuleBypassTransitions && atn.grammarType === ATN.PARSER) {
        this.generateRuleBypassTransitions(atn);
        this.verifyATN(atn);
      }
      return atn;
    }
    checkVersion() {
      const version = this.data[this.pos++];
      if (version !== _ATNDeserializer.SERIALIZED_VERSION) {
        throw new Error("Could not deserialize ATN with version " + version + " (expected " + _ATNDeserializer.SERIALIZED_VERSION + ").");
      }
    }
    readATN() {
      const grammarType = this.data[this.pos++];
      const maxTokenType = this.data[this.pos++];
      return new ATN(grammarType, maxTokenType);
    }
    readStates(atn) {
      let j;
      let stateNumber;
      const loopBackStateNumbers = [];
      const endStateNumbers = [];
      const stateCount = this.data[this.pos++];
      for (let i = 0; i < stateCount; i++) {
        const stateType = this.data[this.pos++];
        if (stateType === ATNState.INVALID_TYPE) {
          atn.addState(null);
          continue;
        }
        const ruleIndex = this.data[this.pos++];
        const s = this.stateFactory(stateType, ruleIndex);
        if (stateType === ATNState.LOOP_END) {
          const loopBackStateNumber = this.data[this.pos++];
          loopBackStateNumbers.push([s, loopBackStateNumber]);
        } else if (s instanceof BlockStartState) {
          const endStateNumber = this.data[this.pos++];
          endStateNumbers.push([s, endStateNumber]);
        }
        atn.addState(s);
      }
      for (j = 0; j < loopBackStateNumbers.length; j++) {
        const pair = loopBackStateNumbers[j];
        pair[0].loopBackState = atn.states[pair[1]] ?? void 0;
      }
      for (j = 0; j < endStateNumbers.length; j++) {
        const pair = endStateNumbers[j];
        pair[0].endState = atn.states[pair[1]];
      }
      const numNonGreedyStates = this.data[this.pos++];
      for (j = 0; j < numNonGreedyStates; j++) {
        stateNumber = this.data[this.pos++];
        atn.states[stateNumber].nonGreedy = true;
      }
      const numPrecedenceStates = this.data[this.pos++];
      for (j = 0; j < numPrecedenceStates; j++) {
        stateNumber = this.data[this.pos++];
        atn.states[stateNumber].isLeftRecursiveRule = true;
      }
    }
    readRules(atn) {
      let i;
      const ruleCount = this.data[this.pos++];
      if (atn.grammarType === ATN.LEXER) {
        atn.ruleToTokenType = new Array(ruleCount);
        atn.ruleToTokenType.fill(0);
      }
      atn.ruleToStartState = new Array(ruleCount);
      atn.ruleToStartState.fill(null);
      for (i = 0; i < ruleCount; i++) {
        const s = this.data[this.pos++];
        atn.ruleToStartState[i] = atn.states[s];
        if (atn.grammarType === ATN.LEXER) {
          const tokenType = this.data[this.pos++];
          atn.ruleToTokenType[i] = tokenType;
        }
      }
      atn.ruleToStopState = new Array(ruleCount);
      atn.ruleToStopState.fill(null);
      for (i = 0; i < atn.states.length; i++) {
        const state = atn.states[i];
        if (!(state instanceof RuleStopState)) {
          continue;
        }
        atn.ruleToStopState[state.ruleIndex] = state;
        atn.ruleToStartState[state.ruleIndex].stopState = state;
      }
    }
    readModes(atn) {
      const modeCount = this.data[this.pos++];
      for (let i = 0; i < modeCount; i++) {
        const s = this.data[this.pos++];
        atn.modeToStartState.push(atn.states[s]);
      }
    }
    readSets(atn, sets) {
      const m2 = this.data[this.pos++];
      for (let i = 0; i < m2; i++) {
        const intervalSet = new IntervalSet();
        sets.push(intervalSet);
        const n2 = this.data[this.pos++];
        const containsEof = this.data[this.pos++];
        if (containsEof !== 0) {
          intervalSet.addOne(-1);
        }
        for (let j = 0; j < n2; j++) {
          const i1 = this.data[this.pos++];
          const i2 = this.data[this.pos++];
          intervalSet.addRange(i1, i2);
        }
      }
    }
    readEdges(atn, sets) {
      let i;
      let j;
      let state;
      let trans;
      let target;
      const edgeCount = this.data[this.pos++];
      for (i = 0; i < edgeCount; i++) {
        const src = this.data[this.pos++];
        const trg = this.data[this.pos++];
        const ttype = this.data[this.pos++];
        const arg1 = this.data[this.pos++];
        const arg2 = this.data[this.pos++];
        const arg3 = this.data[this.pos++];
        trans = this.edgeFactory(atn, ttype, trg, arg1, arg2, arg3, sets);
        const srcState = atn.states[src];
        srcState.addTransition(trans);
      }
      for (i = 0; i < atn.states.length; i++) {
        state = atn.states[i];
        for (j = 0; j < state.transitions.length; j++) {
          const t = state.transitions[j];
          if (!(t instanceof RuleTransition)) {
            continue;
          }
          let outermostPrecedenceReturn = -1;
          if (atn.ruleToStartState[t.target.ruleIndex].isLeftRecursiveRule) {
            if (t.precedence === 0) {
              outermostPrecedenceReturn = t.target.ruleIndex;
            }
          }
          trans = new EpsilonTransition(t.followState, outermostPrecedenceReturn);
          atn.ruleToStopState[t.target.ruleIndex].addTransition(trans);
        }
      }
      for (i = 0; i < atn.states.length; i++) {
        state = atn.states[i];
        if (state instanceof BlockStartState) {
          if (!state.endState) {
            throw new Error("IllegalState");
          }
          if (state.endState.startState) {
            throw new Error("IllegalState");
          }
          state.endState.startState = state;
        }
        if (state instanceof PlusLoopbackState) {
          for (j = 0; j < state.transitions.length; j++) {
            target = state.transitions[j].target;
            if (target instanceof PlusBlockStartState) {
              target.loopBackState = state;
            }
          }
        } else if (state instanceof StarLoopbackState) {
          for (j = 0; j < state.transitions.length; j++) {
            target = state.transitions[j].target;
            if (target instanceof StarLoopEntryState) {
              target.loopBackState = state;
            }
          }
        }
      }
    }
    readDecisions(atn) {
      const decisionCount = this.data[this.pos++];
      for (let i = 0; i < decisionCount; i++) {
        const s = this.data[this.pos++];
        const decState = atn.states[s];
        atn.decisionToState.push(decState);
        decState.decision = i;
      }
    }
    readLexerActions(atn) {
      if (atn.grammarType === ATN.LEXER) {
        const count = this.data[this.pos++];
        atn.lexerActions = [];
        for (let i = 0; i < count; i++) {
          const actionType = this.data[this.pos++];
          const data1 = this.data[this.pos++];
          const data2 = this.data[this.pos++];
          atn.lexerActions.push(this.lexerActionFactory(actionType, data1, data2));
        }
      }
    }
    generateRuleBypassTransitions(atn) {
      let i;
      const count = atn.ruleToStartState.length;
      for (i = 0; i < count; i++) {
        atn.ruleToTokenType[i] = atn.maxTokenType + i + 1;
      }
      for (i = 0; i < count; i++) {
        this.generateRuleBypassTransition(atn, i);
      }
    }
    generateRuleBypassTransition(atn, idx) {
      let i;
      let state;
      const bypassStart = new BasicBlockStartState();
      bypassStart.ruleIndex = idx;
      atn.addState(bypassStart);
      const bypassStop = new BlockEndState();
      bypassStop.ruleIndex = idx;
      atn.addState(bypassStop);
      bypassStart.endState = bypassStop;
      atn.defineDecisionState(bypassStart);
      bypassStop.startState = bypassStart;
      let excludeTransition = null;
      let endState = null;
      if (atn.ruleToStartState[idx].isLeftRecursiveRule) {
        endState = null;
        for (i = 0; i < atn.states.length; i++) {
          state = atn.states[i];
          if (this.stateIsEndStateFor(state, idx)) {
            endState = state;
            excludeTransition = state.loopBackState.transitions[0];
            break;
          }
        }
        if (excludeTransition === null) {
          throw new Error("Couldn't identify final state of the precedence rule prefix section.");
        }
      } else {
        endState = atn.ruleToStopState[idx];
      }
      for (i = 0; i < atn.states.length; i++) {
        state = atn.states[i];
        for (const transition of state.transitions) {
          if (transition === excludeTransition) {
            continue;
          }
          if (transition.target === endState) {
            transition.target = bypassStop;
          }
        }
      }
      const ruleToStartState = atn.ruleToStartState[idx];
      while (ruleToStartState.transitions.length > 0) {
        const transition = ruleToStartState.removeTransition(ruleToStartState.transitions.length - 1);
        bypassStart.addTransition(transition);
      }
      atn.ruleToStartState[idx].addTransition(new EpsilonTransition(bypassStart));
      if (endState) {
        bypassStop.addTransition(new EpsilonTransition(endState));
      }
      const matchState = new BasicState();
      atn.addState(matchState);
      matchState.addTransition(new AtomTransition(bypassStop, atn.ruleToTokenType[idx]));
      bypassStart.addTransition(new EpsilonTransition(matchState));
    }
    stateIsEndStateFor(state, idx) {
      if (state.ruleIndex !== idx) {
        return null;
      }
      if (!(state instanceof StarLoopEntryState)) {
        return null;
      }
      const maybeLoopEndState = state.transitions[state.transitions.length - 1].target;
      if (!(maybeLoopEndState instanceof LoopEndState)) {
        return null;
      }
      if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transitions[0].target instanceof RuleStopState) {
        return state;
      } else {
        return null;
      }
    }
    /**
     * Analyze the {@link StarLoopEntryState} states in the specified ATN to set
     * the {@link StarLoopEntryState} field to the correct value.
     *
     * @param atn The ATN.
     */
    markPrecedenceDecisions(atn) {
      for (const state of atn.states) {
        if (!(state instanceof StarLoopEntryState)) {
          continue;
        }
        if (atn.ruleToStartState[state.ruleIndex].isLeftRecursiveRule) {
          const maybeLoopEndState = state.transitions[state.transitions.length - 1].target;
          if (maybeLoopEndState instanceof LoopEndState) {
            if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transitions[0].target instanceof RuleStopState) {
              state.precedenceRuleDecision = true;
            }
          }
        }
      }
    }
    verifyATN(atn) {
      if (!this.deserializationOptions.verifyATN) {
        return;
      }
      for (const state of atn.states) {
        if (state === null) {
          continue;
        }
        this.checkCondition(state.epsilonOnlyTransitions || state.transitions.length <= 1);
        if (state instanceof PlusBlockStartState) {
          this.checkCondition(state.loopBackState !== null);
        } else if (state instanceof StarLoopEntryState) {
          this.checkCondition(state.loopBackState !== null);
          this.checkCondition(state.transitions.length === 2);
          if (state.transitions[0].target instanceof StarBlockStartState) {
            this.checkCondition(state.transitions[1].target instanceof LoopEndState);
            this.checkCondition(!state.nonGreedy);
          } else if (state.transitions[0].target instanceof LoopEndState) {
            this.checkCondition(state.transitions[1].target instanceof StarBlockStartState);
            this.checkCondition(state.nonGreedy);
          } else {
            throw new Error("IllegalState");
          }
        } else if (state instanceof StarLoopbackState) {
          this.checkCondition(state.transitions.length === 1);
          this.checkCondition(state.transitions[0].target instanceof StarLoopEntryState);
        } else if (state instanceof LoopEndState) {
          this.checkCondition(state.loopBackState !== null);
        } else if (state instanceof RuleStartState) {
          this.checkCondition(state.stopState !== null);
        } else if (state instanceof BlockStartState) {
          this.checkCondition(state.endState !== null);
        } else if (state instanceof BlockEndState) {
          this.checkCondition(state.startState !== null);
        } else if (state instanceof DecisionState) {
          this.checkCondition(state.transitions.length <= 1 || state.decision >= 0);
        } else {
          this.checkCondition(state.transitions.length <= 1 || state instanceof RuleStopState);
        }
      }
    }
    checkCondition(condition, message) {
      if (!condition) {
        if (message === void 0 || message === null) {
          message = "IllegalState";
        }
        throw message;
      }
    }
    edgeFactory(atn, type, trg, arg1, arg2, arg3, sets) {
      const target = atn.states[trg];
      switch (type) {
        case Transition.EPSILON:
          return new EpsilonTransition(target);
        case Transition.RANGE:
          return arg3 !== 0 ? new RangeTransition(target, Token.EOF, arg2) : new RangeTransition(target, arg1, arg2);
        case Transition.RULE:
          return new RuleTransition(atn.states[arg1], arg2, arg3, target);
        case Transition.PREDICATE:
          return new PredicateTransition(target, arg1, arg2, arg3 !== 0);
        case Transition.PRECEDENCE:
          return new PrecedencePredicateTransition(target, arg1);
        case Transition.ATOM:
          return arg3 !== 0 ? new AtomTransition(target, Token.EOF) : new AtomTransition(target, arg1);
        case Transition.ACTION:
          return new ActionTransition(target, arg1, arg2, arg3 !== 0);
        case Transition.SET:
          return new SetTransition(target, sets[arg1]);
        case Transition.NOT_SET:
          return new NotSetTransition(target, sets[arg1]);
        case Transition.WILDCARD:
          return new WildcardTransition(target);
        default:
          throw new Error("The specified transition type: " + type + " is not valid.");
      }
    }
    stateFactory(type, ruleIndex) {
      const ctor = _ATNDeserializer.stateTypeMapper.get(type);
      if (!ctor) {
        throw new Error("The specified state type " + type + " is not valid.");
      }
      const s = new ctor();
      s.ruleIndex = ruleIndex;
      return s;
    }
    lexerActionFactory(type, data1, data2) {
      const factory = _ATNDeserializer.lexerActionFactoryMapper.get(type);
      if (!factory) {
        throw new Error("The specified lexer action type " + type + " is not valid.");
      }
      return factory(data1, data2);
    }
  };
  var OrderedHashMap = class _OrderedHashMap extends HashMap {
    static {
      __name(this, "OrderedHashMap");
    }
    #keys = [];
    clear() {
      super.clear();
      this.#keys = [];
    }
    get(key) {
      return super.get(key);
    }
    set(key, value) {
      const result = super.set(key, value);
      if (result === void 0) {
        this.#keys.push(key);
      }
      return result;
    }
    setIfAbsent(key, value) {
      const result = super.setIfAbsent(key, value);
      if (result === void 0) {
        this.#keys.push(key);
      }
      return result;
    }
    /**
     * @returns an iterable of the values in the map, in the order they were inserted.
     */
    values() {
      return {
        [Symbol.iterator]: () => {
          let index2 = 0;
          return {
            next: /* @__PURE__ */ __name(() => {
              if (index2 < this.#keys.length) {
                return {
                  done: false,
                  value: super.get(this.#keys[index2++])
                };
              }
              return {
                done: true,
                value: void 0
              };
            }, "next")
          };
        }
      };
    }
    /**
     * @returns an iterable of the keys in the map, in the order they were inserted.
     */
    keys() {
      return this.#keys[Symbol.iterator]();
    }
    equals(o) {
      if (!(o instanceof _OrderedHashMap)) {
        return false;
      }
      return super.equals(o);
    }
  };
  var ATNSerializer = class _ATNSerializer {
    static {
      __name(this, "ATNSerializer");
    }
    atn;
    data = [];
    // Note that we use a LinkedHashMap as a set to maintain insertion order while deduplicating entries with the
    // same key.
    sets = new OrderedHashMap(ObjectEqualityComparator.instance);
    nonGreedyStates = [];
    precedenceStates = [];
    constructor(atn) {
      this.atn = atn;
    }
    static getSerialized(atn) {
      return new _ATNSerializer(atn).serialize();
    }
    static serializeSets(data, sets) {
      data.push(sets.length);
      for (const set of sets) {
        const containsEof = set.contains(Token.EOF);
        const intervals = [...set];
        if (containsEof && intervals[0].stop === Token.EOF) {
          data.push(intervals.length - 1);
        } else {
          data.push(intervals.length);
        }
        data.push(containsEof ? 1 : 0);
        for (const interval of intervals) {
          if (interval.start === Token.EOF) {
            if (interval.stop === Token.EOF) {
              continue;
            } else {
              data.push(0);
            }
          } else {
            data.push(interval.start);
          }
          data.push(interval.stop);
        }
      }
    }
    /**
     * Serialize state descriptors, edge descriptors, and decision -> state map
     *  into list of ints.  Likely out of date, but keeping as it could be helpful:
     *
     *      SERIALIZED_VERSION
     *      UUID (2 longs)
     * 		grammar-type, (ANTLRParser.LEXER, ...)
     *  	max token type,
     *  	num states,
     *  	state-0-type ruleIndex, state-1-type ruleIndex, ... state-i-type ruleIndex optional-arg ...
     *  	num rules,
     *  	rule-1-start-state rule-1-args, rule-2-start-state  rule-2-args, ...
     *  	(args are token type,actionIndex in lexer else 0,0)
     *      num modes,
     *      mode-0-start-state, mode-1-start-state, ... (parser has 0 modes)
     *      num unicode-bmp-sets
     *      bmp-set-0-interval-count intervals, bmp-set-1-interval-count intervals, ...
     *      num unicode-smp-sets
     *      smp-set-0-interval-count intervals, smp-set-1-interval-count intervals, ...
     *	num total edges,
     *      src, trg, edge-type, edge arg1, optional edge arg2 (present always), ...
     *      num decisions,
     *      decision-0-start-state, decision-1-start-state, ...
     *
     *  Convenient to pack into unsigned shorts to make as Java string.
     */
    serialize() {
      this.addPreamble();
      const edgeCount = this.addEdges();
      this.addNonGreedyStates();
      this.addPrecedenceStates();
      this.addRuleStatesAndLexerTokenTypes();
      this.addModeStartStates();
      const setIndices = this.addSets();
      this.addEdges(edgeCount, setIndices);
      this.addDecisionStartStates();
      this.addLexerActions();
      return this.data;
    }
    addPreamble() {
      this.data.push(ATNDeserializer.SERIALIZED_VERSION);
      this.data.push(this.atn.grammarType);
      this.data.push(this.atn.maxTokenType);
    }
    addLexerActions() {
      if (this.atn.grammarType === ATN.LEXER) {
        this.data.push(this.atn.lexerActions.length);
        for (const action of this.atn.lexerActions) {
          this.data.push(action.actionType);
          switch (action.actionType) {
            case LexerActionType.CHANNEL: {
              const channel = action.channel;
              this.data.push(channel);
              this.data.push(0);
              break;
            }
            case LexerActionType.CUSTOM: {
              const ruleIndex = action.ruleIndex;
              const actionIndex = action.actionIndex;
              this.data.push(ruleIndex);
              this.data.push(actionIndex);
              break;
            }
            case LexerActionType.MODE: {
              const mode = action.mode;
              this.data.push(mode);
              this.data.push(0);
              break;
            }
            case LexerActionType.MORE: {
              this.data.push(0);
              this.data.push(0);
              break;
            }
            case LexerActionType.POP_MODE: {
              this.data.push(0);
              this.data.push(0);
              break;
            }
            case LexerActionType.PUSH_MODE: {
              const mode = action.mode;
              this.data.push(mode);
              this.data.push(0);
              break;
            }
            case LexerActionType.SKIP: {
              this.data.push(0);
              this.data.push(0);
              break;
            }
            case LexerActionType.TYPE: {
              const type = action.type;
              this.data.push(type);
              this.data.push(0);
              break;
            }
            default: {
              throw new Error(`The specified lexer action type ${action.actionType} is not valid.`);
            }
          }
        }
      }
    }
    addDecisionStartStates() {
      this.data.push(this.atn.decisionToState.length);
      for (const decStartState of this.atn.decisionToState) {
        this.data.push(decStartState.stateNumber);
      }
    }
    addEdges(...args) {
      switch (args.length) {
        case 0: {
          let edgeCount = 0;
          this.data.push(this.atn.states.length);
          for (const s of this.atn.states) {
            if (s === null) {
              this.data.push(ATNState.INVALID_TYPE);
              continue;
            }
            const stateType = s.constructor.stateType;
            if (s instanceof DecisionState && s.nonGreedy) {
              this.nonGreedyStates.push(s.stateNumber);
            }
            if (s instanceof RuleStartState && s.isLeftRecursiveRule) {
              this.precedenceStates.push(s.stateNumber);
            }
            this.data.push(stateType);
            this.data.push(s.ruleIndex);
            if (s.constructor.stateType === ATNState.LOOP_END) {
              this.data.push(s.loopBackState.stateNumber);
            } else {
              if (s instanceof BlockStartState) {
                this.data.push(s.endState.stateNumber);
              }
            }
            if (s.constructor.stateType !== ATNState.RULE_STOP) {
              edgeCount += s.transitions.length;
            }
            for (const t of s.transitions) {
              const edgeType = t.transitionType;
              if (edgeType === Transition.SET || edgeType === Transition.NOT_SET) {
                const st = t;
                this.sets.set(st.set, true);
              }
            }
          }
          return edgeCount;
        }
        case 2: {
          const [edgeCount, setIndices] = args;
          this.data.push(edgeCount);
          for (const s of this.atn.states) {
            if (s === null) {
              continue;
            }
            if (s.constructor.stateType === ATNState.RULE_STOP) {
              continue;
            }
            for (const t of s.transitions) {
              if (this.atn.states[t.target.stateNumber] === null) {
                throw new Error("Cannot serialize a transition to a removed state.");
              }
              const src = s.stateNumber;
              let trg = t.target.stateNumber;
              const edgeType = t.transitionType;
              let arg1 = 0;
              let arg2 = 0;
              let arg3 = 0;
              switch (edgeType) {
                case Transition.RULE: {
                  trg = t.followState.stateNumber;
                  arg1 = t.target.stateNumber;
                  arg2 = t.ruleIndex;
                  arg3 = t.precedence;
                  break;
                }
                case Transition.PRECEDENCE: {
                  const ppt = t;
                  arg1 = ppt.precedence;
                  break;
                }
                case Transition.PREDICATE: {
                  const pt = t;
                  arg1 = pt.ruleIndex;
                  arg2 = pt.predIndex;
                  arg3 = pt.isCtxDependent ? 1 : 0;
                  break;
                }
                case Transition.RANGE: {
                  arg1 = t.start;
                  arg2 = t.stop;
                  if (arg1 === Token.EOF) {
                    arg1 = 0;
                    arg3 = 1;
                  }
                  break;
                }
                case Transition.ATOM: {
                  arg1 = t.labelValue;
                  if (arg1 === Token.EOF) {
                    arg1 = 0;
                    arg3 = 1;
                  }
                  break;
                }
                case Transition.ACTION: {
                  const at = t;
                  arg1 = at.ruleIndex;
                  arg2 = at.actionIndex;
                  arg3 = at.isCtxDependent ? 1 : 0;
                  break;
                }
                case Transition.SET: {
                  arg1 = setIndices.get(t.set);
                  break;
                }
                case Transition.NOT_SET: {
                  arg1 = setIndices.get(t.set);
                  break;
                }
                case Transition.WILDCARD: {
                  break;
                }
                default:
              }
              this.data.push(src);
              this.data.push(trg);
              this.data.push(edgeType);
              this.data.push(arg1);
              this.data.push(arg2);
              this.data.push(arg3);
            }
          }
          break;
        }
        default: {
          throw new Error("Invalid number of arguments");
        }
      }
    }
    addSets() {
      _ATNSerializer.serializeSets(this.data, [...this.sets.keys()]);
      const setIndices = new HashMap();
      let setIndex = 0;
      for (const s of this.sets.keys()) {
        setIndices.set(s, setIndex++);
      }
      return setIndices;
    }
    addModeStartStates() {
      const modeCount = this.atn.modeToStartState.length;
      this.data.push(modeCount);
      if (modeCount > 0) {
        for (const modeStartState of this.atn.modeToStartState) {
          this.data.push(modeStartState.stateNumber);
        }
      }
    }
    addRuleStatesAndLexerTokenTypes() {
      const ruleCount = this.atn.ruleToStartState.length;
      this.data.push(ruleCount);
      for (let r = 0; r < ruleCount; r++) {
        const ruleStartState = this.atn.ruleToStartState[r];
        this.data.push(ruleStartState.stateNumber);
        if (this.atn.grammarType === ATN.LEXER) {
          this.data.push(this.atn.ruleToTokenType[r]);
        }
      }
    }
    addPrecedenceStates() {
      this.data.push(this.precedenceStates.length);
      for (const state of this.precedenceStates) {
        this.data.push(state);
      }
    }
    addNonGreedyStates() {
      this.data.push(this.nonGreedyStates.length);
      for (const state of this.nonGreedyStates) {
        this.data.push(state);
      }
    }
  };
  var DFAState = class _DFAState {
    static {
      __name(this, "DFAState");
    }
    stateNumber = -1;
    configs;
    /**
     * `edges[symbol]` points to target of symbol. Shift up by 1 so (-1) {@link Token.EOF} maps to `edges[0]`.
     */
    edges = [];
    isAcceptState = false;
    /**
     * If accept state, what ttype do we match or alt do we predict? This is set to {@link ATN.INVALID_ALT_NUMBER}
     * when {@link predicates} `!= null` or {@link requiresFullContext}.
     */
    prediction = -1;
    lexerActionExecutor = null;
    /**
     * Indicates that this state was created during SLL prediction that discovered a conflict between the configurations
     * in the state. Future {@link ParserATNSimulator.execATN} invocations immediately jumped doing
     * full context prediction if this field is true.
     */
    requiresFullContext = false;
    /**
     * During SLL parsing, this is a list of predicates associated with the ATN configurations of the DFA state.
     * When we have predicates, {@link requiresFullContext} is `false` since full context prediction evaluates
     * predicates on-the-fly. If this is not null, then {@link prediction} is `ATN.INVALID_ALT_NUMBER`.
     *
     * We only use these for non-{@link #requiresFullContext} but conflicting states. That
     * means we know from the context (it's $ or we don't dip into outer
     * context) that it's an ambiguity not a conflict.
     *
     * This list is computed by {@link ParserATNSimulator#predicateDFAState}.
     */
    predicates = null;
    constructor(configs) {
      if (configs) {
        this.configs = configs;
      }
    }
    static fromState(stateNumber) {
      const result = new _DFAState();
      result.stateNumber = stateNumber;
      return result;
    }
    static fromConfigs(configs) {
      return new _DFAState(configs);
    }
    static hashCode(state) {
      return state.configs.hashCode();
    }
    /**
     * Two {@link DFAState} instances are equal if their ATN configuration sets
     * are the same. This method is used to see if a state already exists.
     *
     * Because the number of alternatives and number of ATN configurations are
     * finite, there is a finite number of DFA states that can be processed.
     * This is necessary to show that the algorithm terminates.
     *
     * Cannot test the DFA state numbers here because in
     * {@link ParserATNSimulator#addDFAState} we need to know if any other state
     * exists that has this exact set of ATN configurations. The
     * {@link #stateNumber} is irrelevant.
     *
     * @param a The first {@link DFAState}.
     * @param b The second {@link DFAState}.
     *
     * @returns `true` if the two states are equal, otherwise `false`.
     */
    static equals(a, b) {
      return a.configs.equals(b.configs);
    }
    /**
     * @returns the set of all alts mentioned by all ATN configurations in this DFA state.
     */
    getAltSet() {
      const alts = /* @__PURE__ */ new Set();
      for (const config of this.configs) {
        alts.add(config.alt);
      }
      if (alts.size === 0) {
        return null;
      }
      return alts;
    }
    toString() {
      let buf = "";
      buf += this.stateNumber;
      buf += ":";
      buf += this.configs ? this.configs.toString() : "";
      if (this.isAcceptState) {
        buf += "=>";
        if (this.predicates) {
          buf += arrayToString(this.predicates);
        } else {
          buf += this.prediction;
        }
      }
      return buf.toString();
    }
  };
  var ATNSimulator = class {
    static {
      __name(this, "ATNSimulator");
    }
    /** Must distinguish between missing edge and edge we know leads nowhere */
    static ERROR = DFAState.fromState(2147483647);
    atn;
    /**
     * The context cache maps all PredictionContext objects that are ==
     * to a single cached copy. This cache is shared across all contexts
     * in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet
     * to use only cached nodes/graphs in addDFAState(). We don't want to
     * fill this during closure() since there are lots of contexts that
     * pop up but are not used ever again. It also greatly slows down closure().
     *
     * This cache makes a huge difference in memory and a little bit in speed.
     * For the Java grammar on java.*, it dropped the memory requirements
     * at the end from 25M to 16M. We don't store any of the full context
     * graphs in the DFA because they are limited to local context only,
     * but apparently there's a lot of repetition there as well. We optimize
     * the config contexts before storing the config set in the DFA states
     * by literally rebuilding them with cached subgraphs only.
     *
     * I tried a cache for use during closure operations, that was
     * whacked after each adaptivePredict(). It cost a little bit
     * more time I think and doesn't save on the overall footprint
     * so it's not worth the complexity.
     */
    sharedContextCache;
    constructor(atn, sharedContextCache) {
      this.atn = atn;
      this.sharedContextCache = sharedContextCache;
      return this;
    }
    getCachedContext(context) {
      if (!this.sharedContextCache) {
        return context;
      }
      const visited = new HashMap(ObjectEqualityComparator.instance);
      return getCachedPredictionContext(context, this.sharedContextCache, visited);
    }
  };
  var CodePointTransitions = class _CodePointTransitions {
    static {
      __name(this, "CodePointTransitions");
    }
    /** @returns new {@link AtomTransition}     */
    static createWithCodePoint(target, codePoint) {
      return _CodePointTransitions.createWithCodePointRange(target, codePoint, codePoint);
    }
    /** @returns new {@link AtomTransition} if range represents one atom else {@link SetTransition}. */
    static createWithCodePointRange(target, codePointFrom, codePointTo) {
      return codePointFrom === codePointTo ? new AtomTransition(target, codePointFrom) : new RangeTransition(target, codePointFrom, codePointTo);
    }
  };
  var DecisionInfo = class {
    static {
      __name(this, "DecisionInfo");
    }
    /**
     * The decision number, which is an index into {@link ATN.decisionToState}.
     */
    decision = 0;
    /**
     * The total number of times {@link ParserATNSimulator.adaptivePredict} was
     * invoked for this decision.
     */
    invocations = 0;
    /**
     * The total time spent in {@link ParserATNSimulator.adaptivePredict} for
     * this decision, in nanoseconds.
     *
     * The value of this field contains the sum of differential results obtained
     * by {@link process.hrtime()}, and is not adjusted to compensate for JIT
     * and/or garbage collection overhead. For best accuracy, use a modern Node.js
     * version that provides precise results from {@link process.hrtime()}, and
     * perform profiling in a separate process which is warmed up by parsing the
     * input prior to profiling.
     */
    timeInPrediction = 0;
    /**
     * The sum of the lookahead required for SLL prediction for this decision.
     * Note that SLL prediction is used before LL prediction for performance
     * reasons even when {@link PredictionMode.LL} or
     * {@link PredictionMode.LL_EXACT_AMBIG_DETECTION} is used.
     */
    sllTotalLook = 0;
    /**
     * Gets the minimum lookahead required for any single SLL prediction to
     * complete for this decision, by reaching a unique prediction, reaching an
     * SLL conflict state, or encountering a syntax error.
     */
    sllMinLook = 0;
    /**
     * Gets the maximum lookahead required for any single SLL prediction to
     * complete for this decision, by reaching a unique prediction, reaching an
     * SLL conflict state, or encountering a syntax error.
     */
    sllMaxLook = 0;
    /**
     * Gets the {@link LookaheadEventInfo} associated with the event where the
     * {@link sllMaxLook} value was set.
     */
    sllMaxLookEvent;
    /**
     * The sum of the lookahead required for LL prediction for this decision.
     * Note that LL prediction is only used when SLL prediction reaches a
     * conflict state.
     */
    llTotalLook = 0;
    /**
     * Gets the minimum lookahead required for any single LL prediction to
     * complete for this decision. An LL prediction completes when the algorithm
     * reaches a unique prediction, a conflict state (for
     * {@link PredictionMode.LL}, an ambiguity state (for
     * {@link PredictionMode.LL_EXACT_AMBIG_DETECTION}, or a syntax error.
     */
    llMinLook = 0;
    /**
     * Gets the maximum lookahead required for any single LL prediction to
     * complete for this decision. An LL prediction completes when the algorithm
     * reaches a unique prediction, a conflict state (for
     * {@link PredictionMode.LL}, an ambiguity state (for
     * {@link PredictionMode.LL_EXACT_AMBIG_DETECTION}, or a syntax error.
     */
    llMaxLook = 0;
    /**
     * Gets the {@link LookaheadEventInfo} associated with the event where the
     * {@link llMaxLook} value was set.
     */
    llMaxLookEvent;
    /**
     * A collection of {@link ContextSensitivityInfo} instances describing the
     * context sensitivities encountered during LL prediction for this decision.
     */
    contextSensitivities;
    /**
     * A collection of {@link DecisionEventInfo} instances describing the parse errors
     * identified during calls to {@link ParserATNSimulator.adaptivePredict} for
     * this decision.
     */
    errors;
    /**
     * A collection of {@link AmbiguityInfo} instances describing the
     * ambiguities encountered during LL prediction for this decision.
     */
    ambiguities;
    /**
     * A collection of {@link PredicateEvalInfo} instances describing the
     * results of evaluating individual predicates during prediction for this
     * decision.
     */
    predicateEvals;
    /**
     * The total number of ATN transitions required during SLL prediction for
     * this decision. An ATN transition is determined by the number of times the
     * DFA does not contain an edge that is required for prediction, resulting
     * in on-the-fly computation of that edge.
    /**
     * If DFA caching of SLL transitions is employed by the implementation, ATN
     * computation may cache the computed edge for efficient lookup during
     * future parsing of this decision. Otherwise, the SLL parsing algorithm
     * will use ATN transitions exclusively.
     *
     * @see sllDFATransitions
     * @see ParserATNSimulator.computeTargetState
     * @see LexerATNSimulator.computeTargetState
     */
    sllATNTransitions = 0;
    /**
     * The total number of DFA transitions required during SLL prediction for
     * this decision.
     *
     * If the ATN simulator implementation does not use DFA caching for SLL
     * transitions, this value will be 0.
     *
     * @see ParserATNSimulator.getExistingTargetState
     * @see LexerATNSimulator.getExistingTargetState
     */
    sllDFATransitions = 0;
    /**
     * Gets the total number of times SLL prediction completed in a conflict
     * state, resulting in fallback to LL prediction.
     *
     * Note that this value is not related to whether or not
     * {@link PredictionMode.SLL} may be used successfully with a particular
     * grammar. If the ambiguity resolution algorithm applied to the SLL
     * conflicts for this decision produce the same result as LL prediction for
     * this decision, {@link PredictionMode.SLL} would produce the same overall
     * parsing result as {@link PredictionMode.LL}.
     */
    llFallback = 0;
    /**
     * The total number of ATN transitions required during LL prediction for
     * this decision. An ATN transition is determined by the number of times the
     * DFA does not contain an edge that is required for prediction, resulting
     * in on-the-fly computation of that edge.
     *
     * If DFA caching of LL transitions is employed by the implementation, ATN
     * computation may cache the computed edge for efficient lookup during
     * future parsing of this decision. Otherwise, the LL parsing algorithm will
     * use ATN transitions exclusively.
     *
     * @see llDFATransitions
     * @see ParserATNSimulator.computeTargetState
     * @see LexerATNSimulator.computeTargetState
     */
    llATNTransitions = 0;
    /**
     * The total number of DFA transitions required during LL prediction for
     * this decision.
     *
     * If the ATN simulator implementation does not use DFA caching for LL
     * transitions, this value will be 0.
     *
     * @see ParserATNSimulator.getExistingTargetState
     * @see LexerATNSimulator.getExistingTargetState
     */
    llDFATransitions = 0;
    /**
     * Constructs a new instance of the {@link DecisionInfo} class to contain
     * statistics for a particular decision.
     *
     * @param decision The decision number
     */
    constructor(decision) {
      this.decision = decision;
      this.contextSensitivities = [];
      this.errors = [];
      this.ambiguities = [];
      this.predicateEvals = [];
    }
    toString() {
      return "{decision=" + this.decision + ", contextSensitivities=" + this.contextSensitivities.length + ", errors=" + this.errors.length + ", ambiguities=" + this.ambiguities.length + ", sllLookahead=" + this.sllTotalLook + ", sllATNTransitions=" + this.sllATNTransitions + ", sllDFATransitions=" + this.sllDFATransitions + ", llFallback=" + this.llFallback + ", llLookahead=" + this.llTotalLook + ", llATNTransitions=" + this.llATNTransitions + "}";
    }
  };
  var LexerATNConfig = class _LexerATNConfig extends ATNConfig {
    static {
      __name(this, "LexerATNConfig");
    }
    /**
     * This is the backing field for {@link #getLexerActionExecutor}.
     */
    lexerActionExecutor;
    passedThroughNonGreedyDecision;
    constructor(config, state, context, lexerActionExecutor) {
      super(config, state, context ?? config.context, context ? SemanticContext.NONE : config.semanticContext);
      this.lexerActionExecutor = context ? lexerActionExecutor : config.lexerActionExecutor ?? null;
      this.passedThroughNonGreedyDecision = _LexerATNConfig.checkNonGreedyDecision(config, this.state);
      return this;
    }
    static createWithExecutor(config, state, lexerActionExecutor) {
      return new _LexerATNConfig(config, state, config.context, lexerActionExecutor);
    }
    static createWithConfig(state, config, context) {
      return new _LexerATNConfig(config, state, context ?? null, config.lexerActionExecutor);
    }
    static createWithContext(state, alt, context) {
      return new _LexerATNConfig({ alt }, state, context, null);
    }
    static checkNonGreedyDecision(source, target) {
      return source.passedThroughNonGreedyDecision || "nonGreedy" in target && target.nonGreedy;
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hashCode = MurmurHash.initialize(7);
        hashCode = MurmurHash.update(hashCode, this.state.stateNumber);
        hashCode = MurmurHash.update(hashCode, this.alt);
        hashCode = MurmurHash.updateFromComparable(hashCode, this.context);
        hashCode = MurmurHash.updateFromComparable(hashCode, this.semanticContext);
        hashCode = MurmurHash.update(hashCode, this.passedThroughNonGreedyDecision ? 1 : 0);
        hashCode = MurmurHash.updateFromComparable(hashCode, this.lexerActionExecutor);
        hashCode = MurmurHash.finish(hashCode, 6);
        this.cachedHashCode = hashCode;
      }
      return this.cachedHashCode;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      return this.passedThroughNonGreedyDecision === other.passedThroughNonGreedyDecision && (this.lexerActionExecutor && other.lexerActionExecutor ? this.lexerActionExecutor.equals(other.lexerActionExecutor) : !other.lexerActionExecutor) && super.equals(other);
    }
  };
  var BaseErrorListener = class {
    static {
      __name(this, "BaseErrorListener");
    }
    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
    }
    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
    }
    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
    }
    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
    }
  };
  var ConsoleErrorListener = class _ConsoleErrorListener extends BaseErrorListener {
    static {
      __name(this, "ConsoleErrorListener");
    }
    /**
     * Provides a default instance of {@link ConsoleErrorListener}.
     */
    static instance = new _ConsoleErrorListener();
    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, _e) {
      console.error("line " + line + ":" + charPositionInLine + " " + msg);
    }
  };
  var ProxyErrorListener = class extends BaseErrorListener {
    constructor(delegates) {
      super();
      this.delegates = delegates;
      return this;
    }
    static {
      __name(this, "ProxyErrorListener");
    }
    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
      this.delegates.forEach((d) => {
        d.syntaxError(recognizer, offendingSymbol, line, column, msg, e);
      });
    }
    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
      this.delegates.forEach((d) => {
        d.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
      });
    }
    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
      this.delegates.forEach((d) => {
        d.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs);
      });
    }
    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
      this.delegates.forEach((d) => {
        d.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs);
      });
    }
  };
  var Recognizer = class _Recognizer {
    static {
      __name(this, "Recognizer");
    }
    static EOF = -1;
    static tokenTypeMapCache = /* @__PURE__ */ new Map();
    static ruleIndexMapCache = /* @__PURE__ */ new Map();
    interpreter;
    listeners = [ConsoleErrorListener.instance];
    stateNumber = -1;
    checkVersion(toolVersion) {
      const runtimeVersion = "4.13.1";
      if (runtimeVersion !== toolVersion) {
        console.error("ANTLR runtime and generated code versions disagree: " + runtimeVersion + "!=" + toolVersion);
      }
    }
    addErrorListener(listener) {
      this.listeners.push(listener);
    }
    removeErrorListeners() {
      this.listeners = [];
    }
    removeErrorListener(listener) {
      for (let i = 0; i < this.listeners.length; i++) {
        if (this.listeners[i] === listener) {
          this.listeners.splice(i, 1);
          return;
        }
      }
    }
    getErrorListeners() {
      return this.listeners;
    }
    getTokenTypeMap() {
      const vocabulary = this.vocabulary;
      let result = _Recognizer.tokenTypeMapCache.get(vocabulary);
      if (!result) {
        result = /* @__PURE__ */ new Map();
        for (let i = 0; i <= this.atn.maxTokenType; i++) {
          const literalName = vocabulary.getLiteralName(i);
          if (literalName) {
            result.set(literalName, i);
          }
          const symbolicName = vocabulary.getSymbolicName(i);
          if (symbolicName) {
            result.set(symbolicName, i);
          }
        }
        result.set("EOF", Token.EOF);
        _Recognizer.tokenTypeMapCache.set(vocabulary, result);
      }
      return result;
    }
    /**
     * Get a map from rule names to rule indexes.
     * Used for XPath and tree pattern compilation.
     */
    getRuleIndexMap() {
      const ruleNames = this.ruleNames;
      let result = _Recognizer.ruleIndexMapCache.get(ruleNames);
      if (!result) {
        result = /* @__PURE__ */ new Map();
        ruleNames.forEach((ruleName, idx) => {
          return result.set(ruleName, idx);
        });
        _Recognizer.ruleIndexMapCache.set(ruleNames, result);
      }
      return result;
    }
    getTokenType(tokenName) {
      const ttype = this.getTokenTypeMap().get(tokenName);
      if (ttype) {
        return ttype;
      }
      return Token.INVALID_TYPE;
    }
    /** What is the error header, normally line/character position information? */
    getErrorHeader(e) {
      const line = e.offendingToken?.line;
      const column = e.offendingToken?.column;
      return "line " + line + ":" + column;
    }
    get errorListenerDispatch() {
      return new ProxyErrorListener(this.listeners);
    }
    /**
     * subclass needs to override these if there are semantic predicates or actions
     * that the ATN interp needs to execute
     */
    sempred(_localctx, _ruleIndex, _actionIndex) {
      return true;
    }
    // TODO: make localCtx an optional parameter, not optional null.
    precpred(_localctx, _precedence) {
      return true;
    }
    action(_localctx, _ruleIndex, _actionIndex) {
    }
    get atn() {
      return this.interpreter.atn;
    }
    get state() {
      return this.stateNumber;
    }
    set state(state) {
      this.stateNumber = state;
    }
    getParseInfo() {
      return void 0;
    }
  };
  var CommonTokenFactory = class _CommonTokenFactory {
    static {
      __name(this, "CommonTokenFactory");
    }
    /**
     * The default {@link CommonTokenFactory} instance.
     *
     *
     * This token factory does not explicitly copy token text when constructing
     * tokens.
     */
    static DEFAULT = new _CommonTokenFactory();
    /**
     * Indicates whether {@link CommonToken.setText} should be called after
     * constructing tokens to explicitly set the text. This is useful for cases
     * where the input stream might not be able to provide arbitrary substrings
     * of text from the input after the lexer creates a token (e.g. the
     * implementation of {@link CharStream.getText} in
     * {@link UnbufferedCharStream} throws an
     * {@link UnsupportedOperationException}). Explicitly setting the token text
     * allows {@link Token.getText} to be called at any time regardless of the
     * input stream implementation.
     *
     *
     * The default value is `false` to avoid the performance and memory
     * overhead of copying text for every token unless explicitly requested.
     */
    copyText = false;
    constructor(copyText) {
      this.copyText = copyText ?? false;
    }
    create(source, type, text, channel, start, stop, line, column) {
      const t = CommonToken.fromSource(source, type, channel, start, stop);
      t.line = line;
      t.column = column;
      if (text) {
        t.text = text;
      } else if (this.copyText && source[1] !== null) {
        t.text = source[1].getTextFromRange(start, stop);
      }
      return t;
    }
  };
  var RecognitionException = class _RecognitionException extends Error {
    static {
      __name(this, "RecognitionException");
    }
    ctx;
    /**
     * The current {@link Token} when an error occurred. Since not all streams
     * support accessing symbols by index, we have to track the {@link Token}
     * instance itself
     */
    offendingToken = null;
    /**
     * Get the ATN state number the parser was in at the time the error
     * occurred. For {@link NoViableAltException} and
     * {@link LexerNoViableAltException} exceptions, this is the
     * {@link DecisionState} number. For others, it is the state whose outgoing
     * edge we couldn't match.
     */
    offendingState = -1;
    recognizer;
    input;
    constructor(params) {
      super(params.message);
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, _RecognitionException);
      }
      this.message = params.message;
      this.recognizer = params.recognizer;
      this.input = params.input;
      this.ctx = params.ctx;
      if (this.recognizer !== null) {
        this.offendingState = this.recognizer.state;
      }
    }
    /**
     * Gets the set of input symbols which could potentially follow the
     * previously matched symbol at the time this exception was thrown.
     *
     * If the set of expected tokens is not known and could not be computed,
     * this method returns `null`.
     *
     * @returns The set of token types that could potentially follow the current
     * state in the ATN, or `null` if the information is not available.
     */
    getExpectedTokens() {
      if (this.recognizer !== null && this.ctx !== null) {
        return this.recognizer.atn.getExpectedTokens(this.offendingState, this.ctx);
      } else {
        return null;
      }
    }
    // If the state number is not known, this method returns -1.
    toString() {
      return this.message;
    }
  };
  var LexerNoViableAltException = class extends RecognitionException {
    static {
      __name(this, "LexerNoViableAltException");
    }
    startIndex;
    deadEndConfigs;
    constructor(lexer, input, startIndex, deadEndConfigs) {
      super({ message: "", recognizer: lexer, input, ctx: null });
      this.startIndex = startIndex;
      this.deadEndConfigs = deadEndConfigs;
    }
    toString() {
      let symbol = "";
      if (this.input && this.startIndex >= 0 && this.startIndex < this.input.size) {
        symbol = this.input.getTextFromRange(this.startIndex, this.startIndex);
      }
      return `LexerNoViableAltException(${symbol})`;
    }
  };
  var Lexer = class _Lexer extends Recognizer {
    static {
      __name(this, "Lexer");
    }
    static DEFAULT_MODE = 0;
    static MORE = -2;
    static SKIP = -3;
    static DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL;
    static HIDDEN = Token.HIDDEN_CHANNEL;
    options = {
      minDFAEdge: 0,
      maxDFAEdge: 256,
      minCodePoint: 0,
      maxCodePoint: 1114111
    };
    /**
     * What character index in the stream did the current token start at?
     *  Needed, for example, to get the text for current token.  Set at
     *  the start of nextToken.
     */
    tokenStartCharIndex = -1;
    /** The channel number for the current token */
    channel = 0;
    /** The token type for the current token */
    type = 0;
    mode = _Lexer.DEFAULT_MODE;
    /** The start column of the current token (the one that was last read by `nextToken`). */
    currentTokenColumn = 0;
    /**
     * The line on which the first character of the current token (the one that was last read by `nextToken`) resides.
     */
    currentTokenStartLine = 0;
    input;
    /**
     * The goal of all lexer rules/methods is to create a token object.
     *  This is an instance variable as multiple rules may collaborate to
     *  create a single token.  nextToken will return this object after
     *  matching lexer rule(s).  If you subclass to allow multiple token
     *  emissions, then set this to the last token to be matched or
     *  something non-null so that the auto token emit mechanism will not
     *  emit another token.
     */
    token = null;
    /**
     * Once we see EOF on char stream, next token will be EOF.
     * If you have DONE : EOF ; then you see DONE EOF.
     */
    hitEOF = false;
    factory;
    #modeStack = [];
    /**
     * The text to be used for the next token. If this is not null, then the text
     * for the next token is fixed and is not subject to change in the normal
     * workflow of the lexer.
     */
    #text;
    constructor(input, options) {
      super();
      this.options = { ...this.options, ...options };
      this.input = input;
      this.factory = CommonTokenFactory.DEFAULT;
    }
    reset(seekBack = true) {
      if (seekBack) {
        this.input.seek(0);
      }
      this.token = null;
      this.type = Token.INVALID_TYPE;
      this.channel = Token.DEFAULT_CHANNEL;
      this.tokenStartCharIndex = -1;
      this.currentTokenColumn = -1;
      this.currentTokenStartLine = -1;
      this.#text = void 0;
      this.hitEOF = false;
      this.mode = _Lexer.DEFAULT_MODE;
      this.#modeStack = [];
      this.interpreter.reset();
    }
    /** @returns a token from this source; i.e., match a token on the char stream. */
    nextToken() {
      if (this.input === null) {
        throw new Error("nextToken requires a non-null input stream.");
      }
      const tokenStartMarker = this.input.mark();
      try {
        while (true) {
          if (this.hitEOF) {
            this.emitEOF();
            return this.token;
          }
          this.token = null;
          this.channel = Token.DEFAULT_CHANNEL;
          this.tokenStartCharIndex = this.input.index;
          this.currentTokenColumn = this.interpreter.column;
          this.currentTokenStartLine = this.interpreter.line;
          this.#text = void 0;
          let continueOuter = false;
          while (true) {
            this.type = Token.INVALID_TYPE;
            let ttype = _Lexer.SKIP;
            try {
              ttype = this.interpreter.match(this.input, this.mode);
            } catch (e) {
              if (e instanceof LexerNoViableAltException) {
                this.notifyListeners(e);
                this.recover(e);
              } else {
                throw e;
              }
            }
            if (this.input.LA(1) === Token.EOF) {
              this.hitEOF = true;
            }
            if (this.type === Token.INVALID_TYPE) {
              this.type = ttype;
            }
            if (this.type === _Lexer.SKIP) {
              continueOuter = true;
              break;
            }
            if (this.type !== _Lexer.MORE) {
              break;
            }
          }
          if (continueOuter) {
            continue;
          }
          if (this.token === null) {
            this.emit();
          }
          return this.token;
        }
      } finally {
        this.input.release(tokenStartMarker);
      }
    }
    /**
     * Instruct the lexer to skip creating a token for current lexer rule
     * and look for another token. nextToken() knows to keep looking when
     * a lexer rule finishes with token set to SKIP_TOKEN. Recall that
     * if token==null at end of any token rule, it creates one for you
     * and emits it.
     */
    skip() {
      this.type = _Lexer.SKIP;
    }
    more() {
      this.type = _Lexer.MORE;
    }
    pushMode(m2) {
      if (LexerATNSimulator.debug) {
        console.log("pushMode " + m2);
      }
      this.#modeStack.push(this.mode);
      this.mode = m2;
    }
    popMode() {
      if (this.#modeStack.length === 0) {
        throw new Error("Empty Stack");
      }
      if (LexerATNSimulator.debug) {
        console.log("popMode back to " + this.#modeStack.slice(0, -1));
      }
      this.mode = this.#modeStack.pop();
      return this.mode;
    }
    get modeStack() {
      return this.#modeStack;
    }
    /**
     * By default does not support multiple emits per nextToken invocation
     * for efficiency reasons. Subclass and override this method, nextToken,
     * and getToken (to push tokens into a list and pull from that list
     * rather than a single variable as this implementation does).
     */
    emitToken(token) {
      this.token = token;
    }
    /**
     * The standard method called to automatically emit a token at the
     * outermost lexical rule. The token object should point into the
     * char buffer start..stop. If there is a text override in 'text',
     * use that to set the token's text. Override this method to emit
     * custom Token objects or provide a new factory.
     */
    emit() {
      const t = this.factory.create(
        [this, this.input],
        this.type,
        this.#text,
        this.channel,
        this.tokenStartCharIndex,
        this.getCharIndex() - 1,
        this.currentTokenStartLine,
        this.currentTokenColumn
      );
      this.emitToken(t);
      return t;
    }
    emitEOF() {
      const eof = this.factory.create(
        [this, this.input],
        Token.EOF,
        void 0,
        Token.DEFAULT_CHANNEL,
        this.input.index,
        this.input.index - 1,
        this.line,
        this.column
      );
      this.emitToken(eof);
      return eof;
    }
    /** What is the index of the current character of lookahead? */
    getCharIndex() {
      return this.input.index;
    }
    /**
     * Return a list of all Token objects in input char stream.
     * Forces load of all tokens. Does not include EOF token.
     */
    getAllTokens() {
      const tokens = [];
      let t = this.nextToken();
      while (t.type !== Token.EOF) {
        tokens.push(t);
        t = this.nextToken();
      }
      return tokens;
    }
    notifyListeners(e) {
      const start = this.tokenStartCharIndex;
      const stop = this.input.index;
      const text = this.input.getTextFromRange(start, stop);
      const msg = "token recognition error at: '" + this.getErrorDisplay(text) + "'";
      this.errorListenerDispatch.syntaxError(this, null, this.currentTokenStartLine, this.currentTokenColumn, msg, e);
    }
    getErrorDisplay(s) {
      return s;
    }
    getErrorDisplayForChar(c) {
      if (c.charCodeAt(0) === Token.EOF) {
        return "<EOF>";
      }
      if (c === "\n") {
        return "\\n";
      }
      if (c === "	") {
        return "\\t";
      }
      if (c === "\r") {
        return "\\r";
      }
      return c;
    }
    getCharErrorDisplay(c) {
      return "'" + this.getErrorDisplayForChar(c) + "'";
    }
    /**
     * Lexers can normally match any char in it's vocabulary after matching
     * a token, so do the easy thing and just kill a character and hope
     * it all works out. You can instead use the rule invocation stack
     * to do sophisticated error recovery if you are in a fragment rule.
     */
    recover(re) {
      if (this.input.LA(1) !== Token.EOF) {
        if (re instanceof LexerNoViableAltException) {
          this.interpreter.consume(this.input);
        } else {
          this.input.consume();
        }
      }
    }
    get inputStream() {
      return this.input;
    }
    set inputStream(input) {
      this.reset(false);
      this.input = input;
    }
    set tokenFactory(factory) {
      this.factory = factory;
    }
    get tokenFactory() {
      return this.factory;
    }
    get sourceName() {
      return this.input.getSourceName();
    }
    get line() {
      return this.interpreter.line;
    }
    set line(line) {
      this.interpreter.line = line;
    }
    get column() {
      return this.interpreter.column;
    }
    set column(column) {
      this.interpreter.column = column;
    }
    get text() {
      if (this.#text) {
        return this.#text;
      } else {
        return this.interpreter.getText(this.input);
      }
    }
    set text(text) {
      this.#text = text;
    }
  };
  var DFASerializer = class {
    static {
      __name(this, "DFASerializer");
    }
    dfa;
    vocabulary;
    constructor(dfa, vocabulary) {
      this.dfa = dfa;
      this.vocabulary = vocabulary;
    }
    toString() {
      if (!this.dfa.s0) {
        return "";
      }
      let buf = "";
      const states = this.dfa.getStates();
      for (const s of states) {
        let n2 = 0;
        n2 = s.edges.length;
        for (let i = 0; i < n2; i++) {
          const t = s.edges[i];
          if (t && t.stateNumber !== 2147483647) {
            buf += this.getStateString(s);
            const label = this.getEdgeLabel(i);
            buf += "-";
            buf += label;
            buf += "->";
            buf += this.getStateString(t);
            buf += "\n";
          }
        }
      }
      return buf;
    }
    getEdgeLabel(i) {
      const name = this.vocabulary.getDisplayName(i - 1);
      return `${name}`;
    }
    getStateString(s) {
      const n2 = s.stateNumber;
      const baseStateStr = (s.isAcceptState ? ":" : "") + "s" + n2 + (s.requiresFullContext ? "^" : "");
      if (s.isAcceptState) {
        if (s.predicates !== null) {
          return `${baseStateStr}=>${s.predicates.toString()}`;
        }
        return `${baseStateStr}=>${s.prediction}`;
      } else {
        return `${baseStateStr}`;
      }
    }
  };
  var LexerDFASerializer = class extends DFASerializer {
    static {
      __name(this, "LexerDFASerializer");
    }
    constructor(dfa) {
      super(dfa, Vocabulary.EMPTY_VOCABULARY);
    }
    getEdgeLabel = /* @__PURE__ */ __name((i) => {
      return "'" + String.fromCharCode(i) + "'";
    }, "getEdgeLabel");
  };
  var DFA = class {
    static {
      __name(this, "DFA");
    }
    s0;
    decision;
    /** From which ATN state did we create this DFA? */
    atnStartState;
    /**
     * Gets whether this DFA is a precedence DFA. Precedence DFAs use a special
     * start state {@link #s0} which is not stored in {@link #states}. The
     * {@link DFAState#edges} array for this start state contains outgoing edges
     * supplying individual start states corresponding to specific precedence
     * values.
     *
     * @returns `true` if this is a precedence DFA; otherwise, `false`.
     */
    isPrecedenceDfa;
    /**
     * A mapping from an ATNConfigSet hash to a DFAState.
     * Used to quick look up the DFA state for a particular configuration set.
     */
    states = /* @__PURE__ */ new Map();
    constructor(atnStartState, decision) {
      this.atnStartState = atnStartState;
      this.decision = decision ?? 0;
      let precedenceDfa = false;
      if (atnStartState instanceof StarLoopEntryState) {
        if (atnStartState.precedenceRuleDecision) {
          precedenceDfa = true;
          this.s0 = DFAState.fromState(-1);
        }
      }
      this.isPrecedenceDfa = precedenceDfa;
    }
    [Symbol.iterator] = () => {
      return this.states.values()[Symbol.iterator]();
    };
    /**
     * Get the start state for a specific precedence value.
     *
     * @param precedence The current precedence.
      @returns The start state corresponding to the specified precedence, or
     * `null` if no start state exists for the specified precedence.
     *
     * @throws IllegalStateException if this is not a precedence DFA.
     * @see #isPrecedenceDfa
     */
    getPrecedenceStartState = /* @__PURE__ */ __name((precedence) => {
      if (!this.isPrecedenceDfa) {
        throw new Error(`Only precedence DFAs may contain a precedence start state.`);
      }
      if (!this.s0 || !this.s0.edges || precedence < 0 || precedence >= this.s0.edges.length) {
        return void 0;
      }
      return this.s0.edges[precedence];
    }, "getPrecedenceStartState");
    /**
     * Set the start state for a specific precedence value.
     *
     * @param precedence The current precedence.
     * @param startState The start state corresponding to the specified precedence.
     */
    setPrecedenceStartState = /* @__PURE__ */ __name((precedence, startState) => {
      if (!this.isPrecedenceDfa) {
        throw new Error(`Only precedence DFAs may contain a precedence start state.`);
      }
      if (precedence < 0 || !this.s0) {
        return;
      }
      this.s0.edges[precedence] = startState;
    }, "setPrecedenceStartState");
    /**
     * @returns a list of all states in this DFA, ordered by state number.
     */
    getStates() {
      const result = [...this.states.values()];
      result.sort((o1, o2) => {
        return o1.stateNumber - o2.stateNumber;
      });
      return result;
    }
    getState(state) {
      return this.states.get(state.configs.hashCode()) ?? null;
    }
    getStateForConfigs(configs) {
      return this.states.get(configs.hashCode()) ?? null;
    }
    addState(state) {
      const hash = state.configs.hashCode();
      if (this.states.has(hash)) {
        return;
      }
      this.states.set(hash, state);
      state.stateNumber = this.states.size - 1;
    }
    toString(vocabulary) {
      if (!vocabulary) {
        return this.toString(Vocabulary.EMPTY_VOCABULARY);
      }
      if (!this.s0) {
        return "";
      }
      const serializer = new DFASerializer(this, vocabulary);
      return serializer.toString() ?? "";
    }
    toLexerString() {
      if (!this.s0) {
        return "";
      }
      const serializer = new LexerDFASerializer(this);
      return serializer.toString() ?? "";
    }
    get length() {
      return this.states.size;
    }
  };
  var LexerIndexedCustomAction = class _LexerIndexedCustomAction {
    static {
      __name(this, "LexerIndexedCustomAction");
    }
    offset;
    action;
    actionType;
    isPositionDependent = true;
    cachedHashCode;
    constructor(offset, action) {
      this.actionType = action.actionType;
      this.offset = offset;
      this.action = action;
    }
    /**
     * This method calls {@link execute} on the result of {@link getAction}
     * using the provided `lexer`.
     */
    execute(lexer) {
      this.action.execute(lexer);
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hash = MurmurHash.initialize();
        hash = MurmurHash.update(hash, this.offset);
        hash = MurmurHash.updateFromComparable(hash, this.action);
        this.cachedHashCode = MurmurHash.finish(hash, 2);
      }
      return this.cachedHashCode;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (!(other instanceof _LexerIndexedCustomAction)) {
        return false;
      }
      return this.offset === other.offset && this.action === other.action;
    }
  };
  var LexerActionExecutor = class _LexerActionExecutor {
    static {
      __name(this, "LexerActionExecutor");
    }
    lexerActions;
    actionType;
    isPositionDependent = false;
    cachedHashCode;
    /**
     * Represents an executor for a sequence of lexer actions which traversed during
     * the matching operation of a lexer rule (token).
     *
     * The executor tracks position information for position-dependent lexer actions
     * efficiently, ensuring that actions appearing only at the end of the rule do
     * not cause bloating of the {@link DFA} created for the lexer.
     */
    constructor(lexerActions) {
      this.actionType = -1;
      this.lexerActions = lexerActions ?? [];
      return this;
    }
    /**
     * Creates a {@link LexerActionExecutor} which executes the actions for
     * the input `lexerActionExecutor` followed by a specified
     * `lexerAction`.
     *
     * @param lexerActionExecutor The executor for actions already traversed by
     * the lexer while matching a token within a particular
     * {@link LexerATNConfig}. If this is `null`, the method behaves as
     * though it were an empty executor.
     * @param lexerAction The lexer action to execute after the actions
     * specified in `lexerActionExecutor`.
     *
     * @returns {LexerActionExecutor} A {@link LexerActionExecutor} for executing the combine actions
     * of `lexerActionExecutor` and `lexerAction`.
     */
    static append(lexerActionExecutor, lexerAction) {
      if (lexerActionExecutor === null) {
        return new _LexerActionExecutor([lexerAction]);
      }
      const lexerActions = lexerActionExecutor.lexerActions.concat([lexerAction]);
      return new _LexerActionExecutor(lexerActions);
    }
    /**
     * Creates a {@link LexerActionExecutor} which encodes the current offset
     * for position-dependent lexer actions.
     *
     * Normally, when the executor encounters lexer actions where
     * {@link LexerAction//isPositionDependent} returns `true`, it calls
     * {@link IntStream.seek} on the input {@link CharStream} to set the input
     * position to the *end* of the current token. This behavior provides
     * for efficient DFA representation of lexer actions which appear at the end
     * of a lexer rule, even when the lexer rule matches a variable number of
     * characters.
     *
     * Prior to traversing a match transition in the ATN, the current offset
     * from the token start index is assigned to all position-dependent lexer
     * actions which have not already been assigned a fixed offset. By storing
     * the offsets relative to the token start index, the DFA representation of
     * lexer actions which appear in the middle of tokens remains efficient due
     * to sharing among tokens of the same length, regardless of their absolute
     * position in the input stream.
     *
     * If the current executor already has offsets assigned to all
     * position-dependent lexer actions, the method returns `this`.
     *
     * @param offset The current offset to assign to all position-dependent
     * lexer actions which do not already have offsets assigned.
     *
     * @returns {LexerActionExecutor} A {@link LexerActionExecutor} which stores input stream offsets
     * for all position-dependent lexer actions.
     */
    fixOffsetBeforeMatch(offset) {
      let updatedLexerActions = null;
      for (let i = 0; i < this.lexerActions.length; i++) {
        if (this.lexerActions[i].isPositionDependent && !(this.lexerActions[i] instanceof LexerIndexedCustomAction)) {
          if (updatedLexerActions === null) {
            updatedLexerActions = this.lexerActions.concat([]);
          }
          updatedLexerActions[i] = new LexerIndexedCustomAction(
            offset,
            this.lexerActions[i]
          );
        }
      }
      if (updatedLexerActions === null) {
        return this;
      } else {
        return new _LexerActionExecutor(updatedLexerActions);
      }
    }
    /**
     * Execute the actions encapsulated by this executor within the context of a
     * particular {@link Lexer}.
     *
     * This method calls {@link IntStream.seek} to set the position of the
     * `input` {@link CharStream} prior to calling
     * {@link LexerAction.execute} on a position-dependent action. Before the
     * method returns, the input position will be restored to the same position
     * it was in when the method was invoked.
     *
     * @param lexer The lexer instance.
     * @param input The input stream which is the source for the current token.
     * When this method is called, the current {@link IntStream.index} for
     * `input` should be the start of the following token, i.e. 1
     * character past the end of the current token.
     * @param startIndex The token start index. This value may be passed to
     * {@link IntStream.seek} to set the `input` position to the beginning
     * of the token.
     */
    execute(lexer, input, startIndex) {
      if (input === void 0 || startIndex === void 0) {
        return;
      }
      let requiresSeek = false;
      const stopIndex = input.index;
      try {
        for (const lexerAction of this.lexerActions) {
          let action = lexerAction;
          if (lexerAction instanceof LexerIndexedCustomAction) {
            const offset = lexerAction.offset;
            input.seek(startIndex + offset);
            action = lexerAction.action;
            requiresSeek = startIndex + offset !== stopIndex;
          } else if (lexerAction.isPositionDependent) {
            input.seek(stopIndex);
            requiresSeek = false;
          }
          action.execute(lexer);
        }
      } finally {
        if (requiresSeek) {
          input.seek(stopIndex);
        }
      }
    }
    hashCode() {
      if (this.cachedHashCode === void 0) {
        let hashCode = MurmurHash.initialize(7);
        for (const lexerAction of this.lexerActions) {
          hashCode = MurmurHash.update(hashCode, lexerAction.hashCode());
        }
        this.cachedHashCode = MurmurHash.finish(hashCode, this.lexerActions.length);
      }
      return this.cachedHashCode;
    }
    equals(other) {
      if (this === other) {
        return true;
      }
      if (this.cachedHashCode !== other.cachedHashCode) {
        return false;
      }
      if (this.lexerActions.length !== other.lexerActions.length) {
        return false;
      }
      return this.lexerActions.every((action, index2) => {
        return action.equals(other.lexerActions[index2]);
      });
    }
  };
  var OrderedHashSet = class _OrderedHashSet extends HashSet {
    static {
      __name(this, "OrderedHashSet");
    }
    elements = [];
    getOrAdd(o) {
      const oldSize = this.size;
      const result = super.getOrAdd(o);
      if (this.size > oldSize) {
        this.elements.push(o);
      }
      return result;
    }
    equals(o) {
      if (!(o instanceof _OrderedHashSet)) {
        return false;
      }
      return super.equals(o);
    }
    clear() {
      super.clear();
      this.elements = [];
    }
    *[Symbol.iterator]() {
      yield* this.elements;
    }
    toArray() {
      return this.elements.slice(0);
    }
  };
  var OrderedATNConfigSet = class extends ATNConfigSet {
    static {
      __name(this, "OrderedATNConfigSet");
    }
    constructor() {
      super();
      this.configLookup = new OrderedHashSet();
    }
  };
  var LexerATNSimulator = class _LexerATNSimulator extends ATNSimulator {
    static {
      __name(this, "LexerATNSimulator");
    }
    static debug = false;
    decisionToDFA;
    recognizer = null;
    /**
     * The current token's starting index into the character stream.
     *  Shared across DFA to ATN simulation in case the ATN fails and the
     *  DFA did not have a previous accept state. In this case, we use the
     *  ATN-generated exception object.
     */
    startIndex = -1;
    /** line number 1..n within the input */
    line = 1;
    /** The index of the character relative to the beginning of the line 0..n-1 */
    column = 0;
    mode = Lexer.DEFAULT_MODE;
    /** Used during DFA/ATN exec to record the most recent accept configuration info */
    prevAccept;
    options;
    /** Lookup table for lexer ATN config creation. */
    lexerATNConfigFactory;
    /**
     * When we hit an accept state in either the DFA or the ATN, we
     * have to notify the character stream to start buffering characters
     * via {@link IntStream//mark} and record the current state. The current sim state
     * includes the current index into the input, the current line,
     * and current character position in that line. Note that the Lexer is
     * tracking the starting line and characterization of the token. These
     * variables track the "state" of the simulator when it hits an accept state.
     *
     * We track these variables separately for the DFA and ATN simulation
     * because the DFA simulation often has to fail over to the ATN
     * simulation. If the ATN simulation fails, we need the DFA to fall
     * back to its previously accepted state, if any. If the ATN succeeds,
     * then the ATN does the accept and the DFA simulator that invoked it
     * can simply return the predicted token type.
     */
    constructor(recog, atn, decisionToDFA, sharedContextCache) {
      super(atn, sharedContextCache);
      this.decisionToDFA = decisionToDFA;
      this.recognizer = recog;
      if (recog) {
        this.options = recog.options;
      } else {
        this.options = {
          minDFAEdge: 0,
          maxDFAEdge: 256,
          minCodePoint: 0,
          maxCodePoint: 1114111
        };
      }
    }
    match(input, mode) {
      this.mode = mode;
      const mark = input.mark();
      try {
        this.startIndex = input.index;
        this.prevAccept = void 0;
        const dfa = this.decisionToDFA[mode];
        if (!dfa.s0) {
          return this.matchATN(input);
        }
        return this.execATN(input, dfa.s0);
      } finally {
        input.release(mark);
      }
    }
    reset() {
      this.prevAccept = void 0;
      this.startIndex = -1;
      this.line = 1;
      this.column = 0;
      this.mode = Lexer.DEFAULT_MODE;
    }
    clearDFA() {
      for (let d = 0; d < this.decisionToDFA.length; d++) {
        this.decisionToDFA[d] = new DFA(this.atn.getDecisionState(d), d);
      }
    }
    getDFA(mode) {
      return this.decisionToDFA[mode];
    }
    /** @returns the text matched so far for the current token. */
    getText(input) {
      return input.getTextFromRange(this.startIndex, input.index - 1);
    }
    consume(input) {
      const curChar = input.LA(1);
      if (curChar === "\n".charCodeAt(0)) {
        this.line += 1;
        this.column = 0;
      } else {
        this.column += 1;
      }
      input.consume();
    }
    getTokenName(tt) {
      if (tt === Token.EOF) {
        return "EOF";
      } else {
        return "'" + String.fromCharCode(tt) + "'";
      }
    }
    matchATN(input) {
      const startState = this.atn.modeToStartState[this.mode];
      if (_LexerATNSimulator.debug) {
        console.log("matchATN mode " + this.mode + " start: " + startState);
      }
      const oldMode = this.mode;
      const s0Closure = this.computeStartState(input, startState);
      const suppressEdge = s0Closure.hasSemanticContext;
      s0Closure.hasSemanticContext = false;
      const next = this.addDFAState(s0Closure);
      if (!suppressEdge) {
        this.decisionToDFA[this.mode].s0 = next;
      }
      const predict = this.execATN(input, next);
      if (_LexerATNSimulator.debug) {
        console.log("DFA after matchATN: " + this.decisionToDFA[oldMode].toLexerString());
      }
      return predict;
    }
    execATN(input, state) {
      if (_LexerATNSimulator.debug) {
        console.log("start state closure=" + state.configs);
      }
      if (state.isAcceptState) {
        this.captureSimState(input, state);
      }
      let t = input.LA(1);
      while (true) {
        if (_LexerATNSimulator.debug) {
          console.log("execATN loop starting closure: " + state.configs);
        }
        let target = this.getExistingTargetState(state, t);
        if (!target) {
          target = this.computeTargetState(input, state, t);
        }
        if (target === ATNSimulator.ERROR) {
          break;
        }
        if (t !== Token.EOF) {
          this.consume(input);
        }
        if (target.isAcceptState) {
          this.captureSimState(input, target);
          if (t === Token.EOF) {
            break;
          }
        }
        t = input.LA(1);
        state = target;
      }
      return this.failOrAccept(input, state.configs, t);
    }
    /**
     * Get an existing target state for an edge in the DFA. If the target state
     * for the edge has not yet been computed or is otherwise not available,
     * this method returns `null`.
     *
     * @param s The current DFA state.
     * @param t The next input symbol.
     *
     * @returns The existing target DFA state for the given input symbol
     * `t`, or `null` if the target state for this edge is not already cached
     */
    getExistingTargetState(s, t) {
      if (t >= this.options.minDFAEdge && t <= this.options.maxDFAEdge) {
        const target = s.edges[t - this.options.minDFAEdge];
        if (_LexerATNSimulator.debug && target) {
          console.log("reuse state " + s.stateNumber + " edge to " + target.stateNumber);
        }
        return target;
      }
      return void 0;
    }
    /**
     * Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding
     * edge to the DFA.
     *
     * @param input The input stream
     * @param s The current DFA state
     * @param t The next input symbol
     *
     * @returns The computed target DFA state for the given input symbol `t`.
     *          If `t` does not lead to a valid DFA state, this method returns `ERROR`.
     */
    computeTargetState(input, s, t) {
      const reach = new OrderedATNConfigSet();
      this.getReachableConfigSet(input, s.configs, reach, t);
      if (reach.length === 0) {
        if (!reach.hasSemanticContext) {
          this.addDFAEdge(s, t, ATNSimulator.ERROR);
        }
        return ATNSimulator.ERROR;
      }
      return this.addDFAEdge(s, t, null, reach);
    }
    failOrAccept(input, reach, t) {
      if (this.prevAccept?.dfaState) {
        const { dfaState, index: index2, line, column } = this.prevAccept;
        this.accept(input, dfaState.lexerActionExecutor, this.startIndex, index2, line, column);
        return dfaState.prediction;
      }
      if (t === Token.EOF && input.index === this.startIndex) {
        return Token.EOF;
      }
      throw new LexerNoViableAltException(this.recognizer, input, this.startIndex, reach);
    }
    /**
     * Given a starting configuration set, figure out all ATN configurations we can reach upon input `t`.
     * Parameter `reach` is a return parameter.
     */
    getReachableConfigSet(input, closure, reach, t) {
      let skipAlt = ATN.INVALID_ALT_NUMBER;
      for (const cfg of closure) {
        const currentAltReachedAcceptState = cfg.alt === skipAlt;
        if (currentAltReachedAcceptState && cfg.passedThroughNonGreedyDecision) {
          continue;
        }
        if (_LexerATNSimulator.debug) {
          console.log("testing %s at %s\n", this.getTokenName(t), cfg.toString(this.recognizer, true));
        }
        for (const trans of cfg.state.transitions) {
          const target = this.getReachableTarget(trans, t);
          if (target) {
            let lexerActionExecutor = cfg.lexerActionExecutor;
            if (lexerActionExecutor) {
              lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - this.startIndex);
            }
            const treatEofAsEpsilon = t === Token.EOF;
            const config = LexerATNConfig.createWithExecutor(
              cfg,
              target,
              lexerActionExecutor
            );
            if (this.closure(input, config, reach, currentAltReachedAcceptState, true, treatEofAsEpsilon)) {
              skipAlt = cfg.alt;
            }
          }
        }
      }
    }
    accept(input, lexerActionExecutor, startIndex, index2, line, charPos) {
      if (_LexerATNSimulator.debug) {
        console.log("ACTION %s\n", lexerActionExecutor);
      }
      input.seek(index2);
      this.line = line;
      this.column = charPos;
      if (lexerActionExecutor && this.recognizer) {
        lexerActionExecutor.execute(this.recognizer, input, startIndex);
      }
    }
    getReachableTarget(trans, t) {
      if (trans.matches(t, this.options.minCodePoint, this.options.maxCodePoint)) {
        return trans.target;
      } else {
        return void 0;
      }
    }
    computeStartState(input, p) {
      const initialContext = EmptyPredictionContext.instance;
      const configs = new OrderedATNConfigSet();
      for (let i = 0; i < p.transitions.length; i++) {
        const target = p.transitions[i].target;
        const cfg = LexerATNConfig.createWithContext(target, i + 1, initialContext);
        this.closure(input, cfg, configs, false, false, false);
      }
      return configs;
    }
    /**
     * Since the alternatives within any lexer decision are ordered by
     * preference, this method stops pursuing the closure as soon as an accept
     * state is reached. After the first accept state is reached by depth-first
     * search from `config`, all other (potentially reachable) states for
     * this rule would have a lower priority.
     *
     * @returns {boolean} `true` if an accept state is reached, otherwise `false`.
     */
    closure(input, config, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon) {
      let cfg = null;
      if (_LexerATNSimulator.debug) {
        console.log("closure(" + config.toString(this.recognizer, true) + ")");
      }
      if (config.state.constructor.stateType === ATNState.RULE_STOP) {
        if (_LexerATNSimulator.debug) {
          if (this.recognizer !== null) {
            console.log(
              "closure at %s rule stop %s\n",
              this.recognizer.ruleNames[config.state.ruleIndex],
              config
            );
          } else {
            console.log("closure at rule stop %s\n", config);
          }
        }
        if (!config.context || config.context.hasEmptyPath()) {
          if (!config.context || config.context.isEmpty()) {
            configs.add(config);
            return true;
          } else {
            configs.add(LexerATNConfig.createWithConfig(config.state, config, EmptyPredictionContext.instance));
            currentAltReachedAcceptState = true;
          }
        }
        if (config.context && !config.context.isEmpty()) {
          for (let i = 0; i < config.context.length; i++) {
            if (config.context.getReturnState(i) !== PredictionContext.EMPTY_RETURN_STATE) {
              const newContext = config.context.getParent(i);
              const returnState = this.atn.states[config.context.getReturnState(i)];
              cfg = LexerATNConfig.createWithConfig(returnState, config, newContext);
              currentAltReachedAcceptState = this.closure(
                input,
                cfg,
                configs,
                currentAltReachedAcceptState,
                speculative,
                treatEofAsEpsilon
              );
            }
          }
        }
        return currentAltReachedAcceptState;
      }
      if (!config.state.epsilonOnlyTransitions) {
        if (!currentAltReachedAcceptState || !config.passedThroughNonGreedyDecision) {
          configs.add(config);
        }
      }
      for (const trans of config.state.transitions) {
        cfg = this.getEpsilonTarget(input, config, trans, configs, speculative, treatEofAsEpsilon);
        if (cfg) {
          currentAltReachedAcceptState = this.closure(
            input,
            cfg,
            configs,
            currentAltReachedAcceptState,
            speculative,
            treatEofAsEpsilon
          );
        }
      }
      return currentAltReachedAcceptState;
    }
    // side-effect: can alter configs.hasSemanticContext
    getEpsilonTarget(input, config, trans, configs, speculative, treatEofAsEpsilon) {
      if (!this.lexerATNConfigFactory) {
        this.setupATNFactoryLookup();
      }
      const factory = this.lexerATNConfigFactory[trans.transitionType];
      if (!factory) {
        return null;
      }
      return factory(input, config, trans, configs, speculative, treatEofAsEpsilon);
    }
    /**
     * Fills the lookup table for creating lexer ATN configs. This helps to avoid frequent checks of the transition
     * type, which determines the configuration of the created config.
     */
    setupATNFactoryLookup() {
      this.lexerATNConfigFactory = [];
      this.lexerATNConfigFactory[Transition.RULE] = (input, config, trans) => {
        const newContext = createSingletonPredictionContext(
          config.context ?? void 0,
          trans.followState.stateNumber
        );
        return LexerATNConfig.createWithConfig(trans.target, config, newContext);
      };
      this.lexerATNConfigFactory[Transition.PRECEDENCE] = () => {
        throw new Error("Precedence predicates are not supported in lexers.");
      };
      this.lexerATNConfigFactory[Transition.PREDICATE] = (input, config, trans, configs, speculative) => {
        const pt = trans;
        if (_LexerATNSimulator.debug) {
          console.log("EVAL rule " + pt.ruleIndex + ":" + pt.predIndex);
        }
        configs.hasSemanticContext = true;
        if (this.evaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative)) {
          return LexerATNConfig.createWithConfig(trans.target, config);
        }
        return null;
      };
      this.lexerATNConfigFactory[Transition.ACTION] = (input, config, trans) => {
        if (config.context === null || config.context.hasEmptyPath()) {
          const lexerActionExecutor = LexerActionExecutor.append(
            config.lexerActionExecutor,
            this.atn.lexerActions[trans.actionIndex]
          );
          return LexerATNConfig.createWithExecutor(config, trans.target, lexerActionExecutor);
        } else {
          return LexerATNConfig.createWithConfig(trans.target, config);
        }
      };
      this.lexerATNConfigFactory[Transition.EPSILON] = (input, config, trans) => {
        return LexerATNConfig.createWithConfig(trans.target, config);
      };
      const simple = /* @__PURE__ */ __name((input, config, trans, configs, speculative, treatEofAsEpsilon) => {
        if (treatEofAsEpsilon) {
          if (trans.matches(Token.EOF, this.options.minCodePoint, this.options.maxCodePoint)) {
            return LexerATNConfig.createWithConfig(trans.target, config);
          }
        }
        return null;
      }, "simple");
      this.lexerATNConfigFactory[Transition.ATOM] = simple;
      this.lexerATNConfigFactory[Transition.RANGE] = simple;
      this.lexerATNConfigFactory[Transition.SET] = simple;
    }
    /**
     * Evaluate a predicate specified in the lexer.
     *
     * If `speculative` is `true`, this method was called before
     * {@link consume} for the matched character. This method should call
     * {@link consume} before evaluating the predicate to ensure position
     * sensitive values, including {@link Lexer//getText}, {@link Lexer//getLine},
     * and {@link Lexer}, properly reflect the current
     * lexer state. This method should restore `input` and the simulator
     * to the original state before returning (i.e. undo the actions made by the
     * call to {@link consume}.
     *
     * @param input The input stream.
     * @param ruleIndex The rule containing the predicate.
     * @param predIndex The index of the predicate within the rule.
     * @param speculative `true` if the current index in `input` is
     * one character before the predicate's location.
     *
     * @returns `true` if the specified predicate evaluates to
     * `true`.
     */
    evaluatePredicate(input, ruleIndex, predIndex, speculative) {
      if (!this.recognizer) {
        return true;
      }
      if (!speculative) {
        return this.recognizer.sempred(null, ruleIndex, predIndex);
      }
      const savedColumn = this.column;
      const savedLine = this.line;
      const index2 = input.index;
      const marker = input.mark();
      try {
        this.consume(input);
        return this.recognizer.sempred(null, ruleIndex, predIndex);
      } finally {
        this.column = savedColumn;
        this.line = savedLine;
        input.seek(index2);
        input.release(marker);
      }
    }
    captureSimState(input, dfaState) {
      this.prevAccept = {
        index: input.index,
        line: this.line,
        column: this.column,
        dfaState
      };
    }
    addDFAEdge(from, tk, to, configs) {
      if (!to && configs) {
        const suppressEdge = configs.hasSemanticContext;
        configs.hasSemanticContext = false;
        to = this.addDFAState(configs);
        if (suppressEdge) {
          return to;
        }
      }
      if (tk < this.options.minDFAEdge || tk > this.options.maxDFAEdge) {
        return to;
      }
      if (_LexerATNSimulator.debug) {
        console.log("EDGE " + from + " -> " + to + " upon " + tk);
      }
      from.edges[tk - this.options.minDFAEdge] = to;
      return to;
    }
    /**
     * Add a new DFA state if there isn't one with this set of configurations already. This method also detects
     * the first configuration containing an ATN rule stop state. Later, when traversing the DFA, we will know
     * which rule to accept.
     */
    addDFAState(configs) {
      const dfa = this.decisionToDFA[this.mode];
      const existing = dfa.getStateForConfigs(configs);
      if (existing) {
        return existing;
      }
      const proposed = DFAState.fromConfigs(configs);
      const firstConfigWithRuleStopState = configs.firstStopState;
      if (firstConfigWithRuleStopState) {
        proposed.isAcceptState = true;
        proposed.lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor;
        proposed.prediction = this.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex];
      }
      configs.setReadonly(true);
      dfa.addState(proposed);
      return proposed;
    }
  };
  var ParseInfo = class {
    static {
      __name(this, "ParseInfo");
    }
    atnSimulator;
    constructor(atnSimulator) {
      this.atnSimulator = atnSimulator;
    }
    /**
     * Gets an array of {@link DecisionInfo} instances containing the profiling
     * information gathered for each decision in the ATN.
     *
     * @returns An array of {@link DecisionInfo} instances, indexed by decision
     * number.
     */
    getDecisionInfo() {
      return this.atnSimulator.getDecisionInfo();
    }
    /**
     * Gets the decision numbers for decisions that required one or more
     * full-context predictions during parsing. These are decisions for which
     * {@link DecisionInfo#llFallback} is non-zero.
     *
     * @returns A list of decision numbers which required one or more
     * full-context predictions during parsing.
     */
    getLLDecisions() {
      const decisions = this.atnSimulator.getDecisionInfo();
      const result = new Array();
      for (let i = 0; i < decisions.length; i++) {
        const fallBack = decisions[i].llFallback;
        if (fallBack > 0) {
          result.push(i);
        }
      }
      return result;
    }
    /**
     * Gets the total time spent during prediction across all decisions made
     * during parsing. This value is the sum of
     * {@link DecisionInfo#timeInPrediction} for all decisions.
     */
    getTotalTimeInPrediction() {
      const decisions = this.atnSimulator.getDecisionInfo();
      let t = 0;
      for (const decision of decisions) {
        t += decision.timeInPrediction;
      }
      return t;
    }
    /**
     * Gets the total number of SLL lookahead operations across all decisions
     * made during parsing. This value is the sum of
     * {@link DecisionInfo#sllTotalLook} for all decisions.
     */
    getTotalSLLLookaheadOps() {
      const decisions = this.atnSimulator.getDecisionInfo();
      let k = 0;
      for (const decision of decisions) {
        k += decision.sllTotalLook;
      }
      return k;
    }
    /**
     * Gets the total number of LL lookahead operations across all decisions
     * made during parsing. This value is the sum of
     * {@link DecisionInfo#llTotalLook} for all decisions.
     */
    getTotalLLLookaheadOps() {
      const decisions = this.atnSimulator.getDecisionInfo();
      let k = 0;
      for (const decision of decisions) {
        k += decision.llTotalLook;
      }
      return k;
    }
    /**
     * Gets the total number of ATN lookahead operations for SLL prediction
     * across all decisions made during parsing.
     */
    getTotalSLLATNLookaheadOps() {
      const decisions = this.atnSimulator.getDecisionInfo();
      let k = 0;
      for (const decision of decisions) {
        k += decision.sllATNTransitions;
      }
      return k;
    }
    /**
     * Gets the total number of ATN lookahead operations for LL prediction
     * across all decisions made during parsing.
     */
    getTotalLLATNLookaheadOps() {
      const decisions = this.atnSimulator.getDecisionInfo();
      let k = 0;
      for (const decision of decisions) {
        k += decision.llATNTransitions;
      }
      return k;
    }
    /**
     * Gets the total number of ATN lookahead operations for SLL and LL
     * prediction across all decisions made during parsing.
     *
     *
     * This value is the sum of {@link #getTotalSLLATNLookaheadOps} and
     * {@link #getTotalLLATNLookaheadOps}.
     */
    getTotalATNLookaheadOps() {
      const decisions = this.atnSimulator.getDecisionInfo();
      let k = 0;
      for (const decision of decisions) {
        k += decision.sllATNTransitions;
        k += decision.llATNTransitions;
      }
      return k;
    }
    getDFASize(decision) {
      if (decision === void 0) {
        let n2 = 0;
        const decisionToDFA = this.atnSimulator.decisionToDFA;
        for (let i = 0; i < decisionToDFA.length; i++) {
          n2 += this.getDFASize(i);
        }
        return n2;
      } else {
        const decisionToDFA = this.atnSimulator.decisionToDFA[decision];
        return decisionToDFA.length;
      }
    }
  };
  var NoViableAltException = class extends RecognitionException {
    static {
      __name(this, "NoViableAltException");
    }
    /** Which configurations did we try at input.index() that couldn't match input.LT(1)? */
    deadEndConfigs = null;
    /**
     * The token object at the start index; the input stream might
     * 	not be buffering tokens so get a reference to it. (At the
     *  time the error occurred, of course the stream needs to keep a
     *  buffer all of the tokens but later we might not have access to those.)
     */
    startToken;
    constructor(recognizer, input = null, startToken = null, offendingToken = null, deadEndConfigs = null, ctx = null) {
      ctx = ctx ?? recognizer.context;
      offendingToken = offendingToken ?? recognizer.getCurrentToken();
      startToken = startToken ?? recognizer.getCurrentToken();
      input = input ?? recognizer.inputStream;
      super({ message: "", recognizer, input, ctx });
      this.deadEndConfigs = deadEndConfigs;
      this.startToken = startToken;
      this.offendingToken = offendingToken;
    }
  };
  var DoubleDict = class {
    static {
      __name(this, "DoubleDict");
    }
    cacheMap;
    constructor() {
      this.cacheMap = new HashMap();
    }
    get(a, b) {
      const d = this.cacheMap.get(a) ?? null;
      return d === null ? null : d.get(b) ?? null;
    }
    set(a, b, o) {
      let d = this.cacheMap.get(a);
      if (!d) {
        d = new HashMap();
        this.cacheMap.set(a, d);
      }
      d.set(b, o);
    }
  };
  var SubsetEqualityComparer = class _SubsetEqualityComparer {
    static {
      __name(this, "SubsetEqualityComparer");
    }
    static instance = new _SubsetEqualityComparer();
    hashCode(config) {
      let hashCode = MurmurHash.initialize(7);
      hashCode = MurmurHash.update(hashCode, config.state.stateNumber);
      hashCode = MurmurHash.updateFromComparable(hashCode, config.context);
      hashCode = MurmurHash.finish(hashCode, 2);
      return hashCode;
    }
    equals(a, b) {
      return a.state.stateNumber === b.state.stateNumber && (a.context?.equals(b.context) ?? true);
    }
  };
  var PredictionMode = class _PredictionMode {
    static {
      __name(this, "PredictionMode");
    }
    /**
     * The SLL(*) prediction mode. This prediction mode ignores the current
     * parser context when making predictions. This is the fastest prediction
     * mode, and provides correct results for many grammars. This prediction
     * mode is more powerful than the prediction mode provided by ANTLR 3, but
     * may result in syntax errors for grammar and input combinations which are
     * not SLL.
     *
     *
     * When using this prediction mode, the parser will either return a correct
     * parse tree (i.e. the same parse tree that would be returned with the
     * {@link LL} prediction mode), or it will report a syntax error. If a
     * syntax error is encountered when using the {@link SLL} prediction mode,
     * it may be due to either an actual syntax error in the input or indicate
     * that the particular combination of grammar and input requires the more
     * powerful {@link LL} prediction abilities to complete successfully.
     *
     *
     * This prediction mode does not provide any guarantees for prediction
     * behavior for syntactically-incorrect inputs.
     */
    static SLL = 0;
    /**
     * The LL(*) prediction mode. This prediction mode allows the current parser
     * context to be used for resolving SLL conflicts that occur during
     * prediction. This is the fastest prediction mode that guarantees correct
     * parse results for all combinations of grammars with syntactically correct
     * inputs.
     *
     *
     * When using this prediction mode, the parser will make correct decisions
     * for all syntactically-correct grammar and input combinations. However, in
     * cases where the grammar is truly ambiguous this prediction mode might not
     * report a precise answer for *exactly which* alternatives are
     * ambiguous.
     *
     *
     * This prediction mode does not provide any guarantees for prediction
     * behavior for syntactically-incorrect inputs.
     */
    static LL = 1;
    /**
     *
     * The LL(*) prediction mode with exact ambiguity detection. In addition to
     * the correctness guarantees provided by the {@link LL} prediction mode,
     * this prediction mode instructs the prediction algorithm to determine the
     * complete and exact set of ambiguous alternatives for every ambiguous
     * decision encountered while parsing.
     *
     *
     * This prediction mode may be used for diagnosing ambiguities during
     * grammar development. Due to the performance overhead of calculating sets
     * of ambiguous alternatives, this prediction mode should be avoided when
     * the exact results are not necessary.
     *
     *
     * This prediction mode does not provide any guarantees for prediction
     * behavior for syntactically-incorrect inputs.
     */
    static LL_EXACT_AMBIG_DETECTION = 2;
    /**
     *
     *Computes the SLL prediction termination condition.
     *
     *
     *This method computes the SLL prediction termination condition for both of
     *the following cases.
     *
     * - The usual SLL+LL fallback upon SLL conflict
     * - Pure SLL without LL fallback
     *
     ***COMBINED SLL+LL PARSING**
     *
     *When LL-fallback is enabled upon SLL conflict, correct predictions are
     *ensured regardless of how the termination condition is computed by this
     *method. Due to the substantially higher cost of LL prediction, the
     *prediction should only fall back to LL when the additional lookahead
     *cannot lead to a unique SLL prediction.
     *
     *Assuming combined SLL+LL parsing, an SLL configuration set with only
     *conflicting subsets should fall back to full LL, even if the
     *configuration sets don't resolve to the same alternative (e.g.
     *`{1,2`} and `{3,4`}. If there is at least one non-conflicting
     *configuration, SLL could continue with the hopes that more lookahead will
     *resolve via one of those non-conflicting configurations.
     *
     *Here's the prediction termination rule them: SLL (for SLL+LL parsing)
     *stops when it sees only conflicting configuration subsets. In contrast,
     *full LL keeps going when there is uncertainty.
     *
     ***HEURISTIC**
     *
     *As a heuristic, we stop prediction when we see any conflicting subset
     *unless we see a state that only has one alternative associated with it.
     *The single-alt-state thing lets prediction continue upon rules like
     *(otherwise, it would admit defeat too soon):
     *
     *`[12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;`
     *
     *When the ATN simulation reaches the state before `';'`, it has a
     *DFA state that looks like: `[12|1|[], 6|2|[], 12|2|[]]`. Naturally
     *`12|1|[]` and `12|2|[]` conflict, but we cannot stop
     *processing this node because alternative to has another way to continue,
     *via `[6|2|[]]`.
     *
     *It also let's us continue for this rule:
     *
     *`[1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;`
     *
     *After matching input A, we reach the stop state for rule A, state 1.
     *State 8 is the state right before B. Clearly alternatives 1 and 2
     *conflict and no amount of further lookahead will separate the two.
     *However, alternative 3 will be able to continue and so we do not stop
     *working on this state. In the previous example, we're concerned with
     *states associated with the conflicting alternatives. Here alt 3 is not
     *associated with the conflicting configs, but since we can continue
     *looking for input reasonably, don't declare the state done.
     *
     ***PURE SLL PARSING**
     *
     *To handle pure SLL parsing, all we have to do is make sure that we
     *combine stack contexts for configurations that differ only by semantic
     *predicate. From there, we can do the usual SLL termination heuristic.
     *
     ***PREDICATES IN SLL+LL PARSING**
     *
     *SLL decisions don't evaluate predicates until after they reach DFA stop
     *states because they need to create the DFA cache that works in all
     *semantic situations. In contrast, full LL evaluates predicates collected
     *during start state computation so it can ignore predicates thereafter.
     *This means that SLL termination detection can totally ignore semantic
     *predicates.
     *
     *Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
     *semantic predicate contexts so we might see two configurations like the
     *following.
     *
     *`(s, 1, x, {`), (s, 1, x', {p})}
     *
     *Before testing these configurations against others, we have to merge
     *`x` and `x'` (without modifying the existing configurations).
     *For example, we test `(x+x')==x''` when looking for conflicts in
     *the following configurations.
     *
     *`(s, 1, x, {`), (s, 1, x', {p}), (s, 2, x'', {})}
     *
     *If the configuration set has predicates (as indicated by
     *{@link ATNConfigSet//hasSemanticContext}), this algorithm makes a copy of
     *the configurations to strip out all of the predicates so that a standard
     *{@link ATNConfigSet} will merge everything ignoring predicates.
     */
    static hasSLLConflictTerminatingPrediction(mode, configs) {
      if (_PredictionMode.allConfigsInRuleStopStates(configs)) {
        return true;
      }
      if (mode === _PredictionMode.SLL) {
        if (configs.hasSemanticContext) {
          const dup = new ATNConfigSet();
          for (let c of configs) {
            c = ATNConfig.duplicate(c, SemanticContext.NONE);
            dup.add(c);
          }
          configs = dup;
        }
      }
      const altSets = _PredictionMode.getConflictingAltSubsets(configs);
      return _PredictionMode.hasConflictingAltSet(altSets) && !_PredictionMode.hasStateAssociatedWithOneAlt(configs);
    }
    /**
     * Checks if any configuration in `configs` is in a
     * {@link RuleStopState}. Configurations meeting this condition have reached
     * the end of the decision rule (local context) or end of start rule (full
     * context).
     *
     * @param configs the configuration set to test
     * @returns `true` if any configuration in `configs` is in a
     * {@link RuleStopState}, otherwise `false`
     */
    static hasConfigInRuleStopState(configs) {
      for (const c of configs) {
        if (c.state instanceof RuleStopState) {
          return true;
        }
      }
      return false;
    }
    /**
     * Checks if all configurations in `configs` are in a
     * {@link RuleStopState}. Configurations meeting this condition have reached
     * the end of the decision rule (local context) or end of start rule (full
     * context).
     *
     * @param configs the configuration set to test
     * @returns `true` if all configurations in `configs` are in a
     * {@link RuleStopState}, otherwise `false`
     */
    static allConfigsInRuleStopStates(configs) {
      for (const c of configs) {
        if (!(c.state instanceof RuleStopState)) {
          return false;
        }
      }
      return true;
    }
    /**
     *
     * Full LL prediction termination.
     *
     * Can we stop looking ahead during ATN simulation or is there some
     * uncertainty as to which alternative we will ultimately pick, after
     * consuming more input? Even if there are partial conflicts, we might know
     * that everything is going to resolve to the same minimum alternative. That
     * means we can stop since no more lookahead will change that fact. On the
     * other hand, there might be multiple conflicts that resolve to different
     * minimums. That means we need more look ahead to decide which of those
     * alternatives we should predict.
     *
     * The basic idea is to split the set of configurations `C`, into
     * conflicting subsets `(s, _, ctx, _)` and singleton subsets with
     * non-conflicting configurations. Two configurations conflict if they have
     * identical {@link ATNConfig.state} and {@link ATNConfig.context} values
     * but different {@link ATNConfig.alt} value, e.g. `(s, i, ctx, _)`
     * and `(s, j, ctx, _)` for `i!=j`.
     *
     * Reduce these configuration subsets to the set of possible alternatives.
     * You can compute the alternative subsets in one pass as follows:
     *
     * `A_s,ctx = {i | (s, i, ctx, _)`} for each configuration in
     * `C` holding `s` and `ctx` fixed.
     *
     * Or in pseudo-code, for each configuration `c` in `C`:
     *
     * ```
     * map[c] U= c.{@link ATNConfig.alt alt} // map hash/equals uses s and x, not
     * alt and not pred
     * ```
     *
     * The values in `map` are the set of `A_s,ctx` sets.
     *
     * If `|A_s,ctx|=1` then there is no conflict associated with
     * `s` and `ctx`.
     *
     * Reduce the subsets to singletons by choosing a minimum of each subset. If
     * the union of these alternative subsets is a singleton, then no amount of
     * more lookahead will help us. We will always pick that alternative. If,
     * however, there is more than one alternative, then we are uncertain which
     * alternative to predict and must continue looking for resolution. We may
     * or may not discover an ambiguity in the future, even if there are no
     * conflicting subsets this round.
     *
     * The biggest sin is to terminate early because it means we've made a
     * decision but were uncertain as to the eventual outcome. We haven't used
     * enough lookahead. On the other hand, announcing a conflict too late is no
     * big deal; you will still have the conflict. It's just inefficient. It
     * might even look until the end of file.
     *
     * No special consideration for semantic predicates is required because
     * predicates are evaluated on-the-fly for full LL prediction, ensuring that
     * no configuration contains a semantic context during the termination
     * check.
     *
     * **CONFLICTING CONFIGS**
     *
     * Two configurations `(s, i, x)` and `(s, j, x')`, conflict when `i!=j` but `x=x'`. Because we merge all
     * `(s, i, _)` configurations together, that means that there are at most `n` configurations associated with state
     * `s` for `n` possible alternatives in the decision. The merged stacks complicate the comparison of configuration
     * contexts `x` and `x'`. Sam checks to see if one is a subset of the other by calling merge and checking to see
     * if the merged result is either `x` or `x'`. If the `x` associated with lowest alternative `i` is the superset,
     * then `i` is the only possible prediction since the others resolve to `min(i)` as well. However, if `x` is
     * associated with `j>i` then at least one stack configuration for `j` is not in conflict with alternative `i`.
     * The algorithm should keep going, looking for more lookahead due to the uncertainty.
     *
     * For simplicity, I'm doing a equality check between `x` and `x'` that lets the algorithm continue to consume
     * lookahead longer than necessary. The reason I like the equality is of course the simplicity but also because
     * that is the test you need to detect the alternatives that are actually in conflict.
     *
     * **CONTINUE/STOP RULE**
     *
     * Continue if union of resolved alternative sets from non-conflicting and conflicting alternative subsets has more
     * than one alternative. We are uncertain about which alternative to predict.
     *
     * The complete set of alternatives, `[i for (_,i,_)]`, tells us which alternatives are still in the running for
     * the amount of input we've consumed at this point. The conflicting sets let us to strip away configurations that
     * won't lead to more states because we resolve conflicts to the configuration with a minimum alternate for the
     * conflicting set.
     *
     * **CASES**
     *
     * - no conflicts and more than 1 alternative in set => continue
     * -  `(s, 1, x)`, `(s, 2, x)`, `(s, 3, z)`, `(s', 1, y)`, `(s', 2, y)` yields non-conflicting set `{3`} U
     *   conflicting sets `min({1,2`)} U `min({1,2`)} = `{1,3`} => continue
     * - `(s, 1, x)`, `(s, 2, x)`, `(s', 1, y)`, `(s', 2, y)`, `(s'', 1, z)` yields non-conflicting set `{1`} U
     *   conflicting sets `min({1,2`)} U `min({1,2`)} = `{1`} => stop and predict 1
     * - `(s, 1, x)`, `(s, 2, x)`, `(s', 1, y)`, `(s', 2, y)` yields conflicting, reduced sets `{1`} U
     *   `{1`} = `{1`} => stop and predict 1, can announce ambiguity `{1,2`}
     * - `(s, 1, x)`, `(s, 2, x)`, `(s', 2, y)`, `(s', 3, y)` yields conflicting, reduced sets `{1`} U
     *   `{2`} = `{1,2`} => continue
     * - `(s, 1, x)`, `(s, 2, x)`, `(s', 3, y)`, `(s', 4, y)` yields conflicting, reduced sets `{1`} U
     *   `{3`} = `{1,3`} => continue
     *
     * **EXACT AMBIGUITY DETECTION**
     *
     *If all states report the same conflicting set of alternatives, then we
     *know we have the exact ambiguity set.
     *
     * `|A_*i*|>1` and `A_*i* = A_*j*` for all *i*, *j*.
     *
     * In other words, we continue examining lookahead until all `A_i` have more than one alternative and all `A_i`
     * are the same. If `A={{1,2`, {1,3}}}, then regular LL prediction would terminate because the resolved set
     * is `{1`}. To determine what the real ambiguity is, we have to know whether the ambiguity is between one and
     * two or one and three so we keep going. We can only stop prediction when we need exact ambiguity detection when
     * the sets look like `A={{1,2`}} or `{{1,2`,{1,2}}}, etc...
     */
    static resolvesToJustOneViableAlt(altSets) {
      return _PredictionMode.getSingleViableAlt(altSets);
    }
    /**
     * Determines if every alternative subset in `altSets` contains more
     * than one alternative.
     *
     * @param altSets a collection of alternative subsets
     * @returns `true` if every {@link BitSet} in `altSets` has
     * {@link BitSet//cardinality cardinality} > 1, otherwise `false`
     */
    static allSubsetsConflict(altSets) {
      return !_PredictionMode.hasNonConflictingAltSet(altSets);
    }
    /**
     * Determines if any single alternative subset in `altSets` contains
     * exactly one alternative.
     *
     * @param altSets a collection of alternative subsets
     * @returns `true` if `altSets` contains a {@link BitSet} with
     * {@link BitSet//cardinality cardinality} 1, otherwise `false`
     */
    static hasNonConflictingAltSet(altSets) {
      for (const alts of altSets) {
        if (alts.length === 1) {
          return true;
        }
      }
      return false;
    }
    /**
     * Determines if any single alternative subset in `altSets` contains
     * more than one alternative.
     *
     * @param altSets a collection of alternative subsets
     * @returns `true` if `altSets` contains a {@link BitSet} with
     * {@link BitSet//cardinality cardinality} > 1, otherwise `false`
     */
    static hasConflictingAltSet(altSets) {
      for (const alts of altSets) {
        if (alts.length > 1) {
          return true;
        }
      }
      return false;
    }
    /**
     * Determines if every alternative subset in `altSets` is equivalent.
     *
     * @param altSets a collection of alternative subsets
     * @returns `true` if every member of `altSets` is equal to the
     * others, otherwise `false`
     */
    static allSubsetsEqual(altSets) {
      let first = null;
      for (const alts of altSets) {
        if (first === null) {
          first = alts;
        } else if (alts !== first) {
          return false;
        }
      }
      return true;
    }
    /**
     * Returns the unique alternative predicted by all alternative subsets in
     * `altSets`. If no such alternative exists, this method returns
     * {@link ATN.INVALID_ALT_NUMBER}.
     *
     * @param altSets a collection of alternative subsets
     */
    static getUniqueAlt(altSets) {
      const all = _PredictionMode.getAlts(altSets);
      if (all.length === 1) {
        return all.nextSetBit(0);
      } else {
        return ATN.INVALID_ALT_NUMBER;
      }
    }
    /**
     * Gets the complete set of represented alternatives for a collection of
     * alternative subsets. This method returns the union of each {@link BitSet}
     * in `altSets`.
     *
     * @param altSets a collection of alternative subsets
     * @returns the set of represented alternatives in `altSets`
     */
    static getAlts(altSets) {
      const all = new BitSet();
      altSets.forEach((alts) => {
        all.or(alts);
      });
      return all;
    }
    /**
     * This function gets the conflicting alt subsets from a configuration set.
     * For each configuration `c` in `configs`:
     *
     * ```
     * map[c] U= c.{@link ATNConfig.alt alt} // map hash/equals uses s and x, not
     * alt and not pred
     * ```
     */
    static getConflictingAltSubsets(configs) {
      const configToAlts = new HashMap(SubsetEqualityComparer.instance);
      for (const cfg of configs) {
        let alts = configToAlts.get(cfg);
        if (!alts) {
          alts = new BitSet();
          configToAlts.set(cfg, alts);
        }
        alts.set(cfg.alt);
      }
      return Array.from(configToAlts.values());
    }
    /**
     * Get a map from state to alt subset from a configuration set. For each configuration `c` in `configs`:
     *
     * ```
     * map[c.state] = c.alt
     * ```
     */
    static getStateToAltMap(configs) {
      const m2 = new HashMap(ObjectEqualityComparator.instance);
      for (const c of configs) {
        let alts = m2.get(c.state);
        if (!alts) {
          alts = new BitSet();
          m2.set(c.state, alts);
        }
        alts.set(c.alt);
      }
      return m2;
    }
    static hasStateAssociatedWithOneAlt(configs) {
      const counts = {};
      for (const c of configs) {
        const stateNumber = c.state.stateNumber;
        if (!counts[stateNumber]) {
          counts[stateNumber] = 0;
        }
        counts[stateNumber]++;
      }
      return Object.values(counts).some((count) => {
        return count === 1;
      });
    }
    static getSingleViableAlt(altSets) {
      let result = null;
      for (const alts of altSets) {
        const minAlt = alts.nextSetBit(0);
        if (result === null) {
          result = minAlt;
        } else if (result !== minAlt) {
          return ATN.INVALID_ALT_NUMBER;
        }
      }
      return result ?? 0;
    }
  };
  var ParserATNSimulator = class _ParserATNSimulator extends ATNSimulator {
    static {
      __name(this, "ParserATNSimulator");
    }
    static traceATNSimulator = false;
    static debug;
    static debugAdd = false;
    static debugClosure = false;
    static dfaDebug = false;
    static retryDebug = false;
    /** SLL, LL, or LL + exact ambig detection? */
    predictionMode;
    decisionToDFA;
    parser;
    /**
     * Each prediction operation uses a cache for merge of prediction contexts.
     * Don't keep around as it wastes huge amounts of memory. DoubleKeyMap
     * isn't synchronized but we're ok since two threads shouldn't reuse same
     * parser/atn sim object because it can only handle one input at a time.
     * This maps graphs a and b to merged result c. (a,b)->c. We can avoid
     * the merge if we ever see a and b again.  Note that (b,a)->c should
     * also be examined during cache lookup.
     */
    mergeCache = new DoubleDict();
    // Used also in the profiling ATN simulator.
    predictionState;
    constructor(recog, atn, decisionToDFA, sharedContextCache) {
      super(atn, sharedContextCache);
      this.parser = recog;
      this.decisionToDFA = decisionToDFA;
    }
    static getUniqueAlt(configs) {
      let alt = ATN.INVALID_ALT_NUMBER;
      for (const c of configs) {
        if (alt === ATN.INVALID_ALT_NUMBER) {
          alt = c.alt;
        } else if (c.alt !== alt) {
          return ATN.INVALID_ALT_NUMBER;
        }
      }
      return alt;
    }
    reset() {
    }
    clearDFA() {
      for (let d = 0; d < this.decisionToDFA.length; d++) {
        this.decisionToDFA[d] = new DFA(this.atn.getDecisionState(d), d);
      }
    }
    // TODO: make outerContext an optional parameter, not optional null.
    adaptivePredict(input, decision, outerContext) {
      if (_ParserATNSimulator.debug || _ParserATNSimulator.traceATNSimulator) {
        console.log("adaptivePredict decision " + decision + " exec LA(1)==" + this.getLookaheadName(input) + " line " + input.LT(1).line + ":" + input.LT(1).column);
      }
      const dfa = this.decisionToDFA[decision];
      this.predictionState = {
        input,
        startIndex: input.index,
        outerContext: outerContext ?? void 0,
        dfa
      };
      const m2 = input.mark();
      const index2 = input.index;
      try {
        let s0;
        if (dfa.isPrecedenceDfa) {
          s0 = dfa.getPrecedenceStartState(this.parser.getPrecedence());
        } else {
          s0 = dfa.s0;
        }
        if (!s0) {
          if (!outerContext) {
            outerContext = ParserRuleContext.empty;
          }
          if (_ParserATNSimulator.debug) {
            console.log("predictATN decision " + dfa.decision + " exec LA(1)==" + this.getLookaheadName(input) + ", outerContext=" + outerContext.toString(this.parser.ruleNames));
          }
          const fullCtx = false;
          let s0_closure = this.computeStartState(dfa.atnStartState, ParserRuleContext.empty, fullCtx);
          if (dfa.isPrecedenceDfa) {
            s0_closure = this.applyPrecedenceFilter(s0_closure);
            s0 = this.addDFAState(dfa, DFAState.fromConfigs(s0_closure));
            dfa.setPrecedenceStartState(this.parser.getPrecedence(), s0);
          } else {
            s0 = this.addDFAState(dfa, DFAState.fromConfigs(s0_closure));
            dfa.s0 = s0;
          }
        }
        const alt = this.execATN(dfa, s0, input, index2, outerContext);
        if (_ParserATNSimulator.debug) {
          console.log("DFA after predictATN: " + dfa.toString(this.parser.vocabulary));
        }
        return alt;
      } finally {
        this.predictionState.dfa = void 0;
        this.mergeCache = new DoubleDict();
        input.seek(index2);
        input.release(m2);
      }
    }
    /**
     * Performs ATN simulation to compute a predicted alternative based
     *  upon the remaining input, but also updates the DFA cache to avoid
     *  having to traverse the ATN again for the same input sequence.
     *
     * There are some key conditions we're looking for after computing a new
     * set of ATN configs (proposed DFA state):
     *       if the set is empty, there is no viable alternative for current symbol
     *       does the state uniquely predict an alternative?
     *       does the state have a conflict that would prevent us from
     *         putting it on the work list?
     *
     * We also have some key operations to do:
     *       add an edge from previous DFA state to potentially new DFA state, D,
     *         upon current symbol but only if adding to work list, which means in all
     *         cases except no viable alternative (and possibly non-greedy decisions?)
     *       collecting predicates and adding semantic context to DFA accept states
     *       adding rule context to context-sensitive DFA accept states
     *       consuming an input symbol
     *       reporting a conflict
     *       reporting an ambiguity
     *       reporting a context sensitivity
     *       reporting insufficient predicates
     *
     * cover these cases:
     *    dead end
     *    single alt
     *    single alt + preds
     *    conflict
     *    conflict + preds
     */
    execATN(dfa, s0, input, startIndex, outerContext) {
      if (_ParserATNSimulator.debug || _ParserATNSimulator.traceATNSimulator) {
        console.log("execATN decision " + dfa.decision + ", DFA state " + s0 + ", LA(1)==" + this.getLookaheadName(input) + " line " + input.LT(1).line + ":" + input.LT(1).column);
      }
      let alt;
      let previousState = s0;
      let t = input.LA(1);
      while (true) {
        let nextState = this.getExistingTargetState(previousState, t);
        if (!nextState) {
          nextState = this.computeTargetState(dfa, previousState, t);
        }
        if (nextState === ATNSimulator.ERROR) {
          const e = this.noViableAlt(input, outerContext, previousState.configs, startIndex);
          input.seek(startIndex);
          alt = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousState.configs, outerContext);
          if (alt !== ATN.INVALID_ALT_NUMBER) {
            return alt;
          } else {
            throw e;
          }
        }
        if (nextState.requiresFullContext && this.predictionMode !== PredictionMode.SLL) {
          let conflictingAlts = null;
          if (nextState.predicates !== null) {
            if (_ParserATNSimulator.debug) {
              console.log("DFA state has preds in DFA sim LL failover");
            }
            const conflictIndex = input.index;
            if (conflictIndex !== startIndex) {
              input.seek(startIndex);
            }
            conflictingAlts = this.evalSemanticContext(nextState.predicates, outerContext, true);
            if (conflictingAlts.length === 1) {
              if (_ParserATNSimulator.debug) {
                console.log("Full LL avoided");
              }
              return conflictingAlts.nextSetBit(0);
            }
            if (conflictIndex !== startIndex) {
              input.seek(conflictIndex);
            }
          }
          if (_ParserATNSimulator.dfaDebug) {
            console.log("ctx sensitive state " + outerContext + " in " + nextState);
          }
          const fullCtx = true;
          const s0_closure = this.computeStartState(dfa.atnStartState, outerContext, fullCtx);
          this.reportAttemptingFullContext(dfa, conflictingAlts, nextState.configs, startIndex, input.index);
          alt = this.execATNWithFullContext(dfa, nextState, s0_closure, input, startIndex, outerContext);
          return alt;
        }
        if (nextState.isAcceptState) {
          if (nextState.predicates === null) {
            return nextState.prediction;
          }
          const stopIndex = input.index;
          input.seek(startIndex);
          const alts = this.evalSemanticContext(nextState.predicates, outerContext, true);
          if (alts.length === 0) {
            throw this.noViableAlt(input, outerContext, nextState.configs, startIndex);
          }
          if (alts.length === 1) {
            return alts.nextSetBit(0);
          }
          this.reportAmbiguity(dfa, nextState, startIndex, stopIndex, false, alts, nextState.configs);
          return alts.nextSetBit(0);
        }
        previousState = nextState;
        if (t !== Token.EOF) {
          input.consume();
          t = input.LA(1);
        }
      }
    }
    /**
     * Get an existing target state for an edge in the DFA. If the target state
     * for the edge has not yet been computed or is otherwise not available,
     * this method returns `null`.
     *
     * @param previousD The current DFA state
     * @param t The next input symbol
     * @returns The existing target DFA state for the given input symbol
     * `t`, or `null` if the target state for this edge is not
     * already cached
     */
    getExistingTargetState(previousD, t) {
      return previousD.edges[t + 1];
    }
    /**
     * Compute a target state for an edge in the DFA, and attempt to add the
     * computed state and corresponding edge to the DFA.
     *
     * @param dfa The DFA
     * @param previousD The current DFA state
     * @param t The next input symbol
     *
     * @returns The computed target DFA state for the given input symbol
     * `t`. If `t` does not lead to a valid DFA state, this method
     * returns {@link ERROR
     */
    computeTargetState(dfa, previousD, t) {
      const reach = this.computeReachSet(previousD.configs, t, false);
      if (reach === null) {
        this.addDFAEdge(dfa, previousD, t, ATNSimulator.ERROR);
        return ATNSimulator.ERROR;
      }
      let D = DFAState.fromConfigs(reach);
      const predictedAlt = _ParserATNSimulator.getUniqueAlt(reach);
      if (_ParserATNSimulator.debug) {
        const altSubSets = PredictionMode.getConflictingAltSubsets(reach);
        console.log("SLL altSubSets=" + arrayToString(altSubSets) + /*", previous=" + previousD.configs + */
        ", configs=" + reach + ", predict=" + predictedAlt + ", allSubsetsConflict=" + PredictionMode.allSubsetsConflict(altSubSets) + ", conflictingAlts=" + this.getConflictingAlts(reach));
      }
      if (predictedAlt !== ATN.INVALID_ALT_NUMBER) {
        D.isAcceptState = true;
        D.configs.uniqueAlt = predictedAlt;
        D.prediction = predictedAlt;
      } else if (PredictionMode.hasSLLConflictTerminatingPrediction(this.predictionMode, reach)) {
        D.configs.conflictingAlts = this.getConflictingAlts(reach);
        D.requiresFullContext = true;
        D.isAcceptState = true;
        D.prediction = D.configs.conflictingAlts.nextSetBit(0);
      }
      if (D.isAcceptState && D.configs.hasSemanticContext) {
        this.predicateDFAState(D, this.atn.getDecisionState(dfa.decision));
        if (D.predicates !== null) {
          D.prediction = ATN.INVALID_ALT_NUMBER;
        }
      }
      D = this.addDFAEdge(dfa, previousD, t, D);
      return D;
    }
    getRuleName(index2) {
      if (this.parser !== null && index2 >= 0) {
        return this.parser.ruleNames[index2];
      } else {
        return "<rule " + index2 + ">";
      }
    }
    getTokenName(t) {
      if (t === Token.EOF) {
        return "EOF";
      }
      const vocabulary = this.parser?.vocabulary ?? Vocabulary.EMPTY_VOCABULARY;
      const displayName = vocabulary.getDisplayName(t);
      if (displayName === t.toString()) {
        return displayName;
      }
      return displayName + "<" + t + ">";
    }
    getLookaheadName(input) {
      return this.getTokenName(input.LA(1));
    }
    /**
     * Used for debugging in adaptivePredict around execATN but I cut
     * it out for clarity now that alg. works well. We can leave this
     * "dead" code for a bit
     */
    dumpDeadEndConfigs(e) {
      console.log("dead end configs: ");
      const decs = e.deadEndConfigs;
      for (const c of decs) {
        let trans = "no edges";
        if (c.state.transitions.length > 0) {
          const t = c.state.transitions[0];
          if (t instanceof AtomTransition) {
            trans = "Atom " + this.getTokenName(t.labelValue);
          } else if (t instanceof SetTransition) {
            const neg = t instanceof NotSetTransition;
            trans = (neg ? "~" : "") + "Set " + t.label;
          }
        }
        console.error(c.toString(this.parser, true) + ":" + trans);
      }
    }
    predicateDFAState(dfaState, decisionState) {
      const altCount = decisionState.transitions.length;
      const altsToCollectPredsFrom = this.getConflictingAltsOrUniqueAlt(dfaState.configs);
      const altToPred = this.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, altCount);
      if (altToPred !== null) {
        dfaState.predicates = this.getPredicatePredictions(altsToCollectPredsFrom, altToPred);
        dfaState.prediction = ATN.INVALID_ALT_NUMBER;
      } else {
        dfaState.prediction = altsToCollectPredsFrom.nextSetBit(0);
      }
    }
    // comes back with reach.uniqueAlt set to a valid alt
    execATNWithFullContext(dfa, D, s0, input, startIndex, outerContext) {
      if (_ParserATNSimulator.debug || _ParserATNSimulator.traceATNSimulator) {
        console.log("execATNWithFullContext " + s0);
      }
      const fullCtx = true;
      let foundExactAmbig = false;
      let reach;
      let previous = s0;
      input.seek(startIndex);
      let t = input.LA(1);
      let predictedAlt = -1;
      for (; ; ) {
        reach = this.computeReachSet(previous, t, fullCtx);
        if (reach === null) {
          const e = this.noViableAlt(input, outerContext, previous, startIndex);
          input.seek(startIndex);
          const alt = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext);
          if (alt !== ATN.INVALID_ALT_NUMBER) {
            return alt;
          } else {
            throw e;
          }
        }
        const altSubSets = PredictionMode.getConflictingAltSubsets(reach);
        if (_ParserATNSimulator.debug) {
          console.log("LL altSubSets=" + altSubSets + ", predict=" + PredictionMode.getUniqueAlt(altSubSets) + ", resolvesToJustOneViableAlt=" + PredictionMode.resolvesToJustOneViableAlt(altSubSets));
        }
        reach.uniqueAlt = _ParserATNSimulator.getUniqueAlt(reach);
        if (reach.uniqueAlt !== ATN.INVALID_ALT_NUMBER) {
          predictedAlt = reach.uniqueAlt;
          break;
        } else if (this.predictionMode !== PredictionMode.LL_EXACT_AMBIG_DETECTION) {
          predictedAlt = PredictionMode.resolvesToJustOneViableAlt(altSubSets);
          if (predictedAlt !== ATN.INVALID_ALT_NUMBER) {
            break;
          }
        } else {
          if (PredictionMode.allSubsetsConflict(altSubSets) && PredictionMode.allSubsetsEqual(altSubSets)) {
            foundExactAmbig = true;
            predictedAlt = PredictionMode.getSingleViableAlt(altSubSets);
            break;
          }
        }
        previous = reach;
        if (t !== Token.EOF) {
          input.consume();
          t = input.LA(1);
        }
      }
      if (reach.uniqueAlt !== ATN.INVALID_ALT_NUMBER) {
        this.reportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.index);
        return predictedAlt;
      }
      this.reportAmbiguity(dfa, D, startIndex, input.index, foundExactAmbig, reach.getAlts(), reach);
      return predictedAlt;
    }
    computeReachSet(closure, t, fullCtx) {
      if (_ParserATNSimulator.debug) {
        console.log("in computeReachSet, starting closure: " + closure);
      }
      const intermediate = new ATNConfigSet(fullCtx);
      let skippedStopStates = null;
      for (const c of closure) {
        if (_ParserATNSimulator.debug) {
          console.log("testing " + this.getTokenName(t) + " at " + c);
        }
        if (c.state instanceof RuleStopState) {
          if (fullCtx || t === Token.EOF) {
            if (skippedStopStates === null) {
              skippedStopStates = [];
            }
            skippedStopStates.push(c);
          }
          continue;
        }
        for (const trans of c.state.transitions) {
          const target = this.getReachableTarget(trans, t);
          if (target !== null) {
            const cfg = ATNConfig.createWithConfig(target, c);
            intermediate.add(cfg, this.mergeCache);
            if (_ParserATNSimulator.debugAdd) {
              console.log("added " + cfg + " to intermediate");
            }
          }
        }
      }
      let reach = null;
      if (skippedStopStates === null && t !== Token.EOF) {
        if (intermediate.length === 1) {
          reach = intermediate;
        } else if (_ParserATNSimulator.getUniqueAlt(intermediate) !== ATN.INVALID_ALT_NUMBER) {
          reach = intermediate;
        }
      }
      if (reach === null) {
        reach = new ATNConfigSet(fullCtx);
        const closureBusy = new HashSet();
        const treatEofAsEpsilon = t === Token.EOF;
        for (const config of intermediate) {
          this.closure(config, reach, closureBusy, false, fullCtx, treatEofAsEpsilon);
        }
      }
      if (t === Token.EOF) {
        reach = this.removeAllConfigsNotInRuleStopState(reach, reach === intermediate);
      }
      if (skippedStopStates !== null && (!fullCtx || !PredictionMode.hasConfigInRuleStopState(reach))) {
        for (const config of skippedStopStates) {
          reach.add(config, this.mergeCache);
        }
      }
      if (_ParserATNSimulator.traceATNSimulator) {
        console.log("computeReachSet " + closure + " -> " + reach);
      }
      if (reach.length === 0) {
        return null;
      } else {
        return reach;
      }
    }
    /**
     * Return a configuration set containing only the configurations from
     * `configs` which are in a {@link RuleStopState}. If all
     * configurations in `configs` are already in a rule stop state, this
     * method simply returns `configs`.
     *
     * When `lookToEndOfRule` is true, this method uses
     * {@link ATN.nextTokens} for each configuration in `configs` which is
     * not already in a rule stop state to see if a rule stop state is reachable
     * from the configuration via epsilon-only transitions.
     *
     * @param configs the configuration set to update
     * @param lookToEndOfRule when true, this method checks for rule stop states
     * reachable by epsilon-only transitions from each configuration in
     * `configs`.
     *
     * @returns `configs` if all configurations in `configs` are in a
     * rule stop state, otherwise return a new configuration set containing only
     * the configurations from `configs` which are in a rule stop state
     */
    removeAllConfigsNotInRuleStopState(configs, lookToEndOfRule) {
      if (PredictionMode.allConfigsInRuleStopStates(configs)) {
        return configs;
      }
      const result = new ATNConfigSet(configs.fullCtx);
      for (const config of configs) {
        if (config.state instanceof RuleStopState) {
          result.add(config, this.mergeCache);
          continue;
        }
        if (lookToEndOfRule && config.state.epsilonOnlyTransitions) {
          const nextTokens = this.atn.nextTokens(config.state);
          if (nextTokens.contains(Token.EPSILON)) {
            const endOfRuleState = this.atn.ruleToStopState[config.state.ruleIndex];
            result.add(ATNConfig.createWithConfig(endOfRuleState, config), this.mergeCache);
          }
        }
      }
      return result;
    }
    computeStartState(p, ctx, fullCtx) {
      const initialContext = predictionContextFromRuleContext(this.atn, ctx);
      const configs = new ATNConfigSet(fullCtx);
      if (_ParserATNSimulator.traceATNSimulator) {
        console.log("computeStartState from ATN state " + p + " initialContext=" + initialContext.toString(this.parser));
      }
      for (let i = 0; i < p.transitions.length; i++) {
        const target = p.transitions[i].target;
        const c = ATNConfig.createWithContext(target, i + 1, initialContext);
        const closureBusy = new HashSet();
        this.closure(c, configs, closureBusy, true, fullCtx, false);
      }
      return configs;
    }
    /**
     * This method transforms the start state computed by
     * {@link computeStartState} to the special start state used by a
     * precedence DFA for a particular precedence value. The transformation
     * process applies the following changes to the start state's configuration
     * set.
     *
     * 1. Evaluate the precedence predicates for each configuration using
     * {@link SemanticContext//evalPrecedence}.
     * 2. Remove all configurations which predict an alternative greater than
     * 1, for which another configuration that predicts alternative 1 is in the
     * same ATN state with the same prediction context. This transformation is
     * valid for the following reasons:
     * 3. The closure block cannot contain any epsilon transitions which bypass
     * the body of the closure, so all states reachable via alternative 1 are
     * part of the precedence alternatives of the transformed left-recursive
     * rule.
     * 4. The "primary" portion of a left recursive rule cannot contain an
     * epsilon transition, so the only way an alternative other than 1 can exist
     * in a state that is also reachable via alternative 1 is by nesting calls
     * to the left-recursive rule, with the outer calls not being at the
     * preferred precedence level.
     *
     *
     * The prediction context must be considered by this filter to address
     * situations like the following.
     *
     * `
     * ```
     * grammar TA;
     * prog: statement* EOF;
     * statement: letterA | statement letterA 'b' ;
     * letterA: 'a';
     * ```
     * `
     *
     * If the above grammar, the ATN state immediately before the token
     * reference `'a'` in `letterA` is reachable from the left edge
     * of both the primary and closure blocks of the left-recursive rule
     * `statement`. The prediction context associated with each of these
     * configurations distinguishes between them, and prevents the alternative
     * which stepped out to `prog` (and then back in to `statement`
     * from being eliminated by the filter.
     *
     * @param configs The configuration set computed by
     * {@link computeStartState} as the start state for the DFA.
     * @returns The transformed configuration set representing the start state
     * for a precedence DFA at a particular precedence level (determined by
     * calling {@link Parser//getPrecedence})
     */
    applyPrecedenceFilter(configs) {
      const statesFromAlt1 = [];
      const configSet = new ATNConfigSet(configs.fullCtx);
      for (const config of configs) {
        if (config.alt !== 1) {
          continue;
        }
        const updatedContext = config.semanticContext.evalPrecedence(
          this.parser,
          this.predictionState.outerContext
        );
        if (updatedContext === null) {
          continue;
        }
        statesFromAlt1[config.state.stateNumber] = config.context;
        if (updatedContext !== config.semanticContext) {
          configSet.add(ATNConfig.duplicate(config, updatedContext), this.mergeCache);
        } else {
          configSet.add(config, this.mergeCache);
        }
      }
      for (const config of configs) {
        if (config.alt === 1) {
          continue;
        }
        if (!config.precedenceFilterSuppressed) {
          const context = statesFromAlt1[config.state.stateNumber] || null;
          if (context !== null && context.equals(config.context)) {
            continue;
          }
        }
        configSet.add(config, this.mergeCache);
      }
      return configSet;
    }
    getReachableTarget(trans, ttype) {
      if (trans.matches(ttype, 0, this.atn.maxTokenType)) {
        return trans.target;
      } else {
        return null;
      }
    }
    getPredsForAmbigAlts(ambigAlts, configs, altCount) {
      let altToPred = [];
      for (const c of configs) {
        if (ambigAlts.get(c.alt)) {
          altToPred[c.alt] = SemanticContext.orContext(altToPred[c.alt] ?? null, c.semanticContext);
        }
      }
      let nPredAlts = 0;
      for (let i = 1; i < altCount + 1; i++) {
        const pred = altToPred[i] ?? null;
        if (pred === null) {
          altToPred[i] = SemanticContext.NONE;
        } else if (pred !== SemanticContext.NONE) {
          nPredAlts += 1;
        }
      }
      if (nPredAlts === 0) {
        altToPred = null;
      }
      if (_ParserATNSimulator.debug) {
        console.log("getPredsForAmbigAlts result " + arrayToString(altToPred));
      }
      return altToPred;
    }
    getPredicatePredictions(ambigAlts, altToPred) {
      const pairs = [];
      let containsPredicate = false;
      for (let i = 1; i < altToPred.length; i++) {
        const pred = altToPred[i];
        if (ambigAlts.get(i)) {
          pairs.push({ pred, alt: i });
        }
        if (pred !== SemanticContext.NONE) {
          containsPredicate = true;
        }
      }
      if (!containsPredicate) {
        return null;
      }
      return pairs;
    }
    /**
     * This method is used to improve the localization of error messages by
     * choosing an alternative rather than throwing a
     * {@link NoViableAltException} in particular prediction scenarios where the
     * {@link ERROR} state was reached during ATN simulation.
     *
     *
     * The default implementation of this method uses the following
     * algorithm to identify an ATN configuration which successfully parsed the
     * decision entry rule. Choosing such an alternative ensures that the
     * {@link ParserRuleContext} returned by the calling rule will be complete
     * and valid, and the syntax error will be reported later at a more
     * localized location.
     *
     * - If a syntactically valid path or paths reach the end of the decision rule and
     * they are semantically valid if predicated, return the min associated alt.
     * - Else, if a semantically invalid but syntactically valid path exist
     * or paths exist, return the minimum associated alt.
     *
     * - Otherwise, return {@link ATN//INVALID_ALT_NUMBER}.
     *
     *
     * In some scenarios, the algorithm described above could predict an
     * alternative which will result in a {@link FailedPredicateException} in
     * the parser. Specifically, this could occur if the *only* configuration
     * capable of successfully parsing to the end of the decision rule is
     * blocked by a semantic predicate. By choosing this alternative within
     * {@link adaptivePredict} instead of throwing a
     * {@link NoViableAltException}, the resulting
     * {@link FailedPredicateException} in the parser will identify the specific
     * predicate which is preventing the parser from successfully parsing the
     * decision rule, which helps developers identify and correct logic errors
     * in semantic predicates.
     *
     * @param configs The ATN configurations which were valid immediately before
     * the {@link ERROR} state was reached
     * @param outerContext The is the \gamma_0 initial parser context from the paper
     * or the parser stack at the instant before prediction commences.
     *
     * @returns The value to return from {@link adaptivePredict}, or
     * {@link ATN//INVALID_ALT_NUMBER} if a suitable alternative was not
     * identified and {@link adaptivePredict} should report an error instead
     */
    getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(configs, outerContext) {
      const splitConfigs = this.splitAccordingToSemanticValidity(configs, outerContext);
      const semValidConfigs = splitConfigs[0];
      const semInvalidConfigs = splitConfigs[1];
      let alt = this.getAltThatFinishedDecisionEntryRule(semValidConfigs);
      if (alt !== ATN.INVALID_ALT_NUMBER) {
        return alt;
      }
      if (semInvalidConfigs.length > 0) {
        alt = this.getAltThatFinishedDecisionEntryRule(semInvalidConfigs);
        if (alt !== ATN.INVALID_ALT_NUMBER) {
          return alt;
        }
      }
      return ATN.INVALID_ALT_NUMBER;
    }
    getAltThatFinishedDecisionEntryRule(configs) {
      const alts = [];
      for (const c of configs) {
        if (c.reachesIntoOuterContext || c.state instanceof RuleStopState && c.context.hasEmptyPath()) {
          if (alts.indexOf(c.alt) < 0) {
            alts.push(c.alt);
          }
        }
      }
      if (alts.length === 0) {
        return ATN.INVALID_ALT_NUMBER;
      } else {
        return Math.min(...alts);
      }
    }
    /**
     * Walk the list of configurations and split them according to
     * those that have preds evaluating to true/false.  If no pred, assume
     * true pred and include in succeeded set.  Returns Pair of sets.
     *
     * Create a new set so as not to alter the incoming parameter.
     *
     * Assumption: the input stream has been restored to the starting point
     * prediction, which is where predicates need to evaluate.
     */
    splitAccordingToSemanticValidity(configs, outerContext) {
      const succeeded = new ATNConfigSet(configs.fullCtx);
      const failed = new ATNConfigSet(configs.fullCtx);
      for (const c of configs) {
        if (c.semanticContext !== SemanticContext.NONE) {
          const predicateEvaluationResult = c.semanticContext.evaluate(this.parser, outerContext);
          if (predicateEvaluationResult) {
            succeeded.add(c);
          } else {
            failed.add(c);
          }
        } else {
          succeeded.add(c);
        }
      }
      return [succeeded, failed];
    }
    /**
     * Look through a list of predicate/alt pairs, returning alts for the
     * pairs that win. A `NONE` predicate indicates an alt containing an
     * unpredicated config which behaves as "always true." If !complete
     * then we stop at the first predicate that evaluates to true. This
     * includes pairs with null predicates.
     */
    evalSemanticContext(predPredictions, outerContext, complete) {
      const predictions = new BitSet();
      for (const pair of predPredictions) {
        if (pair.pred === SemanticContext.NONE) {
          predictions.set(pair.alt);
          if (!complete) {
            break;
          }
          continue;
        }
        const predicateEvaluationResult = pair.pred.evaluate(this.parser, outerContext);
        if (_ParserATNSimulator.debug || _ParserATNSimulator.dfaDebug) {
          console.log("eval pred " + pair + "=" + predicateEvaluationResult);
        }
        if (predicateEvaluationResult) {
          predictions.set(pair.alt);
          if (!complete) {
            break;
          }
        }
      }
      return predictions;
    }
    // TODO: If we are doing predicates, there is no point in pursuing
    //     closure operations if we reach a DFA state that uniquely predicts
    //     alternative. We will not be caching that DFA state and it is a
    //     waste to pursue the closure. Might have to advance when we do
    //     ambig detection thought :(
    //
    closure(config, configs, closureBusy, collectPredicates, fullCtx, treatEofAsEpsilon) {
      const initialDepth = 0;
      this.closureCheckingStopState(
        config,
        configs,
        closureBusy,
        collectPredicates,
        fullCtx,
        initialDepth,
        treatEofAsEpsilon
      );
    }
    closureCheckingStopState(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon) {
      if (_ParserATNSimulator.traceATNSimulator || _ParserATNSimulator.debugClosure) {
        console.log("closure(" + config.toString(this.parser, true) + ")");
      }
      if (config.state instanceof RuleStopState) {
        if (config.context && !config.context.isEmpty()) {
          for (let i = 0; i < config.context.length; i++) {
            if (config.context.getReturnState(i) === PredictionContext.EMPTY_RETURN_STATE) {
              if (fullCtx) {
                configs.add(
                  ATNConfig.createWithConfig(
                    config.state,
                    config,
                    EmptyPredictionContext.instance
                  ),
                  this.mergeCache
                );
                continue;
              } else {
                if (_ParserATNSimulator.debug) {
                  console.log("FALLING off rule " + this.getRuleName(config.state.ruleIndex));
                }
                this.closure_(
                  config,
                  configs,
                  closureBusy,
                  collectPredicates,
                  fullCtx,
                  depth,
                  treatEofAsEpsilon
                );
              }
              continue;
            }
            const returnState = this.atn.states[config.context.getReturnState(i)];
            const newContext = config.context.getParent(i);
            const c = ATNConfig.createWithContext(returnState, config.alt, newContext, config.semanticContext);
            c.reachesIntoOuterContext = config.reachesIntoOuterContext;
            this.closureCheckingStopState(
              c,
              configs,
              closureBusy,
              collectPredicates,
              fullCtx,
              depth - 1,
              treatEofAsEpsilon
            );
          }
          return;
        } else if (fullCtx) {
          configs.add(config, this.mergeCache);
          return;
        } else {
          if (_ParserATNSimulator.debug) {
            console.log("FALLING off rule " + this.getRuleName(config.state.ruleIndex));
          }
        }
      }
      this.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon);
    }
    // Do the actual work of walking epsilon edges//
    closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon) {
      const p = config.state;
      if (!p.epsilonOnlyTransitions) {
        configs.add(config, this.mergeCache);
      }
      for (let i = 0; i < p.transitions.length; i++) {
        if (i === 0 && this.canDropLoopEntryEdgeInLeftRecursiveRule(config)) {
          continue;
        }
        const t = p.transitions[i];
        const continueCollecting = collectPredicates && !(t instanceof ActionTransition);
        const c = this.getEpsilonTarget(config, t, continueCollecting, depth === 0, fullCtx, treatEofAsEpsilon);
        if (c) {
          let newDepth = depth;
          if (config.state.constructor.stateType === ATNState.RULE_STOP) {
            if (this.predictionState.dfa && this.predictionState?.dfa.isPrecedenceDfa) {
              const outermostPrecedenceReturn = t.outermostPrecedenceReturn;
              if (outermostPrecedenceReturn === this.predictionState?.dfa.atnStartState?.ruleIndex) {
                c.precedenceFilterSuppressed = true;
              }
            }
            c.reachesIntoOuterContext = true;
            if (closureBusy.getOrAdd(c) !== c) {
              continue;
            }
            configs.dipsIntoOuterContext = true;
            newDepth -= 1;
            if (_ParserATNSimulator.debug) {
              console.log("dips into outer ctx: " + c);
            }
          } else {
            if (!t.isEpsilon && closureBusy.getOrAdd(c) !== c) {
              continue;
            }
            if (t instanceof RuleTransition) {
              if (newDepth >= 0) {
                newDepth += 1;
              }
            }
          }
          this.closureCheckingStopState(
            c,
            configs,
            closureBusy,
            continueCollecting,
            fullCtx,
            newDepth,
            treatEofAsEpsilon
          );
        }
      }
    }
    canDropLoopEntryEdgeInLeftRecursiveRule(config) {
      const p = config.state;
      if (p.constructor.stateType !== ATNState.STAR_LOOP_ENTRY || !config.context) {
        return false;
      }
      if (!p.precedenceRuleDecision || config.context.isEmpty() || config.context.hasEmptyPath()) {
        return false;
      }
      const numCtxs = config.context.length;
      for (let i = 0; i < numCtxs; i++) {
        const returnState = this.atn.states[config.context.getReturnState(i)];
        if (returnState.ruleIndex !== p.ruleIndex) {
          return false;
        }
      }
      const decisionStartState = p.transitions[0].target;
      const blockEndStateNum = decisionStartState.endState.stateNumber;
      const blockEndState = this.atn.states[blockEndStateNum];
      for (let i = 0; i < numCtxs; i++) {
        const returnStateNumber = config.context.getReturnState(i);
        const returnState = this.atn.states[returnStateNumber];
        if (returnState.transitions.length !== 1 || !returnState.transitions[0].isEpsilon) {
          return false;
        }
        const returnStateTarget = returnState.transitions[0].target;
        if (returnState.constructor.stateType === ATNState.BLOCK_END && returnStateTarget === p) {
          continue;
        }
        if (returnState === blockEndState) {
          continue;
        }
        if (returnStateTarget === blockEndState) {
          continue;
        }
        if (returnStateTarget.constructor.stateType === ATNState.BLOCK_END && returnStateTarget.transitions.length === 1 && returnStateTarget.transitions[0].isEpsilon && returnStateTarget.transitions[0].target === p) {
          continue;
        }
        return false;
      }
      return true;
    }
    getEpsilonTarget(config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon) {
      switch (t.transitionType) {
        case Transition.RULE: {
          return this.ruleTransition(config, t);
        }
        case Transition.PRECEDENCE: {
          return this.precedenceTransition(
            config,
            t,
            collectPredicates,
            inContext,
            fullCtx
          );
        }
        case Transition.PREDICATE: {
          return this.predTransition(config, t, collectPredicates, inContext, fullCtx);
        }
        case Transition.ACTION: {
          if (_ParserATNSimulator.debug) {
            const at = t;
            const index2 = at.actionIndex === -1 ? 65535 : at.actionIndex;
            console.log("ACTION edge " + at.ruleIndex + ":" + index2);
          }
          return ATNConfig.createWithConfig(t.target, config);
        }
        case Transition.EPSILON: {
          return ATNConfig.createWithConfig(t.target, config);
        }
        case Transition.ATOM:
        case Transition.RANGE:
        case Transition.SET: {
          if (treatEofAsEpsilon) {
            if (t.matches(Token.EOF, 0, 1)) {
              return ATNConfig.createWithConfig(t.target, config);
            }
          }
          return null;
        }
        default:
          return null;
      }
    }
    precedenceTransition(config, pt, collectPredicates, inContext, fullCtx) {
      if (_ParserATNSimulator.debug) {
        console.log("PRED (collectPredicates=" + collectPredicates + ") " + pt.precedence + ">=_p, ctx dependent=true");
        if (this.parser !== null) {
          console.log("context surrounding pred is " + arrayToString(this.parser.getRuleInvocationStack()));
        }
      }
      let c = null;
      if (collectPredicates && inContext) {
        if (fullCtx && this.predictionState?.input) {
          const currentPosition = this.predictionState.input.index;
          this.predictionState.input.seek(this.predictionState.startIndex);
          const predSucceeds = pt.getPredicate().evaluate(this.parser, this.predictionState.outerContext);
          this.predictionState.input.seek(currentPosition);
          if (predSucceeds) {
            c = ATNConfig.createWithConfig(pt.target, config);
          }
        } else {
          const newSemCtx = SemanticContext.andContext(config.semanticContext, pt.getPredicate());
          c = ATNConfig.createWithSemanticContext(pt.target, config, newSemCtx);
        }
      } else {
        c = ATNConfig.createWithConfig(pt.target, config);
      }
      if (_ParserATNSimulator.debug) {
        console.log("config from pred transition=" + c);
      }
      return c;
    }
    predTransition(config, pt, collectPredicates, inContext, fullCtx) {
      if (_ParserATNSimulator.debug) {
        console.log("PRED (collectPredicates=" + collectPredicates + ") " + pt.ruleIndex + ":" + pt.predIndex + ", ctx dependent=" + pt.isCtxDependent);
        if (this.parser !== null) {
          console.log("context surrounding pred is " + arrayToString(this.parser.getRuleInvocationStack()));
        }
      }
      let c = null;
      if (collectPredicates && (pt.isCtxDependent && inContext || !pt.isCtxDependent)) {
        if (fullCtx && this.predictionState?.input) {
          const currentPosition = this.predictionState.input.index;
          this.predictionState.input.seek(this.predictionState.startIndex);
          const predSucceeds = pt.getPredicate().evaluate(this.parser, this.predictionState.outerContext);
          this.predictionState.input.seek(currentPosition);
          if (predSucceeds) {
            c = ATNConfig.createWithConfig(pt.target, config);
          }
        } else {
          const newSemCtx = SemanticContext.andContext(config.semanticContext, pt.getPredicate());
          c = ATNConfig.createWithSemanticContext(pt.target, config, newSemCtx);
        }
      } else {
        c = ATNConfig.createWithConfig(pt.target, config);
      }
      if (_ParserATNSimulator.debug) {
        console.log("config from pred transition=" + c);
      }
      return c;
    }
    ruleTransition(config, t) {
      if (_ParserATNSimulator.debug) {
        console.log("CALL rule " + this.getRuleName(t.target.ruleIndex) + ", ctx=" + config.context);
      }
      const returnState = t.followState;
      const newContext = createSingletonPredictionContext(config.context ?? void 0, returnState.stateNumber);
      return ATNConfig.createWithConfig(t.target, config, newContext);
    }
    getConflictingAlts(configs) {
      const altSets = PredictionMode.getConflictingAltSubsets(configs);
      return PredictionMode.getAlts(altSets);
    }
    /**
     * Sam pointed out a problem with the previous definition, v3, of
     * ambiguous states. If we have another state associated with conflicting
     * alternatives, we should keep going. For example, the following grammar
     *
     * s : (ID | ID ID?) ';' ;
     *
     * When the ATN simulation reaches the state before ';', it has a DFA
     * state that looks like: [12|1|[], 6|2|[], 12|2|[]]. Naturally
     * 12|1|[] and 12|2|[] conflict, but we cannot stop processing this node
     * because alternative to has another way to continue, via [6|2|[]].
     * The key is that we have a single state that has config's only associated
     * with a single alternative, 2, and crucially the state transitions
     * among the configurations are all non-epsilon transitions. That means
     * we don't consider any conflicts that include alternative 2. So, we
     * ignore the conflict between alts 1 and 2. We ignore a set of
     * conflicting alts when there is an intersection with an alternative
     * associated with a single alt state in the state -> config-list map.
     *
     * It's also the case that we might have two conflicting configurations but
     * also a 3rd nonconflicting configuration for a different alternative:
     * [1|1|[], 1|2|[], 8|3|[]]. This can come about from grammar:
     *
     * a : A | A | A B ;
     *
     * After matching input A, we reach the stop state for rule A, state 1.
     * State 8 is the state right before B. Clearly alternatives 1 and 2
     * conflict and no amount of further lookahead will separate the two.
     * However, alternative 3 will be able to continue and so we do not
     * stop working on this state. In the previous example, we're concerned
     * with states associated with the conflicting alternatives. Here alt
     * 3 is not associated with the conflicting configs, but since we can continue
     * looking for input reasonably, I don't declare the state done. We
     * ignore a set of conflicting alts when we have an alternative
     * that we still need to pursue
     */
    getConflictingAltsOrUniqueAlt(configs) {
      let conflictingAlts;
      if (configs.uniqueAlt !== ATN.INVALID_ALT_NUMBER) {
        conflictingAlts = new BitSet();
        conflictingAlts.set(configs.uniqueAlt);
      } else {
        conflictingAlts = configs.conflictingAlts;
      }
      return conflictingAlts;
    }
    noViableAlt(input, outerContext, configs, startIndex) {
      return new NoViableAltException(this.parser, input, input.get(startIndex), input.LT(1), configs, outerContext);
    }
    /**
     * Add an edge to the DFA, if possible. This method calls
     * {@link addDFAState} to ensure the `to` state is present in the
     * DFA. If `from` is `null`, or if `t` is outside the
     * range of edges that can be represented in the DFA tables, this method
     * returns without adding the edge to the DFA.
     *
     * If `to` is `null`, this method returns `null`.
     * Otherwise, this method returns the {@link DFAState} returned by calling
     * {@link addDFAState} for the `to` state.
     *
     * @param dfa The DFA
     * @param from The source state for the edge
     * @param t The input symbol
     * @param to The target state for the edge
     *
     * @returns If `to` is `null`, this method returns `null`;
     * otherwise this method returns the result of calling {@link addDFAState}
     * on `to`
     */
    addDFAEdge(dfa, from, t, to) {
      if (_ParserATNSimulator.debug) {
        console.log("EDGE " + from + " -> " + to + " upon " + this.getTokenName(t));
      }
      to = this.addDFAState(dfa, to);
      if (t < -1 || t > this.atn.maxTokenType) {
        return to;
      }
      if (_ParserATNSimulator.debug) {
        console.log("DFA=\n" + dfa.toString(this.parser != null ? this.parser.vocabulary : Vocabulary.EMPTY_VOCABULARY));
      }
      from.edges[t + 1] = to;
      return to;
    }
    /**
     * Add state `D` to the DFA if it is not already present, and return
     * the actual instance stored in the DFA. If a state equivalent to `D`
     * is already in the DFA, the existing state is returned. Otherwise this
     * method returns `D` after adding it to the DFA.
     *
     * If `D` is {@link ERROR}, this method returns {@link ERROR} and
     * does not change the DFA.
     *
     * @param dfa The dfa.
     * @param newState The DFA state to add.
     *
     * @returns The state stored in the DFA. This will be either the existing state if `newState` is already in
     *          the DFA, or `newState` itself if the state was not already present.
     */
    addDFAState(dfa, newState) {
      if (newState === ATNSimulator.ERROR) {
        return newState;
      }
      const existing = dfa.getState(newState);
      if (existing !== null) {
        return existing;
      }
      if (!newState.configs.readOnly) {
        newState.configs.optimizeConfigs(this);
        newState.configs.setReadonly(true);
      }
      if (_ParserATNSimulator.traceATNSimulator) {
        console.log("addDFAState new " + newState);
      }
      dfa.addState(newState);
      return newState;
    }
    reportAttemptingFullContext(dfa, conflictingAlts, configs, startIndex, stopIndex) {
      if (_ParserATNSimulator.debug || _ParserATNSimulator.retryDebug) {
        const interval = new Interval(startIndex, stopIndex + 1);
        console.log("reportAttemptingFullContext decision=" + dfa.decision + ":" + configs + ", input=" + this.parser.tokenStream.getTextFromInterval(interval));
      }
      this.parser.errorListenerDispatch.reportAttemptingFullContext(
        this.parser,
        dfa,
        startIndex,
        stopIndex,
        conflictingAlts,
        configs
      );
    }
    reportContextSensitivity(dfa, prediction, configs, startIndex, stopIndex) {
      if (_ParserATNSimulator.debug || _ParserATNSimulator.retryDebug) {
        const interval = new Interval(startIndex, stopIndex + 1);
        console.log("reportContextSensitivity decision=" + dfa.decision + ":" + configs + ", input=" + this.parser.tokenStream.getTextFromInterval(interval));
      }
      this.parser.errorListenerDispatch.reportContextSensitivity(
        this.parser,
        dfa,
        startIndex,
        stopIndex,
        prediction,
        configs
      );
    }
    // If context sensitive parsing, we know it's ambiguity not conflict.
    reportAmbiguity(dfa, D, startIndex, stopIndex, exact, ambigAlts, configs) {
      if (_ParserATNSimulator.debug || _ParserATNSimulator.retryDebug) {
        const interval = new Interval(startIndex, stopIndex + 1);
        console.log("reportAmbiguity " + ambigAlts + ":" + configs + ", input=" + this.parser.tokenStream.getTextFromInterval(interval));
      }
      this.parser.errorListenerDispatch.reportAmbiguity(
        this.parser,
        dfa,
        startIndex,
        stopIndex,
        exact,
        ambigAlts,
        configs
      );
    }
  };
  var PredictionContextCache = class {
    static {
      __name(this, "PredictionContextCache");
    }
    cache = new HashMap(ObjectEqualityComparator.instance);
    /**
     * Add a context to the cache and return it. If the context already exists,
     * return that one instead and do not add a new context to the cache.
     * Protect shared cache from unsafe thread access.
     *
     * @param ctx tbd
     * @returns tbd
     */
    add(ctx) {
      if (ctx === EmptyPredictionContext.instance) {
        return ctx;
      }
      const existing = this.cache.get(ctx);
      if (existing) {
        return existing;
      }
      this.cache.set(ctx, ctx);
      return ctx;
    }
    get(ctx) {
      return this.cache.get(ctx);
    }
    get length() {
      return this.cache.size;
    }
  };
  var ProfilingATNSimulator = class extends ParserATNSimulator {
    static {
      __name(this, "ProfilingATNSimulator");
    }
    decisions;
    numDecisions = 0;
    currentDecision = 0;
    currentState;
    /**
     * At the point of LL failover, we record how SLL would resolve the conflict so that
     *  we can determine whether or not a decision / input pair is context-sensitive.
     *  If LL gives a different result than SLL's predicted alternative, we have a
     *  context sensitivity for sure. The converse is not necessarily true, however.
     *  It's possible that after conflict resolution chooses minimum alternatives,
     *  SLL could get the same answer as LL. Regardless of whether or not the result indicates
     *  an ambiguity, it is not treated as a context sensitivity because LL prediction
     *  was not required in order to produce a correct prediction for this decision and input sequence.
     *  It may in fact still be a context sensitivity but we don't know by looking at the
     *  minimum alternatives for the current input.
     */
    conflictingAltResolvedBySLL;
    sllStopIndex = 0;
    llStopIndex = 0;
    constructor(parser) {
      const sharedContextCache = parser.interpreter.sharedContextCache;
      super(parser, parser.interpreter.atn, parser.interpreter.decisionToDFA, sharedContextCache);
      if (sharedContextCache) {
        this.numDecisions = this.atn.decisionToState.length;
        this.decisions = new Array(this.numDecisions);
        for (let i = 0; i < this.numDecisions; i++) {
          this.decisions[i] = new DecisionInfo(i);
        }
      }
    }
    adaptivePredict(input, decision, outerContext) {
      try {
        this.sllStopIndex = -1;
        this.llStopIndex = -1;
        this.currentDecision = decision;
        const start = performance.now();
        const alt = super.adaptivePredict(input, decision, outerContext);
        const stop = performance.now();
        this.decisions[decision].timeInPrediction += stop - start;
        this.decisions[decision].invocations++;
        const sllLook = this.sllStopIndex - this.predictionState.startIndex + 1;
        this.decisions[decision].sllTotalLook += sllLook;
        this.decisions[decision].sllMinLook = this.decisions[decision].sllMinLook === 0 ? sllLook : Math.min(this.decisions[decision].sllMinLook, sllLook);
        if (sllLook > this.decisions[decision].sllMaxLook) {
          this.decisions[decision].sllMaxLook = sllLook;
          this.decisions[decision].sllMaxLookEvent = {
            decision,
            configs: null,
            predictedAlt: alt,
            input,
            startIndex: this.predictionState.startIndex,
            stopIndex: this.sllStopIndex,
            fullCtx: false
          };
        }
        if (this.llStopIndex >= 0) {
          const llLook = this.llStopIndex - this.predictionState.startIndex + 1;
          this.decisions[decision].llTotalLook += llLook;
          this.decisions[decision].llMinLook = this.decisions[decision].llMinLook === 0 ? llLook : Math.min(this.decisions[decision].llMinLook, llLook);
          if (llLook > this.decisions[decision].llMaxLook) {
            this.decisions[decision].llMaxLook = llLook;
            this.decisions[decision].llMaxLookEvent = {
              decision,
              configs: null,
              predictedAlt: alt,
              input,
              startIndex: this.predictionState.startIndex,
              stopIndex: this.llStopIndex,
              fullCtx: true
            };
          }
        }
        return alt;
      } finally {
        this.currentDecision = -1;
      }
    }
    getExistingTargetState(previousD, t) {
      this.sllStopIndex = this.predictionState.input.index;
      const existingTargetState = super.getExistingTargetState(previousD, t);
      if (existingTargetState !== void 0) {
        this.decisions[this.currentDecision].sllDFATransitions++;
        if (existingTargetState === ATNSimulator.ERROR) {
          this.decisions[this.currentDecision].errors.push({
            decision: this.currentDecision,
            configs: previousD.configs,
            input: this.predictionState.input,
            startIndex: this.predictionState.startIndex,
            stopIndex: this.sllStopIndex,
            fullCtx: false
          });
        }
      }
      this.currentState = existingTargetState;
      return existingTargetState;
    }
    computeTargetState(dfa, previousD, t) {
      const state = super.computeTargetState(dfa, previousD, t);
      this.currentState = state;
      return state;
    }
    computeReachSet(closure, t, fullCtx) {
      if (fullCtx && this.predictionState?.input) {
        this.llStopIndex = this.predictionState.input.index;
      }
      const reachConfigs = super.computeReachSet(closure, t, fullCtx);
      if (this.predictionState?.input) {
        if (fullCtx) {
          this.decisions[this.currentDecision].llATNTransitions++;
          if (reachConfigs === null) {
            this.decisions[this.currentDecision].errors.push({
              decision: this.currentDecision,
              configs: closure,
              input: this.predictionState.input,
              startIndex: this.predictionState.startIndex,
              stopIndex: this.sllStopIndex,
              fullCtx: true
            });
          }
        } else {
          this.decisions[this.currentDecision].sllATNTransitions++;
          if (reachConfigs === null) {
            this.decisions[this.currentDecision].errors.push({
              decision: this.currentDecision,
              configs: closure,
              input: this.predictionState.input,
              startIndex: this.predictionState.startIndex,
              stopIndex: this.sllStopIndex,
              fullCtx: false
            });
          }
        }
      }
      return reachConfigs;
    }
    reportAttemptingFullContext(dfa, conflictingAlts, configs, startIndex, stopIndex) {
      if (conflictingAlts !== null) {
        this.conflictingAltResolvedBySLL = conflictingAlts.nextSetBit(0);
      } else {
        this.conflictingAltResolvedBySLL = configs.getAlts().nextSetBit(0);
      }
      this.decisions[this.currentDecision].llFallback++;
      if (conflictingAlts) {
        super.reportAttemptingFullContext(dfa, conflictingAlts, configs, startIndex, stopIndex);
      }
    }
    reportContextSensitivity(dfa, prediction, configs, startIndex, stopIndex) {
      if (prediction !== this.conflictingAltResolvedBySLL && this.predictionState.input) {
        this.decisions[this.currentDecision].contextSensitivities.push({
          decision: this.currentDecision,
          configs,
          input: this.predictionState.input,
          startIndex,
          stopIndex,
          fullCtx: true
        });
      }
      super.reportContextSensitivity(dfa, prediction, configs, startIndex, stopIndex);
    }
    reportAmbiguity(dfa, state, startIndex, stopIndex, exact, ambigAlts, configs) {
      let prediction;
      if (ambigAlts) {
        prediction = ambigAlts.nextSetBit(0);
      } else {
        prediction = configs.getAlts().nextSetBit(0);
      }
      if (this.predictionState?.input) {
        if (configs.fullCtx && prediction !== this.conflictingAltResolvedBySLL) {
          this.decisions[this.currentDecision].contextSensitivities.push({
            decision: this.currentDecision,
            configs,
            input: this.predictionState.input,
            startIndex,
            stopIndex,
            fullCtx: true
          });
        }
        this.decisions[this.currentDecision].ambiguities.push({
          ambigAlts,
          decision: this.currentDecision,
          configs,
          input: this.predictionState.input,
          startIndex,
          stopIndex,
          fullCtx: configs.fullCtx
        });
      }
      super.reportAmbiguity(dfa, state, startIndex, stopIndex, exact, ambigAlts, configs);
    }
    getDecisionInfo() {
      return this.decisions;
    }
    getCurrentState() {
      return this.currentState;
    }
  };
  var PredPrediction;
  ((PredPrediction2) => {
    PredPrediction2.toString = /* @__PURE__ */ __name((prediction) => {
      return `(${prediction.pred}, ${prediction.alt})`;
    }, "toString");
  })(PredPrediction || (PredPrediction = {}));
  var ParseCancellationException = class extends Error {
    static {
      __name(this, "ParseCancellationException");
    }
    constructor(e) {
      super();
      this.cause = e;
    }
  };
  var InterpreterDataReader = class {
    static {
      __name(this, "InterpreterDataReader");
    }
    /**
     * The structure of the data file is very simple. Everything is line based with empty lines
     * separating the different parts. For lexers the layout is:
     * token literal names:
     * ...
     *
     * token symbolic names:
     * ...
     *
     * rule names:
     * ...
     *
     * channel names:
     * ...
     *
     * mode names:
     * ...
     *
     * atn:
     * a single line with comma separated int values, enclosed in a pair of squared brackets.
     *
     * Data for a parser does not contain channel and mode names.
     */
    static parseInterpreterData(source) {
      const ruleNames = [];
      const channels = [];
      const modes = [];
      const literalNames = [];
      const symbolicNames = [];
      const lines = source.split("\n");
      let index2 = 0;
      let line = lines[index2++];
      if (line !== "token literal names:") {
        throw new Error("Unexpected data entry");
      }
      do {
        line = lines[index2++];
        if (line.length === 0) {
          break;
        }
        literalNames.push(line === "null" ? null : line);
      } while (true);
      line = lines[index2++];
      if (line !== "token symbolic names:") {
        throw new Error("Unexpected data entry");
      }
      do {
        line = lines[index2++];
        if (line.length === 0) {
          break;
        }
        symbolicNames.push(line === "null" ? null : line);
      } while (true);
      line = lines[index2++];
      if (line !== "rule names:") {
        throw new Error("Unexpected data entry");
      }
      do {
        line = lines[index2++];
        if (line.length === 0) {
          break;
        }
        ruleNames.push(line);
      } while (true);
      line = lines[index2++];
      if (line === "channel names:") {
        do {
          line = lines[index2++];
          if (line.length === 0) {
            break;
          }
          channels.push(line);
        } while (true);
        line = lines[index2++];
        if (line !== "mode names:") {
          throw new Error("Unexpected data entry");
        }
        do {
          line = lines[index2++];
          if (line.length === 0) {
            break;
          }
          modes.push(line);
        } while (true);
      }
      line = lines[index2++];
      if (line !== "atn:") {
        throw new Error("Unexpected data entry");
      }
      line = lines[index2++];
      const elements = line.split(",");
      let value;
      const serializedATN = [];
      for (let i = 0; i < elements.length; ++i) {
        const element = elements[i];
        if (element.startsWith("[")) {
          value = Number(element.substring(1).trim());
        } else if (element.endsWith("]")) {
          value = Number(element.substring(0, element.length - 1).trim());
        } else {
          value = Number(element.trim());
        }
        serializedATN[i] = value;
      }
      const deserializer = new ATNDeserializer();
      return {
        atn: deserializer.deserialize(serializedATN),
        vocabulary: new Vocabulary(literalNames, symbolicNames, []),
        ruleNames,
        channels: channels.length > 0 ? channels : void 0,
        modes: modes.length > 0 ? modes : void 0
      };
    }
  };
  var AbstractParseTreeVisitor = class {
    static {
      __name(this, "AbstractParseTreeVisitor");
    }
    visit(tree) {
      return tree.accept(this);
    }
    visitChildren(node) {
      let result = this.defaultResult();
      const n2 = node.getChildCount();
      for (let i = 0; i < n2; i++) {
        if (!this.shouldVisitNextChild(node, result)) {
          break;
        }
        const c = node.getChild(i);
        if (c) {
          const childResult = c.accept(this);
          result = this.aggregateResult(result, childResult);
        }
      }
      return result;
    }
    visitTerminal(_node) {
      return this.defaultResult();
    }
    visitErrorNode(_node) {
      return this.defaultResult();
    }
    defaultResult() {
      return null;
    }
    shouldVisitNextChild(_node, _currentResult) {
      return true;
    }
    aggregateResult(aggregate, nextResult) {
      return nextResult;
    }
  };
  var ParseTreeWalker = class _ParseTreeWalker {
    static {
      __name(this, "ParseTreeWalker");
    }
    static DEFAULT = new _ParseTreeWalker();
    /**
     * Performs a walk on the given parse tree starting at the root and going down recursively
     * with depth-first search. On each node, {@link ParseTreeWalker.enterRule} is called before
     * recursively walking down into child nodes, then
     * {@link ParseTreeWalker.exitRule} is called after the recursive call to wind up.
     *
     * @param listener The listener used by the walker to process grammar rules
     * @param t The parse tree to be walked on
     */
    walk(listener, t) {
      const errorNode = t instanceof ErrorNode;
      if (errorNode) {
        listener.visitErrorNode(t);
      } else if (t instanceof TerminalNode) {
        listener.visitTerminal(t);
      } else {
        const r = t;
        this.enterRule(listener, r);
        for (let i = 0; i < t.getChildCount(); i++) {
          this.walk(listener, t.getChild(i));
        }
        this.exitRule(listener, r);
      }
    }
    /**
     * Enters a grammar rule by first triggering the generic event {@link ParseTreeListener.enterEveryRule}
     * then by triggering the event specific to the given parse tree node
     *
     * @param listener The listener responding to the trigger events
     * @param r The grammar rule containing the rule context
     */
    enterRule(listener, r) {
      const ctx = r.ruleContext;
      listener.enterEveryRule(ctx);
      ctx.enterRule(listener);
    }
    /**
     * Exits a grammar rule by first triggering the event specific to the given parse tree node
     * then by triggering the generic event {@link ParseTreeListener.exitEveryRule}
     *
     * @param listener The listener responding to the trigger events
     * @param r The grammar rule containing the rule context
     */
    exitRule(listener, r) {
      const ctx = r.ruleContext;
      ctx.exitRule(listener);
      listener.exitEveryRule(ctx);
    }
  };
  var CharStream;
  ((CharStream2) => {
    CharStream2.fromString = /* @__PURE__ */ __name((str) => {
      return new CharStreamImpl(str);
    }, "fromString");
  })(CharStream || (CharStream = {}));
  var CharStreamImpl = class {
    static {
      __name(this, "CharStreamImpl");
    }
    name = "";
    index = 0;
    data;
    constructor(input) {
      const codePoints = [];
      for (const char of input) {
        codePoints.push(char.codePointAt(0));
      }
      this.data = new Uint32Array(codePoints);
    }
    /**
     * Reset the stream so that it's in the same state it was
     * when the object was created *except* the data array is not
     * touched.
     */
    reset() {
      this.index = 0;
    }
    consume() {
      if (this.index >= this.data.length) {
        throw new Error("cannot consume EOF");
      }
      this.index += 1;
    }
    LA(offset) {
      if (offset === 0) {
        return 0;
      }
      if (offset < 0) {
        offset += 1;
      }
      const pos = this.index + offset - 1;
      if (pos < 0 || pos >= this.data.length) {
        return Token.EOF;
      }
      return this.data[pos];
    }
    // mark/release do nothing; we have entire buffer
    mark() {
      return -1;
    }
    release(_marker) {
    }
    /**
     * consume() ahead until p==_index; can't just set p=_index as we must
     * update line and column. If we seek backwards, just set p
     */
    seek(index2) {
      if (index2 <= this.index) {
        this.index = index2;
        return;
      }
      this.index = Math.min(index2, this.data.length);
    }
    getTextFromRange(start, stop) {
      stop = stop ?? this.data.length - 1;
      if (stop >= this.data.length) {
        stop = this.data.length - 1;
      }
      if (start >= this.data.length) {
        return "";
      }
      return this.stringFromRange(start, stop + 1);
    }
    getTextFromInterval(interval) {
      const start = interval.start;
      let stop = interval.stop;
      if (stop >= this.data.length) {
        stop = this.data.length - 1;
      }
      if (start >= this.data.length) {
        return "";
      }
      return this.stringFromRange(start, stop + 1);
    }
    toString() {
      return this.stringFromRange(0);
    }
    get size() {
      return this.data.length;
    }
    getSourceName() {
      if (this.name) {
        return this.name;
      }
      return IntStream.UNKNOWN_SOURCE_NAME;
    }
    stringFromRange(start, stop) {
      const data = this.data.slice(start, stop);
      let result = "";
      data.forEach((value) => {
        result += String.fromCodePoint(value);
      });
      return result;
    }
  };
  var isWritableToken = /* @__PURE__ */ __name((candidate) => {
    return candidate.setText !== void 0;
  }, "isWritableToken");
  var BufferedTokenStream = class {
    static {
      __name(this, "BufferedTokenStream");
    }
    /**
     * The {@link TokenSource} from which tokens for this stream are fetched.
     */
    tokenSource;
    /**
     * A collection of all tokens fetched from the token source. The list is
     * considered a complete view of the input once {@link fetchedEOF} is set
     * to `true`.
     */
    tokens = [];
    /**
     * The index into {@link tokens} of the current token (next token to
     * {@link consume}). {@link tokens}`[p]` should be
     * {@link LT LT(1)}.
     *
     * This field is set to -1 when the stream is first constructed or when
     * {@link setTokenSource} is called, indicating that the first token has
     * not yet been fetched from the token source. For additional information,
     * see the documentation of {@link IntStream} for a description of
     * Initializing Methods.
     */
    p = -1;
    /**
     * Indicates whether the {@link Token.EOF} token has been fetched from
     * {@link tokenSource} and added to {@link tokens}. This field improves
     * performance for the following cases:
     *
     * - {@link consume}: The lookahead check in {@link consume} to prevent
     * consuming the EOF symbol is optimized by checking the values of
     * {@link fetchedEOF} and {@link p} instead of calling {@link LA}.
     * - {@link fetch}: The check to prevent adding multiple EOF symbols into
     * {@link tokens} is trivial with this field.
     */
    fetchedEOF = false;
    constructor(tokenSource) {
      this.tokenSource = tokenSource;
    }
    mark() {
      return 0;
    }
    release(_marker) {
    }
    reset() {
      this.seek(0);
    }
    seek(index2) {
      this.lazyInit();
      this.p = this.adjustSeekIndex(index2);
    }
    get size() {
      return this.tokens.length;
    }
    get index() {
      return this.p;
    }
    get(index2) {
      this.lazyInit();
      return this.tokens[index2];
    }
    consume() {
      let skipEofCheck = false;
      if (this.p >= 0) {
        if (this.fetchedEOF) {
          skipEofCheck = this.p < this.tokens.length - 1;
        } else {
          skipEofCheck = this.p < this.tokens.length;
        }
      } else {
        skipEofCheck = false;
      }
      if (!skipEofCheck && this.LA(1) === Token.EOF) {
        throw new Error("cannot consume EOF");
      }
      if (this.sync(this.p + 1)) {
        this.p = this.adjustSeekIndex(this.p + 1);
      }
    }
    /**
     * Make sure index `i` in tokens has a token.
     *
     * @returns {boolean} `true` if a token is located at index `i`, otherwise `false`.
     */
    sync(i) {
      const n2 = i - this.tokens.length + 1;
      if (n2 > 0) {
        const fetched = this.fetch(n2);
        return fetched >= n2;
      }
      return true;
    }
    /**
     * Add `n` elements to buffer.
     *
     * @returns {number} The actual number of elements added to the buffer.
     */
    fetch(n2) {
      if (this.fetchedEOF) {
        return 0;
      }
      for (let i = 0; i < n2; i++) {
        const t = this.tokenSource.nextToken();
        if (isWritableToken(t)) {
          t.tokenIndex = this.tokens.length;
        }
        this.tokens.push(t);
        if (t.type === Token.EOF) {
          this.fetchedEOF = true;
          return i + 1;
        }
      }
      return n2;
    }
    /** Get all tokens from start..stop, inclusively. */
    getTokens(start, stop, types) {
      this.lazyInit();
      if (start === void 0 && stop === void 0) {
        return this.tokens;
      }
      start ??= 0;
      if (stop === void 0) {
        stop = this.tokens.length - 1;
      }
      if (start < 0 || stop >= this.tokens.length || stop < 0 || start >= this.tokens.length) {
        throw new RangeError("start " + start + " or stop " + stop + " not in 0.." + (this.tokens.length - 1));
      }
      if (start > stop) {
        return [];
      }
      if (types === void 0) {
        return this.tokens.slice(start, stop + 1);
      }
      const subset = [];
      if (stop >= this.tokens.length) {
        stop = this.tokens.length - 1;
      }
      for (let i = start; i < stop; i++) {
        const t = this.tokens[i];
        if (t.type === Token.EOF) {
          subset.push(t);
          break;
        }
        if (types.has(t.type)) {
          subset.push(t);
        }
      }
      return subset;
    }
    LA(k) {
      return this.LT(k)?.type ?? Token.INVALID_TYPE;
    }
    LB(k) {
      if (this.p - k < 0) {
        return null;
      }
      return this.tokens[this.p - k];
    }
    LT(k) {
      this.lazyInit();
      if (k === 0) {
        return null;
      }
      if (k < 0) {
        return this.LB(-k);
      }
      const i = this.p + k - 1;
      this.sync(i);
      if (i >= this.tokens.length) {
        return this.tokens[this.tokens.length - 1];
      }
      return this.tokens[i];
    }
    /**
     * Allowed derived classes to modify the behavior of operations which change
     * the current stream position by adjusting the target token index of a seek
     * operation. The default implementation simply returns `i`. If an
     * exception is thrown in this method, the current stream index should not be
     * changed.
     *
     * For example, {@link CommonTokenStream} overrides this method to ensure that
     * the seek target is always an on-channel token.
     *
     * @param  i The target token index.
     *
     * @returns The adjusted target token index.
     */
    adjustSeekIndex(i) {
      return i;
    }
    lazyInit() {
      if (this.p === -1) {
        this.setup();
      }
    }
    setup() {
      this.sync(0);
      this.p = this.adjustSeekIndex(0);
    }
    /** Reset this token stream by setting its token source. */
    setTokenSource(tokenSource) {
      this.tokenSource = tokenSource;
      this.tokens = [];
      this.p = -1;
      this.fetchedEOF = false;
    }
    /**
     * Given a starting index, return the index of the next token on channel.
     * Return i if tokens[i] is on channel. Return -1 if there are no tokens
     * on channel between i and EOF.
     */
    nextTokenOnChannel(i, channel) {
      this.sync(i);
      if (i >= this.tokens.length) {
        return -1;
      }
      let token = this.tokens[i];
      while (token.channel !== channel) {
        if (token.type === Token.EOF) {
          return -1;
        }
        i += 1;
        this.sync(i);
        token = this.tokens[i];
      }
      return i;
    }
    /**
     * Given a starting index, return the index of the previous token on
     * channel. Return `i` if `tokens[i]` is on channel. Return -1
     * if there are no tokens on channel between `i` and 0.
     *
     * If `i` specifies an index at or after the EOF token, the EOF token
     * index is returned. This is due to the fact that the EOF token is treated
     * as though it were on every channel.
     */
    previousTokenOnChannel(i, channel) {
      if (i >= this.tokens.length) {
        return this.tokens.length - 1;
      }
      while (i >= 0) {
        const token = this.tokens[i];
        if (token.type === Token.EOF || token.channel === channel) {
          return i;
        }
        --i;
      }
      return i;
    }
    /**
     * Collect all tokens on specified channel to the right of
     * the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or
     * EOF. If channel is -1, find any non default channel token.
     */
    getHiddenTokensToRight(tokenIndex, channel) {
      if (channel === void 0) {
        channel = -1;
      }
      this.lazyInit();
      if (tokenIndex < 0 || tokenIndex >= this.tokens.length) {
        throw new Error(`${tokenIndex} not in 0..${this.tokens.length - 1}`);
      }
      const nextOnChannel = this.nextTokenOnChannel(tokenIndex + 1, Lexer.DEFAULT_TOKEN_CHANNEL);
      const from = tokenIndex + 1;
      const to = nextOnChannel === -1 ? this.tokens.length - 1 : nextOnChannel;
      return this.filterForChannel(from, to, channel);
    }
    /**
     * Collect all tokens on specified channel to the left of
     * the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.
     * If channel is -1, find any non default channel token.
     */
    getHiddenTokensToLeft(tokenIndex, channel) {
      if (channel === void 0) {
        channel = -1;
      }
      this.lazyInit();
      if (tokenIndex < 0 || tokenIndex >= this.tokens.length) {
        throw new Error(`${tokenIndex} not in 0..${this.tokens.length - 1}`);
      }
      const prevOnChannel = this.previousTokenOnChannel(tokenIndex - 1, Lexer.DEFAULT_TOKEN_CHANNEL);
      if (prevOnChannel === tokenIndex - 1) {
        return void 0;
      }
      const from = prevOnChannel + 1;
      const to = tokenIndex - 1;
      return this.filterForChannel(from, to, channel);
    }
    filterForChannel(left, right, channel) {
      const hidden = [];
      for (let i = left; i < right + 1; i++) {
        const t = this.tokens[i];
        if (channel === -1) {
          if (t.channel !== Lexer.DEFAULT_TOKEN_CHANNEL) {
            hidden.push(t);
          }
        } else if (t.channel === channel) {
          hidden.push(t);
        }
      }
      if (hidden.length === 0) {
        return void 0;
      }
      return hidden;
    }
    getSourceName() {
      return this.tokenSource.sourceName;
    }
    /** Get the text of all tokens in this buffer. */
    getText() {
      return this.getTextFromInterval(Interval.of(0, this.size - 1));
    }
    getTextFromInterval(interval) {
      const start = interval.start;
      let stop = interval.stop;
      if (start < 0 || stop < 0) {
        return "";
      }
      this.sync(stop);
      if (stop >= this.tokens.length) {
        stop = this.tokens.length - 1;
      }
      let result = "";
      for (let i = start; i <= stop; ++i) {
        const t = this.tokens[i];
        if (t.type === Token.EOF) {
          break;
        }
        result += t.text;
      }
      return result;
    }
    getTextFromContext(ctx) {
      return this.getTextFromInterval(ctx.getSourceInterval());
    }
    getTextFromRange(start, stop) {
      if (start !== null && stop !== null) {
        return this.getTextFromInterval(Interval.of(start.tokenIndex, stop.tokenIndex));
      }
      return "";
    }
    /** Get all tokens from lexer until EOF. */
    fill() {
      this.lazyInit();
      while (this.fetch(1e3) === 1e3) {
        ;
      }
    }
    setLine(line) {
      this.tokenSource.line = line;
    }
    setColumn(column) {
      this.tokenSource.column = column;
    }
  };
  var CommonTokenStream = class extends BufferedTokenStream {
    static {
      __name(this, "CommonTokenStream");
    }
    /**
     * Specifies the channel to use for filtering tokens.
     *
     *
     * The default value is {@link Token.DEFAULT_CHANNEL}, which matches the
     * default channel assigned to tokens created by the lexer.
     */
    channel = Token.DEFAULT_CHANNEL;
    constructor(lexer, channel) {
      super(lexer);
      this.channel = channel ?? Token.DEFAULT_CHANNEL;
    }
    adjustSeekIndex(i) {
      return this.nextTokenOnChannel(i, this.channel);
    }
    LB(k) {
      if (k === 0 || this.index - k < 0) {
        return null;
      }
      let i = this.index;
      let n2 = 1;
      while (n2 <= k) {
        i = this.previousTokenOnChannel(i - 1, this.channel);
        n2 += 1;
      }
      if (i < 0) {
        return null;
      }
      return this.tokens[i];
    }
    LT(k) {
      this.lazyInit();
      if (k === 0) {
        return null;
      }
      if (k < 0) {
        return this.LB(-k);
      }
      let i = this.index;
      let n2 = 1;
      while (n2 < k) {
        if (this.sync(i + 1)) {
          i = this.nextTokenOnChannel(i + 1, this.channel);
        }
        n2 += 1;
      }
      return this.tokens[i];
    }
    // Count EOF just once.
    getNumberOfOnChannelTokens() {
      let n2 = 0;
      this.fill();
      for (const t of this.tokens) {
        if (t.channel === this.channel) {
          n2 += 1;
        }
        if (t.type === Token.EOF) {
          break;
        }
      }
      return n2;
    }
  };
  var XPathLexer = class _XPathLexer extends Lexer {
    static {
      __name(this, "XPathLexer");
    }
    static TOKEN_REF = 1;
    static RULE_REF = 2;
    static ANYWHERE = 3;
    static ROOT = 4;
    static WILDCARD = 5;
    static BANG = 6;
    static ID = 7;
    static STRING = 8;
    static channelNames = [
      "DEFAULT_TOKEN_CHANNEL",
      "HIDDEN"
    ];
    static literalNames = [
      null,
      null,
      null,
      "'//'",
      "'/'",
      "'*'",
      "'!'"
    ];
    static symbolicNames = [
      null,
      "TOKEN_REF",
      "RULE_REF",
      "ANYWHERE",
      "ROOT",
      "WILDCARD",
      "BANG",
      "ID",
      "STRING"
    ];
    static modeNames = [
      "DEFAULT_MODE"
    ];
    static ruleNames = [
      "ANYWHERE",
      "ROOT",
      "WILDCARD",
      "BANG",
      "ID",
      "NameChar",
      "NameStartChar",
      "STRING"
    ];
    constructor(input) {
      super(input);
      this.interpreter = new LexerATNSimulator(this, _XPathLexer._ATN, _XPathLexer.decisionsToDFA, new PredictionContextCache());
    }
    get grammarFileName() {
      return "XPathLexer.g4";
    }
    get literalNames() {
      return _XPathLexer.literalNames;
    }
    get symbolicNames() {
      return _XPathLexer.symbolicNames;
    }
    get ruleNames() {
      return _XPathLexer.ruleNames;
    }
    get serializedATN() {
      return _XPathLexer._serializedATN;
    }
    get channelNames() {
      return _XPathLexer.channelNames;
    }
    get modeNames() {
      return _XPathLexer.modeNames;
    }
    action(localContext, ruleIndex, actionIndex) {
      switch (ruleIndex) {
        case 4:
          this.ID_action(localContext, actionIndex);
          break;
      }
    }
    ID_action(localContext, actionIndex) {
      switch (actionIndex) {
        case 0:
          const text = this.text;
          if (text.charAt(0) === text.charAt(0).toUpperCase()) {
            this.type = _XPathLexer.TOKEN_REF;
          } else {
            this.type = _XPathLexer.RULE_REF;
          }
          break;
      }
    }
    static _serializedATN = [
      4,
      0,
      8,
      48,
      6,
      -1,
      2,
      0,
      7,
      0,
      2,
      1,
      7,
      1,
      2,
      2,
      7,
      2,
      2,
      3,
      7,
      3,
      2,
      4,
      7,
      4,
      2,
      5,
      7,
      5,
      2,
      6,
      7,
      6,
      2,
      7,
      7,
      7,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      2,
      1,
      2,
      1,
      3,
      1,
      3,
      1,
      4,
      1,
      4,
      5,
      4,
      29,
      8,
      4,
      10,
      4,
      12,
      4,
      32,
      9,
      4,
      1,
      4,
      1,
      4,
      1,
      5,
      1,
      5,
      1,
      6,
      1,
      6,
      1,
      7,
      1,
      7,
      5,
      7,
      42,
      8,
      7,
      10,
      7,
      12,
      7,
      45,
      9,
      7,
      1,
      7,
      1,
      7,
      1,
      43,
      0,
      8,
      1,
      3,
      3,
      4,
      5,
      5,
      7,
      6,
      9,
      7,
      11,
      0,
      13,
      0,
      15,
      8,
      1,
      0,
      2,
      784,
      0,
      0,
      8,
      14,
      27,
      48,
      57,
      65,
      90,
      95,
      95,
      97,
      122,
      127,
      159,
      170,
      170,
      173,
      173,
      181,
      181,
      186,
      186,
      192,
      214,
      216,
      246,
      248,
      705,
      710,
      721,
      736,
      740,
      748,
      748,
      750,
      750,
      768,
      884,
      886,
      887,
      890,
      893,
      895,
      895,
      902,
      902,
      904,
      906,
      908,
      908,
      910,
      929,
      931,
      1013,
      1015,
      1153,
      1155,
      1159,
      1162,
      1327,
      1329,
      1366,
      1369,
      1369,
      1376,
      1416,
      1425,
      1469,
      1471,
      1471,
      1473,
      1474,
      1476,
      1477,
      1479,
      1479,
      1488,
      1514,
      1519,
      1522,
      1536,
      1541,
      1552,
      1562,
      1564,
      1564,
      1568,
      1641,
      1646,
      1747,
      1749,
      1757,
      1759,
      1768,
      1770,
      1788,
      1791,
      1791,
      1807,
      1866,
      1869,
      1969,
      1984,
      2037,
      2042,
      2042,
      2045,
      2045,
      2048,
      2093,
      2112,
      2139,
      2144,
      2154,
      2160,
      2183,
      2185,
      2190,
      2192,
      2193,
      2200,
      2403,
      2406,
      2415,
      2417,
      2435,
      2437,
      2444,
      2447,
      2448,
      2451,
      2472,
      2474,
      2480,
      2482,
      2482,
      2486,
      2489,
      2492,
      2500,
      2503,
      2504,
      2507,
      2510,
      2519,
      2519,
      2524,
      2525,
      2527,
      2531,
      2534,
      2545,
      2556,
      2556,
      2558,
      2558,
      2561,
      2563,
      2565,
      2570,
      2575,
      2576,
      2579,
      2600,
      2602,
      2608,
      2610,
      2611,
      2613,
      2614,
      2616,
      2617,
      2620,
      2620,
      2622,
      2626,
      2631,
      2632,
      2635,
      2637,
      2641,
      2641,
      2649,
      2652,
      2654,
      2654,
      2662,
      2677,
      2689,
      2691,
      2693,
      2701,
      2703,
      2705,
      2707,
      2728,
      2730,
      2736,
      2738,
      2739,
      2741,
      2745,
      2748,
      2757,
      2759,
      2761,
      2763,
      2765,
      2768,
      2768,
      2784,
      2787,
      2790,
      2799,
      2809,
      2815,
      2817,
      2819,
      2821,
      2828,
      2831,
      2832,
      2835,
      2856,
      2858,
      2864,
      2866,
      2867,
      2869,
      2873,
      2876,
      2884,
      2887,
      2888,
      2891,
      2893,
      2901,
      2903,
      2908,
      2909,
      2911,
      2915,
      2918,
      2927,
      2929,
      2929,
      2946,
      2947,
      2949,
      2954,
      2958,
      2960,
      2962,
      2965,
      2969,
      2970,
      2972,
      2972,
      2974,
      2975,
      2979,
      2980,
      2984,
      2986,
      2990,
      3001,
      3006,
      3010,
      3014,
      3016,
      3018,
      3021,
      3024,
      3024,
      3031,
      3031,
      3046,
      3055,
      3072,
      3084,
      3086,
      3088,
      3090,
      3112,
      3114,
      3129,
      3132,
      3140,
      3142,
      3144,
      3146,
      3149,
      3157,
      3158,
      3160,
      3162,
      3165,
      3165,
      3168,
      3171,
      3174,
      3183,
      3200,
      3203,
      3205,
      3212,
      3214,
      3216,
      3218,
      3240,
      3242,
      3251,
      3253,
      3257,
      3260,
      3268,
      3270,
      3272,
      3274,
      3277,
      3285,
      3286,
      3293,
      3294,
      3296,
      3299,
      3302,
      3311,
      3313,
      3315,
      3328,
      3340,
      3342,
      3344,
      3346,
      3396,
      3398,
      3400,
      3402,
      3406,
      3412,
      3415,
      3423,
      3427,
      3430,
      3439,
      3450,
      3455,
      3457,
      3459,
      3461,
      3478,
      3482,
      3505,
      3507,
      3515,
      3517,
      3517,
      3520,
      3526,
      3530,
      3530,
      3535,
      3540,
      3542,
      3542,
      3544,
      3551,
      3558,
      3567,
      3570,
      3571,
      3585,
      3642,
      3648,
      3662,
      3664,
      3673,
      3713,
      3714,
      3716,
      3716,
      3718,
      3722,
      3724,
      3747,
      3749,
      3749,
      3751,
      3773,
      3776,
      3780,
      3782,
      3782,
      3784,
      3790,
      3792,
      3801,
      3804,
      3807,
      3840,
      3840,
      3864,
      3865,
      3872,
      3881,
      3893,
      3893,
      3895,
      3895,
      3897,
      3897,
      3902,
      3911,
      3913,
      3948,
      3953,
      3972,
      3974,
      3991,
      3993,
      4028,
      4038,
      4038,
      4096,
      4169,
      4176,
      4253,
      4256,
      4293,
      4295,
      4295,
      4301,
      4301,
      4304,
      4346,
      4348,
      4680,
      4682,
      4685,
      4688,
      4694,
      4696,
      4696,
      4698,
      4701,
      4704,
      4744,
      4746,
      4749,
      4752,
      4784,
      4786,
      4789,
      4792,
      4798,
      4800,
      4800,
      4802,
      4805,
      4808,
      4822,
      4824,
      4880,
      4882,
      4885,
      4888,
      4954,
      4957,
      4959,
      4992,
      5007,
      5024,
      5109,
      5112,
      5117,
      5121,
      5740,
      5743,
      5759,
      5761,
      5786,
      5792,
      5866,
      5870,
      5880,
      5888,
      5909,
      5919,
      5940,
      5952,
      5971,
      5984,
      5996,
      5998,
      6e3,
      6002,
      6003,
      6016,
      6099,
      6103,
      6103,
      6108,
      6109,
      6112,
      6121,
      6155,
      6169,
      6176,
      6264,
      6272,
      6314,
      6320,
      6389,
      6400,
      6430,
      6432,
      6443,
      6448,
      6459,
      6470,
      6509,
      6512,
      6516,
      6528,
      6571,
      6576,
      6601,
      6608,
      6617,
      6656,
      6683,
      6688,
      6750,
      6752,
      6780,
      6783,
      6793,
      6800,
      6809,
      6823,
      6823,
      6832,
      6845,
      6847,
      6862,
      6912,
      6988,
      6992,
      7001,
      7019,
      7027,
      7040,
      7155,
      7168,
      7223,
      7232,
      7241,
      7245,
      7293,
      7296,
      7304,
      7312,
      7354,
      7357,
      7359,
      7376,
      7378,
      7380,
      7418,
      7424,
      7957,
      7960,
      7965,
      7968,
      8005,
      8008,
      8013,
      8016,
      8023,
      8025,
      8025,
      8027,
      8027,
      8029,
      8029,
      8031,
      8061,
      8064,
      8116,
      8118,
      8124,
      8126,
      8126,
      8130,
      8132,
      8134,
      8140,
      8144,
      8147,
      8150,
      8155,
      8160,
      8172,
      8178,
      8180,
      8182,
      8188,
      8203,
      8207,
      8234,
      8238,
      8255,
      8256,
      8276,
      8276,
      8288,
      8292,
      8294,
      8303,
      8305,
      8305,
      8319,
      8319,
      8336,
      8348,
      8400,
      8412,
      8417,
      8417,
      8421,
      8432,
      8450,
      8450,
      8455,
      8455,
      8458,
      8467,
      8469,
      8469,
      8473,
      8477,
      8484,
      8484,
      8486,
      8486,
      8488,
      8488,
      8490,
      8493,
      8495,
      8505,
      8508,
      8511,
      8517,
      8521,
      8526,
      8526,
      8544,
      8584,
      11264,
      11492,
      11499,
      11507,
      11520,
      11557,
      11559,
      11559,
      11565,
      11565,
      11568,
      11623,
      11631,
      11631,
      11647,
      11670,
      11680,
      11686,
      11688,
      11694,
      11696,
      11702,
      11704,
      11710,
      11712,
      11718,
      11720,
      11726,
      11728,
      11734,
      11736,
      11742,
      11744,
      11775,
      11823,
      11823,
      12293,
      12295,
      12321,
      12335,
      12337,
      12341,
      12344,
      12348,
      12353,
      12438,
      12441,
      12442,
      12445,
      12447,
      12449,
      12538,
      12540,
      12543,
      12549,
      12591,
      12593,
      12686,
      12704,
      12735,
      12784,
      12799,
      13312,
      19903,
      19968,
      42124,
      42192,
      42237,
      42240,
      42508,
      42512,
      42539,
      42560,
      42607,
      42612,
      42621,
      42623,
      42737,
      42775,
      42783,
      42786,
      42888,
      42891,
      42954,
      42960,
      42961,
      42963,
      42963,
      42965,
      42969,
      42994,
      43047,
      43052,
      43052,
      43072,
      43123,
      43136,
      43205,
      43216,
      43225,
      43232,
      43255,
      43259,
      43259,
      43261,
      43309,
      43312,
      43347,
      43360,
      43388,
      43392,
      43456,
      43471,
      43481,
      43488,
      43518,
      43520,
      43574,
      43584,
      43597,
      43600,
      43609,
      43616,
      43638,
      43642,
      43714,
      43739,
      43741,
      43744,
      43759,
      43762,
      43766,
      43777,
      43782,
      43785,
      43790,
      43793,
      43798,
      43808,
      43814,
      43816,
      43822,
      43824,
      43866,
      43868,
      43881,
      43888,
      44010,
      44012,
      44013,
      44016,
      44025,
      44032,
      55203,
      55216,
      55238,
      55243,
      55291,
      63744,
      64109,
      64112,
      64217,
      64256,
      64262,
      64275,
      64279,
      64285,
      64296,
      64298,
      64310,
      64312,
      64316,
      64318,
      64318,
      64320,
      64321,
      64323,
      64324,
      64326,
      64433,
      64467,
      64829,
      64848,
      64911,
      64914,
      64967,
      65008,
      65019,
      65024,
      65039,
      65056,
      65071,
      65075,
      65076,
      65101,
      65103,
      65136,
      65140,
      65142,
      65276,
      65279,
      65279,
      65296,
      65305,
      65313,
      65338,
      65343,
      65343,
      65345,
      65370,
      65382,
      65470,
      65474,
      65479,
      65482,
      65487,
      65490,
      65495,
      65498,
      65500,
      65529,
      65531,
      65536,
      65547,
      65549,
      65574,
      65576,
      65594,
      65596,
      65597,
      65599,
      65613,
      65616,
      65629,
      65664,
      65786,
      65856,
      65908,
      66045,
      66045,
      66176,
      66204,
      66208,
      66256,
      66272,
      66272,
      66304,
      66335,
      66349,
      66378,
      66384,
      66426,
      66432,
      66461,
      66464,
      66499,
      66504,
      66511,
      66513,
      66517,
      66560,
      66717,
      66720,
      66729,
      66736,
      66771,
      66776,
      66811,
      66816,
      66855,
      66864,
      66915,
      66928,
      66938,
      66940,
      66954,
      66956,
      66962,
      66964,
      66965,
      66967,
      66977,
      66979,
      66993,
      66995,
      67001,
      67003,
      67004,
      67072,
      67382,
      67392,
      67413,
      67424,
      67431,
      67456,
      67461,
      67463,
      67504,
      67506,
      67514,
      67584,
      67589,
      67592,
      67592,
      67594,
      67637,
      67639,
      67640,
      67644,
      67644,
      67647,
      67669,
      67680,
      67702,
      67712,
      67742,
      67808,
      67826,
      67828,
      67829,
      67840,
      67861,
      67872,
      67897,
      67968,
      68023,
      68030,
      68031,
      68096,
      68099,
      68101,
      68102,
      68108,
      68115,
      68117,
      68119,
      68121,
      68149,
      68152,
      68154,
      68159,
      68159,
      68192,
      68220,
      68224,
      68252,
      68288,
      68295,
      68297,
      68326,
      68352,
      68405,
      68416,
      68437,
      68448,
      68466,
      68480,
      68497,
      68608,
      68680,
      68736,
      68786,
      68800,
      68850,
      68864,
      68903,
      68912,
      68921,
      69248,
      69289,
      69291,
      69292,
      69296,
      69297,
      69373,
      69404,
      69415,
      69415,
      69424,
      69456,
      69488,
      69509,
      69552,
      69572,
      69600,
      69622,
      69632,
      69702,
      69734,
      69749,
      69759,
      69818,
      69821,
      69821,
      69826,
      69826,
      69837,
      69837,
      69840,
      69864,
      69872,
      69881,
      69888,
      69940,
      69942,
      69951,
      69956,
      69959,
      69968,
      70003,
      70006,
      70006,
      70016,
      70084,
      70089,
      70092,
      70094,
      70106,
      70108,
      70108,
      70144,
      70161,
      70163,
      70199,
      70206,
      70209,
      70272,
      70278,
      70280,
      70280,
      70282,
      70285,
      70287,
      70301,
      70303,
      70312,
      70320,
      70378,
      70384,
      70393,
      70400,
      70403,
      70405,
      70412,
      70415,
      70416,
      70419,
      70440,
      70442,
      70448,
      70450,
      70451,
      70453,
      70457,
      70459,
      70468,
      70471,
      70472,
      70475,
      70477,
      70480,
      70480,
      70487,
      70487,
      70493,
      70499,
      70502,
      70508,
      70512,
      70516,
      70656,
      70730,
      70736,
      70745,
      70750,
      70753,
      70784,
      70853,
      70855,
      70855,
      70864,
      70873,
      71040,
      71093,
      71096,
      71104,
      71128,
      71133,
      71168,
      71232,
      71236,
      71236,
      71248,
      71257,
      71296,
      71352,
      71360,
      71369,
      71424,
      71450,
      71453,
      71467,
      71472,
      71481,
      71488,
      71494,
      71680,
      71738,
      71840,
      71913,
      71935,
      71942,
      71945,
      71945,
      71948,
      71955,
      71957,
      71958,
      71960,
      71989,
      71991,
      71992,
      71995,
      72003,
      72016,
      72025,
      72096,
      72103,
      72106,
      72151,
      72154,
      72161,
      72163,
      72164,
      72192,
      72254,
      72263,
      72263,
      72272,
      72345,
      72349,
      72349,
      72368,
      72440,
      72704,
      72712,
      72714,
      72758,
      72760,
      72768,
      72784,
      72793,
      72818,
      72847,
      72850,
      72871,
      72873,
      72886,
      72960,
      72966,
      72968,
      72969,
      72971,
      73014,
      73018,
      73018,
      73020,
      73021,
      73023,
      73031,
      73040,
      73049,
      73056,
      73061,
      73063,
      73064,
      73066,
      73102,
      73104,
      73105,
      73107,
      73112,
      73120,
      73129,
      73440,
      73462,
      73472,
      73488,
      73490,
      73530,
      73534,
      73538,
      73552,
      73561,
      73648,
      73648,
      73728,
      74649,
      74752,
      74862,
      74880,
      75075,
      77712,
      77808,
      77824,
      78933,
      82944,
      83526,
      92160,
      92728,
      92736,
      92766,
      92768,
      92777,
      92784,
      92862,
      92864,
      92873,
      92880,
      92909,
      92912,
      92916,
      92928,
      92982,
      92992,
      92995,
      93008,
      93017,
      93027,
      93047,
      93053,
      93071,
      93760,
      93823,
      93952,
      94026,
      94031,
      94087,
      94095,
      94111,
      94176,
      94177,
      94179,
      94180,
      94192,
      94193,
      94208,
      100343,
      100352,
      101589,
      101632,
      101640,
      110576,
      110579,
      110581,
      110587,
      110589,
      110590,
      110592,
      110882,
      110898,
      110898,
      110928,
      110930,
      110933,
      110933,
      110948,
      110951,
      110960,
      111355,
      113664,
      113770,
      113776,
      113788,
      113792,
      113800,
      113808,
      113817,
      113821,
      113822,
      113824,
      113827,
      118528,
      118573,
      118576,
      118598,
      119141,
      119145,
      119149,
      119170,
      119173,
      119179,
      119210,
      119213,
      119362,
      119364,
      119808,
      119892,
      119894,
      119964,
      119966,
      119967,
      119970,
      119970,
      119973,
      119974,
      119977,
      119980,
      119982,
      119993,
      119995,
      119995,
      119997,
      120003,
      120005,
      120069,
      120071,
      120074,
      120077,
      120084,
      120086,
      120092,
      120094,
      120121,
      120123,
      120126,
      120128,
      120132,
      120134,
      120134,
      120138,
      120144,
      120146,
      120485,
      120488,
      120512,
      120514,
      120538,
      120540,
      120570,
      120572,
      120596,
      120598,
      120628,
      120630,
      120654,
      120656,
      120686,
      120688,
      120712,
      120714,
      120744,
      120746,
      120770,
      120772,
      120779,
      120782,
      120831,
      121344,
      121398,
      121403,
      121452,
      121461,
      121461,
      121476,
      121476,
      121499,
      121503,
      121505,
      121519,
      122624,
      122654,
      122661,
      122666,
      122880,
      122886,
      122888,
      122904,
      122907,
      122913,
      122915,
      122916,
      122918,
      122922,
      122928,
      122989,
      123023,
      123023,
      123136,
      123180,
      123184,
      123197,
      123200,
      123209,
      123214,
      123214,
      123536,
      123566,
      123584,
      123641,
      124112,
      124153,
      124896,
      124902,
      124904,
      124907,
      124909,
      124910,
      124912,
      124926,
      124928,
      125124,
      125136,
      125142,
      125184,
      125259,
      125264,
      125273,
      126464,
      126467,
      126469,
      126495,
      126497,
      126498,
      126500,
      126500,
      126503,
      126503,
      126505,
      126514,
      126516,
      126519,
      126521,
      126521,
      126523,
      126523,
      126530,
      126530,
      126535,
      126535,
      126537,
      126537,
      126539,
      126539,
      126541,
      126543,
      126545,
      126546,
      126548,
      126548,
      126551,
      126551,
      126553,
      126553,
      126555,
      126555,
      126557,
      126557,
      126559,
      126559,
      126561,
      126562,
      126564,
      126564,
      126567,
      126570,
      126572,
      126578,
      126580,
      126583,
      126585,
      126588,
      126590,
      126590,
      126592,
      126601,
      126603,
      126619,
      126625,
      126627,
      126629,
      126633,
      126635,
      126651,
      130032,
      130041,
      131072,
      173791,
      173824,
      177977,
      177984,
      178205,
      178208,
      183969,
      183984,
      191456,
      194560,
      195101,
      196608,
      201546,
      201552,
      205743,
      917505,
      917505,
      917536,
      917631,
      917760,
      917999,
      662,
      0,
      65,
      90,
      97,
      122,
      170,
      170,
      181,
      181,
      186,
      186,
      192,
      214,
      216,
      246,
      248,
      705,
      710,
      721,
      736,
      740,
      748,
      748,
      750,
      750,
      880,
      884,
      886,
      887,
      890,
      893,
      895,
      895,
      902,
      902,
      904,
      906,
      908,
      908,
      910,
      929,
      931,
      1013,
      1015,
      1153,
      1162,
      1327,
      1329,
      1366,
      1369,
      1369,
      1376,
      1416,
      1488,
      1514,
      1519,
      1522,
      1568,
      1610,
      1646,
      1647,
      1649,
      1747,
      1749,
      1749,
      1765,
      1766,
      1774,
      1775,
      1786,
      1788,
      1791,
      1791,
      1808,
      1808,
      1810,
      1839,
      1869,
      1957,
      1969,
      1969,
      1994,
      2026,
      2036,
      2037,
      2042,
      2042,
      2048,
      2069,
      2074,
      2074,
      2084,
      2084,
      2088,
      2088,
      2112,
      2136,
      2144,
      2154,
      2160,
      2183,
      2185,
      2190,
      2208,
      2249,
      2308,
      2361,
      2365,
      2365,
      2384,
      2384,
      2392,
      2401,
      2417,
      2432,
      2437,
      2444,
      2447,
      2448,
      2451,
      2472,
      2474,
      2480,
      2482,
      2482,
      2486,
      2489,
      2493,
      2493,
      2510,
      2510,
      2524,
      2525,
      2527,
      2529,
      2544,
      2545,
      2556,
      2556,
      2565,
      2570,
      2575,
      2576,
      2579,
      2600,
      2602,
      2608,
      2610,
      2611,
      2613,
      2614,
      2616,
      2617,
      2649,
      2652,
      2654,
      2654,
      2674,
      2676,
      2693,
      2701,
      2703,
      2705,
      2707,
      2728,
      2730,
      2736,
      2738,
      2739,
      2741,
      2745,
      2749,
      2749,
      2768,
      2768,
      2784,
      2785,
      2809,
      2809,
      2821,
      2828,
      2831,
      2832,
      2835,
      2856,
      2858,
      2864,
      2866,
      2867,
      2869,
      2873,
      2877,
      2877,
      2908,
      2909,
      2911,
      2913,
      2929,
      2929,
      2947,
      2947,
      2949,
      2954,
      2958,
      2960,
      2962,
      2965,
      2969,
      2970,
      2972,
      2972,
      2974,
      2975,
      2979,
      2980,
      2984,
      2986,
      2990,
      3001,
      3024,
      3024,
      3077,
      3084,
      3086,
      3088,
      3090,
      3112,
      3114,
      3129,
      3133,
      3133,
      3160,
      3162,
      3165,
      3165,
      3168,
      3169,
      3200,
      3200,
      3205,
      3212,
      3214,
      3216,
      3218,
      3240,
      3242,
      3251,
      3253,
      3257,
      3261,
      3261,
      3293,
      3294,
      3296,
      3297,
      3313,
      3314,
      3332,
      3340,
      3342,
      3344,
      3346,
      3386,
      3389,
      3389,
      3406,
      3406,
      3412,
      3414,
      3423,
      3425,
      3450,
      3455,
      3461,
      3478,
      3482,
      3505,
      3507,
      3515,
      3517,
      3517,
      3520,
      3526,
      3585,
      3632,
      3634,
      3635,
      3648,
      3654,
      3713,
      3714,
      3716,
      3716,
      3718,
      3722,
      3724,
      3747,
      3749,
      3749,
      3751,
      3760,
      3762,
      3763,
      3773,
      3773,
      3776,
      3780,
      3782,
      3782,
      3804,
      3807,
      3840,
      3840,
      3904,
      3911,
      3913,
      3948,
      3976,
      3980,
      4096,
      4138,
      4159,
      4159,
      4176,
      4181,
      4186,
      4189,
      4193,
      4193,
      4197,
      4198,
      4206,
      4208,
      4213,
      4225,
      4238,
      4238,
      4256,
      4293,
      4295,
      4295,
      4301,
      4301,
      4304,
      4346,
      4348,
      4680,
      4682,
      4685,
      4688,
      4694,
      4696,
      4696,
      4698,
      4701,
      4704,
      4744,
      4746,
      4749,
      4752,
      4784,
      4786,
      4789,
      4792,
      4798,
      4800,
      4800,
      4802,
      4805,
      4808,
      4822,
      4824,
      4880,
      4882,
      4885,
      4888,
      4954,
      4992,
      5007,
      5024,
      5109,
      5112,
      5117,
      5121,
      5740,
      5743,
      5759,
      5761,
      5786,
      5792,
      5866,
      5870,
      5880,
      5888,
      5905,
      5919,
      5937,
      5952,
      5969,
      5984,
      5996,
      5998,
      6e3,
      6016,
      6067,
      6103,
      6103,
      6108,
      6108,
      6176,
      6264,
      6272,
      6276,
      6279,
      6312,
      6314,
      6314,
      6320,
      6389,
      6400,
      6430,
      6480,
      6509,
      6512,
      6516,
      6528,
      6571,
      6576,
      6601,
      6656,
      6678,
      6688,
      6740,
      6823,
      6823,
      6917,
      6963,
      6981,
      6988,
      7043,
      7072,
      7086,
      7087,
      7098,
      7141,
      7168,
      7203,
      7245,
      7247,
      7258,
      7293,
      7296,
      7304,
      7312,
      7354,
      7357,
      7359,
      7401,
      7404,
      7406,
      7411,
      7413,
      7414,
      7418,
      7418,
      7424,
      7615,
      7680,
      7957,
      7960,
      7965,
      7968,
      8005,
      8008,
      8013,
      8016,
      8023,
      8025,
      8025,
      8027,
      8027,
      8029,
      8029,
      8031,
      8061,
      8064,
      8116,
      8118,
      8124,
      8126,
      8126,
      8130,
      8132,
      8134,
      8140,
      8144,
      8147,
      8150,
      8155,
      8160,
      8172,
      8178,
      8180,
      8182,
      8188,
      8305,
      8305,
      8319,
      8319,
      8336,
      8348,
      8450,
      8450,
      8455,
      8455,
      8458,
      8467,
      8469,
      8469,
      8473,
      8477,
      8484,
      8484,
      8486,
      8486,
      8488,
      8488,
      8490,
      8493,
      8495,
      8505,
      8508,
      8511,
      8517,
      8521,
      8526,
      8526,
      8544,
      8584,
      11264,
      11492,
      11499,
      11502,
      11506,
      11507,
      11520,
      11557,
      11559,
      11559,
      11565,
      11565,
      11568,
      11623,
      11631,
      11631,
      11648,
      11670,
      11680,
      11686,
      11688,
      11694,
      11696,
      11702,
      11704,
      11710,
      11712,
      11718,
      11720,
      11726,
      11728,
      11734,
      11736,
      11742,
      11823,
      11823,
      12293,
      12295,
      12321,
      12329,
      12337,
      12341,
      12344,
      12348,
      12353,
      12438,
      12445,
      12447,
      12449,
      12538,
      12540,
      12543,
      12549,
      12591,
      12593,
      12686,
      12704,
      12735,
      12784,
      12799,
      13312,
      19903,
      19968,
      42124,
      42192,
      42237,
      42240,
      42508,
      42512,
      42527,
      42538,
      42539,
      42560,
      42606,
      42623,
      42653,
      42656,
      42735,
      42775,
      42783,
      42786,
      42888,
      42891,
      42954,
      42960,
      42961,
      42963,
      42963,
      42965,
      42969,
      42994,
      43009,
      43011,
      43013,
      43015,
      43018,
      43020,
      43042,
      43072,
      43123,
      43138,
      43187,
      43250,
      43255,
      43259,
      43259,
      43261,
      43262,
      43274,
      43301,
      43312,
      43334,
      43360,
      43388,
      43396,
      43442,
      43471,
      43471,
      43488,
      43492,
      43494,
      43503,
      43514,
      43518,
      43520,
      43560,
      43584,
      43586,
      43588,
      43595,
      43616,
      43638,
      43642,
      43642,
      43646,
      43695,
      43697,
      43697,
      43701,
      43702,
      43705,
      43709,
      43712,
      43712,
      43714,
      43714,
      43739,
      43741,
      43744,
      43754,
      43762,
      43764,
      43777,
      43782,
      43785,
      43790,
      43793,
      43798,
      43808,
      43814,
      43816,
      43822,
      43824,
      43866,
      43868,
      43881,
      43888,
      44002,
      44032,
      55203,
      55216,
      55238,
      55243,
      55291,
      63744,
      64109,
      64112,
      64217,
      64256,
      64262,
      64275,
      64279,
      64285,
      64285,
      64287,
      64296,
      64298,
      64310,
      64312,
      64316,
      64318,
      64318,
      64320,
      64321,
      64323,
      64324,
      64326,
      64433,
      64467,
      64829,
      64848,
      64911,
      64914,
      64967,
      65008,
      65019,
      65136,
      65140,
      65142,
      65276,
      65313,
      65338,
      65345,
      65370,
      65382,
      65470,
      65474,
      65479,
      65482,
      65487,
      65490,
      65495,
      65498,
      65500,
      65536,
      65547,
      65549,
      65574,
      65576,
      65594,
      65596,
      65597,
      65599,
      65613,
      65616,
      65629,
      65664,
      65786,
      65856,
      65908,
      66176,
      66204,
      66208,
      66256,
      66304,
      66335,
      66349,
      66378,
      66384,
      66421,
      66432,
      66461,
      66464,
      66499,
      66504,
      66511,
      66513,
      66517,
      66560,
      66717,
      66736,
      66771,
      66776,
      66811,
      66816,
      66855,
      66864,
      66915,
      66928,
      66938,
      66940,
      66954,
      66956,
      66962,
      66964,
      66965,
      66967,
      66977,
      66979,
      66993,
      66995,
      67001,
      67003,
      67004,
      67072,
      67382,
      67392,
      67413,
      67424,
      67431,
      67456,
      67461,
      67463,
      67504,
      67506,
      67514,
      67584,
      67589,
      67592,
      67592,
      67594,
      67637,
      67639,
      67640,
      67644,
      67644,
      67647,
      67669,
      67680,
      67702,
      67712,
      67742,
      67808,
      67826,
      67828,
      67829,
      67840,
      67861,
      67872,
      67897,
      67968,
      68023,
      68030,
      68031,
      68096,
      68096,
      68112,
      68115,
      68117,
      68119,
      68121,
      68149,
      68192,
      68220,
      68224,
      68252,
      68288,
      68295,
      68297,
      68324,
      68352,
      68405,
      68416,
      68437,
      68448,
      68466,
      68480,
      68497,
      68608,
      68680,
      68736,
      68786,
      68800,
      68850,
      68864,
      68899,
      69248,
      69289,
      69296,
      69297,
      69376,
      69404,
      69415,
      69415,
      69424,
      69445,
      69488,
      69505,
      69552,
      69572,
      69600,
      69622,
      69635,
      69687,
      69745,
      69746,
      69749,
      69749,
      69763,
      69807,
      69840,
      69864,
      69891,
      69926,
      69956,
      69956,
      69959,
      69959,
      69968,
      70002,
      70006,
      70006,
      70019,
      70066,
      70081,
      70084,
      70106,
      70106,
      70108,
      70108,
      70144,
      70161,
      70163,
      70187,
      70207,
      70208,
      70272,
      70278,
      70280,
      70280,
      70282,
      70285,
      70287,
      70301,
      70303,
      70312,
      70320,
      70366,
      70405,
      70412,
      70415,
      70416,
      70419,
      70440,
      70442,
      70448,
      70450,
      70451,
      70453,
      70457,
      70461,
      70461,
      70480,
      70480,
      70493,
      70497,
      70656,
      70708,
      70727,
      70730,
      70751,
      70753,
      70784,
      70831,
      70852,
      70853,
      70855,
      70855,
      71040,
      71086,
      71128,
      71131,
      71168,
      71215,
      71236,
      71236,
      71296,
      71338,
      71352,
      71352,
      71424,
      71450,
      71488,
      71494,
      71680,
      71723,
      71840,
      71903,
      71935,
      71942,
      71945,
      71945,
      71948,
      71955,
      71957,
      71958,
      71960,
      71983,
      71999,
      71999,
      72001,
      72001,
      72096,
      72103,
      72106,
      72144,
      72161,
      72161,
      72163,
      72163,
      72192,
      72192,
      72203,
      72242,
      72250,
      72250,
      72272,
      72272,
      72284,
      72329,
      72349,
      72349,
      72368,
      72440,
      72704,
      72712,
      72714,
      72750,
      72768,
      72768,
      72818,
      72847,
      72960,
      72966,
      72968,
      72969,
      72971,
      73008,
      73030,
      73030,
      73056,
      73061,
      73063,
      73064,
      73066,
      73097,
      73112,
      73112,
      73440,
      73458,
      73474,
      73474,
      73476,
      73488,
      73490,
      73523,
      73648,
      73648,
      73728,
      74649,
      74752,
      74862,
      74880,
      75075,
      77712,
      77808,
      77824,
      78895,
      78913,
      78918,
      82944,
      83526,
      92160,
      92728,
      92736,
      92766,
      92784,
      92862,
      92880,
      92909,
      92928,
      92975,
      92992,
      92995,
      93027,
      93047,
      93053,
      93071,
      93760,
      93823,
      93952,
      94026,
      94032,
      94032,
      94099,
      94111,
      94176,
      94177,
      94179,
      94179,
      94208,
      100343,
      100352,
      101589,
      101632,
      101640,
      110576,
      110579,
      110581,
      110587,
      110589,
      110590,
      110592,
      110882,
      110898,
      110898,
      110928,
      110930,
      110933,
      110933,
      110948,
      110951,
      110960,
      111355,
      113664,
      113770,
      113776,
      113788,
      113792,
      113800,
      113808,
      113817,
      119808,
      119892,
      119894,
      119964,
      119966,
      119967,
      119970,
      119970,
      119973,
      119974,
      119977,
      119980,
      119982,
      119993,
      119995,
      119995,
      119997,
      120003,
      120005,
      120069,
      120071,
      120074,
      120077,
      120084,
      120086,
      120092,
      120094,
      120121,
      120123,
      120126,
      120128,
      120132,
      120134,
      120134,
      120138,
      120144,
      120146,
      120485,
      120488,
      120512,
      120514,
      120538,
      120540,
      120570,
      120572,
      120596,
      120598,
      120628,
      120630,
      120654,
      120656,
      120686,
      120688,
      120712,
      120714,
      120744,
      120746,
      120770,
      120772,
      120779,
      122624,
      122654,
      122661,
      122666,
      122928,
      122989,
      123136,
      123180,
      123191,
      123197,
      123214,
      123214,
      123536,
      123565,
      123584,
      123627,
      124112,
      124139,
      124896,
      124902,
      124904,
      124907,
      124909,
      124910,
      124912,
      124926,
      124928,
      125124,
      125184,
      125251,
      125259,
      125259,
      126464,
      126467,
      126469,
      126495,
      126497,
      126498,
      126500,
      126500,
      126503,
      126503,
      126505,
      126514,
      126516,
      126519,
      126521,
      126521,
      126523,
      126523,
      126530,
      126530,
      126535,
      126535,
      126537,
      126537,
      126539,
      126539,
      126541,
      126543,
      126545,
      126546,
      126548,
      126548,
      126551,
      126551,
      126553,
      126553,
      126555,
      126555,
      126557,
      126557,
      126559,
      126559,
      126561,
      126562,
      126564,
      126564,
      126567,
      126570,
      126572,
      126578,
      126580,
      126583,
      126585,
      126588,
      126590,
      126590,
      126592,
      126601,
      126603,
      126619,
      126625,
      126627,
      126629,
      126633,
      126635,
      126651,
      131072,
      173791,
      173824,
      177977,
      177984,
      178205,
      178208,
      183969,
      183984,
      191456,
      194560,
      195101,
      196608,
      201546,
      201552,
      205743,
      47,
      0,
      1,
      1,
      0,
      0,
      0,
      0,
      3,
      1,
      0,
      0,
      0,
      0,
      5,
      1,
      0,
      0,
      0,
      0,
      7,
      1,
      0,
      0,
      0,
      0,
      9,
      1,
      0,
      0,
      0,
      0,
      15,
      1,
      0,
      0,
      0,
      1,
      17,
      1,
      0,
      0,
      0,
      3,
      20,
      1,
      0,
      0,
      0,
      5,
      22,
      1,
      0,
      0,
      0,
      7,
      24,
      1,
      0,
      0,
      0,
      9,
      26,
      1,
      0,
      0,
      0,
      11,
      35,
      1,
      0,
      0,
      0,
      13,
      37,
      1,
      0,
      0,
      0,
      15,
      39,
      1,
      0,
      0,
      0,
      17,
      18,
      5,
      47,
      0,
      0,
      18,
      19,
      5,
      47,
      0,
      0,
      19,
      2,
      1,
      0,
      0,
      0,
      20,
      21,
      5,
      47,
      0,
      0,
      21,
      4,
      1,
      0,
      0,
      0,
      22,
      23,
      5,
      42,
      0,
      0,
      23,
      6,
      1,
      0,
      0,
      0,
      24,
      25,
      5,
      33,
      0,
      0,
      25,
      8,
      1,
      0,
      0,
      0,
      26,
      30,
      3,
      13,
      6,
      0,
      27,
      29,
      3,
      11,
      5,
      0,
      28,
      27,
      1,
      0,
      0,
      0,
      29,
      32,
      1,
      0,
      0,
      0,
      30,
      28,
      1,
      0,
      0,
      0,
      30,
      31,
      1,
      0,
      0,
      0,
      31,
      33,
      1,
      0,
      0,
      0,
      32,
      30,
      1,
      0,
      0,
      0,
      33,
      34,
      6,
      4,
      0,
      0,
      34,
      10,
      1,
      0,
      0,
      0,
      35,
      36,
      7,
      0,
      0,
      0,
      36,
      12,
      1,
      0,
      0,
      0,
      37,
      38,
      7,
      1,
      0,
      0,
      38,
      14,
      1,
      0,
      0,
      0,
      39,
      43,
      5,
      39,
      0,
      0,
      40,
      42,
      9,
      0,
      0,
      0,
      41,
      40,
      1,
      0,
      0,
      0,
      42,
      45,
      1,
      0,
      0,
      0,
      43,
      44,
      1,
      0,
      0,
      0,
      43,
      41,
      1,
      0,
      0,
      0,
      44,
      46,
      1,
      0,
      0,
      0,
      45,
      43,
      1,
      0,
      0,
      0,
      46,
      47,
      5,
      39,
      0,
      0,
      47,
      16,
      1,
      0,
      0,
      0,
      3,
      0,
      30,
      43,
      1,
      1,
      4,
      0
    ];
    static __ATN;
    static get _ATN() {
      if (!_XPathLexer.__ATN) {
        _XPathLexer.__ATN = new ATNDeserializer().deserialize(_XPathLexer._serializedATN);
      }
      return _XPathLexer.__ATN;
    }
    static vocabulary = new Vocabulary(_XPathLexer.literalNames, _XPathLexer.symbolicNames, []);
    get vocabulary() {
      return _XPathLexer.vocabulary;
    }
    static decisionsToDFA = _XPathLexer._ATN.decisionToState.map((ds, index2) => {
      return new DFA(ds, index2);
    });
  };
  var XPathLexerErrorListener = class extends BaseErrorListener {
    static {
      __name(this, "XPathLexerErrorListener");
    }
    syntaxError(_recognizer, _offendingSymbol, _line, _charPositionInLine, _msg, _e) {
    }
  };
  var XPathElement = class {
    static {
      __name(this, "XPathElement");
    }
    invert;
    nodeName;
    /**
     * Construct element like `/ID` or `ID` or `/*` etc... `nodeName` is undefined if just node
     *
     * @param nodeName The name of the node; may be undefined for any node.
     */
    constructor(nodeName) {
      this.nodeName = nodeName;
      this.invert = false;
    }
    toString() {
      const inv = this.invert ? "!" : "";
      return "XPathElement[" + inv + this.nodeName + "]";
    }
  };
  var XPathRuleAnywhereElement = class extends XPathElement {
    static {
      __name(this, "XPathRuleAnywhereElement");
    }
    ruleIndex;
    constructor(ruleName, ruleIndex) {
      super(ruleName);
      this.ruleIndex = ruleIndex;
    }
    evaluate(t) {
      return Trees.findAllRuleNodes(t, this.ruleIndex);
    }
    toString() {
      const inv = this.invert ? "!" : "";
      return "XPathRuleAnywhereElement[" + inv + this.nodeName + "]";
    }
  };
  var XPathRuleElement = class extends XPathElement {
    static {
      __name(this, "XPathRuleElement");
    }
    ruleIndex;
    constructor(ruleName, ruleIndex) {
      super(ruleName);
      this.ruleIndex = ruleIndex;
    }
    evaluate(t) {
      const nodes = [];
      for (const c of Trees.getChildren(t)) {
        if (c instanceof ParserRuleContext) {
          if (c.ruleIndex === this.ruleIndex && !this.invert || c.ruleIndex !== this.ruleIndex && this.invert) {
            nodes.push(c);
          }
        }
      }
      return nodes;
    }
    toString() {
      const inv = this.invert ? "!" : "";
      return "XPathRuleElement[" + inv + this.nodeName + "]";
    }
  };
  var XPathTokenAnywhereElement = class extends XPathElement {
    static {
      __name(this, "XPathTokenAnywhereElement");
    }
    tokenType;
    constructor(tokenName, tokenType) {
      super(tokenName);
      this.tokenType = tokenType;
    }
    evaluate(t) {
      return Trees.findAllTokenNodes(t, this.tokenType);
    }
    toString() {
      const inv = this.invert ? "!" : "";
      return "XPathTokenAnywhereElement[" + inv + this.nodeName + "]";
    }
  };
  var XPathTokenElement = class extends XPathElement {
    static {
      __name(this, "XPathTokenElement");
    }
    tokenType;
    constructor(tokenName, tokenType) {
      super(tokenName);
      this.tokenType = tokenType;
    }
    evaluate(t) {
      const nodes = [];
      for (const c of Trees.getChildren(t)) {
        if (c instanceof TerminalNode && c.symbol) {
          if (c.symbol.type === this.tokenType && !this.invert || c.symbol.type !== this.tokenType && this.invert) {
            nodes.push(c);
          }
        }
      }
      return nodes;
    }
    toString() {
      const inv = this.invert ? "!" : "";
      return "XPathTokenElement[" + inv + this.nodeName + "]";
    }
  };
  var XPathWildcardAnywhereElement = class extends XPathElement {
    static {
      __name(this, "XPathWildcardAnywhereElement");
    }
    constructor() {
      super(XPath.WILDCARD);
    }
    evaluate(t) {
      if (this.invert) {
        return [];
      }
      return Trees.descendants(t);
    }
    toString() {
      const inv = this.invert ? "!" : "";
      return "XPathWildcardAnywhereElement[" + inv + this.nodeName + "]";
    }
  };
  var XPathWildcardElement = class extends XPathElement {
    static {
      __name(this, "XPathWildcardElement");
    }
    constructor() {
      super(XPath.WILDCARD);
    }
    evaluate(t) {
      const kids = [];
      if (this.invert) {
        return kids;
      }
      for (const c of Trees.getChildren(t)) {
        kids.push(c);
      }
      return kids;
    }
    toString() {
      const inv = this.invert ? "!" : "";
      return "XPathWildcardElement[" + inv + this.nodeName + "]";
    }
  };
  var XPath = class _XPath {
    static {
      __name(this, "XPath");
    }
    static WILDCARD = "*";
    // word not operator/separator
    static NOT = "!";
    // word for invert operator
    path;
    elements;
    parser;
    constructor(parser, path) {
      this.parser = parser;
      this.path = path;
      this.elements = this.split(path);
    }
    static findAll(tree, xpath, parser) {
      const p = new _XPath(parser, xpath);
      return p.evaluate(tree);
    }
    // TODO: check for invalid token/rule names, bad syntax
    split(path) {
      const lexer = new XPathLexer(CharStream.fromString(path));
      lexer.recover = (e) => {
        throw e;
      };
      lexer.removeErrorListeners();
      lexer.addErrorListener(new XPathLexerErrorListener());
      const tokenStream = new CommonTokenStream(lexer);
      try {
        tokenStream.fill();
      } catch (e) {
        if (e instanceof LexerNoViableAltException) {
          const pos = lexer.column;
          const msg = "Invalid tokens or characters at index " + pos + " in path '" + path + "' -- " + e.message;
          throw new RangeError(msg);
        }
        throw e;
      }
      const tokens = tokenStream.getTokens();
      const elements = [];
      const n2 = tokens.length;
      let i = 0;
      loop:
        while (i < n2) {
          const el = tokens[i];
          let next;
          switch (el.type) {
            case XPathLexer.ROOT:
            case XPathLexer.ANYWHERE:
              const anywhere = el.type === XPathLexer.ANYWHERE;
              i++;
              next = tokens[i];
              const invert = next.type === XPathLexer.BANG;
              if (invert) {
                i++;
                next = tokens[i];
              }
              const pathElement = this.getXPathElement(next, anywhere);
              pathElement.invert = invert;
              elements.push(pathElement);
              i++;
              break;
            case XPathLexer.TOKEN_REF:
            case XPathLexer.RULE_REF:
            case XPathLexer.WILDCARD:
              elements.push(this.getXPathElement(el, false));
              ++i;
              break;
            case Token.EOF:
              break loop;
            default:
              throw new Error("Unknown path element " + el);
          }
        }
      return elements;
    }
    /**
     * Return a list of all nodes starting at `t` as root that satisfy the
     * path. The root `/` is relative to the node passed to {@link evaluate}.
     */
    evaluate(t) {
      const dummyRoot = new ParserRuleContext(null);
      dummyRoot.addChild(t);
      let work = /* @__PURE__ */ new Set([dummyRoot]);
      let i = 0;
      while (i < this.elements.length) {
        const next = /* @__PURE__ */ new Set();
        for (const node of work) {
          if (node.getChildCount() > 0) {
            const matching = this.elements[i].evaluate(node);
            matching.forEach((tree) => {
              next.add(tree);
            }, next);
          }
        }
        i++;
        work = next;
      }
      return work;
    }
    /**
     * Convert word like `*` or `ID` or `expr` to a path
     * element. `anywhere` is `true` if `//` precedes the
     * word.
     */
    getXPathElement(wordToken, anywhere) {
      if (wordToken.type === Token.EOF) {
        throw new Error("Missing path element at end of path");
      }
      const word = wordToken.text;
      if (word == null) {
        throw new Error("Expected wordToken to have text content.");
      }
      const ttype = this.parser.getTokenType(word);
      const ruleIndex = this.parser.getRuleIndex(word);
      switch (wordToken.type) {
        case XPathLexer.WILDCARD:
          return anywhere ? new XPathWildcardAnywhereElement() : new XPathWildcardElement();
        case XPathLexer.TOKEN_REF:
        case XPathLexer.STRING:
          if (ttype === Token.INVALID_TYPE) {
            throw new Error(word + " at index " + wordToken.start + " isn't a valid token name");
          }
          return anywhere ? new XPathTokenAnywhereElement(word, ttype) : new XPathTokenElement(word, ttype);
        default:
          if (ruleIndex === -1) {
            throw new Error(word + " at index " + wordToken.start + " isn't a valid rule name");
          }
          return anywhere ? new XPathRuleAnywhereElement(word, ruleIndex) : new XPathRuleElement(word, ruleIndex);
      }
    }
  };
  var Chunk = class {
    static {
      __name(this, "Chunk");
    }
  };
  var ParseTreeMatch = class {
    static {
      __name(this, "ParseTreeMatch");
    }
    /**
     * This is the backing field for {@link #getTree()}.
     */
    tree;
    /**
     * This is the backing field for {@link #getPattern()}.
     */
    pattern;
    /**
     * This is the backing field for {@link #getLabels()}.
     */
    labels;
    /**
     * This is the backing field for {@link #getMismatchedNode()}.
     */
    mismatchedNode;
    /**
     * Constructs a new instance of {@link ParseTreeMatch} from the specified
     * parse tree and pattern.
     *
     * @param tree The parse tree to match against the pattern.
     * @param pattern The parse tree pattern.
     * @param labels A mapping from label names to collections of
     * {@link ParseTree} objects located by the tree pattern matching process.
     * @param mismatchedNode The first node which failed to match the tree
     * pattern during the matching process.
     */
    constructor(tree, pattern, labels, mismatchedNode) {
      this.tree = tree;
      this.pattern = pattern;
      this.labels = labels;
      this.mismatchedNode = mismatchedNode;
    }
    /**
     * Get the last node associated with a specific `label`.
     *
     * For example, for pattern `<id:ID>`, `get("id")` returns the
     * node matched for that `ID`. If more than one node
     * matched the specified label, only the last is returned. If there is
     * no node associated with the label, this returns `null`.
     *
     * Pattern tags like `<ID>` and `<expr>` without labels are
     * considered to be labeled with `ID` and `expr`, respectively.
     *
     * @param label The label to check.
     *
     * @returns The last {@link ParseTree} to match a tag with the specified
     * label, or `null` if no parse tree matched a tag with the label.
     */
    get(label) {
      const parseTrees = this.labels.get(label);
      if (!parseTrees || parseTrees.length === 0) {
        return null;
      }
      return parseTrees[parseTrees.length - 1];
    }
    /**
     * Return all nodes matching a rule or token tag with the specified label.
     *
     * If the `label` is the name of a parser rule or token in the
     * grammar, the resulting list will contain both the parse trees matching
     * rule or tags explicitly labeled with the label and the complete set of
     * parse trees matching the labeled and unlabeled tags in the pattern for
     * the parser rule or token. For example, if `label` is `"foo"`,
     * the result will contain *all* of the following.
     *
     * - Parse tree nodes matching tags of the form `<foo:anyRuleName>` and
     * `<foo:AnyTokenName>`.
     * - Parse tree nodes matching tags of the form `<anyLabel:foo>`.
     * - Parse tree nodes matching tags of the form `<foo>`.
     *
     * @param label The label.
     *
     * @returns A collection of all {@link ParseTree} nodes matching tags with
     * the specified `label`. If no nodes matched the label, an empty list
     * is returned.
     */
    getAll(label) {
      const nodes = this.labels.get(label);
      return nodes ?? [];
    }
    /**
     * Return a mapping from label -> [list of nodes].
     *
     * The map includes special entries corresponding to the names of rules and
     * tokens referenced in tags in the original pattern. For additional
     * information, see the description of {@link getAll(String)}.
     *
     * @returns A mapping from labels to parse tree nodes. If the parse tree
     * pattern did not contain any rule or token tags, this map will be empty.
     */
    getLabels() {
      return this.labels;
    }
    /**
     * Get the node at which we first detected a mismatch.
     *
     * @returns the node at which we first detected a mismatch, or `null`
     * if the match was successful.
     */
    getMismatchedNode() {
      return this.mismatchedNode;
    }
    /**
     * Gets a value indicating whether the match operation succeeded.
     *
     * @returns `true` if the match operation succeeded; otherwise, `false`.
     */
    succeeded() {
      return !this.mismatchedNode;
    }
    /**
     * Get the tree pattern we are matching against.
     *
     * @returns The tree pattern we are matching against.
     */
    getPattern() {
      return this.pattern;
    }
    /**
     * Get the parse tree we are trying to match to a pattern.
     *
     * @returns The {@link ParseTree} we are trying to match to a pattern.
     */
    getTree() {
      return this.tree;
    }
    toString() {
      return `Match ${this.succeeded() ? "succeeded" : "failed"}; found ${this.getLabels().size} labels`;
    }
  };
  var ParseTreePattern = class {
    static {
      __name(this, "ParseTreePattern");
    }
    /**
     * This is the backing field for {@link #getPatternRuleIndex()}.
     */
    patternRuleIndex;
    /**
     * This is the backing field for {@link #getPattern()}.
     */
    pattern;
    /**
     * This is the backing field for {@link #getPatternTree()}.
     */
    patternTree;
    /**
     * This is the backing field for {@link #getMatcher()}.
     */
    matcher;
    /**
     * Construct a new instance of the {@link ParseTreePattern} class.
     *
     * @param matcher The {@link ParseTreePatternMatcher} which created this
     * tree pattern.
     * @param pattern The tree pattern in concrete syntax form.
     * @param patternRuleIndex The parser rule which serves as the root of the
     * tree pattern.
     * @param patternTree The tree pattern in {@link ParseTree} form.
     */
    constructor(matcher, pattern, patternRuleIndex, patternTree) {
      this.matcher = matcher;
      this.patternRuleIndex = patternRuleIndex;
      this.pattern = pattern;
      this.patternTree = patternTree;
    }
    /**
     * Match a specific parse tree against this tree pattern.
     *
     * @param tree The parse tree to match against this tree pattern.
     * @returns A {@link ParseTreeMatch} object describing the result of the
     * match operation. The {@link ParseTreeMatch#succeeded()} method can be
     * used to determine whether or not the match was successful.
     */
    match(tree) {
      return this.matcher.match(tree, this);
    }
    /**
     * Determine whether or not a parse tree matches this tree pattern.
     *
     * @param tree The parse tree to match against this tree pattern.
     * @returns `true` if `tree` is a match for the current tree
     * pattern; otherwise, `false`.
     */
    matches(tree) {
      return this.matcher.match(tree, this).succeeded();
    }
    /**
     * Find all nodes using XPath and then try to match those subtrees against
     * this tree pattern.
     *
     * @param tree The {@link ParseTree} to match against this pattern.
     * @param xpath An expression matching the nodes
     *
     * @returns A collection of {@link ParseTreeMatch} objects describing the
     * successful matches. Unsuccessful matches are omitted from the result,
     * regardless of the reason for the failure.
     */
    findAll(tree, xpath) {
      const subtrees = XPath.findAll(tree, xpath, this.matcher.getParser());
      const matches = new Array();
      for (const t of subtrees) {
        const match = this.match(t);
        if (match.succeeded()) {
          matches.push(match);
        }
      }
      return matches;
    }
    /**
     * Get the {@link ParseTreePatternMatcher} which created this tree pattern.
     *
     * @returns The {@link ParseTreePatternMatcher} which created this tree
     * pattern.
     */
    getMatcher() {
      return this.matcher;
    }
    /**
     * Get the tree pattern in concrete syntax form.
     *
     * @returns The tree pattern in concrete syntax form.
     */
    getPattern() {
      return this.pattern;
    }
    /**
     * Get the parser rule which serves as the outermost rule for the tree
     * pattern.
     *
     * @returns The parser rule which serves as the outermost rule for the tree
     * pattern.
     */
    getPatternRuleIndex() {
      return this.patternRuleIndex;
    }
    /**
     * Get the tree pattern as a {@link ParseTree}. The rule and token tags from
     * the pattern are present in the parse tree as terminal nodes with a symbol
     * of type {@link RuleTagToken} or {@link TokenTagToken}.
     *
     * @returns The tree pattern as a {@link ParseTree}.
     */
    getPatternTree() {
      return this.patternTree;
    }
  };
  var InputMismatchException = class extends RecognitionException {
    static {
      __name(this, "InputMismatchException");
    }
    constructor(recognizer) {
      super({ message: "", recognizer, input: recognizer.inputStream, ctx: recognizer.context });
      this.offendingToken = recognizer.getCurrentToken();
    }
  };
  var FailedPredicateException = class extends RecognitionException {
    static {
      __name(this, "FailedPredicateException");
    }
    ruleIndex = 0;
    predicateIndex = 0;
    predicate;
    constructor(recognizer, predicate, message = null) {
      super({
        message: formatMessage(predicate ?? "no predicate", message ?? null),
        recognizer,
        input: recognizer.inputStream,
        ctx: recognizer.context
      });
      const s = recognizer.atn.states[recognizer.state];
      const trans = s.transitions[0];
      if (trans instanceof PredicateTransition) {
        this.ruleIndex = trans.ruleIndex;
        this.predicateIndex = trans.predIndex;
      } else {
        this.ruleIndex = 0;
        this.predicateIndex = 0;
      }
      this.predicate = predicate;
      this.offendingToken = recognizer.getCurrentToken();
    }
  };
  var formatMessage = /* @__PURE__ */ __name((predicate, message) => {
    if (message !== null) {
      return message;
    }
    return "failed predicate: {" + predicate + "}?";
  }, "formatMessage");
  var DefaultErrorStrategy = class {
    static {
      __name(this, "DefaultErrorStrategy");
    }
    /**
     * Indicates whether the error strategy is currently "recovering from an
     * error". This is used to suppress reporting multiple error messages while
     * attempting to recover from a detected syntax error.
     *
     * @see #inErrorRecoveryMode
     */
    errorRecoveryMode = false;
    /**
     * The index into the input stream where the last error occurred.
     * 	This is used to prevent infinite loops where an error is found
     *  but no token is consumed during recovery...another error is found,
     *  ad nauseam.  This is a failsafe mechanism to guarantee that at least
     *  one token/tree node is consumed for two errors.
     */
    lastErrorIndex = -1;
    lastErrorStates = new IntervalSet();
    /**
     * This field is used to propagate information about the lookahead following
     * the previous match. Since prediction prefers completing the current rule
     * to error recovery efforts, error reporting may occur later than the
     * original point where it was discoverable. The original context is used to
     * compute the true expected sets as though the reporting occurred as early
     * as possible.
     */
    nextTokensContext = null;
    nextTokenState = 0;
    /**
     * The default implementation simply calls {@link endErrorCondition} to
     * ensure that the handler is not in error recovery mode.
     */
    reset(recognizer) {
      this.endErrorCondition(recognizer);
    }
    /**
     * This method is called to enter error recovery mode when a recognition
     * exception is reported.
     *
     * @param _recognizer the parser instance
     */
    beginErrorCondition(_recognizer) {
      this.errorRecoveryMode = true;
    }
    inErrorRecoveryMode(_recognizer) {
      return this.errorRecoveryMode;
    }
    /**
     * This method is called to leave error recovery mode after recovering from
     * a recognition exception.
     */
    endErrorCondition(_recognizer) {
      this.errorRecoveryMode = false;
      this.lastErrorStates = new IntervalSet();
      this.lastErrorIndex = -1;
    }
    /**
     * The default implementation simply calls {@link endErrorCondition}.
     */
    reportMatch(recognizer) {
      this.endErrorCondition(recognizer);
    }
    /**
     * The default implementation returns immediately if the handler is already
     * in error recovery mode. Otherwise, it calls {@link beginErrorCondition}
     * and dispatches the reporting task based on the runtime type of `e`
     * according to the following table.
     *
     * - {@link NoViableAltException}: Dispatches the call to {@link reportNoViableAlternative}
     * - {@link InputMismatchException}: Dispatches the call to {@link reportInputMismatch}
     * - {@link FailedPredicateException}: Dispatches the call to {@link reportFailedPredicate}
     * - All other types: calls {@link Parser.notifyErrorListeners} to report the exception
     */
    reportError(recognizer, e) {
      if (this.inErrorRecoveryMode(recognizer)) {
        return;
      }
      this.beginErrorCondition(recognizer);
      if (e instanceof NoViableAltException) {
        this.reportNoViableAlternative(recognizer, e);
      } else if (e instanceof InputMismatchException) {
        this.reportInputMismatch(recognizer, e);
      } else if (e instanceof FailedPredicateException) {
        this.reportFailedPredicate(recognizer, e);
      } else {
        recognizer.notifyErrorListeners(e.message, e.offendingToken, e);
      }
    }
    /**
     * The default implementation resynchronizes the parser by consuming tokens
     * until we find one in the resynchronization set--loosely the set of tokens
     * that can follow the current rule.
     *
     */
    recover(recognizer, _e) {
      if (this.lastErrorIndex === recognizer.inputStream?.index && this.lastErrorStates.contains(recognizer.state)) {
        recognizer.consume();
      }
      this.lastErrorIndex = recognizer.inputStream?.index ?? 0;
      this.lastErrorStates.addOne(recognizer.state);
      const followSet = this.getErrorRecoverySet(recognizer);
      this.consumeUntil(recognizer, followSet);
    }
    /**
     * The default implementation of {@link ANTLRErrorStrategy.sync} makes sure
     * that the current lookahead symbol is consistent with what were expecting
     * at this point in the ATN. You can call this anytime but ANTLR only
     * generates code to check before subrules/loops and each iteration.
     *
     * Implements Jim Idle's magic sync mechanism in closures and optional
     * subrules. E.g.,
     *
     * ```
     * a : sync ( stuff sync )* ;
     * sync : {consume to what can follow sync} ;
     * ```
     *
     * At the start of a sub rule upon error, {@link sync} performs single
     * token deletion, if possible. If it can't do that, it bails on the current
     * rule and uses the default error recovery, which consumes until the
     * resynchronization set of the current rule.
     *
     * If the sub rule is optional (`(...)?`, `(...)*`, or block
     * with an empty alternative), then the expected set includes what follows
     * the subrule.
     *
     * During loop iteration, it consumes until it sees a token that can start a
     * sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
     * stay in the loop as long as possible.
     *
     * **ORIGINS**
     *
     * Previous versions of ANTLR did a poor job of their recovery within loops.
     * A single mismatch token or missing token would force the parser to bail
     * out of the entire rules surrounding the loop. So, for rule
     *
     * ```
     * classDef : 'class' ID '{' member* '}'
     * ```
     *
     * input with an extra token between members would force the parser to
     * consume until it found the next class definition rather than the next
     * member definition of the current class.
     *
     * This functionality cost a little bit of effort because the parser has to
     * compare token set at the start of the loop and at each iteration. If for
     * some reason speed is suffering for you, you can turn off this
     * functionality by simply overriding this method as a blank { }.
     *
     */
    sync(recognizer) {
      if (this.inErrorRecoveryMode(recognizer)) {
        return;
      }
      const s = recognizer.atn.states[recognizer.state];
      const la = recognizer.tokenStream.LA(1);
      const nextTokens = recognizer.atn.nextTokens(s);
      if (nextTokens.contains(la)) {
        this.nextTokensContext = null;
        this.nextTokenState = ATNState.INVALID_STATE_NUMBER;
        return;
      }
      if (nextTokens.contains(Token.EPSILON)) {
        if (this.nextTokensContext === null) {
          this.nextTokensContext = recognizer.context;
          this.nextTokenState = recognizer.state;
        }
        return;
      }
      switch (s.constructor.stateType) {
        case ATNState.BLOCK_START:
        case ATNState.STAR_BLOCK_START:
        case ATNState.PLUS_BLOCK_START:
        case ATNState.STAR_LOOP_ENTRY: {
          if (this.singleTokenDeletion(recognizer) !== null) {
            return;
          }
          throw new InputMismatchException(recognizer);
        }
        case ATNState.PLUS_LOOP_BACK:
        case ATNState.STAR_LOOP_BACK: {
          this.reportUnwantedToken(recognizer);
          const expecting = new IntervalSet();
          expecting.addSet(recognizer.getExpectedTokens());
          const whatFollowsLoopIterationOrRule = expecting.addSet(this.getErrorRecoverySet(recognizer));
          this.consumeUntil(recognizer, whatFollowsLoopIterationOrRule);
          break;
        }
        default:
      }
    }
    /**
     * This is called by {@link reportError} when the exception is a
     * {@link NoViableAltException}.
     *
     * @see reportError
     *
     * @param recognizer the parser instance
     * @param e the recognition exception
     */
    reportNoViableAlternative(recognizer, e) {
      if (e.message.length > 0) {
        recognizer.notifyErrorListeners(e.message, e.offendingToken, e);
        return;
      }
      const tokens = recognizer.tokenStream;
      let input;
      if (tokens !== null && e.startToken) {
        if (e.startToken.type === Token.EOF) {
          input = "<EOF>";
        } else {
          input = tokens.getTextFromRange(e.startToken, e.offendingToken);
        }
      } else {
        input = "<unknown input>";
      }
      const msg = "no viable alternative at input " + this.escapeWSAndQuote(input);
      recognizer.notifyErrorListeners(msg, e.offendingToken, e);
    }
    /**
     * This is called by {@link reportError} when the exception is an {@link InputMismatchException}.
     *
     * @see reportError
     *
     * @param recognizer the parser instance
     * @param e the recognition exception
     */
    reportInputMismatch(recognizer, e) {
      if (e.message.length > 0) {
        recognizer.notifyErrorListeners(e.message, e.offendingToken, e);
        return;
      }
      const msg = "mismatched input " + this.getTokenErrorDisplay(e.offendingToken) + " expecting " + e.getExpectedTokens().toStringWithVocabulary(recognizer.vocabulary);
      recognizer.notifyErrorListeners(msg, e.offendingToken, e);
    }
    /**
     * This is called by {@link reportError} when the exception is a
     * {@link FailedPredicateException}.
     *
     * @see reportError
     *
     * @param recognizer the parser instance
     * @param e the recognition exception
     */
    reportFailedPredicate(recognizer, e) {
      const ruleName = recognizer.ruleNames[recognizer.context.ruleIndex];
      const msg = "rule " + ruleName + " " + e.message;
      recognizer.notifyErrorListeners(msg, e.offendingToken, e);
    }
    /**
     * This method is called to report a syntax error which requires the removal
     * of a token from the input stream. At the time this method is called, the
     * erroneous symbol is current `LT(1)` symbol and has not yet been
     * removed from the input stream. When this method returns,
     * `recognizer` is in error recovery mode.
     *
     * This method is called when {@link singleTokenDeletion} identifies
     * single-token deletion as a viable recovery strategy for a mismatched
     * input error.
     *
     * The default implementation simply returns if the handler is already in
     * error recovery mode. Otherwise, it calls {@link beginErrorCondition} to
     * enter error recovery mode, followed by calling
     * {@link Parser.notifyErrorListeners}.
     *
     * @param recognizer the parser instance
     */
    reportUnwantedToken(recognizer) {
      if (this.inErrorRecoveryMode(recognizer)) {
        return;
      }
      this.beginErrorCondition(recognizer);
      const t = recognizer.getCurrentToken();
      const tokenName = this.getTokenErrorDisplay(t);
      const expecting = this.getExpectedTokens(recognizer);
      const msg = "extraneous input " + tokenName + " expecting " + expecting.toStringWithVocabulary(recognizer.vocabulary);
      recognizer.notifyErrorListeners(msg, t, null);
    }
    /**
     * This method is called to report a syntax error which requires the
     * insertion of a missing token into the input stream. At the time this
     * method is called, the missing token has not yet been inserted. When this
     * method returns, `recognizer` is in error recovery mode.
     *
     * This method is called when {@link singleTokenInsertion} identifies
     * single-token insertion as a viable recovery strategy for a mismatched
     * input error.
     *
     * The default implementation simply returns if the handler is already in
     * error recovery mode. Otherwise, it calls {@link beginErrorCondition} to
     * enter error recovery mode, followed by calling
     * {@link Parser.notifyErrorListeners}.
     *
     * @param recognizer the parser instance
     */
    reportMissingToken(recognizer) {
      if (this.inErrorRecoveryMode(recognizer)) {
        return;
      }
      this.beginErrorCondition(recognizer);
      const t = recognizer.getCurrentToken();
      const expecting = this.getExpectedTokens(recognizer);
      const msg = "missing " + expecting.toStringWithVocabulary(recognizer.vocabulary) + " at " + this.getTokenErrorDisplay(t);
      recognizer.notifyErrorListeners(msg, t, null);
    }
    /**
     * The default implementation attempts to recover from the mismatched input
     * by using single token insertion and deletion as described below. If the
     * recovery attempt fails, this method throws an
     * {@link InputMismatchException}.
     *
     * **EXTRA TOKEN** (single token deletion)
     *
     * `LA(1)` is not what we are looking for. If `LA(2)` has the
     * right token, however, then assume `LA(1)` is some extra spurious
     * token and delete it. Then consume and return the next token (which was
     * the `LA(2)` token) as the successful result of the match operation.
     *
     * This recovery strategy is implemented by {@link singleTokenDeletion}.
     *
     * **MISSING TOKEN** (single token insertion)
     *
     * If current token (at `LA(1)`) is consistent with what could come
     * after the expected `LA(1)` token, then assume the token is missing
     * and use the parser's {@link TokenFactory} to create it on the fly. The
     * "insertion" is performed by returning the created token as the successful
     * result of the match operation.
     *
     * This recovery strategy is implemented by {@link singleTokenInsertion}.
     *
     * **EXAMPLE**
     *
     * For example, Input `i=(3;` is clearly missing the `')'`. When
     * the parser returns from the nested call to `expr`, it will have
     * call chain:
     *
     * ```
     * stat -> expr -> atom
     * ```
     *
     * and it will be trying to match the `')'` at this point in the
     * derivation:
     *
     * ```
     * => ID '=' '(' INT ')' ('+' atom)* ';'
     * ^
     * ```
     *
     * The attempt to match `')'` will fail when it sees `';'` and
     * call {@link recoverInline}. To recover, it sees that `LA(1)==';'`
     * is in the set of tokens that can follow the `')'` token reference
     * in rule `atom`. It can assume that you forgot the `')'`.
     */
    recoverInline(recognizer) {
      const matchedSymbol = this.singleTokenDeletion(recognizer);
      if (matchedSymbol) {
        recognizer.consume();
        return matchedSymbol;
      }
      if (this.singleTokenInsertion(recognizer)) {
        return this.getMissingSymbol(recognizer);
      }
      throw new InputMismatchException(recognizer);
    }
    /**
     * This method implements the single-token insertion inline error recovery
     * strategy. It is called by {@link recoverInline} if the single-token
     * deletion strategy fails to recover from the mismatched input. If this
     * method returns `true`, `recognizer` will be in error recovery
     * mode.
     *
     * This method determines whether or not single-token insertion is viable by
     * checking if the `LA(1)` input symbol could be successfully matched
     * if it were instead the `LA(2)` symbol. If this method returns
     * `true`, the caller is responsible for creating and inserting a
     * token with the correct type to produce this behavior.
     *
     * @param recognizer the parser instance
     * @returns `true` if single-token insertion is a viable recovery
     * strategy for the current mismatched input, otherwise `false`
     */
    singleTokenInsertion(recognizer) {
      const currentSymbolType = recognizer.tokenStream?.LA(1) ?? -1;
      const atn = recognizer.atn;
      const currentState = atn.states[recognizer.state];
      const next = currentState.transitions[0].target;
      const expectingAtLL2 = atn.nextTokens(next, recognizer.context ?? void 0);
      if (expectingAtLL2.contains(currentSymbolType)) {
        this.reportMissingToken(recognizer);
        return true;
      }
      return false;
    }
    /**
     * This method implements the single-token deletion inline error recovery
     * strategy. It is called by {@link recoverInline} to attempt to recover
     * from mismatched input. If this method returns null, the parser and error
     * handler state will not have changed. If this method returns non-null,
     * `recognizer` will *not* be in error recovery mode since the
     * returned token was a successful match.
     *
     * If the single-token deletion is successful, this method calls
     * {@link reportUnwantedToken} to report the error, followed by
     * {@link Parser.consume} to actually "delete" the extraneous token. Then,
     * before returning {@link reportMatch} is called to signal a successful
     * match.
     *
     * @param recognizer the parser instance
     * @returns the successfully matched {@link Token} instance if single-token
     * deletion successfully recovers from the mismatched input, otherwise
     * `null`
     */
    singleTokenDeletion(recognizer) {
      const nextTokenType = recognizer.tokenStream?.LA(2) ?? -1;
      const expecting = this.getExpectedTokens(recognizer);
      if (expecting.contains(nextTokenType)) {
        this.reportUnwantedToken(recognizer);
        recognizer.consume();
        const matchedSymbol = recognizer.getCurrentToken();
        this.reportMatch(recognizer);
        return matchedSymbol;
      }
      return null;
    }
    /**
     * Conjure up a missing token during error recovery.
     *
     * The recognizer attempts to recover from single missing
     * symbols. But, actions might refer to that missing symbol.
     * For example, x=ID {f($x);}. The action clearly assumes
     * that there has been an identifier matched previously and that
     * $x points at that token. If that token is missing, but
     * the next token in the stream is what we want we assume that
     * this token is missing and we keep going. Because we
     * have to return some token to replace the missing token,
     * we have to conjure one up. This method gives the user control
     * over the tokens returned for missing tokens. Mostly,
     * you will want to create something special for identifier
     * tokens. For literals such as '{' and ',', the default
     * action in the parser or tree parser works. It simply creates
     * a CommonToken of the appropriate type. The text will be the token.
     * If you change what tokens must be created by the lexer,
     * override this method to create the appropriate tokens.
     */
    getMissingSymbol(recognizer) {
      const currentSymbol = recognizer.getCurrentToken();
      const expecting = this.getExpectedTokens(recognizer);
      let expectedTokenType = Token.INVALID_TYPE;
      if (expecting.length !== 0) {
        expectedTokenType = expecting.minElement;
      }
      let tokenText;
      if (expectedTokenType === Token.EOF) {
        tokenText = "<missing EOF>";
      } else {
        tokenText = "<missing " + recognizer.vocabulary.getDisplayName(expectedTokenType) + ">";
      }
      let current = currentSymbol;
      const lookBack = recognizer.tokenStream?.LT(-1);
      if (current.type === Token.EOF && lookBack !== null) {
        current = lookBack;
      }
      return recognizer.getTokenFactory().create(
        current.source,
        expectedTokenType,
        tokenText,
        Token.DEFAULT_CHANNEL,
        -1,
        -1,
        current.line,
        current.column
      );
    }
    getExpectedTokens(recognizer) {
      return recognizer.getExpectedTokens();
    }
    /**
     * How should a token be displayed in an error message? The default
     * is to display just the text, but during development you might
     * want to have a lot of information spit out. Override in that case
     * to use t.toString() (which, for CommonToken, dumps everything about
     * the token). This is better than forcing you to override a method in
     * your token objects because you don't have to go modify your lexer
     * so that it creates a new Java type.
     */
    getTokenErrorDisplay(t) {
      if (t === null) {
        return "<no token>";
      }
      let s = t.text;
      if (!s) {
        if (t.type === Token.EOF) {
          s = "<EOF>";
        } else {
          s = "<" + t.type + ">";
        }
      }
      return this.escapeWSAndQuote(s);
    }
    escapeWSAndQuote(s) {
      s = s.replace(/\n/g, "\\n");
      s = s.replace(/\r/g, "\\r");
      s = s.replace(/\t/g, "\\t");
      return "'" + s + "'";
    }
    /**
     * Compute the error recovery set for the current rule. During
     * rule invocation, the parser pushes the set of tokens that can
     * follow that rule reference on the stack; this amounts to
     * computing FIRST of what follows the rule reference in the
     * enclosing rule. See LinearApproximator.FIRST().
     * This local follow set only includes tokens
     * from within the rule; i.e., the FIRST computation done by
     * ANTLR stops at the end of a rule.
     *
     * EXAMPLE
     *
     * When you find a "no viable alt exception", the input is not
     * consistent with any of the alternatives for rule r. The best
     * thing to do is to consume tokens until you see something that
     * can legally follow a call to r//or* any rule that called r.
     * You don't want the exact set of viable next tokens because the
     * input might just be missing a token--you might consume the
     * rest of the input looking for one of the missing tokens.
     *
     * Consider grammar:
     *
     * a : '[' b ']'
     * | '(' b ')'
     * ;
     * b : c '^' INT ;
     * c : ID
     * | INT
     * ;
     *
     * At each rule invocation, the set of tokens that could follow
     * that rule is pushed on a stack. Here are the various
     * context-sensitive follow sets:
     *
     * FOLLOW(b1_in_a) = FIRST(']') = ']'
     * FOLLOW(b2_in_a) = FIRST(')') = ')'
     * FOLLOW(c_in_b) = FIRST('^') = '^'
     *
     * Upon erroneous input "[]", the call chain is
     *
     * a -> b -> c
     *
     * and, hence, the follow context stack is:
     *
     * depth follow set start of rule execution
     * 0 <EOF> a (from main())
     * 1 ']' b
     * 2 '^' c
     *
     * Notice that ')' is not included, because b would have to have
     * been called from a different context in rule a for ')' to be
     * included.
     *
     * For error recovery, we cannot consider FOLLOW(c)
     * (context-sensitive or otherwise). We need the combined set of
     * all context-sensitive FOLLOW sets--the set of all tokens that
     * could follow any reference in the call chain. We need to
     * resync to one of those tokens. Note that FOLLOW(c)='^' and if
     * we resync'd to that token, we'd consume until EOF. We need to
     * sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.
     * In this case, for input "[]", LA(1) is ']' and in the set, so we would
     * not consume anything. After printing an error, rule c would
     * return normally. Rule b would not find the required '^' though.
     * At this point, it gets a mismatched token error and throws an
     * exception (since LA(1) is not in the viable following token
     * set). The rule exception handler tries to recover, but finds
     * the same recovery set and doesn't consume anything. Rule b
     * exits normally returning to rule a. Now it finds the ']' (and
     * with the successful match exits errorRecovery mode).
     *
     * So, you can see that the parser walks up the call chain looking
     * for the token that was a member of the recovery set.
     *
     * Errors are not generated in errorRecovery mode.
     *
     * ANTLR's error recovery mechanism is based upon original ideas:
     *
     * "Algorithms + Data Structures = Programs" by Niklaus Wirth
     *
     * and
     *
     * "A note on error recovery in recursive descent parsers":
     * http://portal.acm.org/citation.cfm?id=947902.947905
     *
     * Later, Josef Grosch had some good ideas:
     *
     * "Efficient and Comfortable Error Recovery in Recursive Descent
     * Parsers":
     * ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip
     *
     * Like Grosch I implement context-sensitive FOLLOW sets that are combined
     * at run-time upon error to avoid overhead during parsing.
     */
    getErrorRecoverySet(recognizer) {
      const atn = recognizer.atn;
      let ctx = recognizer.context;
      const recoverSet = new IntervalSet();
      while (ctx !== null && ctx.invokingState >= 0) {
        const invokingState = atn.states[ctx.invokingState];
        const rt = invokingState.transitions[0];
        const follow = atn.nextTokens(rt.followState);
        recoverSet.addSet(follow);
        ctx = ctx.parent;
      }
      recoverSet.removeOne(Token.EPSILON);
      return recoverSet;
    }
    /** Consume tokens until one matches the given token set. */
    consumeUntil(recognizer, set) {
      let ttype = recognizer.tokenStream?.LA(1) ?? -1;
      while (ttype !== Token.EOF && !set.contains(ttype)) {
        recognizer.consume();
        ttype = recognizer.tokenStream?.LA(1) ?? -1;
      }
    }
  };
  var BailErrorStrategy = class extends DefaultErrorStrategy {
    static {
      __name(this, "BailErrorStrategy");
    }
    /**
     * Instead of recovering from exception `e`, re-throw it wrapped
     * in a {@link ParseCancellationException} so it is not caught by the
     * rule function catches. Use {@link Exception//getCause()} to get the
     * original {@link RecognitionException}.
     */
    recover(recognizer, e) {
      throw new ParseCancellationException(e);
    }
    /**
     * Make sure we don't attempt to recover inline; if the parser
     * successfully recovers, it won't throw an exception.
     */
    recoverInline(recognizer) {
      const exception = new InputMismatchException(recognizer);
      throw new ParseCancellationException(exception);
    }
    // Make sure we don't attempt to recover from problems in subrules.
    sync(_recognizer) {
    }
  };
  var ListTokenSource = class {
    static {
      __name(this, "ListTokenSource");
    }
    /**
     * The name of the input source. If this value is `null`, a call to
     * {@link #getSourceName} should return the source name used to create the
     * the next token in {@link #tokens} (or the previous token if the end of
     * the input has been reached).
     */
    sourceName;
    tokenFactory = CommonTokenFactory.DEFAULT;
    /**
     * The wrapped collection of {@link Token} objects to return.
     */
    tokens = [];
    /**
     * The index into {@link tokens} of token to return by the next call to
     * {@link #nextToken}. The end of the input is indicated by this value
     * being greater than or equal to the number of items in {@link #tokens}.
     */
    i = 0;
    /**
     * This field caches the EOF token for the token source.
     */
    eofToken = null;
    constructor(tokens, sourceName) {
      this.tokens = tokens;
      this.sourceName = sourceName ?? "";
    }
    get column() {
      if (this.i < this.tokens.length) {
        return this.tokens[this.i].column;
      }
      if (this.eofToken !== null) {
        return this.eofToken.column;
      }
      if (this.tokens.length > 0) {
        const lastToken = this.tokens[this.tokens.length - 1];
        const tokenText = lastToken.text;
        if (tokenText) {
          const lastNewLine = tokenText.lastIndexOf("\n");
          if (lastNewLine >= 0) {
            return tokenText.length - lastNewLine - 1;
          }
        }
        return lastToken.column + lastToken.stop - lastToken.start + 1;
      }
      return 0;
    }
    nextToken() {
      if (this.i >= this.tokens.length) {
        if (this.eofToken === null) {
          let start = -1;
          if (this.tokens.length > 0) {
            const previousStop = this.tokens[this.tokens.length - 1].stop;
            if (previousStop !== -1) {
              start = previousStop + 1;
            }
          }
          const stop = Math.max(-1, start - 1);
          this.eofToken = this.tokenFactory.create(
            [this, this.inputStream],
            Token.EOF,
            "EOF",
            Token.DEFAULT_CHANNEL,
            start,
            stop,
            this.line,
            this.column
          );
        }
        return this.eofToken;
      }
      const t = this.tokens[this.i];
      if (this.i === this.tokens.length - 1 && t.type === Token.EOF) {
        this.eofToken = t;
      }
      this.i++;
      return t;
    }
    get line() {
      if (this.i < this.tokens.length) {
        return this.tokens[this.i].line;
      }
      if (this.eofToken !== null) {
        return this.eofToken.line;
      }
      if (this.tokens.length > 0) {
        const lastToken = this.tokens[this.tokens.length - 1];
        let line = lastToken.line;
        const tokenText = lastToken.text;
        if (tokenText) {
          for (const char of tokenText) {
            if (char === "\n") {
              line++;
            }
          }
        }
        return line;
      }
      return 1;
    }
    get inputStream() {
      if (this.i < this.tokens.length) {
        return this.tokens[this.i].inputStream;
      }
      if (this.eofToken !== null) {
        return this.eofToken.inputStream;
      }
      if (this.tokens.length > 0) {
        return this.tokens[this.tokens.length - 1].inputStream;
      }
      return null;
    }
    getSourceName() {
      if (this.sourceName !== null) {
        return this.sourceName;
      }
      const inputStream = this.inputStream;
      if (inputStream !== null) {
        return inputStream.getSourceName();
      }
      return "List";
    }
  };
  var InterpreterRuleContext = class extends ParserRuleContext {
    static {
      __name(this, "InterpreterRuleContext");
    }
    /** This is the backing field for {@link #getRuleIndex}. */
    #ruleIndex;
    constructor(ruleIndex, parent, invokingStateNumber) {
      super(parent, invokingStateNumber);
      this.#ruleIndex = ruleIndex;
    }
    get ruleIndex() {
      return this.#ruleIndex;
    }
  };
  var TraceListener = class {
    static {
      __name(this, "TraceListener");
    }
    parser;
    constructor(parser) {
      this.parser = parser;
    }
    enterEveryRule(ctx) {
      console.log("enter   " + this.parser.ruleNames[ctx.ruleIndex] + ", LT(1)=" + this.parser.inputStream?.LT(1)?.text);
    }
    visitTerminal(node) {
      console.log("consume " + node.getSymbol() + " rule " + this.parser.ruleNames[this.parser.context.ruleIndex]);
    }
    exitEveryRule(ctx) {
      console.log("exit    " + this.parser.ruleNames[ctx.ruleIndex] + ", LT(1)=" + this.parser.inputStream?.LT(1)?.text);
    }
    visitErrorNode(_node) {
    }
  };
  var Parser = class extends Recognizer {
    static {
      __name(this, "Parser");
    }
    /** For testing only. */
    printer = null;
    /**
     * Specifies whether or not the parser should construct a parse tree during
     * the parsing process. The default value is `true`.
     *
     * @see #getBuildParseTree
     * @see #setBuildParseTree
     */
    buildParseTrees = true;
    /**
     * The error handling strategy for the parser. The default value is a new
     * instance of {@link DefaultErrorStrategy}.
     *
     * @see #getErrorHandler
     * @see #setErrorHandler
     */
    errorHandler = new DefaultErrorStrategy();
    /**
     * The {@link ParserRuleContext} object for the currently executing rule.
     * This is always non-null during the parsing process.
     */
    // TODO: make private
    context = null;
    precedenceStack = [];
    /**
     * The list of {@link ParseTreeListener} listeners registered to receive
     * events during the parse.
     *
     * @see #addParseListener
     */
    parseListeners = null;
    /**
     * The number of syntax errors reported during parsing. This value is
     * incremented each time {@link #notifyErrorListeners} is called.
     */
    syntaxErrors = 0;
    /** Indicates parser has matched EOF token. See {@link #exitRule()}. */
    matchedEOF = false;
    /**
     * When {@link #setTrace}`(true)` is called, a reference to the
     * {@link TraceListener} is stored here so it can be easily removed in a
     * later call to {@link #setTrace}`(false)`. The listener itself is
     * implemented as a parser listener so this field is not directly used by
     * other parser methods.
     */
    tracer = null;
    /**
     * This field holds the deserialized {@link ATN} with bypass alternatives, created
     * lazily upon first demand. In 4.10 I changed from map<serializedATNString, ATN>
     * since we only need one per parser object and also it complicates other targets
     * that don't use ATN strings.
     *
     * @see ATNDeserializationOptions#isGenerateRuleBypassTransitions()
     */
    bypassAltsAtnCache = null;
    #inputStream;
    /**
     * This is all the parsing support code essentially. Most of it is error recovery stuff.
     */
    constructor(input) {
      super();
      this.precedenceStack.push(0);
      this.syntaxErrors = 0;
      this.#inputStream = input;
    }
    /** reset the parser's state */
    reset(rewindInputStream = true) {
      if (rewindInputStream) {
        this.inputStream.seek(0);
      }
      this.errorHandler.reset(this);
      this.context = null;
      this.syntaxErrors = 0;
      this.matchedEOF = false;
      this.setTrace(false);
      this.precedenceStack = [];
      this.precedenceStack.push(0);
      if (this.interpreter) {
        this.interpreter.reset();
      }
    }
    /**
     * Match current input symbol against `ttype`. If the symbol type
     * matches, {@link ANTLRErrorStrategy//reportMatch} and {@link consume} are
     * called to complete the match process.
     *
     * If the symbol type does not match,
     * {@link ANTLRErrorStrategy//recoverInline} is called on the current error
     * strategy to attempt recovery. If {@link buildParseTree} is
     * `true` and the token index of the symbol returned by
     * {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to
     * the parse tree by calling {@link ParserRuleContext//addErrorNode}.
     *
     * @param ttype the token type to match
     * @returns the matched symbol
     * @throws RecognitionException if the current input symbol did not match
     * `ttype` and the error strategy could not recover from the
     * mismatched symbol
     */
    match(ttype) {
      let t = this.getCurrentToken();
      if (t.type === ttype) {
        if (ttype === Token.EOF) {
          this.matchedEOF = true;
        }
        this.errorHandler.reportMatch(this);
        this.consume();
      } else {
        t = this.errorHandler.recoverInline(this);
        if (this.buildParseTrees && t.tokenIndex === -1) {
          this.context.addErrorNode(this.createErrorNode(this.context, t));
        }
      }
      return t;
    }
    /**
     * Match current input symbol as a wildcard. If the symbol type matches
     * (i.e. has a value greater than 0), {@link ANTLRErrorStrategy//reportMatch}
     * and {@link consume} are called to complete the match process.
     *
     * If the symbol type does not match,
     * {@link ANTLRErrorStrategy//recoverInline} is called on the current error
     * strategy to attempt recovery. If {@link buildParseTree} is
     * `true` and the token index of the symbol returned by
     * {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to
     * the parse tree by calling {@link ParserRuleContext//addErrorNode}.
     *
     * @returns the matched symbol
     * @throws RecognitionException if the current input symbol did not match
     * a wildcard and the error strategy could not recover from the mismatched
     * symbol
     */
    matchWildcard() {
      let t = this.getCurrentToken();
      if (t.type > 0) {
        this.errorHandler.reportMatch(this);
        this.consume();
      } else {
        t = this.errorHandler.recoverInline(this);
        if (this.buildParseTrees && t.tokenIndex === -1) {
          this.context.addErrorNode(this.createErrorNode(this.context, t));
        }
      }
      return t;
    }
    getParseListeners() {
      return this.parseListeners ?? [];
    }
    /**
     * Registers `listener` to receive events during the parsing process.
     *
     * To support output-preserving grammar transformations (including but not
     * limited to left-recursion removal, automated left-factoring, and
     * optimized code generation), calls to listener methods during the parse
     * may differ substantially from calls made by
     * {@link ParseTreeWalker//DEFAULT} used after the parse is complete. In
     * particular, rule entry and exit events may occur in a different order
     * during the parse than after the parser. In addition, calls to certain
     * rule entry methods may be omitted.
     *
     * With the following specific exceptions, calls to listener events are
     * deterministic*, i.e. for identical input the calls to listener
     * methods will be the same.
     *
     * - Alterations to the grammar used to generate code may change the
     * behavior of the listener calls.
     * - Alterations to the command line options passed to ANTLR 4 when
     * generating the parser may change the behavior of the listener calls.
     * - Changing the version of the ANTLR Tool used to generate the parser
     * may change the behavior of the listener calls.
     *
     * @param listener the listener to add
     *
     * @throws NullPointerException if {@code} listener is `null`
     */
    addParseListener(listener) {
      if (listener === null) {
        throw new Error("listener");
      }
      if (this.parseListeners === null) {
        this.parseListeners = [];
      }
      this.parseListeners.push(listener);
    }
    /**
     * Remove `listener` from the list of parse listeners.
     *
     * If `listener` is `null` or has not been added as a parse
     * listener, this method does nothing.
     *
     * @param listener the listener to remove
     */
    removeParseListener(listener) {
      if (this.parseListeners !== null && listener !== null) {
        const idx = this.parseListeners.indexOf(listener);
        if (idx >= 0) {
          this.parseListeners.splice(idx, 1);
        }
        if (this.parseListeners.length === 0) {
          this.parseListeners = null;
        }
      }
    }
    // Remove all parse listeners.
    removeParseListeners() {
      this.parseListeners = null;
    }
    // Notify any parse listeners of an enter rule event.
    triggerEnterRuleEvent() {
      if (this.parseListeners !== null) {
        const ctx = this.context;
        this.parseListeners.forEach((listener) => {
          listener.enterEveryRule(ctx);
          ctx.enterRule(listener);
        });
      }
    }
    /**
     * Notify any parse listeners of an exit rule event.
     *
     * @see //addParseListener
     */
    triggerExitRuleEvent() {
      if (this.parseListeners !== null) {
        const ctx = this.context;
        this.parseListeners.slice(0).reverse().forEach((listener) => {
          ctx.exitRule(listener);
          listener.exitEveryRule(ctx);
        });
      }
    }
    getTokenFactory() {
      return this.inputStream.tokenSource.tokenFactory;
    }
    // Tell our token source and error strategy about a new way to create tokens.
    setTokenFactory(factory) {
      this.inputStream.tokenSource.tokenFactory = factory;
    }
    /**
     * The preferred method of getting a tree pattern. For example, here's a
     * sample use:
     *
     * ```
     * const t = parser.expr();
     * const p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
     * const m = p.match(t);
     * const id = m.get("ID");
     * ```
     */
    compileParseTreePattern(pattern, patternRuleIndex, lexer) {
      if (!lexer) {
        if (this.tokenStream !== null) {
          const tokenSource = this.tokenStream.tokenSource;
          if (tokenSource instanceof Lexer) {
            lexer = tokenSource;
          }
        }
      }
      if (!lexer) {
        throw new Error("Parser can't discover a lexer to use");
      }
      const m2 = new ParseTreePatternMatcher(lexer, this);
      return m2.compile(pattern, patternRuleIndex);
    }
    /**
     * The ATN with bypass alternatives is expensive to create so we create it
     * lazily.
     *
     * @throws UnsupportedOperationException if the current parser does not
     * implement the {@link getSerializedATN()} method.
     */
    getATNWithBypassAlts() {
      const serializedAtn = this.serializedATN;
      if (serializedAtn === null) {
        throw new Error("The current parser does not support an ATN with bypass alternatives.");
      }
      if (this.bypassAltsAtnCache !== null) {
        return this.bypassAltsAtnCache;
      }
      const deserializationOptions = { readOnly: false, verifyATN: true, generateRuleBypassTransitions: true };
      this.bypassAltsAtnCache = new ATNDeserializer(deserializationOptions).deserialize(serializedAtn);
      return this.bypassAltsAtnCache;
    }
    /**
     * Gets the number of syntax errors reported during parsing. This value is
     * incremented each time {@link notifyErrorListeners} is called.
     */
    get numberOfSyntaxErrors() {
      return this.syntaxErrors;
    }
    get inputStream() {
      return this.#inputStream;
    }
    set inputStream(input) {
      this.tokenStream = input;
    }
    get tokenStream() {
      return this.#inputStream;
    }
    /** Set the token stream and reset the parser. */
    set tokenStream(input) {
      this.reset(false);
      this.#inputStream = input;
    }
    /**
     * Match needs to return the current input symbol, which gets put
     * into the label for the associated token ref; e.g., x=ID.
     */
    getCurrentToken() {
      return this.inputStream.LT(1);
    }
    notifyErrorListeners(msg, offendingToken, err) {
      offendingToken = offendingToken ?? null;
      err = err ?? null;
      if (offendingToken === null) {
        offendingToken = this.getCurrentToken();
      }
      this.syntaxErrors += 1;
      const line = offendingToken.line;
      const column = offendingToken.column;
      this.errorListenerDispatch.syntaxError(this, offendingToken, line, column, msg, err);
    }
    /**
     * Consume and return the {@link getCurrentToken current symbol}.
     *
     * E.g., given the following input with `A` being the current
     * lookahead symbol, this function moves the cursor to `B` and returns
     * `A`.
     *
     * ```
     * A B
     * ^
     * ```
     *
     * If the parser is not in error recovery mode, the consumed symbol is added
     * to the parse tree using {@link ParserRuleContext//addChild(Token)}, and
     * {@link ParseTreeListener//visitTerminal} is called on any parse listeners.
     * If the parser *is* in error recovery mode, the consumed symbol is
     * added to the parse tree using
     * {@link ParserRuleContext//addErrorNode(Token)}, and
     * {@link ParseTreeListener//visitErrorNode} is called on any parse
     * listeners.
     */
    consume() {
      const o = this.getCurrentToken();
      if (o.type !== Token.EOF) {
        this.tokenStream.consume();
      }
      const hasListener = this.parseListeners !== null && this.parseListeners.length > 0;
      if (this.buildParseTrees || hasListener) {
        let node;
        if (this.errorHandler.inErrorRecoveryMode(this)) {
          node = this.context.addErrorNode(this.createErrorNode(this.context, o));
        } else {
          node = this.context.addTokenNode(o);
        }
        if (hasListener) {
          this.parseListeners.forEach((listener) => {
            if (node instanceof ErrorNode) {
              listener.visitErrorNode(node);
            } else {
              listener.visitTerminal(node);
            }
          });
        }
      }
      return o;
    }
    addContextToParseTree() {
      if (this.context?.parent) {
        this.context.parent.addChild(this.context);
      }
    }
    /**
     * Always called by generated parsers upon entry to a rule. Access field
     * {@link context} get the current context.
     */
    enterRule(localctx, state, _ruleIndex) {
      this.state = state;
      this.context = localctx;
      this.context.start = this.inputStream.LT(1);
      if (this.buildParseTrees) {
        this.addContextToParseTree();
      }
      this.triggerEnterRuleEvent();
    }
    exitRule() {
      if (this.matchedEOF) {
        this.context.stop = this.inputStream.LT(1);
      } else {
        this.context.stop = this.inputStream.LT(-1);
      }
      this.triggerExitRuleEvent();
      this.state = this.context.invokingState;
      this.context = this.context.parent;
    }
    enterOuterAlt(localctx, altNum) {
      localctx.setAltNumber(altNum);
      if (this.buildParseTrees && this.context !== localctx) {
        if (this.context?.parent) {
          this.context.parent.removeLastChild();
          this.context.parent.addChild(localctx);
        }
      }
      this.context = localctx;
    }
    /**
     * Get the precedence level for the top-most precedence rule.
     *
     * @returns The precedence level for the top-most precedence rule, or -1 if
     * the parser context is not nested within a precedence rule.
     */
    getPrecedence() {
      if (this.precedenceStack.length === 0) {
        return -1;
      }
      return this.precedenceStack[this.precedenceStack.length - 1];
    }
    enterRecursionRule(localctx, state, ruleIndex, precedence) {
      this.state = state;
      this.precedenceStack.push(precedence);
      this.context = localctx;
      this.context.start = this.inputStream.LT(1);
      this.triggerEnterRuleEvent();
    }
    /** Like {@link enterRule} but for recursive rules. */
    pushNewRecursionContext(localctx, state, _ruleIndex) {
      const previous = this.context;
      previous.parent = localctx;
      previous.invokingState = state;
      previous.stop = this.inputStream.LT(-1);
      this.context = localctx;
      this.context.start = previous.start;
      if (this.buildParseTrees) {
        this.context.addChild(previous);
      }
      this.triggerEnterRuleEvent();
    }
    unrollRecursionContexts(parent) {
      this.precedenceStack.pop();
      this.context.stop = this.inputStream.LT(-1);
      const retCtx = this.context;
      const parseListeners = this.getParseListeners();
      if (parseListeners !== null && parseListeners.length > 0) {
        while (this.context !== parent) {
          this.triggerExitRuleEvent();
          this.context = this.context.parent;
        }
      } else {
        this.context = parent;
      }
      retCtx.parent = parent;
      if (this.buildParseTrees && parent !== null) {
        parent.addChild(retCtx);
      }
    }
    getInvokingContext(ruleIndex) {
      let ctx = this.context;
      while (ctx !== null) {
        if (ctx.ruleIndex === ruleIndex) {
          return ctx;
        }
        ctx = ctx.parent;
      }
      return null;
    }
    precpred(_localctx, precedence) {
      return precedence >= this.precedenceStack[this.precedenceStack.length - 1];
    }
    /**
     * Checks whether or not `symbol` can follow the current state in the
     * ATN. The behavior of this method is equivalent to the following, but is
     * implemented such that the complete context-sensitive follow set does not
     * need to be explicitly constructed.
     *
     * ```
     * return getExpectedTokens().contains(symbol);
     * ```
     *
     * @param symbol the symbol type to check
     * @returns `true` if `symbol` can follow the current state in
     * the ATN, otherwise `false`.
     */
    isExpectedToken(symbol) {
      const atn = this.interpreter.atn;
      let ctx = this.context;
      const s = atn.states[this.state];
      let following = atn.nextTokens(s);
      if (following.contains(symbol)) {
        return true;
      }
      if (!following.contains(Token.EPSILON)) {
        return false;
      }
      while (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) {
        const invokingState = atn.states[ctx.invokingState];
        const rt = invokingState.transitions[0];
        following = atn.nextTokens(rt.followState);
        if (following.contains(symbol)) {
          return true;
        }
        ctx = ctx.parent;
      }
      if (following.contains(Token.EPSILON) && symbol === Token.EOF) {
        return true;
      } else {
        return false;
      }
    }
    /**
     * Computes the set of input symbols which could follow the current parser
     * state and context, as given by {@link getState} and {@link getContext},
     * respectively.
     *
     * {@link ATN.getExpectedTokens ATN.getExpectedTokens(int, RuleContext)}
     */
    getExpectedTokens() {
      return this.interpreter.atn.getExpectedTokens(this.state, this.context);
    }
    getExpectedTokensWithinCurrentRule() {
      const atn = this.interpreter.atn;
      const s = atn.states[this.state];
      return atn.nextTokens(s);
    }
    /** Get a rule's index (i.e., `RULE_ruleName` field) or -1 if not found. */
    getRuleIndex(ruleName) {
      return this.getRuleIndexMap().get(ruleName) ?? -1;
    }
    /**
     * @returns an array of string of the rule names in your parser instance
     * leading up to a call to the current rule. You could override if
     * you want more details such as the file/line info of where
     * in the ATN a rule is invoked.
     *
     * this is very useful for error messages.
     */
    getRuleInvocationStack(p) {
      p = p ?? null;
      if (p === null) {
        p = this.context;
      }
      const stack = [];
      while (p !== null) {
        const ruleIndex = p.ruleIndex;
        if (ruleIndex < 0) {
          stack.push("n/a");
        } else {
          stack.push(this.ruleNames[ruleIndex]);
        }
        p = p.parent;
      }
      return stack;
    }
    /**
     * For debugging and other purposes.
     *
     * TODO: this differs from the Java version. Change it.
     */
    getDFAStrings() {
      return this.interpreter.decisionToDFA.toString();
    }
    /** For debugging and other purposes. */
    dumpDFA() {
      let seenOne = false;
      for (const dfa of this.interpreter.decisionToDFA) {
        if (dfa.length > 0) {
          if (seenOne) {
            console.log();
          }
          if (this.printer) {
            this.printer.println("Decision " + dfa.decision + ":");
            this.printer.print(dfa.toString(this.vocabulary));
          }
          seenOne = true;
        }
      }
    }
    getSourceName() {
      return this.inputStream.getSourceName();
    }
    getParseInfo() {
      const interp = this.interpreter;
      if (interp instanceof ProfilingATNSimulator) {
        return new ParseInfo(interp);
      }
      return void 0;
    }
    setProfile(profile) {
      const interp = this.interpreter;
      const saveMode = interp.predictionMode;
      if (profile) {
        if (!(interp instanceof ProfilingATNSimulator)) {
          this.interpreter = new ProfilingATNSimulator(this);
        }
      } else if (interp instanceof ProfilingATNSimulator) {
        const sharedContextCache = interp.sharedContextCache;
        if (sharedContextCache) {
          const sim = new ParserATNSimulator(this, this.atn, interp.decisionToDFA, sharedContextCache);
          this.interpreter = sim;
        }
      }
      this.interpreter.predictionMode = saveMode;
    }
    /**
     * During a parse is sometimes useful to listen in on the rule entry and exit
     * events as well as token matches. this is for quick and dirty debugging.
     */
    setTrace(trace) {
      if (!trace) {
        this.removeParseListener(this.tracer);
        this.tracer = null;
      } else {
        if (this.tracer !== null) {
          this.removeParseListener(this.tracer);
        }
        this.tracer = new TraceListener(this);
        this.addParseListener(this.tracer);
      }
    }
    createTerminalNode(parent, t) {
      return new TerminalNode(t);
    }
    createErrorNode(parent, t) {
      return new ErrorNode(t);
    }
  };
  var ParserInterpreter = class extends Parser {
    static {
      __name(this, "ParserInterpreter");
    }
    rootContext;
    overrideDecisionRoot = null;
    parentContextStack = [];
    overrideDecisionAlt = -1;
    overrideDecisionReached = false;
    decisionToDFA;
    sharedContextCache = new PredictionContextCache();
    pushRecursionContextStates;
    #overrideDecision = -1;
    #overrideDecisionInputIndex = -1;
    #grammarFileName;
    #atn;
    #ruleNames;
    #vocabulary;
    constructor(grammarFileName, vocabulary, ruleNames, atn, input) {
      super(input);
      this.#grammarFileName = grammarFileName;
      this.#atn = atn;
      this.#ruleNames = ruleNames.slice(0);
      this.#vocabulary = vocabulary;
      this.pushRecursionContextStates = new BitSet();
      for (const state of atn.states) {
        if (state instanceof StarLoopEntryState && state.precedenceRuleDecision) {
          this.pushRecursionContextStates.set(state.stateNumber);
        }
      }
      this.decisionToDFA = atn.decisionToState.map((ds, i) => {
        return new DFA(ds, i);
      });
      this.interpreter = new ParserATNSimulator(this, atn, this.decisionToDFA, this.sharedContextCache);
    }
    reset() {
      super.reset();
      this.overrideDecisionReached = false;
      this.overrideDecisionRoot = null;
    }
    get atn() {
      return this.#atn;
    }
    get vocabulary() {
      return this.#vocabulary;
    }
    get ruleNames() {
      return this.#ruleNames;
    }
    get grammarFileName() {
      return this.#grammarFileName;
    }
    get atnState() {
      return this.#atn.states[this.state];
    }
    parse(startRuleIndex) {
      const startRuleStartState = this.#atn.ruleToStartState[startRuleIndex];
      this.rootContext = this.createInterpreterRuleContext(null, ATNState.INVALID_STATE_NUMBER, startRuleIndex);
      if (startRuleStartState.isLeftRecursiveRule) {
        this.enterRecursionRule(this.rootContext, startRuleStartState.stateNumber, startRuleIndex, 0);
      } else {
        this.enterRule(this.rootContext, startRuleStartState.stateNumber, startRuleIndex);
      }
      while (true) {
        const p = this.atnState;
        switch (p.constructor.stateType) {
          case ATNState.RULE_STOP: {
            if (this.context?.isEmpty()) {
              if (startRuleStartState.isLeftRecursiveRule) {
                const result = this.context;
                const parentContext = this.parentContextStack.pop();
                this.unrollRecursionContexts(parentContext[0]);
                return result;
              } else {
                this.exitRule();
                return this.rootContext;
              }
            }
            this.visitRuleStopState(p);
            break;
          }
          default: {
            try {
              this.visitState(p);
            } catch (e) {
              if (e instanceof RecognitionException) {
                this.state = this.#atn.ruleToStopState[p.ruleIndex].stateNumber;
                this.errorHandler.reportError(this, e);
                this.recover(e);
              } else {
                throw e;
              }
            }
            break;
          }
        }
      }
    }
    addDecisionOverride(decision, tokenIndex, forcedAlt) {
      this.#overrideDecision = decision;
      this.#overrideDecisionInputIndex = tokenIndex;
      this.overrideDecisionAlt = forcedAlt;
    }
    get overrideDecision() {
      return this.#overrideDecision;
    }
    get overrideDecisionInputIndex() {
      return this.#overrideDecisionInputIndex;
    }
    enterRecursionRule(localctx, state, ruleIndex, precedence) {
      this.parentContextStack.push([this.context, localctx.invokingState]);
      super.enterRecursionRule(localctx, state, ruleIndex, precedence);
    }
    get serializedATN() {
      throw new Error("The ParserInterpreter does not support the serializedATN property.");
    }
    visitState(p) {
      let predictedAlt = 1;
      if (p instanceof DecisionState) {
        predictedAlt = this.visitDecisionState(p);
      }
      const transition = p.transitions[predictedAlt - 1];
      switch (transition.transitionType) {
        case Transition.EPSILON:
          if (this.pushRecursionContextStates.get(p.stateNumber) && !(transition.target.constructor.stateType === ATNState.LOOP_END)) {
            const parentContext = this.parentContextStack[this.parentContextStack.length - 1];
            const localctx = this.createInterpreterRuleContext(parentContext[0], parentContext[1], this.context.ruleIndex);
            this.pushNewRecursionContext(
              localctx,
              this.#atn.ruleToStartState[p.ruleIndex].stateNumber,
              this.context.ruleIndex
            );
          }
          break;
        case Transition.ATOM:
          this.match(transition.label.minElement);
          break;
        case Transition.RANGE:
        case Transition.SET:
        case Transition.NOT_SET:
          if (!transition.matches(this.inputStream.LA(1), Token.MIN_USER_TOKEN_TYPE, 65535)) {
            this.recoverInline();
          }
          this.matchWildcard();
          break;
        case Transition.WILDCARD:
          this.matchWildcard();
          break;
        case Transition.RULE:
          const ruleStartState = transition.target;
          const ruleIndex = ruleStartState.ruleIndex;
          const newContext = this.createInterpreterRuleContext(this.context, p.stateNumber, ruleIndex);
          if (ruleStartState.isLeftRecursiveRule) {
            this.enterRecursionRule(
              newContext,
              ruleStartState.stateNumber,
              ruleIndex,
              transition.precedence
            );
          } else {
            this.enterRule(newContext, transition.target.stateNumber, ruleIndex);
          }
          break;
        case Transition.PREDICATE:
          const predicateTransition = transition;
          if (!this.sempred(this.context, predicateTransition.ruleIndex, predicateTransition.predIndex)) {
            throw new FailedPredicateException(this);
          }
          break;
        case Transition.ACTION:
          const actionTransition = transition;
          this.action(this.context, actionTransition.ruleIndex, actionTransition.actionIndex);
          break;
        case Transition.PRECEDENCE:
          if (!this.precpred(this.context, transition.precedence)) {
            const precedence = transition.precedence;
            throw new FailedPredicateException(this, `precpred(_ctx, ${precedence})`);
          }
          break;
        default:
          throw new Error("UnsupportedOperationException: Unrecognized ATN transition type.");
      }
      this.state = transition.target.stateNumber;
    }
    visitDecisionState(p) {
      let predictedAlt = 1;
      if (p.transitions.length > 1) {
        this.errorHandler.sync(this);
        const decision = p.decision;
        if (decision === this.#overrideDecision && this.inputStream.index === this.#overrideDecisionInputIndex && !this.overrideDecisionReached) {
          predictedAlt = this.overrideDecisionAlt;
          this.overrideDecisionReached = true;
        } else {
          predictedAlt = this.interpreter.adaptivePredict(this.inputStream, decision, this.context);
        }
      }
      return predictedAlt;
    }
    createInterpreterRuleContext(parent, invokingStateNumber, ruleIndex) {
      return new InterpreterRuleContext(ruleIndex, parent, invokingStateNumber);
    }
    visitRuleStopState(p) {
      const ruleStartState = this.#atn.ruleToStartState[p.ruleIndex];
      if (ruleStartState.isLeftRecursiveRule) {
        const [parentContext, state] = this.parentContextStack.pop();
        this.unrollRecursionContexts(parentContext);
        this.state = state;
      } else {
        this.exitRule();
      }
      const ruleTransition = this.#atn.states[this.state].transitions[0];
      this.state = ruleTransition.followState.stateNumber;
    }
    recover(e) {
      const i = this.inputStream.index;
      this.errorHandler.recover(this, e);
      if (this.inputStream.index === i) {
        const tok = e.offendingToken;
        if (!tok) {
          throw new Error("Expected exception to have an offending token");
        }
        const source = tok.tokenSource;
        const stream = source?.inputStream ?? null;
        const sourcePair = [source, stream];
        if (e instanceof InputMismatchException) {
          const expectedTokens = e.getExpectedTokens();
          if (!expectedTokens) {
            throw new Error("Expected the exception to provide expected tokens");
          }
          let expectedTokenType = Token.INVALID_TYPE;
          if (expectedTokens.length !== 0) {
            expectedTokenType = expectedTokens.minElement;
          }
          const errToken = this.getTokenFactory().create(
            sourcePair,
            expectedTokenType,
            tok.text,
            Token.DEFAULT_CHANNEL,
            -1,
            -1,
            tok.line,
            tok.column
          );
          this.context.addErrorNode(this.createErrorNode(this.context, errToken));
        } else {
          const errToken = this.getTokenFactory().create(
            sourcePair,
            Token.INVALID_TYPE,
            tok.text,
            Token.DEFAULT_CHANNEL,
            -1,
            -1,
            tok.line,
            tok.column
          );
          this.context.addErrorNode(this.createErrorNode(this.context, errToken));
        }
      }
    }
    recoverInline() {
      return this.errorHandler.recoverInline(this);
    }
  };
  var MultiMap = class extends Map {
    static {
      __name(this, "MultiMap");
    }
    map(key, value) {
      let elementsForKey = this.get(key);
      if (!elementsForKey) {
        elementsForKey = new Array();
        this.set(key, elementsForKey);
      }
      elementsForKey.push(value);
    }
    getPairs() {
      const pairs = new Array();
      for (const key of this.keys()) {
        const keys = this.get(key) ?? [];
        for (const value of keys) {
          pairs.push([key, value]);
        }
      }
      return pairs;
    }
    toString() {
      const entries = [];
      this.forEach((value, key) => {
        entries.push(`${key}=[${value.join(", ")}]`);
      });
      return `{${entries.join(", ")}}`;
    }
  };
  var CannotInvokeStartRuleError = class extends Error {
    static {
      __name(this, "CannotInvokeStartRuleError");
    }
    constructor(e) {
      super();
      this.cause = e;
    }
  };
  var RuleTagToken = class {
    static {
      __name(this, "RuleTagToken");
    }
    /** The name of the label associated with the rule tag. */
    label;
    /** The name of the parser rule associated with this rule tag. */
    ruleName;
    /**
     * The token type for the current token. This is the token type assigned to
     * the bypass alternative for the rule during ATN deserialization.
     */
    bypassTokenType;
    constructor(ruleName, bypassTokenType, label) {
      this.ruleName = ruleName;
      this.bypassTokenType = bypassTokenType;
      this.label = label;
    }
    /**
     * Rule tag tokens are always placed on the {@link #DEFAULT_CHANNEL}.
     */
    get channel() {
      return Token.DEFAULT_CHANNEL;
    }
    /**
     * This method returns the rule tag formatted with `<` and `>`
     * delimiters.
     */
    get text() {
      if (this.label !== void 0) {
        return "<" + this.label + ":" + this.ruleName + ">";
      }
      return "<" + this.ruleName + ">";
    }
    /**
     * Rule tag tokens have types assigned according to the rule bypass
     * transitions created during ATN deserialization.
     */
    get type() {
      return this.bypassTokenType;
    }
    /**
     * The implementation for {@link RuleTagToken} always returns 0.
     */
    get line() {
      return 0;
    }
    /**
     * The implementation for {@link RuleTagToken} always returns -1.
     */
    get column() {
      return -1;
    }
    /**
     * The implementation for {@link RuleTagToken} always returns -1.
     */
    get tokenIndex() {
      return -1;
    }
    /**
     * The implementation for {@link RuleTagToken} always returns -1.
     */
    get start() {
      return -1;
    }
    /**
     * The implementation for {@link RuleTagToken} always returns -1.
     */
    get stop() {
      return -1;
    }
    /**
     * The implementation for {@link RuleTagToken} always returns `null`.
     */
    get tokenSource() {
      return null;
    }
    /**
     * The implementation for {@link RuleTagToken} always returns `null`.
     */
    get inputStream() {
      return null;
    }
    /**
     * The implementation for {@link RuleTagToken} returns a string of the form
     * `ruleName:bypassTokenType`.
     */
    toString() {
      return this.ruleName + ":" + this.bypassTokenType;
    }
  };
  var StartRuleDoesNotConsumeFullPatternError = class extends Error {
    static {
      __name(this, "StartRuleDoesNotConsumeFullPatternError");
    }
  };
  var TagChunk = class extends Chunk {
    static {
      __name(this, "TagChunk");
    }
    tag;
    label;
    constructor(...args) {
      let label;
      let tag;
      if (args.length === 1) {
        tag = args[0];
      } else {
        label = args[0];
        tag = args[1];
      }
      super();
      if (!tag) {
        throw new Error("tag cannot be null or empty");
      }
      this.label = label;
      this.tag = tag;
    }
    /**
     * @returns a text representation of the tag chunk. Labeled tags
     * are returned in the form `label:tag`, and unlabeled tags are
     * returned as just the tag name.
     */
    toString() {
      if (this.label !== void 0) {
        return this.label + ":" + this.tag;
      }
      return this.tag;
    }
  };
  var TextChunk = class extends Chunk {
    static {
      __name(this, "TextChunk");
    }
    text;
    /**
     * Constructs a new instance of {@link TextChunk} with the specified text.
     *
     * @param text The text of this chunk.
     */
    constructor(text) {
      super();
      this.text = text;
    }
    /**
     * @returns the result of {@link #getText()} in single quotes.
     */
    toString() {
      return "'" + this.text + "'";
    }
  };
  var TokenTagToken = class extends CommonToken {
    static {
      __name(this, "TokenTagToken");
    }
    tokenName;
    /**
     * The name of the label associated with the rule tag, or undefined if this is an unlabeled rule tag.
     */
    label;
    constructor(tokenName, type, label) {
      super({ type, source: CommonToken.EMPTY_SOURCE });
      this.tokenName = tokenName;
      this.label = label;
    }
    /**
     *
     * @returns the token tag formatted with `<` and `>` delimiters.
     */
    get text() {
      if (this.label !== void 0) {
        return "<" + this.label + ":" + this.tokenName + ">";
      }
      return "<" + this.tokenName + ">";
    }
    /**
     * @returns a string of the form `tokenName:type`.
     */
    toString() {
      return this.tokenName + ":" + this.type;
    }
  };
  var ParseTreePatternMatcher = class {
    static {
      __name(this, "ParseTreePatternMatcher");
    }
    start = "<";
    stop = ">";
    escape = "\\";
    // e.g., \< and \> must escape BOTH!
    /**
     * This is the backing field for {@link #getLexer()}.
     */
    lexer;
    /**
     * This is the backing field for {@link #getParser()}.
     */
    parser;
    /**
     * Constructs a {@link ParseTreePatternMatcher} or from a {@link Lexer} and
     * {@link Parser} object. The lexer input stream is altered for tokenizing
     * the tree patterns. The parser is used as a convenient mechanism to get
     * the grammar name, plus token, rule names.
     */
    constructor(lexer, parser) {
      this.lexer = lexer;
      this.parser = parser;
    }
    /**
     * Set the delimiters used for marking rule and token tags within concrete
     * syntax used by the tree pattern parser.
     *
     * @param start The start delimiter.
     * @param stop The stop delimiter.
     * @param escapeLeft The escape sequence to use for escaping a start or stop delimiter.
     *
     * @throws Error if `start` is `null` or empty.
     * @throws Error if `stop` is `null` or empty.
     */
    setDelimiters(start, stop, escapeLeft) {
      if (start === null || start.length === 0) {
        throw new Error("start cannot be null or empty");
      }
      if (stop === null || stop.length === 0) {
        throw new Error("stop cannot be null or empty");
      }
      this.start = start;
      this.stop = stop;
      this.escape = escapeLeft;
    }
    matches(...args) {
      switch (args.length) {
        case 2: {
          const [tree, pattern] = args;
          const labels = new MultiMap();
          const mismatchedNode = this.matchImpl(tree, pattern.getPatternTree(), labels);
          return mismatchedNode === null;
        }
        case 3: {
          const [tree, pattern, patternRuleIndex] = args;
          const p = this.compile(pattern, patternRuleIndex);
          return this.matches(tree, p);
        }
        default: {
          throw new Error("Invalid number of arguments");
        }
      }
    }
    match(...args) {
      switch (args.length) {
        case 2: {
          const [tree, pattern] = args;
          const labels = new MultiMap();
          const mismatchedNode = this.matchImpl(tree, pattern.getPatternTree(), labels);
          return new ParseTreeMatch(tree, pattern, labels, mismatchedNode);
        }
        case 3: {
          const [tree, pattern, patternRuleIndex] = args;
          const p = this.compile(pattern, patternRuleIndex);
          return this.match(tree, p);
        }
        default: {
          throw new Error("Invalid number of arguments");
        }
      }
    }
    /**
     * For repeated use of a tree pattern, compile it to a
     * {@link ParseTreePattern} using this method.
     */
    compile(pattern, patternRuleIndex) {
      const tokenList = this.tokenize(pattern);
      const tokenSrc = new ListTokenSource(tokenList);
      const tokens = new CommonTokenStream(tokenSrc);
      const parserInterp = new ParserInterpreter(
        this.parser.grammarFileName,
        this.parser.vocabulary,
        this.parser.ruleNames,
        this.parser.getATNWithBypassAlts(),
        tokens
      );
      parserInterp.removeErrorListeners();
      let tree = null;
      try {
        parserInterp.errorHandler = new BailErrorStrategy();
        tree = parserInterp.parse(patternRuleIndex);
      } catch (error) {
        if (error instanceof ParseCancellationException) {
          throw error.cause;
        } else if (error instanceof RecognitionException) {
          throw error;
        } else if (error instanceof Error) {
          throw new CannotInvokeStartRuleError(error);
        } else {
          throw error;
        }
      }
      if (tokens.LA(1) !== Token.EOF) {
        throw new StartRuleDoesNotConsumeFullPatternError();
      }
      return new ParseTreePattern(this, pattern, patternRuleIndex, tree);
    }
    /**
     * Used to convert the tree pattern string into a series of tokens. The
     * input stream is reset.
     */
    getLexer() {
      return this.lexer;
    }
    /**
     * Used to collect to the grammar file name, token names, rule names for
     * used to parse the pattern into a parse tree.
     */
    getParser() {
      return this.parser;
    }
    // ---- SUPPORT CODE ----
    tokenize(pattern) {
      const chunks = this.split(pattern);
      const tokens = new Array();
      for (const chunk of chunks) {
        if (chunk instanceof TagChunk) {
          const tagChunk = chunk;
          const char = tagChunk.tag[0];
          if (char === char.toUpperCase()) {
            const ttype = this.parser.getTokenType(tagChunk.tag);
            if (ttype === Token.INVALID_TYPE) {
              throw new Error("Unknown token " + tagChunk.tag + " in pattern: " + pattern);
            }
            const t = new TokenTagToken(tagChunk.tag, ttype, tagChunk.label);
            tokens.push(t);
          } else {
            if (char === char.toLowerCase()) {
              const ruleIndex = this.parser.getRuleIndex(tagChunk.tag);
              if (ruleIndex === -1) {
                throw new Error("Unknown rule " + tagChunk.tag + " in pattern: " + pattern);
              }
              const ruleImaginaryTokenType = this.parser.getATNWithBypassAlts().ruleToTokenType[ruleIndex];
              tokens.push(new RuleTagToken(tagChunk.tag, ruleImaginaryTokenType, tagChunk.label));
            } else {
              throw new Error("invalid tag: " + tagChunk.tag + " in pattern: " + pattern);
            }
          }
        } else {
          const textChunk = chunk;
          const input = CharStream.fromString(textChunk.text);
          this.lexer.inputStream = input;
          let t = this.lexer.nextToken();
          while (t.type !== Token.EOF) {
            tokens.push(t);
            t = this.lexer.nextToken();
          }
        }
      }
      return tokens;
    }
    /**
     * Split `<ID> = <e:expr> ;` into 4 chunks for tokenizing by {@link #tokenize}.
     */
    split(pattern) {
      let p = 0;
      const n2 = pattern.length;
      const chunks = new Array();
      const starts = new Array();
      const stops = new Array();
      while (p < n2) {
        if (p === pattern.indexOf(this.escape + this.start, p)) {
          p += this.escape.length + this.start.length;
        } else {
          if (p === pattern.indexOf(this.escape + this.stop, p)) {
            p += this.escape.length + this.stop.length;
          } else {
            if (p === pattern.indexOf(this.start, p)) {
              starts.push(p);
              p += this.start.length;
            } else {
              if (p === pattern.indexOf(this.stop, p)) {
                stops.push(p);
                p += this.stop.length;
              } else {
                p++;
              }
            }
          }
        }
      }
      if (starts.length > stops.length) {
        throw new Error("unterminated tag in pattern: " + pattern);
      }
      if (starts.length < stops.length) {
        throw new Error("missing start tag in pattern: " + pattern);
      }
      const tagCount = starts.length;
      for (let i = 0; i < tagCount; i++) {
        if (starts[i] >= stops[i]) {
          throw new Error("tag delimiters out of order in pattern: " + pattern);
        }
      }
      if (tagCount === 0) {
        const text = pattern.substring(0, n2);
        chunks.push(new TextChunk(text));
      }
      if (tagCount > 0 && starts[0] > 0) {
        const text = pattern.substring(0, starts[0]);
        chunks.push(new TextChunk(text));
      }
      for (let i = 0; i < tagCount; i++) {
        const tag = pattern.substring(starts[i] + this.start.length, stops[i]);
        let ruleOrToken = tag;
        let label;
        const colon = tag.indexOf(":");
        if (colon >= 0) {
          label = tag.substring(0, colon);
          ruleOrToken = tag.substring(colon + 1, tag.length);
        }
        chunks.push(new TagChunk(label, ruleOrToken));
        if (i + 1 < tagCount) {
          const text = pattern.substring(stops[i] + this.stop.length, starts[i + 1]);
          chunks.push(new TextChunk(text));
        }
      }
      if (tagCount > 0) {
        const afterLastTag = stops[tagCount - 1] + this.stop.length;
        if (afterLastTag < n2) {
          const text = pattern.substring(afterLastTag, n2);
          chunks.push(new TextChunk(text));
        }
      }
      for (let i = 0; i < chunks.length; i++) {
        const c = chunks[i];
        if (c instanceof TextChunk) {
          const tc = c;
          const unescaped = tc.text.replaceAll(this.escape, "");
          if (unescaped.length < tc.text.length) {
            chunks[i] = new TextChunk(unescaped);
          }
        }
      }
      return chunks;
    }
    /**
     * Recursively walk `tree` against `patternTree`, filling
     * `match.`{@link ParseTreeMatch#labels labels}.
     *
     * @returns the first node encountered in `tree` which does not match
     * a corresponding node in `patternTree`, or `null` if the match
     * was successful. The specific node returned depends on the matching
     * algorithm used by the implementation, and may be overridden.
     */
    matchImpl(tree, patternTree, labels) {
      if (tree instanceof TerminalNode && patternTree instanceof TerminalNode) {
        const t1 = tree;
        const t2 = patternTree;
        let mismatchedNode;
        if (t1.getSymbol().type === t2.getSymbol().type) {
          if (t2.getSymbol() instanceof TokenTagToken) {
            const tokenTagToken = t2.getSymbol();
            labels.map(tokenTagToken.tokenName, tree);
            if (tokenTagToken.label !== void 0) {
              labels.map(tokenTagToken.label, tree);
            }
          } else {
            if (t1.getText() === t2.getText()) {
            } else {
              if (!mismatchedNode) {
                mismatchedNode = t1;
              }
            }
          }
        } else {
          if (!mismatchedNode) {
            mismatchedNode = t1;
          }
        }
        return mismatchedNode;
      }
      if (tree instanceof ParserRuleContext && patternTree instanceof ParserRuleContext) {
        let mismatchedNode;
        const ruleTagToken = this.getRuleTagToken(patternTree);
        if (ruleTagToken) {
          if (tree.ruleIndex === patternTree.ruleIndex) {
            labels.map(ruleTagToken.ruleName, tree);
            if (ruleTagToken.label) {
              labels.map(ruleTagToken.label, tree);
            }
          } else {
            if (!mismatchedNode) {
              mismatchedNode = tree;
            }
          }
          return mismatchedNode;
        }
        if (tree.getChildCount() !== patternTree.getChildCount()) {
          if (!mismatchedNode) {
            mismatchedNode = tree;
          }
          return mismatchedNode;
        }
        const n2 = tree.getChildCount();
        for (let i = 0; i < n2; i++) {
          const childMatch = this.matchImpl(tree.getChild(i), patternTree.getChild(i), labels);
          if (childMatch) {
            return childMatch;
          }
        }
        return mismatchedNode;
      }
      return tree;
    }
    /**
     * Is `t` `(expr <expr>)` subtree?
     */
    getRuleTagToken(t) {
      if (t instanceof ParserRuleContext) {
        if (t.getChildCount() === 1 && t.getChild(0) instanceof TerminalNode) {
          const c = t.getChild(0);
          if (c.getSymbol() instanceof RuleTagToken) {
            return c.getSymbol();
          }
        }
      }
      return void 0;
    }
  };
  var DiagnosticErrorListener = class extends BaseErrorListener {
    static {
      __name(this, "DiagnosticErrorListener");
    }
    /**
     * When `true`, only exactly known ambiguities are reported.
     */
    exactOnly;
    constructor(exactOnly) {
      super();
      this.exactOnly = exactOnly ?? true;
    }
    reportAmbiguity = /* @__PURE__ */ __name((recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) => {
      if (this.exactOnly && !exact) {
        return;
      }
      const decision = this.getDecisionDescription(recognizer, dfa);
      const conflictingAlts = this.getConflictingAlts(ambigAlts, configs);
      const text = recognizer.tokenStream?.getTextFromInterval(Interval.of(startIndex, stopIndex));
      const message = `reportAmbiguity d=${decision}: ambigAlts=${conflictingAlts}, input='${text}'`;
      recognizer.notifyErrorListeners(message, null, null);
    }, "reportAmbiguity");
    reportAttemptingFullContext = /* @__PURE__ */ __name((recognizer, dfa, startIndex, stopIndex, _conflictingAlts, _configs) => {
      const decision = this.getDecisionDescription(recognizer, dfa);
      const text = recognizer.tokenStream?.getTextFromInterval(Interval.of(startIndex, stopIndex));
      const message = `reportAttemptingFullContext d=${decision}, input='${text}'`;
      recognizer.notifyErrorListeners(message, null, null);
    }, "reportAttemptingFullContext");
    reportContextSensitivity = /* @__PURE__ */ __name((recognizer, dfa, startIndex, stopIndex, _prediction, _configs) => {
      const decision = this.getDecisionDescription(recognizer, dfa);
      const text = recognizer.tokenStream?.getTextFromInterval(Interval.of(startIndex, stopIndex));
      const message = `reportContextSensitivity d=${decision}, input='${text}'`;
      recognizer.notifyErrorListeners(message, null, null);
    }, "reportContextSensitivity");
    getDecisionDescription = /* @__PURE__ */ __name((recognizer, dfa) => {
      const decision = dfa.decision;
      const ruleIndex = dfa.atnStartState.ruleIndex;
      const ruleNames = recognizer.ruleNames;
      if (ruleIndex < 0 || ruleIndex >= ruleNames.length) {
        return decision.toString();
      }
      const ruleName = ruleNames[ruleIndex];
      if (ruleName.length === 0) {
        return decision.toString();
      }
      return `${decision} (${ruleName})`;
    }, "getDecisionDescription");
    /**
     * Computes the set of conflicting or ambiguous alternatives from a
     * configuration set, if that information was not already provided by the
     * parser.
     *
     * @param reportedAlts The set of conflicting or ambiguous alternatives, as
     * reported by the parser.
     * @param configs The conflicting or ambiguous configuration set.
     * @returns Returns `reportedAlts` if it is not `null`, otherwise
     * returns the set of alternatives represented in `configs`.
     */
    getConflictingAlts = /* @__PURE__ */ __name((reportedAlts, configs) => {
      if (reportedAlts) {
        return reportedAlts;
      }
      const result = new BitSet();
      for (let i = 0; i < configs.configs.length; i++) {
        result.set(configs.configs[i].alt);
      }
      return result;
    }, "getConflictingAlts");
  };
  var LexerInterpreter = class extends Lexer {
    static {
      __name(this, "LexerInterpreter");
    }
    decisionToDFA;
    sharedContextCache = new PredictionContextCache();
    #grammarFileName;
    #atn;
    #ruleNames;
    #channelNames;
    #modeNames;
    #vocabulary;
    constructor(grammarFileName, vocabulary, ruleNames, channelNames, modeNames, atn, input) {
      super(input);
      if (atn.grammarType !== ATN.LEXER) {
        throw new Error("IllegalArgumentException: The ATN must be a lexer ATN.");
      }
      this.#grammarFileName = grammarFileName;
      this.#atn = atn;
      this.#ruleNames = ruleNames.slice(0);
      this.#channelNames = channelNames.slice(0);
      this.#modeNames = modeNames.slice(0);
      this.#vocabulary = vocabulary;
      this.decisionToDFA = atn.decisionToState.map((ds, i) => {
        return new DFA(ds, i);
      });
      this.interpreter = new LexerATNSimulator(this, atn, this.decisionToDFA, this.sharedContextCache);
    }
    get atn() {
      return this.#atn;
    }
    get grammarFileName() {
      return this.#grammarFileName;
    }
    get ruleNames() {
      return this.#ruleNames;
    }
    get channelNames() {
      return this.#channelNames;
    }
    get modeNames() {
      return this.#modeNames;
    }
    get vocabulary() {
      return this.#vocabulary;
    }
    get serializedATN() {
      throw new Error("The LexerInterpreter does not support the serializedATN property.");
    }
  };
  var RuntimeMetaData = class _RuntimeMetaData {
    static {
      __name(this, "RuntimeMetaData");
    }
    /**
     * A compile-time constant containing the current version of the ANTLR 4
     * runtime library.
     *
     * This compile-time constant value allows generated parsers and other
     * libraries to include a literal reference to the version of the ANTLR 4
     * runtime library the code was compiled against. At each release, we
     * change this value.
     *
     * Version numbers are assumed to have the form
     *
     * major.minor.patch.revision-suffix,
     *
     * with the individual components defined as follows.
     *
     * - major is a required non-negative integer, and is equal to `4` for ANTLR 4.
     * - minor is a required non-negative integer.
     * - patch is an optional non-negative integer. When patch is omitted, the `.` (dot) appearing before it is
     *   also omitted.
     * - revision is an optional non-negative integer, and may only be included when patch is also included.
     *   When revision is omitted, the `.` (dot) appearing before it is also omitted.
     * - suffix is an optional string. When suffix is omitted, the `-` (hyphen-minus) appearing before it is also
     *   omitted.
     */
    static VERSION = "4.13.1";
    /**
     * Gets the currently executing version of the ANTLR 4 runtime library.
     *
     * This method provides runtime access to the {@link VERSION} field, as
     * opposed to directly referencing the field as a compile-time constant.
     *
     * @returns The currently executing version of the ANTLR 4 library
     */
    static getRuntimeVersion() {
      return _RuntimeMetaData.VERSION;
    }
    /**
     * This method provides the ability to detect mismatches between the version
     * of ANTLR 4 used to generate a parser, the version of the ANTLR runtime a
     * parser was compiled against, and the version of the ANTLR runtime which
     * is currently executing.
     *
     * The version check is designed to detect the following two specific
     * scenarios.
     *
     * - The ANTLR Tool version used for code generation does not match the
     * currently executing runtime version.
     * - The ANTLR Runtime version referenced at the time a parser was
     * compiled does not match the currently executing runtime version.
     *
     *
     * Starting with ANTLR 4.3, the code generator emits a call to this method
     * using two constants in each generated lexer and parser: a hard-coded
     * constant indicating the version of the tool used to generate the parser
     * and a reference to the compile-time constant {@link VERSION}. At
     * runtime, this method is called during the initialization of the generated
     * parser to detect mismatched versions, and notify the registered listeners
     * prior to creating instances of the parser.
     *
     *
     * This method does not perform any detection or filtering of semantic
     * changes between tool and runtime versions. It simply checks for a
     * version match and emits an error to stderr if a difference
     * is detected.
     *
     *
     * Note that some breaking changes between releases could result in other
     * types of runtime exceptions, such as a {@link LinkageError}, prior to
     * calling this method. In these cases, the underlying version mismatch will
     * not be reported here. This method is primarily intended to
     * notify users of potential semantic changes between releases that do not
     * result in binary compatibility problems which would be detected by the
     * class loader. As with semantic changes, changes that break binary
     * compatibility between releases are mentioned in the release notes
     * accompanying the affected release.
     *
     *
     * **Additional note for target developers:** The version check
     * implemented by this class is designed to address specific compatibility
     * concerns that may arise during the execution of Java applications. Other
     * targets should consider the implementation of this method in the context
     * of that target's known execution environment, which may or may not
     * resemble the design provided for the Java target.
     *
     * @param generatingToolVersion The version of the tool used to generate a parser.
     * This value may be null when called from user code that was not generated
     * by, and does not reference, the ANTLR 4 Tool itself.
     * @param compileTimeVersion The version of the runtime the parser was
     * compiled against. This should always be passed using a direct reference
     * to {@link VERSION}.
     */
    static checkVersion(generatingToolVersion, compileTimeVersion) {
      const runtimeVersion = _RuntimeMetaData.VERSION;
      let runtimeConflictsWithGeneratingTool = false;
      let runtimeConflictsWithCompileTimeTool = false;
      runtimeConflictsWithGeneratingTool = runtimeVersion !== generatingToolVersion && _RuntimeMetaData.getMajorMinorVersion(runtimeVersion) !== _RuntimeMetaData.getMajorMinorVersion(generatingToolVersion);
      runtimeConflictsWithCompileTimeTool = runtimeVersion !== compileTimeVersion && _RuntimeMetaData.getMajorMinorVersion(runtimeVersion) !== _RuntimeMetaData.getMajorMinorVersion(compileTimeVersion);
      if (runtimeConflictsWithGeneratingTool) {
        console.error(`ANTLR Tool version ${generatingToolVersion} used for code generation does not match the current runtime version ${runtimeVersion}`);
      }
      if (runtimeConflictsWithCompileTimeTool) {
        console.error(`ANTLR Runtime version ${compileTimeVersion} used for parser compilation does not match the current runtime version ${runtimeVersion}`);
      }
    }
    /**
     * Gets the major and minor version numbers from a version string. For
     * details about the syntax of the input `version`.
     * E.g., from x.y.z return x.y.
     *
     * @param version The complete version string.
     * @returns A string of the form *major*.*minor* containing
     * only the major and minor components of the version string.
     */
    static getMajorMinorVersion(version) {
      const firstDot = version.indexOf(".");
      const secondDot = firstDot >= 0 ? version.indexOf(".", firstDot + 1) : -1;
      const firstDash = version.indexOf("-");
      let referenceLength = version.length;
      if (secondDot >= 0) {
        referenceLength = Math.min(referenceLength, secondDot);
      }
      if (firstDash >= 0) {
        referenceLength = Math.min(referenceLength, firstDash);
      }
      return version.substring(0, referenceLength);
    }
  };
  var TokenStreamRewriter = class _TokenStreamRewriter {
    static {
      __name(this, "TokenStreamRewriter");
    }
    static DEFAULT_PROGRAM_NAME = "default";
    static PROGRAM_INIT_SIZE = 100;
    static MIN_TOKEN_INDEX = 0;
    /** Our source stream */
    tokens;
    /**
     * You may have multiple, named streams of rewrite operations.
     *  I'm calling these things "programs."
     *  Maps String (name) -> rewrite (List)
     */
    programs = /* @__PURE__ */ new Map();
    /** Map String (program name) -> Integer index */
    lastRewriteTokenIndexes;
    /**
     * @param tokens The token stream to modify
     */
    constructor(tokens) {
      this.tokens = tokens;
    }
    getTokenStream() {
      return this.tokens;
    }
    /**
     * Insert the supplied text after the specified token (or token index)
     */
    insertAfter(tokenOrIndex, text, programName = _TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
      let index2;
      if (typeof tokenOrIndex === "number") {
        index2 = tokenOrIndex;
      } else {
        index2 = tokenOrIndex.tokenIndex;
      }
      const rewrites = this.getProgram(programName);
      const op = new InsertAfterOp(this.tokens, index2, rewrites.length, text);
      rewrites.push(op);
    }
    /**
     * Insert the supplied text before the specified token (or token index)
     */
    insertBefore(tokenOrIndex, text, programName = _TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
      let index2;
      if (typeof tokenOrIndex === "number") {
        index2 = tokenOrIndex;
      } else {
        index2 = tokenOrIndex.tokenIndex;
      }
      const rewrites = this.getProgram(programName);
      const op = new InsertBeforeOp(this.tokens, index2, rewrites.length, text);
      rewrites.push(op);
    }
    /**
     * Replace the specified token with the supplied text
     */
    replaceSingle(tokenOrIndex, text, programName = _TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
      this.replace(tokenOrIndex, tokenOrIndex, text, programName);
    }
    /**
     * Replace the specified range of tokens with the supplied text.
     */
    replace(from, to, text, programName = _TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
      if (typeof from !== "number") {
        from = from.tokenIndex;
      }
      if (typeof to !== "number") {
        to = to.tokenIndex;
      }
      if (from > to || from < 0 || to < 0 || to >= this.tokens.size) {
        throw new RangeError(`replace: range invalid: ${from}..${to}(size=${this.tokens.size})`);
      }
      const rewrites = this.getProgram(programName);
      const op = new ReplaceOp(this.tokens, from, to, rewrites.length, text);
      rewrites.push(op);
    }
    /**
     * Delete the specified range of tokens
     */
    delete(from, to, programName = _TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
      if (to == null) {
        to = from;
      }
      this.replace(from, to, null, programName);
    }
    getProgram(name) {
      let is = this.programs.get(name);
      if (is == null) {
        is = this.initializeProgram(name);
      }
      return is;
    }
    initializeProgram(name) {
      const is = [];
      this.programs.set(name, is);
      return is;
    }
    /**
     * @returns the text from the original tokens altered per the instructions given to this rewriter
     */
    getText(intervalOrProgram, programName = _TokenStreamRewriter.DEFAULT_PROGRAM_NAME) {
      let interval;
      if (intervalOrProgram instanceof Interval) {
        interval = intervalOrProgram;
      } else {
        interval = new Interval(0, this.tokens.size - 1);
      }
      if (typeof intervalOrProgram === "string") {
        programName = intervalOrProgram;
      }
      const rewrites = this.programs.get(programName);
      let start = interval.start;
      let stop = interval.stop;
      if (stop > this.tokens.size - 1) {
        stop = this.tokens.size - 1;
      }
      if (start < 0) {
        start = 0;
      }
      if (rewrites == null || rewrites.length === 0) {
        return this.tokens.getTextFromInterval(new Interval(start, stop));
      }
      const buf = [];
      const indexToOp = this.reduceToSingleOperationPerIndex(rewrites);
      let i = start;
      while (i <= stop && i < this.tokens.size) {
        const op = indexToOp.get(i);
        indexToOp.delete(i);
        const t = this.tokens.get(i);
        if (op == null) {
          if (t.type !== Token.EOF) {
            buf.push(String(t.text));
          }
          i++;
        } else {
          i = op.execute(buf);
        }
      }
      if (stop === this.tokens.size - 1) {
        for (const op of indexToOp.values()) {
          if (op && op.index >= this.tokens.size - 1) {
            buf.push(String(op.text));
          }
        }
      }
      return buf.join("");
    }
    /**
     * @returns a map from token index to operation
     */
    reduceToSingleOperationPerIndex(rewrites) {
      for (let i = 0; i < rewrites.length; i++) {
        const op = rewrites[i];
        if (op == null) {
          continue;
        }
        if (!(op instanceof ReplaceOp)) {
          continue;
        }
        const rop = op;
        const inserts = this.getKindOfOps(rewrites, InsertBeforeOp, i);
        for (const iop of inserts) {
          if (iop.index === rop.index) {
            rewrites[iop.instructionIndex] = null;
            rop.text = String(iop.text) + (rop.text != null ? rop.text.toString() : "");
          } else if (iop.index > rop.index && iop.index <= rop.lastIndex) {
            rewrites[iop.instructionIndex] = null;
          }
        }
        const prevReplaces = this.getKindOfOps(rewrites, ReplaceOp, i);
        for (const prevRop of prevReplaces) {
          if (prevRop.index >= rop.index && prevRop.lastIndex <= rop.lastIndex) {
            rewrites[prevRop.instructionIndex] = null;
            continue;
          }
          const disjoint = prevRop.lastIndex < rop.index || prevRop.index > rop.lastIndex;
          if (prevRop.text == null && rop.text == null && !disjoint) {
            rewrites[prevRop.instructionIndex] = null;
            rop.index = Math.min(prevRop.index, rop.index);
            rop.lastIndex = Math.max(prevRop.lastIndex, rop.lastIndex);
          } else if (!disjoint) {
            throw new Error(`replace op boundaries of ${rop} overlap with previous ${prevRop}`);
          }
        }
      }
      for (let i = 0; i < rewrites.length; i++) {
        const op = rewrites[i];
        if (op == null) {
          continue;
        }
        if (!(op instanceof InsertBeforeOp)) {
          continue;
        }
        const iop = op;
        const prevInserts = this.getKindOfOps(rewrites, InsertBeforeOp, i);
        for (const prevIop of prevInserts) {
          if (prevIop.index === iop.index) {
            if (prevIop instanceof InsertAfterOp) {
              iop.text = this.catOpText(prevIop.text, iop.text);
              rewrites[prevIop.instructionIndex] = null;
            } else if (prevIop instanceof InsertBeforeOp) {
              iop.text = this.catOpText(iop.text, prevIop.text);
              rewrites[prevIop.instructionIndex] = null;
            }
          }
        }
        const prevReplaces = this.getKindOfOps(rewrites, ReplaceOp, i);
        for (const rop of prevReplaces) {
          if (iop.index === rop.index) {
            rop.text = this.catOpText(iop.text, rop.text);
            rewrites[i] = null;
            continue;
          }
          if (iop.index >= rop.index && iop.index <= rop.lastIndex) {
            throw new Error(`insert op ${iop} within boundaries of previous ${rop}`);
          }
        }
      }
      const m2 = /* @__PURE__ */ new Map();
      for (const op of rewrites) {
        if (op == null) {
          continue;
        }
        if (m2.get(op.index) != null) {
          throw new Error("should only be one op per index");
        }
        m2.set(op.index, op);
      }
      return m2;
    }
    catOpText(a, b) {
      let x = "";
      let y = "";
      if (a != null) {
        x = a.toString();
      }
      if (b != null) {
        y = b.toString();
      }
      return x + y;
    }
    /**
     * Get all operations before an index of a particular kind
     */
    getKindOfOps(rewrites, kind, before) {
      return rewrites.slice(0, before).filter((op) => {
        return op && op instanceof kind;
      });
    }
  };
  var RewriteOperation = class {
    static {
      __name(this, "RewriteOperation");
    }
    /** What index into rewrites List are we? */
    instructionIndex;
    /** Token buffer index. */
    index;
    text;
    tokens;
    constructor(tokens, index2, instructionIndex, text) {
      this.tokens = tokens;
      this.instructionIndex = instructionIndex;
      this.index = index2;
      this.text = text === void 0 ? "" : text;
    }
    execute(_buf) {
      return this.index;
    }
    toString() {
      return "<RewriteOperation@" + this.tokens.get(this.index) + ':"' + this.text + '">';
    }
  };
  var InsertBeforeOp = class extends RewriteOperation {
    static {
      __name(this, "InsertBeforeOp");
    }
    constructor(tokens, index2, instructionIndex, text) {
      super(tokens, index2, instructionIndex, text);
    }
    /**
     * @returns the index of the next token to operate on
     */
    execute(buf) {
      if (this.text) {
        buf.push(this.text.toString());
      }
      if (this.tokens.get(this.index).type !== Token.EOF) {
        buf.push(String(this.tokens.get(this.index).text));
      }
      return this.index + 1;
    }
    toString() {
      return "<InsertBeforeOp@" + this.tokens.get(this.index) + ':"' + this.text + '">';
    }
  };
  var InsertAfterOp = class extends InsertBeforeOp {
    static {
      __name(this, "InsertAfterOp");
    }
    constructor(tokens, index2, instructionIndex, text) {
      super(tokens, index2 + 1, instructionIndex, text);
    }
    toString() {
      return "<InsertAfterOp@" + this.tokens.get(this.index) + ':"' + this.text + '">';
    }
  };
  var ReplaceOp = class extends RewriteOperation {
    static {
      __name(this, "ReplaceOp");
    }
    lastIndex;
    constructor(tokens, from, to, instructionIndex, text) {
      super(tokens, from, instructionIndex, text);
      this.lastIndex = to;
    }
    /**
     * @returns the index of the next token to operate on
     */
    execute(buf) {
      if (this.text) {
        buf.push(this.text.toString());
      }
      return this.lastIndex + 1;
    }
    toString() {
      if (this.text == null) {
        return "<DeleteOp@" + this.tokens.get(this.index) + ".." + this.tokens.get(this.lastIndex) + ">";
      }
      return "<ReplaceOp@" + this.tokens.get(this.index) + ".." + this.tokens.get(this.lastIndex) + ':"' + this.text + '">';
    }
  };
  var UnbufferedTokenStream = class {
    static {
      __name(this, "UnbufferedTokenStream");
    }
    tokenSource;
    /**
     * A moving window buffer of the data being scanned. While there's a marker,
     * we keep adding to buffer. Otherwise, {@link #consume consume()} resets so
     * we start filling at index 0 again.
     */
    tokens;
    /**
     * The number of tokens currently in {@link #tokens tokens}.
     *
     * This is not the buffer capacity, that's `tokens.length`.
     */
    n;
    /**
     * 0..n-1 index into {@link #tokens tokens} of next token.
     *
     * The `LT(1)` token is `tokens[p]`. If `p == n`, we are
     * out of buffered tokens.
     */
    p = 0;
    /**
     * Count up with {@link #mark mark()} and down with
     * {@link #release release()}. When we `release()` the last mark,
     * `numMarkers` reaches 0 and we reset the buffer. Copy
     * `tokens[p]..tokens[n-1]` to `tokens[0]..tokens[(n-1)-p]`.
     */
    numMarkers = 0;
    /**
     * This is the `LT(-1)` token for the current position.
     */
    lastToken;
    /**
     * When `numMarkers > 0`, this is the `LT(-1)` token for the
     * first token in {@link #tokens}. Otherwise, this is `null`.
     */
    lastTokenBufferStart;
    /**
     * Absolute token index. It's the index of the token about to be read via
     * `LT(1)`. Goes from 0 to the number of tokens in the entire stream,
     * although the stream size is unknown before the end is reached.
     *
     * This value is used to set the token indexes if the stream provides tokens
     * that implement {@link WritableToken}.
     */
    currentTokenIndex = 0;
    constructor(tokenSource, bufferSize) {
      this.tokenSource = tokenSource;
      bufferSize = bufferSize ?? 256;
      this.tokens = new Array(bufferSize);
      this.n = 0;
      this.fill(1);
    }
    get(i) {
      const bufferStartIndex = this.getBufferStartIndex();
      if (i < bufferStartIndex || i >= bufferStartIndex + this.n) {
        throw new Error("get(" + i + ") outside buffer: " + bufferStartIndex + ".." + (bufferStartIndex + this.n));
      }
      return this.tokens[i - bufferStartIndex];
    }
    // eslint-disable-next-line @typescript-eslint/naming-convention
    LT(i) {
      if (i === -1) {
        return this.lastToken;
      }
      this.sync(i);
      const index2 = this.p + i - 1;
      if (index2 < 0) {
        throw new Error("LT(" + i + ") gives negative index");
      }
      if (index2 >= this.n) {
        return this.tokens[this.n - 1];
      }
      return this.tokens[index2];
    }
    // eslint-disable-next-line @typescript-eslint/naming-convention
    LA(i) {
      return this.LT(i).type;
    }
    getText() {
      return "";
    }
    getTextFromContext(ctx) {
      return this.getTextFromInterval(ctx.getSourceInterval());
    }
    getTextFromInterval(interval) {
      const bufferStartIndex = this.getBufferStartIndex();
      const bufferStopIndex = bufferStartIndex + this.tokens.length - 1;
      const start = interval.start;
      const stop = interval.stop;
      if (start < bufferStartIndex || stop > bufferStopIndex) {
        throw new Error("interval " + interval + " not in token buffer window: " + bufferStartIndex + ".." + bufferStopIndex);
      }
      const a = start - bufferStartIndex;
      const b = stop - bufferStartIndex;
      let result = "";
      for (let i = a; i <= b; i++) {
        const t = this.tokens[i];
        result += t.text;
      }
      return result;
    }
    getTextFromRange(start, stop) {
      return this.getTextFromInterval(Interval.of(start.tokenIndex, stop.tokenIndex));
    }
    consume() {
      if (this.LA(1) === Token.EOF) {
        throw new Error("cannot consume EOF");
      }
      this.lastToken = this.tokens[this.p];
      if (this.p === this.n - 1 && this.numMarkers === 0) {
        this.n = 0;
        this.p = -1;
        this.lastTokenBufferStart = this.lastToken;
      }
      this.p++;
      this.currentTokenIndex++;
      this.sync(1);
    }
    /**
     * Return a marker that we can release later.
     *
     * The specific marker value used for this class allows for some level of
     * protection against misuse where `seek()` is called on a mark or
     * `release()` is called in the wrong order.
     */
    mark() {
      if (this.numMarkers === 0) {
        this.lastTokenBufferStart = this.lastToken;
      }
      const mark = -this.numMarkers - 1;
      this.numMarkers++;
      return mark;
    }
    release(marker) {
      const expectedMark = -this.numMarkers;
      if (marker !== expectedMark) {
        throw new Error("release() called with an invalid marker.");
      }
      this.numMarkers--;
      if (this.numMarkers === 0) {
        if (this.p > 0) {
          this.tokens.copyWithin(0, this.p, this.n);
          this.n = this.n - this.p;
          this.p = 0;
        }
        this.lastTokenBufferStart = this.lastToken;
      }
    }
    get index() {
      return this.currentTokenIndex;
    }
    seek(index2) {
      if (index2 === this.currentTokenIndex) {
        return;
      }
      if (index2 > this.currentTokenIndex) {
        this.sync(index2 - this.currentTokenIndex);
        index2 = Math.min(index2, this.getBufferStartIndex() + this.n - 1);
      }
      const bufferStartIndex = this.getBufferStartIndex();
      const i = index2 - bufferStartIndex;
      if (i < 0) {
        throw new Error("cannot seek to negative index " + index2);
      } else {
        if (i >= this.n) {
          throw new Error("seek to index outside buffer: " + index2 + " not in " + bufferStartIndex + ".." + (bufferStartIndex + this.n));
        }
      }
      this.p = i;
      this.currentTokenIndex = index2;
      if (this.p === 0) {
        this.lastToken = this.lastTokenBufferStart;
      } else {
        this.lastToken = this.tokens[this.p - 1];
      }
    }
    get size() {
      throw new Error("Unbuffered stream cannot know its size");
    }
    getSourceName() {
      return this.tokenSource.sourceName;
    }
    setLine(line) {
      this.tokenSource.line = line;
    }
    setColumn(column) {
      this.tokenSource.column = column;
    }
    /**
     * Make sure we have 'need' elements from current position {@link #p p}. Last valid
     * `p` index is `tokens.length-1`.  `p+need-1` is the tokens index 'need' elements
     * ahead.  If we need 1 element, `(p+1-1)==p` must be less than `tokens.length`.
     */
    sync(want) {
      const need = this.p + want - 1 - this.n + 1;
      if (need > 0) {
        this.fill(need);
      }
    }
    /**
     * Add `n` elements to the buffer. Returns the number of tokens
     * actually added to the buffer. If the return value is less than `n`,
     * then EOF was reached before `n` tokens could be added.
     */
    fill(n2) {
      for (let i = 0; i < n2; i++) {
        if (this.n > 0 && this.tokens[this.n - 1].type === Token.EOF) {
          return i;
        }
        const t = this.tokenSource.nextToken();
        this.add(t);
      }
      return n2;
    }
    add(t) {
      if (this.n >= this.tokens.length) {
        this.tokens.length = this.tokens.length * 2;
      }
      if (isWritableToken(t)) {
        t.setTokenIndex(this.getBufferStartIndex() + this.n);
      }
      this.tokens[this.n++] = t;
    }
    getBufferStartIndex() {
      return this.currentTokenIndex - this.p;
    }
  };

  // server/src/generated/SysMLv2Lexer.ts
  var SysMLv2Lexer = class _SysMLv2Lexer extends Lexer {
    static ABOUT = 1;
    static ABSTRACT = 2;
    static ACCEPT = 3;
    static ACTION = 4;
    static ACTOR = 5;
    static AFTER = 6;
    static ALIAS = 7;
    static ALL = 8;
    static ALLOCATE = 9;
    static ALLOCATION = 10;
    static ANALYSIS = 11;
    static AND = 12;
    static AS = 13;
    static ASSERT = 14;
    static ASSIGN = 15;
    static ASSOC = 16;
    static ASSUME = 17;
    static AT = 18;
    static ATTRIBUTE = 19;
    static BEHAVIOR = 20;
    static BIND = 21;
    static BINDING = 22;
    static BOOL = 23;
    static BY = 24;
    static CALC = 25;
    static CASE = 26;
    static CHAINS = 27;
    static CLASS = 28;
    static CLASSIFIER = 29;
    static COMMENT = 30;
    static COMPOSITE = 31;
    static CONCERN = 32;
    static CONJUGATE = 33;
    static CONJUGATES = 34;
    static CONJUGATION = 35;
    static CONNECT = 36;
    static CONNECTION = 37;
    static CONNECTOR = 38;
    static CONST = 39;
    static CONSTANT = 40;
    static CONSTRAINT = 41;
    static CROSSES = 42;
    static DATATYPE = 43;
    static DECIDE = 44;
    static DEF = 45;
    static DEFAULT = 46;
    static DEFINED = 47;
    static DEPENDENCY = 48;
    static DERIVED = 49;
    static DIFFERENCES = 50;
    static DISJOINING = 51;
    static DISJOINT = 52;
    static DO = 53;
    static DOC = 54;
    static ELSE = 55;
    static END = 56;
    static ENTRY = 57;
    static ENUM = 58;
    static EVENT = 59;
    static EXHIBIT = 60;
    static EXIT = 61;
    static EXPOSE = 62;
    static EXPR = 63;
    static FALSE = 64;
    static FEATURE = 65;
    static FEATURED = 66;
    static FEATURING = 67;
    static FILTER = 68;
    static FIRST = 69;
    static FLOW = 70;
    static FOR = 71;
    static FORK = 72;
    static FRAME = 73;
    static FROM = 74;
    static FUNCTION = 75;
    static HASTYPE = 76;
    static IF = 77;
    static IMPLIES = 78;
    static IMPORT = 79;
    static IN = 80;
    static INCLUDE = 81;
    static INDIVIDUAL = 82;
    static INOUT = 83;
    static INTERACTION = 84;
    static INTERFACE = 85;
    static INTERSECTS = 86;
    static INV = 87;
    static INVERSE = 88;
    static INVERTING = 89;
    static ISTYPE = 90;
    static ITEM = 91;
    static JOIN = 92;
    static LANGUAGE = 93;
    static LIBRARY = 94;
    static LOCALE = 95;
    static LOOP = 96;
    static MEMBER = 97;
    static MERGE = 98;
    static MESSAGE = 99;
    static META = 100;
    static METACLASS = 101;
    static METADATA = 102;
    static MULTIPLICITY = 103;
    static NAMESPACE = 104;
    static NEW = 105;
    static NONUNIQUE = 106;
    static NOT = 107;
    static NULL = 108;
    static OBJECTIVE = 109;
    static OCCURRENCE = 110;
    static OF = 111;
    static OR = 112;
    static ORDERED = 113;
    static OUT = 114;
    static PACKAGE = 115;
    static PARALLEL = 116;
    static PART = 117;
    static PERFORM = 118;
    static PORT = 119;
    static PORTION = 120;
    static PREDICATE = 121;
    static PRIVATE = 122;
    static PROTECTED = 123;
    static PUBLIC = 124;
    static REDEFINES = 125;
    static REDEFINITION = 126;
    static REF = 127;
    static REFERENCES = 128;
    static RENDER = 129;
    static RENDERING = 130;
    static REP = 131;
    static REQUIRE = 132;
    static REQUIREMENT = 133;
    static RETURN = 134;
    static SATISFY = 135;
    static SEND = 136;
    static SNAPSHOT = 137;
    static SPECIALIZATION = 138;
    static SPECIALIZES = 139;
    static STAKEHOLDER = 140;
    static STANDARD = 141;
    static STATE = 142;
    static STEP = 143;
    static STRUCT = 144;
    static SUBCLASSIFIER = 145;
    static SUBJECT = 146;
    static SUBSET = 147;
    static SUBSETS = 148;
    static SUBTYPE = 149;
    static SUCCESSION = 150;
    static TERMINATE = 151;
    static THEN = 152;
    static TIMESLICE = 153;
    static TO = 154;
    static TRANSITION = 155;
    static TRUE = 156;
    static TYPE = 157;
    static TYPED = 158;
    static TYPING = 159;
    static UNIONS = 160;
    static UNTIL = 161;
    static USE = 162;
    static VAR = 163;
    static VARIANT = 164;
    static VARIATION = 165;
    static VERIFICATION = 166;
    static VERIFY = 167;
    static VIA = 168;
    static VIEW = 169;
    static VIEWPOINT = 170;
    static WHEN = 171;
    static WHILE = 172;
    static XOR = 173;
    static BANG_EQ_EQ = 174;
    static COLON_COLON_GT = 175;
    static COLON_GT_GT = 176;
    static EQ_EQ_EQ = 177;
    static BANG_EQ = 178;
    static STAR_STAR = 179;
    static ARROW = 180;
    static DOT_DOT = 181;
    static DOT_QUESTION = 182;
    static COLON_COLON = 183;
    static COLON_EQ = 184;
    static COLON_GT = 185;
    static LE = 186;
    static EQ_EQ = 187;
    static FAT_ARROW = 188;
    static GE = 189;
    static QUESTION_QUESTION = 190;
    static AT_AT = 191;
    static HASH = 192;
    static DOLLAR = 193;
    static PERCENT = 194;
    static AMP = 195;
    static LPAREN = 196;
    static RPAREN = 197;
    static STAR = 198;
    static PLUS = 199;
    static COMMA = 200;
    static MINUS = 201;
    static DOT = 202;
    static SLASH = 203;
    static COLON = 204;
    static SEMI = 205;
    static LT = 206;
    static EQ = 207;
    static GT = 208;
    static QUESTION = 209;
    static AT_SIGN = 210;
    static LBRACK = 211;
    static RBRACK = 212;
    static CARET = 213;
    static LBRACE = 214;
    static PIPE = 215;
    static RBRACE = 216;
    static TILDE = 217;
    static IDENTIFIER = 218;
    static STRING = 219;
    static DOUBLE_STRING = 220;
    static INTEGER = 221;
    static REAL = 222;
    static REGULAR_COMMENT = 223;
    static SINGLE_LINE_NOTE = 224;
    static BARE_LINE_COMMENT = 225;
    static WS = 226;
    static channelNames = [
      "DEFAULT_TOKEN_CHANNEL",
      "HIDDEN"
    ];
    static literalNames = [
      null,
      "'about'",
      "'abstract'",
      "'accept'",
      "'action'",
      "'actor'",
      "'after'",
      "'alias'",
      "'all'",
      "'allocate'",
      "'allocation'",
      "'analysis'",
      "'and'",
      "'as'",
      "'assert'",
      "'assign'",
      "'assoc'",
      "'assume'",
      "'at'",
      "'attribute'",
      "'behavior'",
      "'bind'",
      "'binding'",
      "'bool'",
      "'by'",
      "'calc'",
      "'case'",
      "'chains'",
      "'class'",
      "'classifier'",
      "'comment'",
      "'composite'",
      "'concern'",
      "'conjugate'",
      "'conjugates'",
      "'conjugation'",
      "'connect'",
      "'connection'",
      "'connector'",
      "'const'",
      "'constant'",
      "'constraint'",
      "'crosses'",
      "'datatype'",
      "'decide'",
      "'def'",
      "'default'",
      "'defined'",
      "'dependency'",
      "'derived'",
      "'differences'",
      "'disjoining'",
      "'disjoint'",
      "'do'",
      "'doc'",
      "'else'",
      "'end'",
      "'entry'",
      "'enum'",
      "'event'",
      "'exhibit'",
      "'exit'",
      "'expose'",
      "'expr'",
      "'false'",
      "'feature'",
      "'featured'",
      "'featuring'",
      "'filter'",
      "'first'",
      "'flow'",
      "'for'",
      "'fork'",
      "'frame'",
      "'from'",
      "'function'",
      "'hastype'",
      "'if'",
      "'implies'",
      "'import'",
      "'in'",
      "'include'",
      "'individual'",
      "'inout'",
      "'interaction'",
      "'interface'",
      "'intersects'",
      "'inv'",
      "'inverse'",
      "'inverting'",
      "'istype'",
      "'item'",
      "'join'",
      "'language'",
      "'library'",
      "'locale'",
      "'loop'",
      "'member'",
      "'merge'",
      "'message'",
      "'meta'",
      "'metaclass'",
      "'metadata'",
      "'multiplicity'",
      "'namespace'",
      "'new'",
      "'nonunique'",
      "'not'",
      "'null'",
      "'objective'",
      "'occurrence'",
      "'of'",
      "'or'",
      "'ordered'",
      "'out'",
      "'package'",
      "'parallel'",
      "'part'",
      "'perform'",
      "'port'",
      "'portion'",
      "'predicate'",
      "'private'",
      "'protected'",
      "'public'",
      "'redefines'",
      "'redefinition'",
      "'ref'",
      "'references'",
      "'render'",
      "'rendering'",
      "'rep'",
      "'require'",
      "'requirement'",
      "'return'",
      "'satisfy'",
      "'send'",
      "'snapshot'",
      "'specialization'",
      "'specializes'",
      "'stakeholder'",
      "'standard'",
      "'state'",
      "'step'",
      "'struct'",
      "'subclassifier'",
      "'subject'",
      "'subset'",
      "'subsets'",
      "'subtype'",
      "'succession'",
      "'terminate'",
      "'then'",
      "'timeslice'",
      "'to'",
      "'transition'",
      "'true'",
      "'type'",
      "'typed'",
      "'typing'",
      "'unions'",
      "'until'",
      "'use'",
      "'var'",
      "'variant'",
      "'variation'",
      "'verification'",
      "'verify'",
      "'via'",
      "'view'",
      "'viewpoint'",
      "'when'",
      "'while'",
      "'xor'",
      "'!=='",
      "'::>'",
      "':>>'",
      "'==='",
      "'!='",
      "'**'",
      "'->'",
      "'..'",
      "'.?'",
      "'::'",
      "':='",
      "':>'",
      "'<='",
      "'=='",
      "'=>'",
      "'>='",
      "'??'",
      "'@@'",
      "'#'",
      "'$'",
      "'%'",
      "'&'",
      "'('",
      "')'",
      "'*'",
      "'+'",
      "','",
      "'-'",
      "'.'",
      "'/'",
      "':'",
      "';'",
      "'<'",
      "'='",
      "'>'",
      "'?'",
      "'@'",
      "'['",
      "']'",
      "'^'",
      "'{'",
      "'|'",
      "'}'",
      "'~'",
      null,
      null,
      null,
      null,
      null,
      null,
      null,
      "'//'"
    ];
    static symbolicNames = [
      null,
      "ABOUT",
      "ABSTRACT",
      "ACCEPT",
      "ACTION",
      "ACTOR",
      "AFTER",
      "ALIAS",
      "ALL",
      "ALLOCATE",
      "ALLOCATION",
      "ANALYSIS",
      "AND",
      "AS",
      "ASSERT",
      "ASSIGN",
      "ASSOC",
      "ASSUME",
      "AT",
      "ATTRIBUTE",
      "BEHAVIOR",
      "BIND",
      "BINDING",
      "BOOL",
      "BY",
      "CALC",
      "CASE",
      "CHAINS",
      "CLASS",
      "CLASSIFIER",
      "COMMENT",
      "COMPOSITE",
      "CONCERN",
      "CONJUGATE",
      "CONJUGATES",
      "CONJUGATION",
      "CONNECT",
      "CONNECTION",
      "CONNECTOR",
      "CONST",
      "CONSTANT",
      "CONSTRAINT",
      "CROSSES",
      "DATATYPE",
      "DECIDE",
      "DEF",
      "DEFAULT",
      "DEFINED",
      "DEPENDENCY",
      "DERIVED",
      "DIFFERENCES",
      "DISJOINING",
      "DISJOINT",
      "DO",
      "DOC",
      "ELSE",
      "END",
      "ENTRY",
      "ENUM",
      "EVENT",
      "EXHIBIT",
      "EXIT",
      "EXPOSE",
      "EXPR",
      "FALSE",
      "FEATURE",
      "FEATURED",
      "FEATURING",
      "FILTER",
      "FIRST",
      "FLOW",
      "FOR",
      "FORK",
      "FRAME",
      "FROM",
      "FUNCTION",
      "HASTYPE",
      "IF",
      "IMPLIES",
      "IMPORT",
      "IN",
      "INCLUDE",
      "INDIVIDUAL",
      "INOUT",
      "INTERACTION",
      "INTERFACE",
      "INTERSECTS",
      "INV",
      "INVERSE",
      "INVERTING",
      "ISTYPE",
      "ITEM",
      "JOIN",
      "LANGUAGE",
      "LIBRARY",
      "LOCALE",
      "LOOP",
      "MEMBER",
      "MERGE",
      "MESSAGE",
      "META",
      "METACLASS",
      "METADATA",
      "MULTIPLICITY",
      "NAMESPACE",
      "NEW",
      "NONUNIQUE",
      "NOT",
      "NULL",
      "OBJECTIVE",
      "OCCURRENCE",
      "OF",
      "OR",
      "ORDERED",
      "OUT",
      "PACKAGE",
      "PARALLEL",
      "PART",
      "PERFORM",
      "PORT",
      "PORTION",
      "PREDICATE",
      "PRIVATE",
      "PROTECTED",
      "PUBLIC",
      "REDEFINES",
      "REDEFINITION",
      "REF",
      "REFERENCES",
      "RENDER",
      "RENDERING",
      "REP",
      "REQUIRE",
      "REQUIREMENT",
      "RETURN",
      "SATISFY",
      "SEND",
      "SNAPSHOT",
      "SPECIALIZATION",
      "SPECIALIZES",
      "STAKEHOLDER",
      "STANDARD",
      "STATE",
      "STEP",
      "STRUCT",
      "SUBCLASSIFIER",
      "SUBJECT",
      "SUBSET",
      "SUBSETS",
      "SUBTYPE",
      "SUCCESSION",
      "TERMINATE",
      "THEN",
      "TIMESLICE",
      "TO",
      "TRANSITION",
      "TRUE",
      "TYPE",
      "TYPED",
      "TYPING",
      "UNIONS",
      "UNTIL",
      "USE",
      "VAR",
      "VARIANT",
      "VARIATION",
      "VERIFICATION",
      "VERIFY",
      "VIA",
      "VIEW",
      "VIEWPOINT",
      "WHEN",
      "WHILE",
      "XOR",
      "BANG_EQ_EQ",
      "COLON_COLON_GT",
      "COLON_GT_GT",
      "EQ_EQ_EQ",
      "BANG_EQ",
      "STAR_STAR",
      "ARROW",
      "DOT_DOT",
      "DOT_QUESTION",
      "COLON_COLON",
      "COLON_EQ",
      "COLON_GT",
      "LE",
      "EQ_EQ",
      "FAT_ARROW",
      "GE",
      "QUESTION_QUESTION",
      "AT_AT",
      "HASH",
      "DOLLAR",
      "PERCENT",
      "AMP",
      "LPAREN",
      "RPAREN",
      "STAR",
      "PLUS",
      "COMMA",
      "MINUS",
      "DOT",
      "SLASH",
      "COLON",
      "SEMI",
      "LT",
      "EQ",
      "GT",
      "QUESTION",
      "AT_SIGN",
      "LBRACK",
      "RBRACK",
      "CARET",
      "LBRACE",
      "PIPE",
      "RBRACE",
      "TILDE",
      "IDENTIFIER",
      "STRING",
      "DOUBLE_STRING",
      "INTEGER",
      "REAL",
      "REGULAR_COMMENT",
      "SINGLE_LINE_NOTE",
      "BARE_LINE_COMMENT",
      "WS"
    ];
    static modeNames = [
      "DEFAULT_MODE"
    ];
    static ruleNames = [
      "ABOUT",
      "ABSTRACT",
      "ACCEPT",
      "ACTION",
      "ACTOR",
      "AFTER",
      "ALIAS",
      "ALL",
      "ALLOCATE",
      "ALLOCATION",
      "ANALYSIS",
      "AND",
      "AS",
      "ASSERT",
      "ASSIGN",
      "ASSOC",
      "ASSUME",
      "AT",
      "ATTRIBUTE",
      "BEHAVIOR",
      "BIND",
      "BINDING",
      "BOOL",
      "BY",
      "CALC",
      "CASE",
      "CHAINS",
      "CLASS",
      "CLASSIFIER",
      "COMMENT",
      "COMPOSITE",
      "CONCERN",
      "CONJUGATE",
      "CONJUGATES",
      "CONJUGATION",
      "CONNECT",
      "CONNECTION",
      "CONNECTOR",
      "CONST",
      "CONSTANT",
      "CONSTRAINT",
      "CROSSES",
      "DATATYPE",
      "DECIDE",
      "DEF",
      "DEFAULT",
      "DEFINED",
      "DEPENDENCY",
      "DERIVED",
      "DIFFERENCES",
      "DISJOINING",
      "DISJOINT",
      "DO",
      "DOC",
      "ELSE",
      "END",
      "ENTRY",
      "ENUM",
      "EVENT",
      "EXHIBIT",
      "EXIT",
      "EXPOSE",
      "EXPR",
      "FALSE",
      "FEATURE",
      "FEATURED",
      "FEATURING",
      "FILTER",
      "FIRST",
      "FLOW",
      "FOR",
      "FORK",
      "FRAME",
      "FROM",
      "FUNCTION",
      "HASTYPE",
      "IF",
      "IMPLIES",
      "IMPORT",
      "IN",
      "INCLUDE",
      "INDIVIDUAL",
      "INOUT",
      "INTERACTION",
      "INTERFACE",
      "INTERSECTS",
      "INV",
      "INVERSE",
      "INVERTING",
      "ISTYPE",
      "ITEM",
      "JOIN",
      "LANGUAGE",
      "LIBRARY",
      "LOCALE",
      "LOOP",
      "MEMBER",
      "MERGE",
      "MESSAGE",
      "META",
      "METACLASS",
      "METADATA",
      "MULTIPLICITY",
      "NAMESPACE",
      "NEW",
      "NONUNIQUE",
      "NOT",
      "NULL",
      "OBJECTIVE",
      "OCCURRENCE",
      "OF",
      "OR",
      "ORDERED",
      "OUT",
      "PACKAGE",
      "PARALLEL",
      "PART",
      "PERFORM",
      "PORT",
      "PORTION",
      "PREDICATE",
      "PRIVATE",
      "PROTECTED",
      "PUBLIC",
      "REDEFINES",
      "REDEFINITION",
      "REF",
      "REFERENCES",
      "RENDER",
      "RENDERING",
      "REP",
      "REQUIRE",
      "REQUIREMENT",
      "RETURN",
      "SATISFY",
      "SEND",
      "SNAPSHOT",
      "SPECIALIZATION",
      "SPECIALIZES",
      "STAKEHOLDER",
      "STANDARD",
      "STATE",
      "STEP",
      "STRUCT",
      "SUBCLASSIFIER",
      "SUBJECT",
      "SUBSET",
      "SUBSETS",
      "SUBTYPE",
      "SUCCESSION",
      "TERMINATE",
      "THEN",
      "TIMESLICE",
      "TO",
      "TRANSITION",
      "TRUE",
      "TYPE",
      "TYPED",
      "TYPING",
      "UNIONS",
      "UNTIL",
      "USE",
      "VAR",
      "VARIANT",
      "VARIATION",
      "VERIFICATION",
      "VERIFY",
      "VIA",
      "VIEW",
      "VIEWPOINT",
      "WHEN",
      "WHILE",
      "XOR",
      "BANG_EQ_EQ",
      "COLON_COLON_GT",
      "COLON_GT_GT",
      "EQ_EQ_EQ",
      "BANG_EQ",
      "STAR_STAR",
      "ARROW",
      "DOT_DOT",
      "DOT_QUESTION",
      "COLON_COLON",
      "COLON_EQ",
      "COLON_GT",
      "LE",
      "EQ_EQ",
      "FAT_ARROW",
      "GE",
      "QUESTION_QUESTION",
      "AT_AT",
      "HASH",
      "DOLLAR",
      "PERCENT",
      "AMP",
      "LPAREN",
      "RPAREN",
      "STAR",
      "PLUS",
      "COMMA",
      "MINUS",
      "DOT",
      "SLASH",
      "COLON",
      "SEMI",
      "LT",
      "EQ",
      "GT",
      "QUESTION",
      "AT_SIGN",
      "LBRACK",
      "RBRACK",
      "CARET",
      "LBRACE",
      "PIPE",
      "RBRACE",
      "TILDE",
      "IDENTIFIER",
      "STRING",
      "DOUBLE_STRING",
      "INTEGER",
      "REAL",
      "REGULAR_COMMENT",
      "SINGLE_LINE_NOTE",
      "BARE_LINE_COMMENT",
      "WS"
    ];
    constructor(input) {
      super(input);
      this.interpreter = new LexerATNSimulator(this, _SysMLv2Lexer._ATN, _SysMLv2Lexer.decisionsToDFA, new PredictionContextCache());
    }
    get grammarFileName() {
      return "SysMLv2Lexer.g4";
    }
    get literalNames() {
      return _SysMLv2Lexer.literalNames;
    }
    get symbolicNames() {
      return _SysMLv2Lexer.symbolicNames;
    }
    get ruleNames() {
      return _SysMLv2Lexer.ruleNames;
    }
    get serializedATN() {
      return _SysMLv2Lexer._serializedATN;
    }
    get channelNames() {
      return _SysMLv2Lexer.channelNames;
    }
    get modeNames() {
      return _SysMLv2Lexer.modeNames;
    }
    static _serializedATN = [
      4,
      0,
      226,
      1971,
      6,
      -1,
      2,
      0,
      7,
      0,
      2,
      1,
      7,
      1,
      2,
      2,
      7,
      2,
      2,
      3,
      7,
      3,
      2,
      4,
      7,
      4,
      2,
      5,
      7,
      5,
      2,
      6,
      7,
      6,
      2,
      7,
      7,
      7,
      2,
      8,
      7,
      8,
      2,
      9,
      7,
      9,
      2,
      10,
      7,
      10,
      2,
      11,
      7,
      11,
      2,
      12,
      7,
      12,
      2,
      13,
      7,
      13,
      2,
      14,
      7,
      14,
      2,
      15,
      7,
      15,
      2,
      16,
      7,
      16,
      2,
      17,
      7,
      17,
      2,
      18,
      7,
      18,
      2,
      19,
      7,
      19,
      2,
      20,
      7,
      20,
      2,
      21,
      7,
      21,
      2,
      22,
      7,
      22,
      2,
      23,
      7,
      23,
      2,
      24,
      7,
      24,
      2,
      25,
      7,
      25,
      2,
      26,
      7,
      26,
      2,
      27,
      7,
      27,
      2,
      28,
      7,
      28,
      2,
      29,
      7,
      29,
      2,
      30,
      7,
      30,
      2,
      31,
      7,
      31,
      2,
      32,
      7,
      32,
      2,
      33,
      7,
      33,
      2,
      34,
      7,
      34,
      2,
      35,
      7,
      35,
      2,
      36,
      7,
      36,
      2,
      37,
      7,
      37,
      2,
      38,
      7,
      38,
      2,
      39,
      7,
      39,
      2,
      40,
      7,
      40,
      2,
      41,
      7,
      41,
      2,
      42,
      7,
      42,
      2,
      43,
      7,
      43,
      2,
      44,
      7,
      44,
      2,
      45,
      7,
      45,
      2,
      46,
      7,
      46,
      2,
      47,
      7,
      47,
      2,
      48,
      7,
      48,
      2,
      49,
      7,
      49,
      2,
      50,
      7,
      50,
      2,
      51,
      7,
      51,
      2,
      52,
      7,
      52,
      2,
      53,
      7,
      53,
      2,
      54,
      7,
      54,
      2,
      55,
      7,
      55,
      2,
      56,
      7,
      56,
      2,
      57,
      7,
      57,
      2,
      58,
      7,
      58,
      2,
      59,
      7,
      59,
      2,
      60,
      7,
      60,
      2,
      61,
      7,
      61,
      2,
      62,
      7,
      62,
      2,
      63,
      7,
      63,
      2,
      64,
      7,
      64,
      2,
      65,
      7,
      65,
      2,
      66,
      7,
      66,
      2,
      67,
      7,
      67,
      2,
      68,
      7,
      68,
      2,
      69,
      7,
      69,
      2,
      70,
      7,
      70,
      2,
      71,
      7,
      71,
      2,
      72,
      7,
      72,
      2,
      73,
      7,
      73,
      2,
      74,
      7,
      74,
      2,
      75,
      7,
      75,
      2,
      76,
      7,
      76,
      2,
      77,
      7,
      77,
      2,
      78,
      7,
      78,
      2,
      79,
      7,
      79,
      2,
      80,
      7,
      80,
      2,
      81,
      7,
      81,
      2,
      82,
      7,
      82,
      2,
      83,
      7,
      83,
      2,
      84,
      7,
      84,
      2,
      85,
      7,
      85,
      2,
      86,
      7,
      86,
      2,
      87,
      7,
      87,
      2,
      88,
      7,
      88,
      2,
      89,
      7,
      89,
      2,
      90,
      7,
      90,
      2,
      91,
      7,
      91,
      2,
      92,
      7,
      92,
      2,
      93,
      7,
      93,
      2,
      94,
      7,
      94,
      2,
      95,
      7,
      95,
      2,
      96,
      7,
      96,
      2,
      97,
      7,
      97,
      2,
      98,
      7,
      98,
      2,
      99,
      7,
      99,
      2,
      100,
      7,
      100,
      2,
      101,
      7,
      101,
      2,
      102,
      7,
      102,
      2,
      103,
      7,
      103,
      2,
      104,
      7,
      104,
      2,
      105,
      7,
      105,
      2,
      106,
      7,
      106,
      2,
      107,
      7,
      107,
      2,
      108,
      7,
      108,
      2,
      109,
      7,
      109,
      2,
      110,
      7,
      110,
      2,
      111,
      7,
      111,
      2,
      112,
      7,
      112,
      2,
      113,
      7,
      113,
      2,
      114,
      7,
      114,
      2,
      115,
      7,
      115,
      2,
      116,
      7,
      116,
      2,
      117,
      7,
      117,
      2,
      118,
      7,
      118,
      2,
      119,
      7,
      119,
      2,
      120,
      7,
      120,
      2,
      121,
      7,
      121,
      2,
      122,
      7,
      122,
      2,
      123,
      7,
      123,
      2,
      124,
      7,
      124,
      2,
      125,
      7,
      125,
      2,
      126,
      7,
      126,
      2,
      127,
      7,
      127,
      2,
      128,
      7,
      128,
      2,
      129,
      7,
      129,
      2,
      130,
      7,
      130,
      2,
      131,
      7,
      131,
      2,
      132,
      7,
      132,
      2,
      133,
      7,
      133,
      2,
      134,
      7,
      134,
      2,
      135,
      7,
      135,
      2,
      136,
      7,
      136,
      2,
      137,
      7,
      137,
      2,
      138,
      7,
      138,
      2,
      139,
      7,
      139,
      2,
      140,
      7,
      140,
      2,
      141,
      7,
      141,
      2,
      142,
      7,
      142,
      2,
      143,
      7,
      143,
      2,
      144,
      7,
      144,
      2,
      145,
      7,
      145,
      2,
      146,
      7,
      146,
      2,
      147,
      7,
      147,
      2,
      148,
      7,
      148,
      2,
      149,
      7,
      149,
      2,
      150,
      7,
      150,
      2,
      151,
      7,
      151,
      2,
      152,
      7,
      152,
      2,
      153,
      7,
      153,
      2,
      154,
      7,
      154,
      2,
      155,
      7,
      155,
      2,
      156,
      7,
      156,
      2,
      157,
      7,
      157,
      2,
      158,
      7,
      158,
      2,
      159,
      7,
      159,
      2,
      160,
      7,
      160,
      2,
      161,
      7,
      161,
      2,
      162,
      7,
      162,
      2,
      163,
      7,
      163,
      2,
      164,
      7,
      164,
      2,
      165,
      7,
      165,
      2,
      166,
      7,
      166,
      2,
      167,
      7,
      167,
      2,
      168,
      7,
      168,
      2,
      169,
      7,
      169,
      2,
      170,
      7,
      170,
      2,
      171,
      7,
      171,
      2,
      172,
      7,
      172,
      2,
      173,
      7,
      173,
      2,
      174,
      7,
      174,
      2,
      175,
      7,
      175,
      2,
      176,
      7,
      176,
      2,
      177,
      7,
      177,
      2,
      178,
      7,
      178,
      2,
      179,
      7,
      179,
      2,
      180,
      7,
      180,
      2,
      181,
      7,
      181,
      2,
      182,
      7,
      182,
      2,
      183,
      7,
      183,
      2,
      184,
      7,
      184,
      2,
      185,
      7,
      185,
      2,
      186,
      7,
      186,
      2,
      187,
      7,
      187,
      2,
      188,
      7,
      188,
      2,
      189,
      7,
      189,
      2,
      190,
      7,
      190,
      2,
      191,
      7,
      191,
      2,
      192,
      7,
      192,
      2,
      193,
      7,
      193,
      2,
      194,
      7,
      194,
      2,
      195,
      7,
      195,
      2,
      196,
      7,
      196,
      2,
      197,
      7,
      197,
      2,
      198,
      7,
      198,
      2,
      199,
      7,
      199,
      2,
      200,
      7,
      200,
      2,
      201,
      7,
      201,
      2,
      202,
      7,
      202,
      2,
      203,
      7,
      203,
      2,
      204,
      7,
      204,
      2,
      205,
      7,
      205,
      2,
      206,
      7,
      206,
      2,
      207,
      7,
      207,
      2,
      208,
      7,
      208,
      2,
      209,
      7,
      209,
      2,
      210,
      7,
      210,
      2,
      211,
      7,
      211,
      2,
      212,
      7,
      212,
      2,
      213,
      7,
      213,
      2,
      214,
      7,
      214,
      2,
      215,
      7,
      215,
      2,
      216,
      7,
      216,
      2,
      217,
      7,
      217,
      2,
      218,
      7,
      218,
      2,
      219,
      7,
      219,
      2,
      220,
      7,
      220,
      2,
      221,
      7,
      221,
      2,
      222,
      7,
      222,
      2,
      223,
      7,
      223,
      2,
      224,
      7,
      224,
      2,
      225,
      7,
      225,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      2,
      1,
      2,
      1,
      2,
      1,
      2,
      1,
      2,
      1,
      2,
      1,
      2,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      4,
      1,
      4,
      1,
      4,
      1,
      4,
      1,
      4,
      1,
      4,
      1,
      5,
      1,
      5,
      1,
      5,
      1,
      5,
      1,
      5,
      1,
      5,
      1,
      6,
      1,
      6,
      1,
      6,
      1,
      6,
      1,
      6,
      1,
      6,
      1,
      7,
      1,
      7,
      1,
      7,
      1,
      7,
      1,
      8,
      1,
      8,
      1,
      8,
      1,
      8,
      1,
      8,
      1,
      8,
      1,
      8,
      1,
      8,
      1,
      8,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      9,
      1,
      10,
      1,
      10,
      1,
      10,
      1,
      10,
      1,
      10,
      1,
      10,
      1,
      10,
      1,
      10,
      1,
      10,
      1,
      11,
      1,
      11,
      1,
      11,
      1,
      11,
      1,
      12,
      1,
      12,
      1,
      12,
      1,
      13,
      1,
      13,
      1,
      13,
      1,
      13,
      1,
      13,
      1,
      13,
      1,
      13,
      1,
      14,
      1,
      14,
      1,
      14,
      1,
      14,
      1,
      14,
      1,
      14,
      1,
      14,
      1,
      15,
      1,
      15,
      1,
      15,
      1,
      15,
      1,
      15,
      1,
      15,
      1,
      16,
      1,
      16,
      1,
      16,
      1,
      16,
      1,
      16,
      1,
      16,
      1,
      16,
      1,
      17,
      1,
      17,
      1,
      17,
      1,
      18,
      1,
      18,
      1,
      18,
      1,
      18,
      1,
      18,
      1,
      18,
      1,
      18,
      1,
      18,
      1,
      18,
      1,
      18,
      1,
      19,
      1,
      19,
      1,
      19,
      1,
      19,
      1,
      19,
      1,
      19,
      1,
      19,
      1,
      19,
      1,
      19,
      1,
      20,
      1,
      20,
      1,
      20,
      1,
      20,
      1,
      20,
      1,
      21,
      1,
      21,
      1,
      21,
      1,
      21,
      1,
      21,
      1,
      21,
      1,
      21,
      1,
      21,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      23,
      1,
      23,
      1,
      23,
      1,
      24,
      1,
      24,
      1,
      24,
      1,
      24,
      1,
      24,
      1,
      25,
      1,
      25,
      1,
      25,
      1,
      25,
      1,
      25,
      1,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      1,
      27,
      1,
      27,
      1,
      27,
      1,
      27,
      1,
      27,
      1,
      27,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      28,
      1,
      29,
      1,
      29,
      1,
      29,
      1,
      29,
      1,
      29,
      1,
      29,
      1,
      29,
      1,
      29,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      31,
      1,
      31,
      1,
      31,
      1,
      31,
      1,
      31,
      1,
      31,
      1,
      31,
      1,
      31,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      33,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      35,
      1,
      35,
      1,
      35,
      1,
      35,
      1,
      35,
      1,
      35,
      1,
      35,
      1,
      35,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      36,
      1,
      37,
      1,
      37,
      1,
      37,
      1,
      37,
      1,
      37,
      1,
      37,
      1,
      37,
      1,
      37,
      1,
      37,
      1,
      37,
      1,
      38,
      1,
      38,
      1,
      38,
      1,
      38,
      1,
      38,
      1,
      38,
      1,
      39,
      1,
      39,
      1,
      39,
      1,
      39,
      1,
      39,
      1,
      39,
      1,
      39,
      1,
      39,
      1,
      39,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      40,
      1,
      41,
      1,
      41,
      1,
      41,
      1,
      41,
      1,
      41,
      1,
      41,
      1,
      41,
      1,
      41,
      1,
      42,
      1,
      42,
      1,
      42,
      1,
      42,
      1,
      42,
      1,
      42,
      1,
      42,
      1,
      42,
      1,
      42,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      44,
      1,
      44,
      1,
      44,
      1,
      44,
      1,
      45,
      1,
      45,
      1,
      45,
      1,
      45,
      1,
      45,
      1,
      45,
      1,
      45,
      1,
      45,
      1,
      46,
      1,
      46,
      1,
      46,
      1,
      46,
      1,
      46,
      1,
      46,
      1,
      46,
      1,
      46,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      47,
      1,
      48,
      1,
      48,
      1,
      48,
      1,
      48,
      1,
      48,
      1,
      48,
      1,
      48,
      1,
      48,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      49,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      51,
      1,
      51,
      1,
      51,
      1,
      51,
      1,
      51,
      1,
      51,
      1,
      51,
      1,
      51,
      1,
      51,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      54,
      1,
      54,
      1,
      54,
      1,
      54,
      1,
      54,
      1,
      55,
      1,
      55,
      1,
      55,
      1,
      55,
      1,
      56,
      1,
      56,
      1,
      56,
      1,
      56,
      1,
      56,
      1,
      56,
      1,
      57,
      1,
      57,
      1,
      57,
      1,
      57,
      1,
      57,
      1,
      58,
      1,
      58,
      1,
      58,
      1,
      58,
      1,
      58,
      1,
      58,
      1,
      59,
      1,
      59,
      1,
      59,
      1,
      59,
      1,
      59,
      1,
      59,
      1,
      59,
      1,
      59,
      1,
      60,
      1,
      60,
      1,
      60,
      1,
      60,
      1,
      60,
      1,
      61,
      1,
      61,
      1,
      61,
      1,
      61,
      1,
      61,
      1,
      61,
      1,
      61,
      1,
      62,
      1,
      62,
      1,
      62,
      1,
      62,
      1,
      62,
      1,
      63,
      1,
      63,
      1,
      63,
      1,
      63,
      1,
      63,
      1,
      63,
      1,
      64,
      1,
      64,
      1,
      64,
      1,
      64,
      1,
      64,
      1,
      64,
      1,
      64,
      1,
      64,
      1,
      65,
      1,
      65,
      1,
      65,
      1,
      65,
      1,
      65,
      1,
      65,
      1,
      65,
      1,
      65,
      1,
      65,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      67,
      1,
      67,
      1,
      67,
      1,
      67,
      1,
      67,
      1,
      67,
      1,
      67,
      1,
      68,
      1,
      68,
      1,
      68,
      1,
      68,
      1,
      68,
      1,
      68,
      1,
      69,
      1,
      69,
      1,
      69,
      1,
      69,
      1,
      69,
      1,
      70,
      1,
      70,
      1,
      70,
      1,
      70,
      1,
      71,
      1,
      71,
      1,
      71,
      1,
      71,
      1,
      71,
      1,
      72,
      1,
      72,
      1,
      72,
      1,
      72,
      1,
      72,
      1,
      72,
      1,
      73,
      1,
      73,
      1,
      73,
      1,
      73,
      1,
      73,
      1,
      74,
      1,
      74,
      1,
      74,
      1,
      74,
      1,
      74,
      1,
      74,
      1,
      74,
      1,
      74,
      1,
      74,
      1,
      75,
      1,
      75,
      1,
      75,
      1,
      75,
      1,
      75,
      1,
      75,
      1,
      75,
      1,
      75,
      1,
      76,
      1,
      76,
      1,
      76,
      1,
      77,
      1,
      77,
      1,
      77,
      1,
      77,
      1,
      77,
      1,
      77,
      1,
      77,
      1,
      77,
      1,
      78,
      1,
      78,
      1,
      78,
      1,
      78,
      1,
      78,
      1,
      78,
      1,
      78,
      1,
      79,
      1,
      79,
      1,
      79,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      81,
      1,
      82,
      1,
      82,
      1,
      82,
      1,
      82,
      1,
      82,
      1,
      82,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      84,
      1,
      84,
      1,
      84,
      1,
      84,
      1,
      84,
      1,
      84,
      1,
      84,
      1,
      84,
      1,
      84,
      1,
      84,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      85,
      1,
      86,
      1,
      86,
      1,
      86,
      1,
      86,
      1,
      87,
      1,
      87,
      1,
      87,
      1,
      87,
      1,
      87,
      1,
      87,
      1,
      87,
      1,
      87,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      89,
      1,
      89,
      1,
      89,
      1,
      89,
      1,
      89,
      1,
      89,
      1,
      89,
      1,
      90,
      1,
      90,
      1,
      90,
      1,
      90,
      1,
      90,
      1,
      91,
      1,
      91,
      1,
      91,
      1,
      91,
      1,
      91,
      1,
      92,
      1,
      92,
      1,
      92,
      1,
      92,
      1,
      92,
      1,
      92,
      1,
      92,
      1,
      92,
      1,
      92,
      1,
      93,
      1,
      93,
      1,
      93,
      1,
      93,
      1,
      93,
      1,
      93,
      1,
      93,
      1,
      93,
      1,
      94,
      1,
      94,
      1,
      94,
      1,
      94,
      1,
      94,
      1,
      94,
      1,
      94,
      1,
      95,
      1,
      95,
      1,
      95,
      1,
      95,
      1,
      95,
      1,
      96,
      1,
      96,
      1,
      96,
      1,
      96,
      1,
      96,
      1,
      96,
      1,
      96,
      1,
      97,
      1,
      97,
      1,
      97,
      1,
      97,
      1,
      97,
      1,
      97,
      1,
      98,
      1,
      98,
      1,
      98,
      1,
      98,
      1,
      98,
      1,
      98,
      1,
      98,
      1,
      98,
      1,
      99,
      1,
      99,
      1,
      99,
      1,
      99,
      1,
      99,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      101,
      1,
      101,
      1,
      101,
      1,
      101,
      1,
      101,
      1,
      101,
      1,
      101,
      1,
      101,
      1,
      101,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      103,
      1,
      103,
      1,
      103,
      1,
      103,
      1,
      103,
      1,
      103,
      1,
      103,
      1,
      103,
      1,
      103,
      1,
      103,
      1,
      104,
      1,
      104,
      1,
      104,
      1,
      104,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      106,
      1,
      106,
      1,
      106,
      1,
      106,
      1,
      107,
      1,
      107,
      1,
      107,
      1,
      107,
      1,
      107,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      110,
      1,
      110,
      1,
      110,
      1,
      111,
      1,
      111,
      1,
      111,
      1,
      112,
      1,
      112,
      1,
      112,
      1,
      112,
      1,
      112,
      1,
      112,
      1,
      112,
      1,
      112,
      1,
      113,
      1,
      113,
      1,
      113,
      1,
      113,
      1,
      114,
      1,
      114,
      1,
      114,
      1,
      114,
      1,
      114,
      1,
      114,
      1,
      114,
      1,
      114,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      116,
      1,
      116,
      1,
      116,
      1,
      116,
      1,
      116,
      1,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      1,
      118,
      1,
      118,
      1,
      118,
      1,
      118,
      1,
      118,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      120,
      1,
      120,
      1,
      120,
      1,
      120,
      1,
      120,
      1,
      120,
      1,
      120,
      1,
      120,
      1,
      120,
      1,
      120,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      123,
      1,
      123,
      1,
      123,
      1,
      123,
      1,
      123,
      1,
      123,
      1,
      123,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      126,
      1,
      126,
      1,
      126,
      1,
      126,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      127,
      1,
      128,
      1,
      128,
      1,
      128,
      1,
      128,
      1,
      128,
      1,
      128,
      1,
      128,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      130,
      1,
      130,
      1,
      130,
      1,
      130,
      1,
      131,
      1,
      131,
      1,
      131,
      1,
      131,
      1,
      131,
      1,
      131,
      1,
      131,
      1,
      131,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      132,
      1,
      133,
      1,
      133,
      1,
      133,
      1,
      133,
      1,
      133,
      1,
      133,
      1,
      133,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      135,
      1,
      135,
      1,
      135,
      1,
      135,
      1,
      135,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      141,
      1,
      141,
      1,
      141,
      1,
      141,
      1,
      141,
      1,
      141,
      1,
      142,
      1,
      142,
      1,
      142,
      1,
      142,
      1,
      142,
      1,
      143,
      1,
      143,
      1,
      143,
      1,
      143,
      1,
      143,
      1,
      143,
      1,
      143,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      145,
      1,
      145,
      1,
      145,
      1,
      145,
      1,
      145,
      1,
      145,
      1,
      145,
      1,
      145,
      1,
      146,
      1,
      146,
      1,
      146,
      1,
      146,
      1,
      146,
      1,
      146,
      1,
      146,
      1,
      147,
      1,
      147,
      1,
      147,
      1,
      147,
      1,
      147,
      1,
      147,
      1,
      147,
      1,
      147,
      1,
      148,
      1,
      148,
      1,
      148,
      1,
      148,
      1,
      148,
      1,
      148,
      1,
      148,
      1,
      148,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      149,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      151,
      1,
      151,
      1,
      151,
      1,
      151,
      1,
      151,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      153,
      1,
      153,
      1,
      153,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      154,
      1,
      155,
      1,
      155,
      1,
      155,
      1,
      155,
      1,
      155,
      1,
      156,
      1,
      156,
      1,
      156,
      1,
      156,
      1,
      156,
      1,
      157,
      1,
      157,
      1,
      157,
      1,
      157,
      1,
      157,
      1,
      157,
      1,
      158,
      1,
      158,
      1,
      158,
      1,
      158,
      1,
      158,
      1,
      158,
      1,
      158,
      1,
      159,
      1,
      159,
      1,
      159,
      1,
      159,
      1,
      159,
      1,
      159,
      1,
      159,
      1,
      160,
      1,
      160,
      1,
      160,
      1,
      160,
      1,
      160,
      1,
      160,
      1,
      161,
      1,
      161,
      1,
      161,
      1,
      161,
      1,
      162,
      1,
      162,
      1,
      162,
      1,
      162,
      1,
      163,
      1,
      163,
      1,
      163,
      1,
      163,
      1,
      163,
      1,
      163,
      1,
      163,
      1,
      163,
      1,
      164,
      1,
      164,
      1,
      164,
      1,
      164,
      1,
      164,
      1,
      164,
      1,
      164,
      1,
      164,
      1,
      164,
      1,
      164,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      165,
      1,
      166,
      1,
      166,
      1,
      166,
      1,
      166,
      1,
      166,
      1,
      166,
      1,
      166,
      1,
      167,
      1,
      167,
      1,
      167,
      1,
      167,
      1,
      168,
      1,
      168,
      1,
      168,
      1,
      168,
      1,
      168,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      170,
      1,
      170,
      1,
      170,
      1,
      170,
      1,
      170,
      1,
      171,
      1,
      171,
      1,
      171,
      1,
      171,
      1,
      171,
      1,
      171,
      1,
      172,
      1,
      172,
      1,
      172,
      1,
      172,
      1,
      173,
      1,
      173,
      1,
      173,
      1,
      173,
      1,
      174,
      1,
      174,
      1,
      174,
      1,
      174,
      1,
      175,
      1,
      175,
      1,
      175,
      1,
      175,
      1,
      176,
      1,
      176,
      1,
      176,
      1,
      176,
      1,
      177,
      1,
      177,
      1,
      177,
      1,
      178,
      1,
      178,
      1,
      178,
      1,
      179,
      1,
      179,
      1,
      179,
      1,
      180,
      1,
      180,
      1,
      180,
      1,
      181,
      1,
      181,
      1,
      181,
      1,
      182,
      1,
      182,
      1,
      182,
      1,
      183,
      1,
      183,
      1,
      183,
      1,
      184,
      1,
      184,
      1,
      184,
      1,
      185,
      1,
      185,
      1,
      185,
      1,
      186,
      1,
      186,
      1,
      186,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      188,
      1,
      188,
      1,
      188,
      1,
      189,
      1,
      189,
      1,
      189,
      1,
      190,
      1,
      190,
      1,
      190,
      1,
      191,
      1,
      191,
      1,
      192,
      1,
      192,
      1,
      193,
      1,
      193,
      1,
      194,
      1,
      194,
      1,
      195,
      1,
      195,
      1,
      196,
      1,
      196,
      1,
      197,
      1,
      197,
      1,
      198,
      1,
      198,
      1,
      199,
      1,
      199,
      1,
      200,
      1,
      200,
      1,
      201,
      1,
      201,
      1,
      202,
      1,
      202,
      1,
      203,
      1,
      203,
      1,
      204,
      1,
      204,
      1,
      205,
      1,
      205,
      1,
      206,
      1,
      206,
      1,
      207,
      1,
      207,
      1,
      208,
      1,
      208,
      1,
      209,
      1,
      209,
      1,
      210,
      1,
      210,
      1,
      211,
      1,
      211,
      1,
      212,
      1,
      212,
      1,
      213,
      1,
      213,
      1,
      214,
      1,
      214,
      1,
      215,
      1,
      215,
      1,
      216,
      1,
      216,
      1,
      217,
      1,
      217,
      5,
      217,
      1852,
      8,
      217,
      10,
      217,
      12,
      217,
      1855,
      9,
      217,
      1,
      218,
      1,
      218,
      1,
      218,
      1,
      218,
      5,
      218,
      1861,
      8,
      218,
      10,
      218,
      12,
      218,
      1864,
      9,
      218,
      1,
      218,
      1,
      218,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      5,
      219,
      1872,
      8,
      219,
      10,
      219,
      12,
      219,
      1875,
      9,
      219,
      1,
      219,
      1,
      219,
      1,
      220,
      4,
      220,
      1880,
      8,
      220,
      11,
      220,
      12,
      220,
      1881,
      1,
      221,
      5,
      221,
      1885,
      8,
      221,
      10,
      221,
      12,
      221,
      1888,
      9,
      221,
      1,
      221,
      1,
      221,
      4,
      221,
      1892,
      8,
      221,
      11,
      221,
      12,
      221,
      1893,
      1,
      221,
      1,
      221,
      3,
      221,
      1898,
      8,
      221,
      1,
      221,
      4,
      221,
      1901,
      8,
      221,
      11,
      221,
      12,
      221,
      1902,
      3,
      221,
      1905,
      8,
      221,
      1,
      221,
      4,
      221,
      1908,
      8,
      221,
      11,
      221,
      12,
      221,
      1909,
      1,
      221,
      1,
      221,
      3,
      221,
      1914,
      8,
      221,
      1,
      221,
      4,
      221,
      1917,
      8,
      221,
      11,
      221,
      12,
      221,
      1918,
      3,
      221,
      1921,
      8,
      221,
      1,
      222,
      1,
      222,
      1,
      222,
      1,
      222,
      5,
      222,
      1927,
      8,
      222,
      10,
      222,
      12,
      222,
      1930,
      9,
      222,
      1,
      222,
      1,
      222,
      1,
      222,
      1,
      222,
      1,
      222,
      1,
      222,
      1,
      222,
      5,
      222,
      1939,
      8,
      222,
      10,
      222,
      12,
      222,
      1942,
      9,
      222,
      1,
      222,
      1,
      222,
      3,
      222,
      1946,
      8,
      222,
      1,
      223,
      1,
      223,
      1,
      223,
      1,
      223,
      1,
      223,
      5,
      223,
      1953,
      8,
      223,
      10,
      223,
      12,
      223,
      1956,
      9,
      223,
      1,
      223,
      1,
      223,
      1,
      224,
      1,
      224,
      1,
      224,
      1,
      224,
      1,
      224,
      1,
      225,
      4,
      225,
      1966,
      8,
      225,
      11,
      225,
      12,
      225,
      1967,
      1,
      225,
      1,
      225,
      2,
      1928,
      1940,
      0,
      226,
      1,
      1,
      3,
      2,
      5,
      3,
      7,
      4,
      9,
      5,
      11,
      6,
      13,
      7,
      15,
      8,
      17,
      9,
      19,
      10,
      21,
      11,
      23,
      12,
      25,
      13,
      27,
      14,
      29,
      15,
      31,
      16,
      33,
      17,
      35,
      18,
      37,
      19,
      39,
      20,
      41,
      21,
      43,
      22,
      45,
      23,
      47,
      24,
      49,
      25,
      51,
      26,
      53,
      27,
      55,
      28,
      57,
      29,
      59,
      30,
      61,
      31,
      63,
      32,
      65,
      33,
      67,
      34,
      69,
      35,
      71,
      36,
      73,
      37,
      75,
      38,
      77,
      39,
      79,
      40,
      81,
      41,
      83,
      42,
      85,
      43,
      87,
      44,
      89,
      45,
      91,
      46,
      93,
      47,
      95,
      48,
      97,
      49,
      99,
      50,
      101,
      51,
      103,
      52,
      105,
      53,
      107,
      54,
      109,
      55,
      111,
      56,
      113,
      57,
      115,
      58,
      117,
      59,
      119,
      60,
      121,
      61,
      123,
      62,
      125,
      63,
      127,
      64,
      129,
      65,
      131,
      66,
      133,
      67,
      135,
      68,
      137,
      69,
      139,
      70,
      141,
      71,
      143,
      72,
      145,
      73,
      147,
      74,
      149,
      75,
      151,
      76,
      153,
      77,
      155,
      78,
      157,
      79,
      159,
      80,
      161,
      81,
      163,
      82,
      165,
      83,
      167,
      84,
      169,
      85,
      171,
      86,
      173,
      87,
      175,
      88,
      177,
      89,
      179,
      90,
      181,
      91,
      183,
      92,
      185,
      93,
      187,
      94,
      189,
      95,
      191,
      96,
      193,
      97,
      195,
      98,
      197,
      99,
      199,
      100,
      201,
      101,
      203,
      102,
      205,
      103,
      207,
      104,
      209,
      105,
      211,
      106,
      213,
      107,
      215,
      108,
      217,
      109,
      219,
      110,
      221,
      111,
      223,
      112,
      225,
      113,
      227,
      114,
      229,
      115,
      231,
      116,
      233,
      117,
      235,
      118,
      237,
      119,
      239,
      120,
      241,
      121,
      243,
      122,
      245,
      123,
      247,
      124,
      249,
      125,
      251,
      126,
      253,
      127,
      255,
      128,
      257,
      129,
      259,
      130,
      261,
      131,
      263,
      132,
      265,
      133,
      267,
      134,
      269,
      135,
      271,
      136,
      273,
      137,
      275,
      138,
      277,
      139,
      279,
      140,
      281,
      141,
      283,
      142,
      285,
      143,
      287,
      144,
      289,
      145,
      291,
      146,
      293,
      147,
      295,
      148,
      297,
      149,
      299,
      150,
      301,
      151,
      303,
      152,
      305,
      153,
      307,
      154,
      309,
      155,
      311,
      156,
      313,
      157,
      315,
      158,
      317,
      159,
      319,
      160,
      321,
      161,
      323,
      162,
      325,
      163,
      327,
      164,
      329,
      165,
      331,
      166,
      333,
      167,
      335,
      168,
      337,
      169,
      339,
      170,
      341,
      171,
      343,
      172,
      345,
      173,
      347,
      174,
      349,
      175,
      351,
      176,
      353,
      177,
      355,
      178,
      357,
      179,
      359,
      180,
      361,
      181,
      363,
      182,
      365,
      183,
      367,
      184,
      369,
      185,
      371,
      186,
      373,
      187,
      375,
      188,
      377,
      189,
      379,
      190,
      381,
      191,
      383,
      192,
      385,
      193,
      387,
      194,
      389,
      195,
      391,
      196,
      393,
      197,
      395,
      198,
      397,
      199,
      399,
      200,
      401,
      201,
      403,
      202,
      405,
      203,
      407,
      204,
      409,
      205,
      411,
      206,
      413,
      207,
      415,
      208,
      417,
      209,
      419,
      210,
      421,
      211,
      423,
      212,
      425,
      213,
      427,
      214,
      429,
      215,
      431,
      216,
      433,
      217,
      435,
      218,
      437,
      219,
      439,
      220,
      441,
      221,
      443,
      222,
      445,
      223,
      447,
      224,
      449,
      225,
      451,
      226,
      1,
      0,
      10,
      3,
      0,
      65,
      90,
      95,
      95,
      97,
      122,
      4,
      0,
      48,
      57,
      65,
      90,
      95,
      95,
      97,
      122,
      2,
      0,
      39,
      39,
      92,
      92,
      2,
      0,
      34,
      34,
      92,
      92,
      1,
      0,
      48,
      57,
      2,
      0,
      69,
      69,
      101,
      101,
      2,
      0,
      43,
      43,
      45,
      45,
      3,
      0,
      10,
      10,
      13,
      13,
      42,
      42,
      2,
      0,
      10,
      10,
      13,
      13,
      3,
      0,
      9,
      10,
      13,
      13,
      32,
      32,
      1990,
      0,
      1,
      1,
      0,
      0,
      0,
      0,
      3,
      1,
      0,
      0,
      0,
      0,
      5,
      1,
      0,
      0,
      0,
      0,
      7,
      1,
      0,
      0,
      0,
      0,
      9,
      1,
      0,
      0,
      0,
      0,
      11,
      1,
      0,
      0,
      0,
      0,
      13,
      1,
      0,
      0,
      0,
      0,
      15,
      1,
      0,
      0,
      0,
      0,
      17,
      1,
      0,
      0,
      0,
      0,
      19,
      1,
      0,
      0,
      0,
      0,
      21,
      1,
      0,
      0,
      0,
      0,
      23,
      1,
      0,
      0,
      0,
      0,
      25,
      1,
      0,
      0,
      0,
      0,
      27,
      1,
      0,
      0,
      0,
      0,
      29,
      1,
      0,
      0,
      0,
      0,
      31,
      1,
      0,
      0,
      0,
      0,
      33,
      1,
      0,
      0,
      0,
      0,
      35,
      1,
      0,
      0,
      0,
      0,
      37,
      1,
      0,
      0,
      0,
      0,
      39,
      1,
      0,
      0,
      0,
      0,
      41,
      1,
      0,
      0,
      0,
      0,
      43,
      1,
      0,
      0,
      0,
      0,
      45,
      1,
      0,
      0,
      0,
      0,
      47,
      1,
      0,
      0,
      0,
      0,
      49,
      1,
      0,
      0,
      0,
      0,
      51,
      1,
      0,
      0,
      0,
      0,
      53,
      1,
      0,
      0,
      0,
      0,
      55,
      1,
      0,
      0,
      0,
      0,
      57,
      1,
      0,
      0,
      0,
      0,
      59,
      1,
      0,
      0,
      0,
      0,
      61,
      1,
      0,
      0,
      0,
      0,
      63,
      1,
      0,
      0,
      0,
      0,
      65,
      1,
      0,
      0,
      0,
      0,
      67,
      1,
      0,
      0,
      0,
      0,
      69,
      1,
      0,
      0,
      0,
      0,
      71,
      1,
      0,
      0,
      0,
      0,
      73,
      1,
      0,
      0,
      0,
      0,
      75,
      1,
      0,
      0,
      0,
      0,
      77,
      1,
      0,
      0,
      0,
      0,
      79,
      1,
      0,
      0,
      0,
      0,
      81,
      1,
      0,
      0,
      0,
      0,
      83,
      1,
      0,
      0,
      0,
      0,
      85,
      1,
      0,
      0,
      0,
      0,
      87,
      1,
      0,
      0,
      0,
      0,
      89,
      1,
      0,
      0,
      0,
      0,
      91,
      1,
      0,
      0,
      0,
      0,
      93,
      1,
      0,
      0,
      0,
      0,
      95,
      1,
      0,
      0,
      0,
      0,
      97,
      1,
      0,
      0,
      0,
      0,
      99,
      1,
      0,
      0,
      0,
      0,
      101,
      1,
      0,
      0,
      0,
      0,
      103,
      1,
      0,
      0,
      0,
      0,
      105,
      1,
      0,
      0,
      0,
      0,
      107,
      1,
      0,
      0,
      0,
      0,
      109,
      1,
      0,
      0,
      0,
      0,
      111,
      1,
      0,
      0,
      0,
      0,
      113,
      1,
      0,
      0,
      0,
      0,
      115,
      1,
      0,
      0,
      0,
      0,
      117,
      1,
      0,
      0,
      0,
      0,
      119,
      1,
      0,
      0,
      0,
      0,
      121,
      1,
      0,
      0,
      0,
      0,
      123,
      1,
      0,
      0,
      0,
      0,
      125,
      1,
      0,
      0,
      0,
      0,
      127,
      1,
      0,
      0,
      0,
      0,
      129,
      1,
      0,
      0,
      0,
      0,
      131,
      1,
      0,
      0,
      0,
      0,
      133,
      1,
      0,
      0,
      0,
      0,
      135,
      1,
      0,
      0,
      0,
      0,
      137,
      1,
      0,
      0,
      0,
      0,
      139,
      1,
      0,
      0,
      0,
      0,
      141,
      1,
      0,
      0,
      0,
      0,
      143,
      1,
      0,
      0,
      0,
      0,
      145,
      1,
      0,
      0,
      0,
      0,
      147,
      1,
      0,
      0,
      0,
      0,
      149,
      1,
      0,
      0,
      0,
      0,
      151,
      1,
      0,
      0,
      0,
      0,
      153,
      1,
      0,
      0,
      0,
      0,
      155,
      1,
      0,
      0,
      0,
      0,
      157,
      1,
      0,
      0,
      0,
      0,
      159,
      1,
      0,
      0,
      0,
      0,
      161,
      1,
      0,
      0,
      0,
      0,
      163,
      1,
      0,
      0,
      0,
      0,
      165,
      1,
      0,
      0,
      0,
      0,
      167,
      1,
      0,
      0,
      0,
      0,
      169,
      1,
      0,
      0,
      0,
      0,
      171,
      1,
      0,
      0,
      0,
      0,
      173,
      1,
      0,
      0,
      0,
      0,
      175,
      1,
      0,
      0,
      0,
      0,
      177,
      1,
      0,
      0,
      0,
      0,
      179,
      1,
      0,
      0,
      0,
      0,
      181,
      1,
      0,
      0,
      0,
      0,
      183,
      1,
      0,
      0,
      0,
      0,
      185,
      1,
      0,
      0,
      0,
      0,
      187,
      1,
      0,
      0,
      0,
      0,
      189,
      1,
      0,
      0,
      0,
      0,
      191,
      1,
      0,
      0,
      0,
      0,
      193,
      1,
      0,
      0,
      0,
      0,
      195,
      1,
      0,
      0,
      0,
      0,
      197,
      1,
      0,
      0,
      0,
      0,
      199,
      1,
      0,
      0,
      0,
      0,
      201,
      1,
      0,
      0,
      0,
      0,
      203,
      1,
      0,
      0,
      0,
      0,
      205,
      1,
      0,
      0,
      0,
      0,
      207,
      1,
      0,
      0,
      0,
      0,
      209,
      1,
      0,
      0,
      0,
      0,
      211,
      1,
      0,
      0,
      0,
      0,
      213,
      1,
      0,
      0,
      0,
      0,
      215,
      1,
      0,
      0,
      0,
      0,
      217,
      1,
      0,
      0,
      0,
      0,
      219,
      1,
      0,
      0,
      0,
      0,
      221,
      1,
      0,
      0,
      0,
      0,
      223,
      1,
      0,
      0,
      0,
      0,
      225,
      1,
      0,
      0,
      0,
      0,
      227,
      1,
      0,
      0,
      0,
      0,
      229,
      1,
      0,
      0,
      0,
      0,
      231,
      1,
      0,
      0,
      0,
      0,
      233,
      1,
      0,
      0,
      0,
      0,
      235,
      1,
      0,
      0,
      0,
      0,
      237,
      1,
      0,
      0,
      0,
      0,
      239,
      1,
      0,
      0,
      0,
      0,
      241,
      1,
      0,
      0,
      0,
      0,
      243,
      1,
      0,
      0,
      0,
      0,
      245,
      1,
      0,
      0,
      0,
      0,
      247,
      1,
      0,
      0,
      0,
      0,
      249,
      1,
      0,
      0,
      0,
      0,
      251,
      1,
      0,
      0,
      0,
      0,
      253,
      1,
      0,
      0,
      0,
      0,
      255,
      1,
      0,
      0,
      0,
      0,
      257,
      1,
      0,
      0,
      0,
      0,
      259,
      1,
      0,
      0,
      0,
      0,
      261,
      1,
      0,
      0,
      0,
      0,
      263,
      1,
      0,
      0,
      0,
      0,
      265,
      1,
      0,
      0,
      0,
      0,
      267,
      1,
      0,
      0,
      0,
      0,
      269,
      1,
      0,
      0,
      0,
      0,
      271,
      1,
      0,
      0,
      0,
      0,
      273,
      1,
      0,
      0,
      0,
      0,
      275,
      1,
      0,
      0,
      0,
      0,
      277,
      1,
      0,
      0,
      0,
      0,
      279,
      1,
      0,
      0,
      0,
      0,
      281,
      1,
      0,
      0,
      0,
      0,
      283,
      1,
      0,
      0,
      0,
      0,
      285,
      1,
      0,
      0,
      0,
      0,
      287,
      1,
      0,
      0,
      0,
      0,
      289,
      1,
      0,
      0,
      0,
      0,
      291,
      1,
      0,
      0,
      0,
      0,
      293,
      1,
      0,
      0,
      0,
      0,
      295,
      1,
      0,
      0,
      0,
      0,
      297,
      1,
      0,
      0,
      0,
      0,
      299,
      1,
      0,
      0,
      0,
      0,
      301,
      1,
      0,
      0,
      0,
      0,
      303,
      1,
      0,
      0,
      0,
      0,
      305,
      1,
      0,
      0,
      0,
      0,
      307,
      1,
      0,
      0,
      0,
      0,
      309,
      1,
      0,
      0,
      0,
      0,
      311,
      1,
      0,
      0,
      0,
      0,
      313,
      1,
      0,
      0,
      0,
      0,
      315,
      1,
      0,
      0,
      0,
      0,
      317,
      1,
      0,
      0,
      0,
      0,
      319,
      1,
      0,
      0,
      0,
      0,
      321,
      1,
      0,
      0,
      0,
      0,
      323,
      1,
      0,
      0,
      0,
      0,
      325,
      1,
      0,
      0,
      0,
      0,
      327,
      1,
      0,
      0,
      0,
      0,
      329,
      1,
      0,
      0,
      0,
      0,
      331,
      1,
      0,
      0,
      0,
      0,
      333,
      1,
      0,
      0,
      0,
      0,
      335,
      1,
      0,
      0,
      0,
      0,
      337,
      1,
      0,
      0,
      0,
      0,
      339,
      1,
      0,
      0,
      0,
      0,
      341,
      1,
      0,
      0,
      0,
      0,
      343,
      1,
      0,
      0,
      0,
      0,
      345,
      1,
      0,
      0,
      0,
      0,
      347,
      1,
      0,
      0,
      0,
      0,
      349,
      1,
      0,
      0,
      0,
      0,
      351,
      1,
      0,
      0,
      0,
      0,
      353,
      1,
      0,
      0,
      0,
      0,
      355,
      1,
      0,
      0,
      0,
      0,
      357,
      1,
      0,
      0,
      0,
      0,
      359,
      1,
      0,
      0,
      0,
      0,
      361,
      1,
      0,
      0,
      0,
      0,
      363,
      1,
      0,
      0,
      0,
      0,
      365,
      1,
      0,
      0,
      0,
      0,
      367,
      1,
      0,
      0,
      0,
      0,
      369,
      1,
      0,
      0,
      0,
      0,
      371,
      1,
      0,
      0,
      0,
      0,
      373,
      1,
      0,
      0,
      0,
      0,
      375,
      1,
      0,
      0,
      0,
      0,
      377,
      1,
      0,
      0,
      0,
      0,
      379,
      1,
      0,
      0,
      0,
      0,
      381,
      1,
      0,
      0,
      0,
      0,
      383,
      1,
      0,
      0,
      0,
      0,
      385,
      1,
      0,
      0,
      0,
      0,
      387,
      1,
      0,
      0,
      0,
      0,
      389,
      1,
      0,
      0,
      0,
      0,
      391,
      1,
      0,
      0,
      0,
      0,
      393,
      1,
      0,
      0,
      0,
      0,
      395,
      1,
      0,
      0,
      0,
      0,
      397,
      1,
      0,
      0,
      0,
      0,
      399,
      1,
      0,
      0,
      0,
      0,
      401,
      1,
      0,
      0,
      0,
      0,
      403,
      1,
      0,
      0,
      0,
      0,
      405,
      1,
      0,
      0,
      0,
      0,
      407,
      1,
      0,
      0,
      0,
      0,
      409,
      1,
      0,
      0,
      0,
      0,
      411,
      1,
      0,
      0,
      0,
      0,
      413,
      1,
      0,
      0,
      0,
      0,
      415,
      1,
      0,
      0,
      0,
      0,
      417,
      1,
      0,
      0,
      0,
      0,
      419,
      1,
      0,
      0,
      0,
      0,
      421,
      1,
      0,
      0,
      0,
      0,
      423,
      1,
      0,
      0,
      0,
      0,
      425,
      1,
      0,
      0,
      0,
      0,
      427,
      1,
      0,
      0,
      0,
      0,
      429,
      1,
      0,
      0,
      0,
      0,
      431,
      1,
      0,
      0,
      0,
      0,
      433,
      1,
      0,
      0,
      0,
      0,
      435,
      1,
      0,
      0,
      0,
      0,
      437,
      1,
      0,
      0,
      0,
      0,
      439,
      1,
      0,
      0,
      0,
      0,
      441,
      1,
      0,
      0,
      0,
      0,
      443,
      1,
      0,
      0,
      0,
      0,
      445,
      1,
      0,
      0,
      0,
      0,
      447,
      1,
      0,
      0,
      0,
      0,
      449,
      1,
      0,
      0,
      0,
      0,
      451,
      1,
      0,
      0,
      0,
      1,
      453,
      1,
      0,
      0,
      0,
      3,
      459,
      1,
      0,
      0,
      0,
      5,
      468,
      1,
      0,
      0,
      0,
      7,
      475,
      1,
      0,
      0,
      0,
      9,
      482,
      1,
      0,
      0,
      0,
      11,
      488,
      1,
      0,
      0,
      0,
      13,
      494,
      1,
      0,
      0,
      0,
      15,
      500,
      1,
      0,
      0,
      0,
      17,
      504,
      1,
      0,
      0,
      0,
      19,
      513,
      1,
      0,
      0,
      0,
      21,
      524,
      1,
      0,
      0,
      0,
      23,
      533,
      1,
      0,
      0,
      0,
      25,
      537,
      1,
      0,
      0,
      0,
      27,
      540,
      1,
      0,
      0,
      0,
      29,
      547,
      1,
      0,
      0,
      0,
      31,
      554,
      1,
      0,
      0,
      0,
      33,
      560,
      1,
      0,
      0,
      0,
      35,
      567,
      1,
      0,
      0,
      0,
      37,
      570,
      1,
      0,
      0,
      0,
      39,
      580,
      1,
      0,
      0,
      0,
      41,
      589,
      1,
      0,
      0,
      0,
      43,
      594,
      1,
      0,
      0,
      0,
      45,
      602,
      1,
      0,
      0,
      0,
      47,
      607,
      1,
      0,
      0,
      0,
      49,
      610,
      1,
      0,
      0,
      0,
      51,
      615,
      1,
      0,
      0,
      0,
      53,
      620,
      1,
      0,
      0,
      0,
      55,
      627,
      1,
      0,
      0,
      0,
      57,
      633,
      1,
      0,
      0,
      0,
      59,
      644,
      1,
      0,
      0,
      0,
      61,
      652,
      1,
      0,
      0,
      0,
      63,
      662,
      1,
      0,
      0,
      0,
      65,
      670,
      1,
      0,
      0,
      0,
      67,
      680,
      1,
      0,
      0,
      0,
      69,
      691,
      1,
      0,
      0,
      0,
      71,
      703,
      1,
      0,
      0,
      0,
      73,
      711,
      1,
      0,
      0,
      0,
      75,
      722,
      1,
      0,
      0,
      0,
      77,
      732,
      1,
      0,
      0,
      0,
      79,
      738,
      1,
      0,
      0,
      0,
      81,
      747,
      1,
      0,
      0,
      0,
      83,
      758,
      1,
      0,
      0,
      0,
      85,
      766,
      1,
      0,
      0,
      0,
      87,
      775,
      1,
      0,
      0,
      0,
      89,
      782,
      1,
      0,
      0,
      0,
      91,
      786,
      1,
      0,
      0,
      0,
      93,
      794,
      1,
      0,
      0,
      0,
      95,
      802,
      1,
      0,
      0,
      0,
      97,
      813,
      1,
      0,
      0,
      0,
      99,
      821,
      1,
      0,
      0,
      0,
      101,
      833,
      1,
      0,
      0,
      0,
      103,
      844,
      1,
      0,
      0,
      0,
      105,
      853,
      1,
      0,
      0,
      0,
      107,
      856,
      1,
      0,
      0,
      0,
      109,
      860,
      1,
      0,
      0,
      0,
      111,
      865,
      1,
      0,
      0,
      0,
      113,
      869,
      1,
      0,
      0,
      0,
      115,
      875,
      1,
      0,
      0,
      0,
      117,
      880,
      1,
      0,
      0,
      0,
      119,
      886,
      1,
      0,
      0,
      0,
      121,
      894,
      1,
      0,
      0,
      0,
      123,
      899,
      1,
      0,
      0,
      0,
      125,
      906,
      1,
      0,
      0,
      0,
      127,
      911,
      1,
      0,
      0,
      0,
      129,
      917,
      1,
      0,
      0,
      0,
      131,
      925,
      1,
      0,
      0,
      0,
      133,
      934,
      1,
      0,
      0,
      0,
      135,
      944,
      1,
      0,
      0,
      0,
      137,
      951,
      1,
      0,
      0,
      0,
      139,
      957,
      1,
      0,
      0,
      0,
      141,
      962,
      1,
      0,
      0,
      0,
      143,
      966,
      1,
      0,
      0,
      0,
      145,
      971,
      1,
      0,
      0,
      0,
      147,
      977,
      1,
      0,
      0,
      0,
      149,
      982,
      1,
      0,
      0,
      0,
      151,
      991,
      1,
      0,
      0,
      0,
      153,
      999,
      1,
      0,
      0,
      0,
      155,
      1002,
      1,
      0,
      0,
      0,
      157,
      1010,
      1,
      0,
      0,
      0,
      159,
      1017,
      1,
      0,
      0,
      0,
      161,
      1020,
      1,
      0,
      0,
      0,
      163,
      1028,
      1,
      0,
      0,
      0,
      165,
      1039,
      1,
      0,
      0,
      0,
      167,
      1045,
      1,
      0,
      0,
      0,
      169,
      1057,
      1,
      0,
      0,
      0,
      171,
      1067,
      1,
      0,
      0,
      0,
      173,
      1078,
      1,
      0,
      0,
      0,
      175,
      1082,
      1,
      0,
      0,
      0,
      177,
      1090,
      1,
      0,
      0,
      0,
      179,
      1100,
      1,
      0,
      0,
      0,
      181,
      1107,
      1,
      0,
      0,
      0,
      183,
      1112,
      1,
      0,
      0,
      0,
      185,
      1117,
      1,
      0,
      0,
      0,
      187,
      1126,
      1,
      0,
      0,
      0,
      189,
      1134,
      1,
      0,
      0,
      0,
      191,
      1141,
      1,
      0,
      0,
      0,
      193,
      1146,
      1,
      0,
      0,
      0,
      195,
      1153,
      1,
      0,
      0,
      0,
      197,
      1159,
      1,
      0,
      0,
      0,
      199,
      1167,
      1,
      0,
      0,
      0,
      201,
      1172,
      1,
      0,
      0,
      0,
      203,
      1182,
      1,
      0,
      0,
      0,
      205,
      1191,
      1,
      0,
      0,
      0,
      207,
      1204,
      1,
      0,
      0,
      0,
      209,
      1214,
      1,
      0,
      0,
      0,
      211,
      1218,
      1,
      0,
      0,
      0,
      213,
      1228,
      1,
      0,
      0,
      0,
      215,
      1232,
      1,
      0,
      0,
      0,
      217,
      1237,
      1,
      0,
      0,
      0,
      219,
      1247,
      1,
      0,
      0,
      0,
      221,
      1258,
      1,
      0,
      0,
      0,
      223,
      1261,
      1,
      0,
      0,
      0,
      225,
      1264,
      1,
      0,
      0,
      0,
      227,
      1272,
      1,
      0,
      0,
      0,
      229,
      1276,
      1,
      0,
      0,
      0,
      231,
      1284,
      1,
      0,
      0,
      0,
      233,
      1293,
      1,
      0,
      0,
      0,
      235,
      1298,
      1,
      0,
      0,
      0,
      237,
      1306,
      1,
      0,
      0,
      0,
      239,
      1311,
      1,
      0,
      0,
      0,
      241,
      1319,
      1,
      0,
      0,
      0,
      243,
      1329,
      1,
      0,
      0,
      0,
      245,
      1337,
      1,
      0,
      0,
      0,
      247,
      1347,
      1,
      0,
      0,
      0,
      249,
      1354,
      1,
      0,
      0,
      0,
      251,
      1364,
      1,
      0,
      0,
      0,
      253,
      1377,
      1,
      0,
      0,
      0,
      255,
      1381,
      1,
      0,
      0,
      0,
      257,
      1392,
      1,
      0,
      0,
      0,
      259,
      1399,
      1,
      0,
      0,
      0,
      261,
      1409,
      1,
      0,
      0,
      0,
      263,
      1413,
      1,
      0,
      0,
      0,
      265,
      1421,
      1,
      0,
      0,
      0,
      267,
      1433,
      1,
      0,
      0,
      0,
      269,
      1440,
      1,
      0,
      0,
      0,
      271,
      1448,
      1,
      0,
      0,
      0,
      273,
      1453,
      1,
      0,
      0,
      0,
      275,
      1462,
      1,
      0,
      0,
      0,
      277,
      1477,
      1,
      0,
      0,
      0,
      279,
      1489,
      1,
      0,
      0,
      0,
      281,
      1501,
      1,
      0,
      0,
      0,
      283,
      1510,
      1,
      0,
      0,
      0,
      285,
      1516,
      1,
      0,
      0,
      0,
      287,
      1521,
      1,
      0,
      0,
      0,
      289,
      1528,
      1,
      0,
      0,
      0,
      291,
      1542,
      1,
      0,
      0,
      0,
      293,
      1550,
      1,
      0,
      0,
      0,
      295,
      1557,
      1,
      0,
      0,
      0,
      297,
      1565,
      1,
      0,
      0,
      0,
      299,
      1573,
      1,
      0,
      0,
      0,
      301,
      1584,
      1,
      0,
      0,
      0,
      303,
      1594,
      1,
      0,
      0,
      0,
      305,
      1599,
      1,
      0,
      0,
      0,
      307,
      1609,
      1,
      0,
      0,
      0,
      309,
      1612,
      1,
      0,
      0,
      0,
      311,
      1623,
      1,
      0,
      0,
      0,
      313,
      1628,
      1,
      0,
      0,
      0,
      315,
      1633,
      1,
      0,
      0,
      0,
      317,
      1639,
      1,
      0,
      0,
      0,
      319,
      1646,
      1,
      0,
      0,
      0,
      321,
      1653,
      1,
      0,
      0,
      0,
      323,
      1659,
      1,
      0,
      0,
      0,
      325,
      1663,
      1,
      0,
      0,
      0,
      327,
      1667,
      1,
      0,
      0,
      0,
      329,
      1675,
      1,
      0,
      0,
      0,
      331,
      1685,
      1,
      0,
      0,
      0,
      333,
      1698,
      1,
      0,
      0,
      0,
      335,
      1705,
      1,
      0,
      0,
      0,
      337,
      1709,
      1,
      0,
      0,
      0,
      339,
      1714,
      1,
      0,
      0,
      0,
      341,
      1724,
      1,
      0,
      0,
      0,
      343,
      1729,
      1,
      0,
      0,
      0,
      345,
      1735,
      1,
      0,
      0,
      0,
      347,
      1739,
      1,
      0,
      0,
      0,
      349,
      1743,
      1,
      0,
      0,
      0,
      351,
      1747,
      1,
      0,
      0,
      0,
      353,
      1751,
      1,
      0,
      0,
      0,
      355,
      1755,
      1,
      0,
      0,
      0,
      357,
      1758,
      1,
      0,
      0,
      0,
      359,
      1761,
      1,
      0,
      0,
      0,
      361,
      1764,
      1,
      0,
      0,
      0,
      363,
      1767,
      1,
      0,
      0,
      0,
      365,
      1770,
      1,
      0,
      0,
      0,
      367,
      1773,
      1,
      0,
      0,
      0,
      369,
      1776,
      1,
      0,
      0,
      0,
      371,
      1779,
      1,
      0,
      0,
      0,
      373,
      1782,
      1,
      0,
      0,
      0,
      375,
      1785,
      1,
      0,
      0,
      0,
      377,
      1788,
      1,
      0,
      0,
      0,
      379,
      1791,
      1,
      0,
      0,
      0,
      381,
      1794,
      1,
      0,
      0,
      0,
      383,
      1797,
      1,
      0,
      0,
      0,
      385,
      1799,
      1,
      0,
      0,
      0,
      387,
      1801,
      1,
      0,
      0,
      0,
      389,
      1803,
      1,
      0,
      0,
      0,
      391,
      1805,
      1,
      0,
      0,
      0,
      393,
      1807,
      1,
      0,
      0,
      0,
      395,
      1809,
      1,
      0,
      0,
      0,
      397,
      1811,
      1,
      0,
      0,
      0,
      399,
      1813,
      1,
      0,
      0,
      0,
      401,
      1815,
      1,
      0,
      0,
      0,
      403,
      1817,
      1,
      0,
      0,
      0,
      405,
      1819,
      1,
      0,
      0,
      0,
      407,
      1821,
      1,
      0,
      0,
      0,
      409,
      1823,
      1,
      0,
      0,
      0,
      411,
      1825,
      1,
      0,
      0,
      0,
      413,
      1827,
      1,
      0,
      0,
      0,
      415,
      1829,
      1,
      0,
      0,
      0,
      417,
      1831,
      1,
      0,
      0,
      0,
      419,
      1833,
      1,
      0,
      0,
      0,
      421,
      1835,
      1,
      0,
      0,
      0,
      423,
      1837,
      1,
      0,
      0,
      0,
      425,
      1839,
      1,
      0,
      0,
      0,
      427,
      1841,
      1,
      0,
      0,
      0,
      429,
      1843,
      1,
      0,
      0,
      0,
      431,
      1845,
      1,
      0,
      0,
      0,
      433,
      1847,
      1,
      0,
      0,
      0,
      435,
      1849,
      1,
      0,
      0,
      0,
      437,
      1856,
      1,
      0,
      0,
      0,
      439,
      1867,
      1,
      0,
      0,
      0,
      441,
      1879,
      1,
      0,
      0,
      0,
      443,
      1920,
      1,
      0,
      0,
      0,
      445,
      1945,
      1,
      0,
      0,
      0,
      447,
      1947,
      1,
      0,
      0,
      0,
      449,
      1959,
      1,
      0,
      0,
      0,
      451,
      1965,
      1,
      0,
      0,
      0,
      453,
      454,
      5,
      97,
      0,
      0,
      454,
      455,
      5,
      98,
      0,
      0,
      455,
      456,
      5,
      111,
      0,
      0,
      456,
      457,
      5,
      117,
      0,
      0,
      457,
      458,
      5,
      116,
      0,
      0,
      458,
      2,
      1,
      0,
      0,
      0,
      459,
      460,
      5,
      97,
      0,
      0,
      460,
      461,
      5,
      98,
      0,
      0,
      461,
      462,
      5,
      115,
      0,
      0,
      462,
      463,
      5,
      116,
      0,
      0,
      463,
      464,
      5,
      114,
      0,
      0,
      464,
      465,
      5,
      97,
      0,
      0,
      465,
      466,
      5,
      99,
      0,
      0,
      466,
      467,
      5,
      116,
      0,
      0,
      467,
      4,
      1,
      0,
      0,
      0,
      468,
      469,
      5,
      97,
      0,
      0,
      469,
      470,
      5,
      99,
      0,
      0,
      470,
      471,
      5,
      99,
      0,
      0,
      471,
      472,
      5,
      101,
      0,
      0,
      472,
      473,
      5,
      112,
      0,
      0,
      473,
      474,
      5,
      116,
      0,
      0,
      474,
      6,
      1,
      0,
      0,
      0,
      475,
      476,
      5,
      97,
      0,
      0,
      476,
      477,
      5,
      99,
      0,
      0,
      477,
      478,
      5,
      116,
      0,
      0,
      478,
      479,
      5,
      105,
      0,
      0,
      479,
      480,
      5,
      111,
      0,
      0,
      480,
      481,
      5,
      110,
      0,
      0,
      481,
      8,
      1,
      0,
      0,
      0,
      482,
      483,
      5,
      97,
      0,
      0,
      483,
      484,
      5,
      99,
      0,
      0,
      484,
      485,
      5,
      116,
      0,
      0,
      485,
      486,
      5,
      111,
      0,
      0,
      486,
      487,
      5,
      114,
      0,
      0,
      487,
      10,
      1,
      0,
      0,
      0,
      488,
      489,
      5,
      97,
      0,
      0,
      489,
      490,
      5,
      102,
      0,
      0,
      490,
      491,
      5,
      116,
      0,
      0,
      491,
      492,
      5,
      101,
      0,
      0,
      492,
      493,
      5,
      114,
      0,
      0,
      493,
      12,
      1,
      0,
      0,
      0,
      494,
      495,
      5,
      97,
      0,
      0,
      495,
      496,
      5,
      108,
      0,
      0,
      496,
      497,
      5,
      105,
      0,
      0,
      497,
      498,
      5,
      97,
      0,
      0,
      498,
      499,
      5,
      115,
      0,
      0,
      499,
      14,
      1,
      0,
      0,
      0,
      500,
      501,
      5,
      97,
      0,
      0,
      501,
      502,
      5,
      108,
      0,
      0,
      502,
      503,
      5,
      108,
      0,
      0,
      503,
      16,
      1,
      0,
      0,
      0,
      504,
      505,
      5,
      97,
      0,
      0,
      505,
      506,
      5,
      108,
      0,
      0,
      506,
      507,
      5,
      108,
      0,
      0,
      507,
      508,
      5,
      111,
      0,
      0,
      508,
      509,
      5,
      99,
      0,
      0,
      509,
      510,
      5,
      97,
      0,
      0,
      510,
      511,
      5,
      116,
      0,
      0,
      511,
      512,
      5,
      101,
      0,
      0,
      512,
      18,
      1,
      0,
      0,
      0,
      513,
      514,
      5,
      97,
      0,
      0,
      514,
      515,
      5,
      108,
      0,
      0,
      515,
      516,
      5,
      108,
      0,
      0,
      516,
      517,
      5,
      111,
      0,
      0,
      517,
      518,
      5,
      99,
      0,
      0,
      518,
      519,
      5,
      97,
      0,
      0,
      519,
      520,
      5,
      116,
      0,
      0,
      520,
      521,
      5,
      105,
      0,
      0,
      521,
      522,
      5,
      111,
      0,
      0,
      522,
      523,
      5,
      110,
      0,
      0,
      523,
      20,
      1,
      0,
      0,
      0,
      524,
      525,
      5,
      97,
      0,
      0,
      525,
      526,
      5,
      110,
      0,
      0,
      526,
      527,
      5,
      97,
      0,
      0,
      527,
      528,
      5,
      108,
      0,
      0,
      528,
      529,
      5,
      121,
      0,
      0,
      529,
      530,
      5,
      115,
      0,
      0,
      530,
      531,
      5,
      105,
      0,
      0,
      531,
      532,
      5,
      115,
      0,
      0,
      532,
      22,
      1,
      0,
      0,
      0,
      533,
      534,
      5,
      97,
      0,
      0,
      534,
      535,
      5,
      110,
      0,
      0,
      535,
      536,
      5,
      100,
      0,
      0,
      536,
      24,
      1,
      0,
      0,
      0,
      537,
      538,
      5,
      97,
      0,
      0,
      538,
      539,
      5,
      115,
      0,
      0,
      539,
      26,
      1,
      0,
      0,
      0,
      540,
      541,
      5,
      97,
      0,
      0,
      541,
      542,
      5,
      115,
      0,
      0,
      542,
      543,
      5,
      115,
      0,
      0,
      543,
      544,
      5,
      101,
      0,
      0,
      544,
      545,
      5,
      114,
      0,
      0,
      545,
      546,
      5,
      116,
      0,
      0,
      546,
      28,
      1,
      0,
      0,
      0,
      547,
      548,
      5,
      97,
      0,
      0,
      548,
      549,
      5,
      115,
      0,
      0,
      549,
      550,
      5,
      115,
      0,
      0,
      550,
      551,
      5,
      105,
      0,
      0,
      551,
      552,
      5,
      103,
      0,
      0,
      552,
      553,
      5,
      110,
      0,
      0,
      553,
      30,
      1,
      0,
      0,
      0,
      554,
      555,
      5,
      97,
      0,
      0,
      555,
      556,
      5,
      115,
      0,
      0,
      556,
      557,
      5,
      115,
      0,
      0,
      557,
      558,
      5,
      111,
      0,
      0,
      558,
      559,
      5,
      99,
      0,
      0,
      559,
      32,
      1,
      0,
      0,
      0,
      560,
      561,
      5,
      97,
      0,
      0,
      561,
      562,
      5,
      115,
      0,
      0,
      562,
      563,
      5,
      115,
      0,
      0,
      563,
      564,
      5,
      117,
      0,
      0,
      564,
      565,
      5,
      109,
      0,
      0,
      565,
      566,
      5,
      101,
      0,
      0,
      566,
      34,
      1,
      0,
      0,
      0,
      567,
      568,
      5,
      97,
      0,
      0,
      568,
      569,
      5,
      116,
      0,
      0,
      569,
      36,
      1,
      0,
      0,
      0,
      570,
      571,
      5,
      97,
      0,
      0,
      571,
      572,
      5,
      116,
      0,
      0,
      572,
      573,
      5,
      116,
      0,
      0,
      573,
      574,
      5,
      114,
      0,
      0,
      574,
      575,
      5,
      105,
      0,
      0,
      575,
      576,
      5,
      98,
      0,
      0,
      576,
      577,
      5,
      117,
      0,
      0,
      577,
      578,
      5,
      116,
      0,
      0,
      578,
      579,
      5,
      101,
      0,
      0,
      579,
      38,
      1,
      0,
      0,
      0,
      580,
      581,
      5,
      98,
      0,
      0,
      581,
      582,
      5,
      101,
      0,
      0,
      582,
      583,
      5,
      104,
      0,
      0,
      583,
      584,
      5,
      97,
      0,
      0,
      584,
      585,
      5,
      118,
      0,
      0,
      585,
      586,
      5,
      105,
      0,
      0,
      586,
      587,
      5,
      111,
      0,
      0,
      587,
      588,
      5,
      114,
      0,
      0,
      588,
      40,
      1,
      0,
      0,
      0,
      589,
      590,
      5,
      98,
      0,
      0,
      590,
      591,
      5,
      105,
      0,
      0,
      591,
      592,
      5,
      110,
      0,
      0,
      592,
      593,
      5,
      100,
      0,
      0,
      593,
      42,
      1,
      0,
      0,
      0,
      594,
      595,
      5,
      98,
      0,
      0,
      595,
      596,
      5,
      105,
      0,
      0,
      596,
      597,
      5,
      110,
      0,
      0,
      597,
      598,
      5,
      100,
      0,
      0,
      598,
      599,
      5,
      105,
      0,
      0,
      599,
      600,
      5,
      110,
      0,
      0,
      600,
      601,
      5,
      103,
      0,
      0,
      601,
      44,
      1,
      0,
      0,
      0,
      602,
      603,
      5,
      98,
      0,
      0,
      603,
      604,
      5,
      111,
      0,
      0,
      604,
      605,
      5,
      111,
      0,
      0,
      605,
      606,
      5,
      108,
      0,
      0,
      606,
      46,
      1,
      0,
      0,
      0,
      607,
      608,
      5,
      98,
      0,
      0,
      608,
      609,
      5,
      121,
      0,
      0,
      609,
      48,
      1,
      0,
      0,
      0,
      610,
      611,
      5,
      99,
      0,
      0,
      611,
      612,
      5,
      97,
      0,
      0,
      612,
      613,
      5,
      108,
      0,
      0,
      613,
      614,
      5,
      99,
      0,
      0,
      614,
      50,
      1,
      0,
      0,
      0,
      615,
      616,
      5,
      99,
      0,
      0,
      616,
      617,
      5,
      97,
      0,
      0,
      617,
      618,
      5,
      115,
      0,
      0,
      618,
      619,
      5,
      101,
      0,
      0,
      619,
      52,
      1,
      0,
      0,
      0,
      620,
      621,
      5,
      99,
      0,
      0,
      621,
      622,
      5,
      104,
      0,
      0,
      622,
      623,
      5,
      97,
      0,
      0,
      623,
      624,
      5,
      105,
      0,
      0,
      624,
      625,
      5,
      110,
      0,
      0,
      625,
      626,
      5,
      115,
      0,
      0,
      626,
      54,
      1,
      0,
      0,
      0,
      627,
      628,
      5,
      99,
      0,
      0,
      628,
      629,
      5,
      108,
      0,
      0,
      629,
      630,
      5,
      97,
      0,
      0,
      630,
      631,
      5,
      115,
      0,
      0,
      631,
      632,
      5,
      115,
      0,
      0,
      632,
      56,
      1,
      0,
      0,
      0,
      633,
      634,
      5,
      99,
      0,
      0,
      634,
      635,
      5,
      108,
      0,
      0,
      635,
      636,
      5,
      97,
      0,
      0,
      636,
      637,
      5,
      115,
      0,
      0,
      637,
      638,
      5,
      115,
      0,
      0,
      638,
      639,
      5,
      105,
      0,
      0,
      639,
      640,
      5,
      102,
      0,
      0,
      640,
      641,
      5,
      105,
      0,
      0,
      641,
      642,
      5,
      101,
      0,
      0,
      642,
      643,
      5,
      114,
      0,
      0,
      643,
      58,
      1,
      0,
      0,
      0,
      644,
      645,
      5,
      99,
      0,
      0,
      645,
      646,
      5,
      111,
      0,
      0,
      646,
      647,
      5,
      109,
      0,
      0,
      647,
      648,
      5,
      109,
      0,
      0,
      648,
      649,
      5,
      101,
      0,
      0,
      649,
      650,
      5,
      110,
      0,
      0,
      650,
      651,
      5,
      116,
      0,
      0,
      651,
      60,
      1,
      0,
      0,
      0,
      652,
      653,
      5,
      99,
      0,
      0,
      653,
      654,
      5,
      111,
      0,
      0,
      654,
      655,
      5,
      109,
      0,
      0,
      655,
      656,
      5,
      112,
      0,
      0,
      656,
      657,
      5,
      111,
      0,
      0,
      657,
      658,
      5,
      115,
      0,
      0,
      658,
      659,
      5,
      105,
      0,
      0,
      659,
      660,
      5,
      116,
      0,
      0,
      660,
      661,
      5,
      101,
      0,
      0,
      661,
      62,
      1,
      0,
      0,
      0,
      662,
      663,
      5,
      99,
      0,
      0,
      663,
      664,
      5,
      111,
      0,
      0,
      664,
      665,
      5,
      110,
      0,
      0,
      665,
      666,
      5,
      99,
      0,
      0,
      666,
      667,
      5,
      101,
      0,
      0,
      667,
      668,
      5,
      114,
      0,
      0,
      668,
      669,
      5,
      110,
      0,
      0,
      669,
      64,
      1,
      0,
      0,
      0,
      670,
      671,
      5,
      99,
      0,
      0,
      671,
      672,
      5,
      111,
      0,
      0,
      672,
      673,
      5,
      110,
      0,
      0,
      673,
      674,
      5,
      106,
      0,
      0,
      674,
      675,
      5,
      117,
      0,
      0,
      675,
      676,
      5,
      103,
      0,
      0,
      676,
      677,
      5,
      97,
      0,
      0,
      677,
      678,
      5,
      116,
      0,
      0,
      678,
      679,
      5,
      101,
      0,
      0,
      679,
      66,
      1,
      0,
      0,
      0,
      680,
      681,
      5,
      99,
      0,
      0,
      681,
      682,
      5,
      111,
      0,
      0,
      682,
      683,
      5,
      110,
      0,
      0,
      683,
      684,
      5,
      106,
      0,
      0,
      684,
      685,
      5,
      117,
      0,
      0,
      685,
      686,
      5,
      103,
      0,
      0,
      686,
      687,
      5,
      97,
      0,
      0,
      687,
      688,
      5,
      116,
      0,
      0,
      688,
      689,
      5,
      101,
      0,
      0,
      689,
      690,
      5,
      115,
      0,
      0,
      690,
      68,
      1,
      0,
      0,
      0,
      691,
      692,
      5,
      99,
      0,
      0,
      692,
      693,
      5,
      111,
      0,
      0,
      693,
      694,
      5,
      110,
      0,
      0,
      694,
      695,
      5,
      106,
      0,
      0,
      695,
      696,
      5,
      117,
      0,
      0,
      696,
      697,
      5,
      103,
      0,
      0,
      697,
      698,
      5,
      97,
      0,
      0,
      698,
      699,
      5,
      116,
      0,
      0,
      699,
      700,
      5,
      105,
      0,
      0,
      700,
      701,
      5,
      111,
      0,
      0,
      701,
      702,
      5,
      110,
      0,
      0,
      702,
      70,
      1,
      0,
      0,
      0,
      703,
      704,
      5,
      99,
      0,
      0,
      704,
      705,
      5,
      111,
      0,
      0,
      705,
      706,
      5,
      110,
      0,
      0,
      706,
      707,
      5,
      110,
      0,
      0,
      707,
      708,
      5,
      101,
      0,
      0,
      708,
      709,
      5,
      99,
      0,
      0,
      709,
      710,
      5,
      116,
      0,
      0,
      710,
      72,
      1,
      0,
      0,
      0,
      711,
      712,
      5,
      99,
      0,
      0,
      712,
      713,
      5,
      111,
      0,
      0,
      713,
      714,
      5,
      110,
      0,
      0,
      714,
      715,
      5,
      110,
      0,
      0,
      715,
      716,
      5,
      101,
      0,
      0,
      716,
      717,
      5,
      99,
      0,
      0,
      717,
      718,
      5,
      116,
      0,
      0,
      718,
      719,
      5,
      105,
      0,
      0,
      719,
      720,
      5,
      111,
      0,
      0,
      720,
      721,
      5,
      110,
      0,
      0,
      721,
      74,
      1,
      0,
      0,
      0,
      722,
      723,
      5,
      99,
      0,
      0,
      723,
      724,
      5,
      111,
      0,
      0,
      724,
      725,
      5,
      110,
      0,
      0,
      725,
      726,
      5,
      110,
      0,
      0,
      726,
      727,
      5,
      101,
      0,
      0,
      727,
      728,
      5,
      99,
      0,
      0,
      728,
      729,
      5,
      116,
      0,
      0,
      729,
      730,
      5,
      111,
      0,
      0,
      730,
      731,
      5,
      114,
      0,
      0,
      731,
      76,
      1,
      0,
      0,
      0,
      732,
      733,
      5,
      99,
      0,
      0,
      733,
      734,
      5,
      111,
      0,
      0,
      734,
      735,
      5,
      110,
      0,
      0,
      735,
      736,
      5,
      115,
      0,
      0,
      736,
      737,
      5,
      116,
      0,
      0,
      737,
      78,
      1,
      0,
      0,
      0,
      738,
      739,
      5,
      99,
      0,
      0,
      739,
      740,
      5,
      111,
      0,
      0,
      740,
      741,
      5,
      110,
      0,
      0,
      741,
      742,
      5,
      115,
      0,
      0,
      742,
      743,
      5,
      116,
      0,
      0,
      743,
      744,
      5,
      97,
      0,
      0,
      744,
      745,
      5,
      110,
      0,
      0,
      745,
      746,
      5,
      116,
      0,
      0,
      746,
      80,
      1,
      0,
      0,
      0,
      747,
      748,
      5,
      99,
      0,
      0,
      748,
      749,
      5,
      111,
      0,
      0,
      749,
      750,
      5,
      110,
      0,
      0,
      750,
      751,
      5,
      115,
      0,
      0,
      751,
      752,
      5,
      116,
      0,
      0,
      752,
      753,
      5,
      114,
      0,
      0,
      753,
      754,
      5,
      97,
      0,
      0,
      754,
      755,
      5,
      105,
      0,
      0,
      755,
      756,
      5,
      110,
      0,
      0,
      756,
      757,
      5,
      116,
      0,
      0,
      757,
      82,
      1,
      0,
      0,
      0,
      758,
      759,
      5,
      99,
      0,
      0,
      759,
      760,
      5,
      114,
      0,
      0,
      760,
      761,
      5,
      111,
      0,
      0,
      761,
      762,
      5,
      115,
      0,
      0,
      762,
      763,
      5,
      115,
      0,
      0,
      763,
      764,
      5,
      101,
      0,
      0,
      764,
      765,
      5,
      115,
      0,
      0,
      765,
      84,
      1,
      0,
      0,
      0,
      766,
      767,
      5,
      100,
      0,
      0,
      767,
      768,
      5,
      97,
      0,
      0,
      768,
      769,
      5,
      116,
      0,
      0,
      769,
      770,
      5,
      97,
      0,
      0,
      770,
      771,
      5,
      116,
      0,
      0,
      771,
      772,
      5,
      121,
      0,
      0,
      772,
      773,
      5,
      112,
      0,
      0,
      773,
      774,
      5,
      101,
      0,
      0,
      774,
      86,
      1,
      0,
      0,
      0,
      775,
      776,
      5,
      100,
      0,
      0,
      776,
      777,
      5,
      101,
      0,
      0,
      777,
      778,
      5,
      99,
      0,
      0,
      778,
      779,
      5,
      105,
      0,
      0,
      779,
      780,
      5,
      100,
      0,
      0,
      780,
      781,
      5,
      101,
      0,
      0,
      781,
      88,
      1,
      0,
      0,
      0,
      782,
      783,
      5,
      100,
      0,
      0,
      783,
      784,
      5,
      101,
      0,
      0,
      784,
      785,
      5,
      102,
      0,
      0,
      785,
      90,
      1,
      0,
      0,
      0,
      786,
      787,
      5,
      100,
      0,
      0,
      787,
      788,
      5,
      101,
      0,
      0,
      788,
      789,
      5,
      102,
      0,
      0,
      789,
      790,
      5,
      97,
      0,
      0,
      790,
      791,
      5,
      117,
      0,
      0,
      791,
      792,
      5,
      108,
      0,
      0,
      792,
      793,
      5,
      116,
      0,
      0,
      793,
      92,
      1,
      0,
      0,
      0,
      794,
      795,
      5,
      100,
      0,
      0,
      795,
      796,
      5,
      101,
      0,
      0,
      796,
      797,
      5,
      102,
      0,
      0,
      797,
      798,
      5,
      105,
      0,
      0,
      798,
      799,
      5,
      110,
      0,
      0,
      799,
      800,
      5,
      101,
      0,
      0,
      800,
      801,
      5,
      100,
      0,
      0,
      801,
      94,
      1,
      0,
      0,
      0,
      802,
      803,
      5,
      100,
      0,
      0,
      803,
      804,
      5,
      101,
      0,
      0,
      804,
      805,
      5,
      112,
      0,
      0,
      805,
      806,
      5,
      101,
      0,
      0,
      806,
      807,
      5,
      110,
      0,
      0,
      807,
      808,
      5,
      100,
      0,
      0,
      808,
      809,
      5,
      101,
      0,
      0,
      809,
      810,
      5,
      110,
      0,
      0,
      810,
      811,
      5,
      99,
      0,
      0,
      811,
      812,
      5,
      121,
      0,
      0,
      812,
      96,
      1,
      0,
      0,
      0,
      813,
      814,
      5,
      100,
      0,
      0,
      814,
      815,
      5,
      101,
      0,
      0,
      815,
      816,
      5,
      114,
      0,
      0,
      816,
      817,
      5,
      105,
      0,
      0,
      817,
      818,
      5,
      118,
      0,
      0,
      818,
      819,
      5,
      101,
      0,
      0,
      819,
      820,
      5,
      100,
      0,
      0,
      820,
      98,
      1,
      0,
      0,
      0,
      821,
      822,
      5,
      100,
      0,
      0,
      822,
      823,
      5,
      105,
      0,
      0,
      823,
      824,
      5,
      102,
      0,
      0,
      824,
      825,
      5,
      102,
      0,
      0,
      825,
      826,
      5,
      101,
      0,
      0,
      826,
      827,
      5,
      114,
      0,
      0,
      827,
      828,
      5,
      101,
      0,
      0,
      828,
      829,
      5,
      110,
      0,
      0,
      829,
      830,
      5,
      99,
      0,
      0,
      830,
      831,
      5,
      101,
      0,
      0,
      831,
      832,
      5,
      115,
      0,
      0,
      832,
      100,
      1,
      0,
      0,
      0,
      833,
      834,
      5,
      100,
      0,
      0,
      834,
      835,
      5,
      105,
      0,
      0,
      835,
      836,
      5,
      115,
      0,
      0,
      836,
      837,
      5,
      106,
      0,
      0,
      837,
      838,
      5,
      111,
      0,
      0,
      838,
      839,
      5,
      105,
      0,
      0,
      839,
      840,
      5,
      110,
      0,
      0,
      840,
      841,
      5,
      105,
      0,
      0,
      841,
      842,
      5,
      110,
      0,
      0,
      842,
      843,
      5,
      103,
      0,
      0,
      843,
      102,
      1,
      0,
      0,
      0,
      844,
      845,
      5,
      100,
      0,
      0,
      845,
      846,
      5,
      105,
      0,
      0,
      846,
      847,
      5,
      115,
      0,
      0,
      847,
      848,
      5,
      106,
      0,
      0,
      848,
      849,
      5,
      111,
      0,
      0,
      849,
      850,
      5,
      105,
      0,
      0,
      850,
      851,
      5,
      110,
      0,
      0,
      851,
      852,
      5,
      116,
      0,
      0,
      852,
      104,
      1,
      0,
      0,
      0,
      853,
      854,
      5,
      100,
      0,
      0,
      854,
      855,
      5,
      111,
      0,
      0,
      855,
      106,
      1,
      0,
      0,
      0,
      856,
      857,
      5,
      100,
      0,
      0,
      857,
      858,
      5,
      111,
      0,
      0,
      858,
      859,
      5,
      99,
      0,
      0,
      859,
      108,
      1,
      0,
      0,
      0,
      860,
      861,
      5,
      101,
      0,
      0,
      861,
      862,
      5,
      108,
      0,
      0,
      862,
      863,
      5,
      115,
      0,
      0,
      863,
      864,
      5,
      101,
      0,
      0,
      864,
      110,
      1,
      0,
      0,
      0,
      865,
      866,
      5,
      101,
      0,
      0,
      866,
      867,
      5,
      110,
      0,
      0,
      867,
      868,
      5,
      100,
      0,
      0,
      868,
      112,
      1,
      0,
      0,
      0,
      869,
      870,
      5,
      101,
      0,
      0,
      870,
      871,
      5,
      110,
      0,
      0,
      871,
      872,
      5,
      116,
      0,
      0,
      872,
      873,
      5,
      114,
      0,
      0,
      873,
      874,
      5,
      121,
      0,
      0,
      874,
      114,
      1,
      0,
      0,
      0,
      875,
      876,
      5,
      101,
      0,
      0,
      876,
      877,
      5,
      110,
      0,
      0,
      877,
      878,
      5,
      117,
      0,
      0,
      878,
      879,
      5,
      109,
      0,
      0,
      879,
      116,
      1,
      0,
      0,
      0,
      880,
      881,
      5,
      101,
      0,
      0,
      881,
      882,
      5,
      118,
      0,
      0,
      882,
      883,
      5,
      101,
      0,
      0,
      883,
      884,
      5,
      110,
      0,
      0,
      884,
      885,
      5,
      116,
      0,
      0,
      885,
      118,
      1,
      0,
      0,
      0,
      886,
      887,
      5,
      101,
      0,
      0,
      887,
      888,
      5,
      120,
      0,
      0,
      888,
      889,
      5,
      104,
      0,
      0,
      889,
      890,
      5,
      105,
      0,
      0,
      890,
      891,
      5,
      98,
      0,
      0,
      891,
      892,
      5,
      105,
      0,
      0,
      892,
      893,
      5,
      116,
      0,
      0,
      893,
      120,
      1,
      0,
      0,
      0,
      894,
      895,
      5,
      101,
      0,
      0,
      895,
      896,
      5,
      120,
      0,
      0,
      896,
      897,
      5,
      105,
      0,
      0,
      897,
      898,
      5,
      116,
      0,
      0,
      898,
      122,
      1,
      0,
      0,
      0,
      899,
      900,
      5,
      101,
      0,
      0,
      900,
      901,
      5,
      120,
      0,
      0,
      901,
      902,
      5,
      112,
      0,
      0,
      902,
      903,
      5,
      111,
      0,
      0,
      903,
      904,
      5,
      115,
      0,
      0,
      904,
      905,
      5,
      101,
      0,
      0,
      905,
      124,
      1,
      0,
      0,
      0,
      906,
      907,
      5,
      101,
      0,
      0,
      907,
      908,
      5,
      120,
      0,
      0,
      908,
      909,
      5,
      112,
      0,
      0,
      909,
      910,
      5,
      114,
      0,
      0,
      910,
      126,
      1,
      0,
      0,
      0,
      911,
      912,
      5,
      102,
      0,
      0,
      912,
      913,
      5,
      97,
      0,
      0,
      913,
      914,
      5,
      108,
      0,
      0,
      914,
      915,
      5,
      115,
      0,
      0,
      915,
      916,
      5,
      101,
      0,
      0,
      916,
      128,
      1,
      0,
      0,
      0,
      917,
      918,
      5,
      102,
      0,
      0,
      918,
      919,
      5,
      101,
      0,
      0,
      919,
      920,
      5,
      97,
      0,
      0,
      920,
      921,
      5,
      116,
      0,
      0,
      921,
      922,
      5,
      117,
      0,
      0,
      922,
      923,
      5,
      114,
      0,
      0,
      923,
      924,
      5,
      101,
      0,
      0,
      924,
      130,
      1,
      0,
      0,
      0,
      925,
      926,
      5,
      102,
      0,
      0,
      926,
      927,
      5,
      101,
      0,
      0,
      927,
      928,
      5,
      97,
      0,
      0,
      928,
      929,
      5,
      116,
      0,
      0,
      929,
      930,
      5,
      117,
      0,
      0,
      930,
      931,
      5,
      114,
      0,
      0,
      931,
      932,
      5,
      101,
      0,
      0,
      932,
      933,
      5,
      100,
      0,
      0,
      933,
      132,
      1,
      0,
      0,
      0,
      934,
      935,
      5,
      102,
      0,
      0,
      935,
      936,
      5,
      101,
      0,
      0,
      936,
      937,
      5,
      97,
      0,
      0,
      937,
      938,
      5,
      116,
      0,
      0,
      938,
      939,
      5,
      117,
      0,
      0,
      939,
      940,
      5,
      114,
      0,
      0,
      940,
      941,
      5,
      105,
      0,
      0,
      941,
      942,
      5,
      110,
      0,
      0,
      942,
      943,
      5,
      103,
      0,
      0,
      943,
      134,
      1,
      0,
      0,
      0,
      944,
      945,
      5,
      102,
      0,
      0,
      945,
      946,
      5,
      105,
      0,
      0,
      946,
      947,
      5,
      108,
      0,
      0,
      947,
      948,
      5,
      116,
      0,
      0,
      948,
      949,
      5,
      101,
      0,
      0,
      949,
      950,
      5,
      114,
      0,
      0,
      950,
      136,
      1,
      0,
      0,
      0,
      951,
      952,
      5,
      102,
      0,
      0,
      952,
      953,
      5,
      105,
      0,
      0,
      953,
      954,
      5,
      114,
      0,
      0,
      954,
      955,
      5,
      115,
      0,
      0,
      955,
      956,
      5,
      116,
      0,
      0,
      956,
      138,
      1,
      0,
      0,
      0,
      957,
      958,
      5,
      102,
      0,
      0,
      958,
      959,
      5,
      108,
      0,
      0,
      959,
      960,
      5,
      111,
      0,
      0,
      960,
      961,
      5,
      119,
      0,
      0,
      961,
      140,
      1,
      0,
      0,
      0,
      962,
      963,
      5,
      102,
      0,
      0,
      963,
      964,
      5,
      111,
      0,
      0,
      964,
      965,
      5,
      114,
      0,
      0,
      965,
      142,
      1,
      0,
      0,
      0,
      966,
      967,
      5,
      102,
      0,
      0,
      967,
      968,
      5,
      111,
      0,
      0,
      968,
      969,
      5,
      114,
      0,
      0,
      969,
      970,
      5,
      107,
      0,
      0,
      970,
      144,
      1,
      0,
      0,
      0,
      971,
      972,
      5,
      102,
      0,
      0,
      972,
      973,
      5,
      114,
      0,
      0,
      973,
      974,
      5,
      97,
      0,
      0,
      974,
      975,
      5,
      109,
      0,
      0,
      975,
      976,
      5,
      101,
      0,
      0,
      976,
      146,
      1,
      0,
      0,
      0,
      977,
      978,
      5,
      102,
      0,
      0,
      978,
      979,
      5,
      114,
      0,
      0,
      979,
      980,
      5,
      111,
      0,
      0,
      980,
      981,
      5,
      109,
      0,
      0,
      981,
      148,
      1,
      0,
      0,
      0,
      982,
      983,
      5,
      102,
      0,
      0,
      983,
      984,
      5,
      117,
      0,
      0,
      984,
      985,
      5,
      110,
      0,
      0,
      985,
      986,
      5,
      99,
      0,
      0,
      986,
      987,
      5,
      116,
      0,
      0,
      987,
      988,
      5,
      105,
      0,
      0,
      988,
      989,
      5,
      111,
      0,
      0,
      989,
      990,
      5,
      110,
      0,
      0,
      990,
      150,
      1,
      0,
      0,
      0,
      991,
      992,
      5,
      104,
      0,
      0,
      992,
      993,
      5,
      97,
      0,
      0,
      993,
      994,
      5,
      115,
      0,
      0,
      994,
      995,
      5,
      116,
      0,
      0,
      995,
      996,
      5,
      121,
      0,
      0,
      996,
      997,
      5,
      112,
      0,
      0,
      997,
      998,
      5,
      101,
      0,
      0,
      998,
      152,
      1,
      0,
      0,
      0,
      999,
      1e3,
      5,
      105,
      0,
      0,
      1e3,
      1001,
      5,
      102,
      0,
      0,
      1001,
      154,
      1,
      0,
      0,
      0,
      1002,
      1003,
      5,
      105,
      0,
      0,
      1003,
      1004,
      5,
      109,
      0,
      0,
      1004,
      1005,
      5,
      112,
      0,
      0,
      1005,
      1006,
      5,
      108,
      0,
      0,
      1006,
      1007,
      5,
      105,
      0,
      0,
      1007,
      1008,
      5,
      101,
      0,
      0,
      1008,
      1009,
      5,
      115,
      0,
      0,
      1009,
      156,
      1,
      0,
      0,
      0,
      1010,
      1011,
      5,
      105,
      0,
      0,
      1011,
      1012,
      5,
      109,
      0,
      0,
      1012,
      1013,
      5,
      112,
      0,
      0,
      1013,
      1014,
      5,
      111,
      0,
      0,
      1014,
      1015,
      5,
      114,
      0,
      0,
      1015,
      1016,
      5,
      116,
      0,
      0,
      1016,
      158,
      1,
      0,
      0,
      0,
      1017,
      1018,
      5,
      105,
      0,
      0,
      1018,
      1019,
      5,
      110,
      0,
      0,
      1019,
      160,
      1,
      0,
      0,
      0,
      1020,
      1021,
      5,
      105,
      0,
      0,
      1021,
      1022,
      5,
      110,
      0,
      0,
      1022,
      1023,
      5,
      99,
      0,
      0,
      1023,
      1024,
      5,
      108,
      0,
      0,
      1024,
      1025,
      5,
      117,
      0,
      0,
      1025,
      1026,
      5,
      100,
      0,
      0,
      1026,
      1027,
      5,
      101,
      0,
      0,
      1027,
      162,
      1,
      0,
      0,
      0,
      1028,
      1029,
      5,
      105,
      0,
      0,
      1029,
      1030,
      5,
      110,
      0,
      0,
      1030,
      1031,
      5,
      100,
      0,
      0,
      1031,
      1032,
      5,
      105,
      0,
      0,
      1032,
      1033,
      5,
      118,
      0,
      0,
      1033,
      1034,
      5,
      105,
      0,
      0,
      1034,
      1035,
      5,
      100,
      0,
      0,
      1035,
      1036,
      5,
      117,
      0,
      0,
      1036,
      1037,
      5,
      97,
      0,
      0,
      1037,
      1038,
      5,
      108,
      0,
      0,
      1038,
      164,
      1,
      0,
      0,
      0,
      1039,
      1040,
      5,
      105,
      0,
      0,
      1040,
      1041,
      5,
      110,
      0,
      0,
      1041,
      1042,
      5,
      111,
      0,
      0,
      1042,
      1043,
      5,
      117,
      0,
      0,
      1043,
      1044,
      5,
      116,
      0,
      0,
      1044,
      166,
      1,
      0,
      0,
      0,
      1045,
      1046,
      5,
      105,
      0,
      0,
      1046,
      1047,
      5,
      110,
      0,
      0,
      1047,
      1048,
      5,
      116,
      0,
      0,
      1048,
      1049,
      5,
      101,
      0,
      0,
      1049,
      1050,
      5,
      114,
      0,
      0,
      1050,
      1051,
      5,
      97,
      0,
      0,
      1051,
      1052,
      5,
      99,
      0,
      0,
      1052,
      1053,
      5,
      116,
      0,
      0,
      1053,
      1054,
      5,
      105,
      0,
      0,
      1054,
      1055,
      5,
      111,
      0,
      0,
      1055,
      1056,
      5,
      110,
      0,
      0,
      1056,
      168,
      1,
      0,
      0,
      0,
      1057,
      1058,
      5,
      105,
      0,
      0,
      1058,
      1059,
      5,
      110,
      0,
      0,
      1059,
      1060,
      5,
      116,
      0,
      0,
      1060,
      1061,
      5,
      101,
      0,
      0,
      1061,
      1062,
      5,
      114,
      0,
      0,
      1062,
      1063,
      5,
      102,
      0,
      0,
      1063,
      1064,
      5,
      97,
      0,
      0,
      1064,
      1065,
      5,
      99,
      0,
      0,
      1065,
      1066,
      5,
      101,
      0,
      0,
      1066,
      170,
      1,
      0,
      0,
      0,
      1067,
      1068,
      5,
      105,
      0,
      0,
      1068,
      1069,
      5,
      110,
      0,
      0,
      1069,
      1070,
      5,
      116,
      0,
      0,
      1070,
      1071,
      5,
      101,
      0,
      0,
      1071,
      1072,
      5,
      114,
      0,
      0,
      1072,
      1073,
      5,
      115,
      0,
      0,
      1073,
      1074,
      5,
      101,
      0,
      0,
      1074,
      1075,
      5,
      99,
      0,
      0,
      1075,
      1076,
      5,
      116,
      0,
      0,
      1076,
      1077,
      5,
      115,
      0,
      0,
      1077,
      172,
      1,
      0,
      0,
      0,
      1078,
      1079,
      5,
      105,
      0,
      0,
      1079,
      1080,
      5,
      110,
      0,
      0,
      1080,
      1081,
      5,
      118,
      0,
      0,
      1081,
      174,
      1,
      0,
      0,
      0,
      1082,
      1083,
      5,
      105,
      0,
      0,
      1083,
      1084,
      5,
      110,
      0,
      0,
      1084,
      1085,
      5,
      118,
      0,
      0,
      1085,
      1086,
      5,
      101,
      0,
      0,
      1086,
      1087,
      5,
      114,
      0,
      0,
      1087,
      1088,
      5,
      115,
      0,
      0,
      1088,
      1089,
      5,
      101,
      0,
      0,
      1089,
      176,
      1,
      0,
      0,
      0,
      1090,
      1091,
      5,
      105,
      0,
      0,
      1091,
      1092,
      5,
      110,
      0,
      0,
      1092,
      1093,
      5,
      118,
      0,
      0,
      1093,
      1094,
      5,
      101,
      0,
      0,
      1094,
      1095,
      5,
      114,
      0,
      0,
      1095,
      1096,
      5,
      116,
      0,
      0,
      1096,
      1097,
      5,
      105,
      0,
      0,
      1097,
      1098,
      5,
      110,
      0,
      0,
      1098,
      1099,
      5,
      103,
      0,
      0,
      1099,
      178,
      1,
      0,
      0,
      0,
      1100,
      1101,
      5,
      105,
      0,
      0,
      1101,
      1102,
      5,
      115,
      0,
      0,
      1102,
      1103,
      5,
      116,
      0,
      0,
      1103,
      1104,
      5,
      121,
      0,
      0,
      1104,
      1105,
      5,
      112,
      0,
      0,
      1105,
      1106,
      5,
      101,
      0,
      0,
      1106,
      180,
      1,
      0,
      0,
      0,
      1107,
      1108,
      5,
      105,
      0,
      0,
      1108,
      1109,
      5,
      116,
      0,
      0,
      1109,
      1110,
      5,
      101,
      0,
      0,
      1110,
      1111,
      5,
      109,
      0,
      0,
      1111,
      182,
      1,
      0,
      0,
      0,
      1112,
      1113,
      5,
      106,
      0,
      0,
      1113,
      1114,
      5,
      111,
      0,
      0,
      1114,
      1115,
      5,
      105,
      0,
      0,
      1115,
      1116,
      5,
      110,
      0,
      0,
      1116,
      184,
      1,
      0,
      0,
      0,
      1117,
      1118,
      5,
      108,
      0,
      0,
      1118,
      1119,
      5,
      97,
      0,
      0,
      1119,
      1120,
      5,
      110,
      0,
      0,
      1120,
      1121,
      5,
      103,
      0,
      0,
      1121,
      1122,
      5,
      117,
      0,
      0,
      1122,
      1123,
      5,
      97,
      0,
      0,
      1123,
      1124,
      5,
      103,
      0,
      0,
      1124,
      1125,
      5,
      101,
      0,
      0,
      1125,
      186,
      1,
      0,
      0,
      0,
      1126,
      1127,
      5,
      108,
      0,
      0,
      1127,
      1128,
      5,
      105,
      0,
      0,
      1128,
      1129,
      5,
      98,
      0,
      0,
      1129,
      1130,
      5,
      114,
      0,
      0,
      1130,
      1131,
      5,
      97,
      0,
      0,
      1131,
      1132,
      5,
      114,
      0,
      0,
      1132,
      1133,
      5,
      121,
      0,
      0,
      1133,
      188,
      1,
      0,
      0,
      0,
      1134,
      1135,
      5,
      108,
      0,
      0,
      1135,
      1136,
      5,
      111,
      0,
      0,
      1136,
      1137,
      5,
      99,
      0,
      0,
      1137,
      1138,
      5,
      97,
      0,
      0,
      1138,
      1139,
      5,
      108,
      0,
      0,
      1139,
      1140,
      5,
      101,
      0,
      0,
      1140,
      190,
      1,
      0,
      0,
      0,
      1141,
      1142,
      5,
      108,
      0,
      0,
      1142,
      1143,
      5,
      111,
      0,
      0,
      1143,
      1144,
      5,
      111,
      0,
      0,
      1144,
      1145,
      5,
      112,
      0,
      0,
      1145,
      192,
      1,
      0,
      0,
      0,
      1146,
      1147,
      5,
      109,
      0,
      0,
      1147,
      1148,
      5,
      101,
      0,
      0,
      1148,
      1149,
      5,
      109,
      0,
      0,
      1149,
      1150,
      5,
      98,
      0,
      0,
      1150,
      1151,
      5,
      101,
      0,
      0,
      1151,
      1152,
      5,
      114,
      0,
      0,
      1152,
      194,
      1,
      0,
      0,
      0,
      1153,
      1154,
      5,
      109,
      0,
      0,
      1154,
      1155,
      5,
      101,
      0,
      0,
      1155,
      1156,
      5,
      114,
      0,
      0,
      1156,
      1157,
      5,
      103,
      0,
      0,
      1157,
      1158,
      5,
      101,
      0,
      0,
      1158,
      196,
      1,
      0,
      0,
      0,
      1159,
      1160,
      5,
      109,
      0,
      0,
      1160,
      1161,
      5,
      101,
      0,
      0,
      1161,
      1162,
      5,
      115,
      0,
      0,
      1162,
      1163,
      5,
      115,
      0,
      0,
      1163,
      1164,
      5,
      97,
      0,
      0,
      1164,
      1165,
      5,
      103,
      0,
      0,
      1165,
      1166,
      5,
      101,
      0,
      0,
      1166,
      198,
      1,
      0,
      0,
      0,
      1167,
      1168,
      5,
      109,
      0,
      0,
      1168,
      1169,
      5,
      101,
      0,
      0,
      1169,
      1170,
      5,
      116,
      0,
      0,
      1170,
      1171,
      5,
      97,
      0,
      0,
      1171,
      200,
      1,
      0,
      0,
      0,
      1172,
      1173,
      5,
      109,
      0,
      0,
      1173,
      1174,
      5,
      101,
      0,
      0,
      1174,
      1175,
      5,
      116,
      0,
      0,
      1175,
      1176,
      5,
      97,
      0,
      0,
      1176,
      1177,
      5,
      99,
      0,
      0,
      1177,
      1178,
      5,
      108,
      0,
      0,
      1178,
      1179,
      5,
      97,
      0,
      0,
      1179,
      1180,
      5,
      115,
      0,
      0,
      1180,
      1181,
      5,
      115,
      0,
      0,
      1181,
      202,
      1,
      0,
      0,
      0,
      1182,
      1183,
      5,
      109,
      0,
      0,
      1183,
      1184,
      5,
      101,
      0,
      0,
      1184,
      1185,
      5,
      116,
      0,
      0,
      1185,
      1186,
      5,
      97,
      0,
      0,
      1186,
      1187,
      5,
      100,
      0,
      0,
      1187,
      1188,
      5,
      97,
      0,
      0,
      1188,
      1189,
      5,
      116,
      0,
      0,
      1189,
      1190,
      5,
      97,
      0,
      0,
      1190,
      204,
      1,
      0,
      0,
      0,
      1191,
      1192,
      5,
      109,
      0,
      0,
      1192,
      1193,
      5,
      117,
      0,
      0,
      1193,
      1194,
      5,
      108,
      0,
      0,
      1194,
      1195,
      5,
      116,
      0,
      0,
      1195,
      1196,
      5,
      105,
      0,
      0,
      1196,
      1197,
      5,
      112,
      0,
      0,
      1197,
      1198,
      5,
      108,
      0,
      0,
      1198,
      1199,
      5,
      105,
      0,
      0,
      1199,
      1200,
      5,
      99,
      0,
      0,
      1200,
      1201,
      5,
      105,
      0,
      0,
      1201,
      1202,
      5,
      116,
      0,
      0,
      1202,
      1203,
      5,
      121,
      0,
      0,
      1203,
      206,
      1,
      0,
      0,
      0,
      1204,
      1205,
      5,
      110,
      0,
      0,
      1205,
      1206,
      5,
      97,
      0,
      0,
      1206,
      1207,
      5,
      109,
      0,
      0,
      1207,
      1208,
      5,
      101,
      0,
      0,
      1208,
      1209,
      5,
      115,
      0,
      0,
      1209,
      1210,
      5,
      112,
      0,
      0,
      1210,
      1211,
      5,
      97,
      0,
      0,
      1211,
      1212,
      5,
      99,
      0,
      0,
      1212,
      1213,
      5,
      101,
      0,
      0,
      1213,
      208,
      1,
      0,
      0,
      0,
      1214,
      1215,
      5,
      110,
      0,
      0,
      1215,
      1216,
      5,
      101,
      0,
      0,
      1216,
      1217,
      5,
      119,
      0,
      0,
      1217,
      210,
      1,
      0,
      0,
      0,
      1218,
      1219,
      5,
      110,
      0,
      0,
      1219,
      1220,
      5,
      111,
      0,
      0,
      1220,
      1221,
      5,
      110,
      0,
      0,
      1221,
      1222,
      5,
      117,
      0,
      0,
      1222,
      1223,
      5,
      110,
      0,
      0,
      1223,
      1224,
      5,
      105,
      0,
      0,
      1224,
      1225,
      5,
      113,
      0,
      0,
      1225,
      1226,
      5,
      117,
      0,
      0,
      1226,
      1227,
      5,
      101,
      0,
      0,
      1227,
      212,
      1,
      0,
      0,
      0,
      1228,
      1229,
      5,
      110,
      0,
      0,
      1229,
      1230,
      5,
      111,
      0,
      0,
      1230,
      1231,
      5,
      116,
      0,
      0,
      1231,
      214,
      1,
      0,
      0,
      0,
      1232,
      1233,
      5,
      110,
      0,
      0,
      1233,
      1234,
      5,
      117,
      0,
      0,
      1234,
      1235,
      5,
      108,
      0,
      0,
      1235,
      1236,
      5,
      108,
      0,
      0,
      1236,
      216,
      1,
      0,
      0,
      0,
      1237,
      1238,
      5,
      111,
      0,
      0,
      1238,
      1239,
      5,
      98,
      0,
      0,
      1239,
      1240,
      5,
      106,
      0,
      0,
      1240,
      1241,
      5,
      101,
      0,
      0,
      1241,
      1242,
      5,
      99,
      0,
      0,
      1242,
      1243,
      5,
      116,
      0,
      0,
      1243,
      1244,
      5,
      105,
      0,
      0,
      1244,
      1245,
      5,
      118,
      0,
      0,
      1245,
      1246,
      5,
      101,
      0,
      0,
      1246,
      218,
      1,
      0,
      0,
      0,
      1247,
      1248,
      5,
      111,
      0,
      0,
      1248,
      1249,
      5,
      99,
      0,
      0,
      1249,
      1250,
      5,
      99,
      0,
      0,
      1250,
      1251,
      5,
      117,
      0,
      0,
      1251,
      1252,
      5,
      114,
      0,
      0,
      1252,
      1253,
      5,
      114,
      0,
      0,
      1253,
      1254,
      5,
      101,
      0,
      0,
      1254,
      1255,
      5,
      110,
      0,
      0,
      1255,
      1256,
      5,
      99,
      0,
      0,
      1256,
      1257,
      5,
      101,
      0,
      0,
      1257,
      220,
      1,
      0,
      0,
      0,
      1258,
      1259,
      5,
      111,
      0,
      0,
      1259,
      1260,
      5,
      102,
      0,
      0,
      1260,
      222,
      1,
      0,
      0,
      0,
      1261,
      1262,
      5,
      111,
      0,
      0,
      1262,
      1263,
      5,
      114,
      0,
      0,
      1263,
      224,
      1,
      0,
      0,
      0,
      1264,
      1265,
      5,
      111,
      0,
      0,
      1265,
      1266,
      5,
      114,
      0,
      0,
      1266,
      1267,
      5,
      100,
      0,
      0,
      1267,
      1268,
      5,
      101,
      0,
      0,
      1268,
      1269,
      5,
      114,
      0,
      0,
      1269,
      1270,
      5,
      101,
      0,
      0,
      1270,
      1271,
      5,
      100,
      0,
      0,
      1271,
      226,
      1,
      0,
      0,
      0,
      1272,
      1273,
      5,
      111,
      0,
      0,
      1273,
      1274,
      5,
      117,
      0,
      0,
      1274,
      1275,
      5,
      116,
      0,
      0,
      1275,
      228,
      1,
      0,
      0,
      0,
      1276,
      1277,
      5,
      112,
      0,
      0,
      1277,
      1278,
      5,
      97,
      0,
      0,
      1278,
      1279,
      5,
      99,
      0,
      0,
      1279,
      1280,
      5,
      107,
      0,
      0,
      1280,
      1281,
      5,
      97,
      0,
      0,
      1281,
      1282,
      5,
      103,
      0,
      0,
      1282,
      1283,
      5,
      101,
      0,
      0,
      1283,
      230,
      1,
      0,
      0,
      0,
      1284,
      1285,
      5,
      112,
      0,
      0,
      1285,
      1286,
      5,
      97,
      0,
      0,
      1286,
      1287,
      5,
      114,
      0,
      0,
      1287,
      1288,
      5,
      97,
      0,
      0,
      1288,
      1289,
      5,
      108,
      0,
      0,
      1289,
      1290,
      5,
      108,
      0,
      0,
      1290,
      1291,
      5,
      101,
      0,
      0,
      1291,
      1292,
      5,
      108,
      0,
      0,
      1292,
      232,
      1,
      0,
      0,
      0,
      1293,
      1294,
      5,
      112,
      0,
      0,
      1294,
      1295,
      5,
      97,
      0,
      0,
      1295,
      1296,
      5,
      114,
      0,
      0,
      1296,
      1297,
      5,
      116,
      0,
      0,
      1297,
      234,
      1,
      0,
      0,
      0,
      1298,
      1299,
      5,
      112,
      0,
      0,
      1299,
      1300,
      5,
      101,
      0,
      0,
      1300,
      1301,
      5,
      114,
      0,
      0,
      1301,
      1302,
      5,
      102,
      0,
      0,
      1302,
      1303,
      5,
      111,
      0,
      0,
      1303,
      1304,
      5,
      114,
      0,
      0,
      1304,
      1305,
      5,
      109,
      0,
      0,
      1305,
      236,
      1,
      0,
      0,
      0,
      1306,
      1307,
      5,
      112,
      0,
      0,
      1307,
      1308,
      5,
      111,
      0,
      0,
      1308,
      1309,
      5,
      114,
      0,
      0,
      1309,
      1310,
      5,
      116,
      0,
      0,
      1310,
      238,
      1,
      0,
      0,
      0,
      1311,
      1312,
      5,
      112,
      0,
      0,
      1312,
      1313,
      5,
      111,
      0,
      0,
      1313,
      1314,
      5,
      114,
      0,
      0,
      1314,
      1315,
      5,
      116,
      0,
      0,
      1315,
      1316,
      5,
      105,
      0,
      0,
      1316,
      1317,
      5,
      111,
      0,
      0,
      1317,
      1318,
      5,
      110,
      0,
      0,
      1318,
      240,
      1,
      0,
      0,
      0,
      1319,
      1320,
      5,
      112,
      0,
      0,
      1320,
      1321,
      5,
      114,
      0,
      0,
      1321,
      1322,
      5,
      101,
      0,
      0,
      1322,
      1323,
      5,
      100,
      0,
      0,
      1323,
      1324,
      5,
      105,
      0,
      0,
      1324,
      1325,
      5,
      99,
      0,
      0,
      1325,
      1326,
      5,
      97,
      0,
      0,
      1326,
      1327,
      5,
      116,
      0,
      0,
      1327,
      1328,
      5,
      101,
      0,
      0,
      1328,
      242,
      1,
      0,
      0,
      0,
      1329,
      1330,
      5,
      112,
      0,
      0,
      1330,
      1331,
      5,
      114,
      0,
      0,
      1331,
      1332,
      5,
      105,
      0,
      0,
      1332,
      1333,
      5,
      118,
      0,
      0,
      1333,
      1334,
      5,
      97,
      0,
      0,
      1334,
      1335,
      5,
      116,
      0,
      0,
      1335,
      1336,
      5,
      101,
      0,
      0,
      1336,
      244,
      1,
      0,
      0,
      0,
      1337,
      1338,
      5,
      112,
      0,
      0,
      1338,
      1339,
      5,
      114,
      0,
      0,
      1339,
      1340,
      5,
      111,
      0,
      0,
      1340,
      1341,
      5,
      116,
      0,
      0,
      1341,
      1342,
      5,
      101,
      0,
      0,
      1342,
      1343,
      5,
      99,
      0,
      0,
      1343,
      1344,
      5,
      116,
      0,
      0,
      1344,
      1345,
      5,
      101,
      0,
      0,
      1345,
      1346,
      5,
      100,
      0,
      0,
      1346,
      246,
      1,
      0,
      0,
      0,
      1347,
      1348,
      5,
      112,
      0,
      0,
      1348,
      1349,
      5,
      117,
      0,
      0,
      1349,
      1350,
      5,
      98,
      0,
      0,
      1350,
      1351,
      5,
      108,
      0,
      0,
      1351,
      1352,
      5,
      105,
      0,
      0,
      1352,
      1353,
      5,
      99,
      0,
      0,
      1353,
      248,
      1,
      0,
      0,
      0,
      1354,
      1355,
      5,
      114,
      0,
      0,
      1355,
      1356,
      5,
      101,
      0,
      0,
      1356,
      1357,
      5,
      100,
      0,
      0,
      1357,
      1358,
      5,
      101,
      0,
      0,
      1358,
      1359,
      5,
      102,
      0,
      0,
      1359,
      1360,
      5,
      105,
      0,
      0,
      1360,
      1361,
      5,
      110,
      0,
      0,
      1361,
      1362,
      5,
      101,
      0,
      0,
      1362,
      1363,
      5,
      115,
      0,
      0,
      1363,
      250,
      1,
      0,
      0,
      0,
      1364,
      1365,
      5,
      114,
      0,
      0,
      1365,
      1366,
      5,
      101,
      0,
      0,
      1366,
      1367,
      5,
      100,
      0,
      0,
      1367,
      1368,
      5,
      101,
      0,
      0,
      1368,
      1369,
      5,
      102,
      0,
      0,
      1369,
      1370,
      5,
      105,
      0,
      0,
      1370,
      1371,
      5,
      110,
      0,
      0,
      1371,
      1372,
      5,
      105,
      0,
      0,
      1372,
      1373,
      5,
      116,
      0,
      0,
      1373,
      1374,
      5,
      105,
      0,
      0,
      1374,
      1375,
      5,
      111,
      0,
      0,
      1375,
      1376,
      5,
      110,
      0,
      0,
      1376,
      252,
      1,
      0,
      0,
      0,
      1377,
      1378,
      5,
      114,
      0,
      0,
      1378,
      1379,
      5,
      101,
      0,
      0,
      1379,
      1380,
      5,
      102,
      0,
      0,
      1380,
      254,
      1,
      0,
      0,
      0,
      1381,
      1382,
      5,
      114,
      0,
      0,
      1382,
      1383,
      5,
      101,
      0,
      0,
      1383,
      1384,
      5,
      102,
      0,
      0,
      1384,
      1385,
      5,
      101,
      0,
      0,
      1385,
      1386,
      5,
      114,
      0,
      0,
      1386,
      1387,
      5,
      101,
      0,
      0,
      1387,
      1388,
      5,
      110,
      0,
      0,
      1388,
      1389,
      5,
      99,
      0,
      0,
      1389,
      1390,
      5,
      101,
      0,
      0,
      1390,
      1391,
      5,
      115,
      0,
      0,
      1391,
      256,
      1,
      0,
      0,
      0,
      1392,
      1393,
      5,
      114,
      0,
      0,
      1393,
      1394,
      5,
      101,
      0,
      0,
      1394,
      1395,
      5,
      110,
      0,
      0,
      1395,
      1396,
      5,
      100,
      0,
      0,
      1396,
      1397,
      5,
      101,
      0,
      0,
      1397,
      1398,
      5,
      114,
      0,
      0,
      1398,
      258,
      1,
      0,
      0,
      0,
      1399,
      1400,
      5,
      114,
      0,
      0,
      1400,
      1401,
      5,
      101,
      0,
      0,
      1401,
      1402,
      5,
      110,
      0,
      0,
      1402,
      1403,
      5,
      100,
      0,
      0,
      1403,
      1404,
      5,
      101,
      0,
      0,
      1404,
      1405,
      5,
      114,
      0,
      0,
      1405,
      1406,
      5,
      105,
      0,
      0,
      1406,
      1407,
      5,
      110,
      0,
      0,
      1407,
      1408,
      5,
      103,
      0,
      0,
      1408,
      260,
      1,
      0,
      0,
      0,
      1409,
      1410,
      5,
      114,
      0,
      0,
      1410,
      1411,
      5,
      101,
      0,
      0,
      1411,
      1412,
      5,
      112,
      0,
      0,
      1412,
      262,
      1,
      0,
      0,
      0,
      1413,
      1414,
      5,
      114,
      0,
      0,
      1414,
      1415,
      5,
      101,
      0,
      0,
      1415,
      1416,
      5,
      113,
      0,
      0,
      1416,
      1417,
      5,
      117,
      0,
      0,
      1417,
      1418,
      5,
      105,
      0,
      0,
      1418,
      1419,
      5,
      114,
      0,
      0,
      1419,
      1420,
      5,
      101,
      0,
      0,
      1420,
      264,
      1,
      0,
      0,
      0,
      1421,
      1422,
      5,
      114,
      0,
      0,
      1422,
      1423,
      5,
      101,
      0,
      0,
      1423,
      1424,
      5,
      113,
      0,
      0,
      1424,
      1425,
      5,
      117,
      0,
      0,
      1425,
      1426,
      5,
      105,
      0,
      0,
      1426,
      1427,
      5,
      114,
      0,
      0,
      1427,
      1428,
      5,
      101,
      0,
      0,
      1428,
      1429,
      5,
      109,
      0,
      0,
      1429,
      1430,
      5,
      101,
      0,
      0,
      1430,
      1431,
      5,
      110,
      0,
      0,
      1431,
      1432,
      5,
      116,
      0,
      0,
      1432,
      266,
      1,
      0,
      0,
      0,
      1433,
      1434,
      5,
      114,
      0,
      0,
      1434,
      1435,
      5,
      101,
      0,
      0,
      1435,
      1436,
      5,
      116,
      0,
      0,
      1436,
      1437,
      5,
      117,
      0,
      0,
      1437,
      1438,
      5,
      114,
      0,
      0,
      1438,
      1439,
      5,
      110,
      0,
      0,
      1439,
      268,
      1,
      0,
      0,
      0,
      1440,
      1441,
      5,
      115,
      0,
      0,
      1441,
      1442,
      5,
      97,
      0,
      0,
      1442,
      1443,
      5,
      116,
      0,
      0,
      1443,
      1444,
      5,
      105,
      0,
      0,
      1444,
      1445,
      5,
      115,
      0,
      0,
      1445,
      1446,
      5,
      102,
      0,
      0,
      1446,
      1447,
      5,
      121,
      0,
      0,
      1447,
      270,
      1,
      0,
      0,
      0,
      1448,
      1449,
      5,
      115,
      0,
      0,
      1449,
      1450,
      5,
      101,
      0,
      0,
      1450,
      1451,
      5,
      110,
      0,
      0,
      1451,
      1452,
      5,
      100,
      0,
      0,
      1452,
      272,
      1,
      0,
      0,
      0,
      1453,
      1454,
      5,
      115,
      0,
      0,
      1454,
      1455,
      5,
      110,
      0,
      0,
      1455,
      1456,
      5,
      97,
      0,
      0,
      1456,
      1457,
      5,
      112,
      0,
      0,
      1457,
      1458,
      5,
      115,
      0,
      0,
      1458,
      1459,
      5,
      104,
      0,
      0,
      1459,
      1460,
      5,
      111,
      0,
      0,
      1460,
      1461,
      5,
      116,
      0,
      0,
      1461,
      274,
      1,
      0,
      0,
      0,
      1462,
      1463,
      5,
      115,
      0,
      0,
      1463,
      1464,
      5,
      112,
      0,
      0,
      1464,
      1465,
      5,
      101,
      0,
      0,
      1465,
      1466,
      5,
      99,
      0,
      0,
      1466,
      1467,
      5,
      105,
      0,
      0,
      1467,
      1468,
      5,
      97,
      0,
      0,
      1468,
      1469,
      5,
      108,
      0,
      0,
      1469,
      1470,
      5,
      105,
      0,
      0,
      1470,
      1471,
      5,
      122,
      0,
      0,
      1471,
      1472,
      5,
      97,
      0,
      0,
      1472,
      1473,
      5,
      116,
      0,
      0,
      1473,
      1474,
      5,
      105,
      0,
      0,
      1474,
      1475,
      5,
      111,
      0,
      0,
      1475,
      1476,
      5,
      110,
      0,
      0,
      1476,
      276,
      1,
      0,
      0,
      0,
      1477,
      1478,
      5,
      115,
      0,
      0,
      1478,
      1479,
      5,
      112,
      0,
      0,
      1479,
      1480,
      5,
      101,
      0,
      0,
      1480,
      1481,
      5,
      99,
      0,
      0,
      1481,
      1482,
      5,
      105,
      0,
      0,
      1482,
      1483,
      5,
      97,
      0,
      0,
      1483,
      1484,
      5,
      108,
      0,
      0,
      1484,
      1485,
      5,
      105,
      0,
      0,
      1485,
      1486,
      5,
      122,
      0,
      0,
      1486,
      1487,
      5,
      101,
      0,
      0,
      1487,
      1488,
      5,
      115,
      0,
      0,
      1488,
      278,
      1,
      0,
      0,
      0,
      1489,
      1490,
      5,
      115,
      0,
      0,
      1490,
      1491,
      5,
      116,
      0,
      0,
      1491,
      1492,
      5,
      97,
      0,
      0,
      1492,
      1493,
      5,
      107,
      0,
      0,
      1493,
      1494,
      5,
      101,
      0,
      0,
      1494,
      1495,
      5,
      104,
      0,
      0,
      1495,
      1496,
      5,
      111,
      0,
      0,
      1496,
      1497,
      5,
      108,
      0,
      0,
      1497,
      1498,
      5,
      100,
      0,
      0,
      1498,
      1499,
      5,
      101,
      0,
      0,
      1499,
      1500,
      5,
      114,
      0,
      0,
      1500,
      280,
      1,
      0,
      0,
      0,
      1501,
      1502,
      5,
      115,
      0,
      0,
      1502,
      1503,
      5,
      116,
      0,
      0,
      1503,
      1504,
      5,
      97,
      0,
      0,
      1504,
      1505,
      5,
      110,
      0,
      0,
      1505,
      1506,
      5,
      100,
      0,
      0,
      1506,
      1507,
      5,
      97,
      0,
      0,
      1507,
      1508,
      5,
      114,
      0,
      0,
      1508,
      1509,
      5,
      100,
      0,
      0,
      1509,
      282,
      1,
      0,
      0,
      0,
      1510,
      1511,
      5,
      115,
      0,
      0,
      1511,
      1512,
      5,
      116,
      0,
      0,
      1512,
      1513,
      5,
      97,
      0,
      0,
      1513,
      1514,
      5,
      116,
      0,
      0,
      1514,
      1515,
      5,
      101,
      0,
      0,
      1515,
      284,
      1,
      0,
      0,
      0,
      1516,
      1517,
      5,
      115,
      0,
      0,
      1517,
      1518,
      5,
      116,
      0,
      0,
      1518,
      1519,
      5,
      101,
      0,
      0,
      1519,
      1520,
      5,
      112,
      0,
      0,
      1520,
      286,
      1,
      0,
      0,
      0,
      1521,
      1522,
      5,
      115,
      0,
      0,
      1522,
      1523,
      5,
      116,
      0,
      0,
      1523,
      1524,
      5,
      114,
      0,
      0,
      1524,
      1525,
      5,
      117,
      0,
      0,
      1525,
      1526,
      5,
      99,
      0,
      0,
      1526,
      1527,
      5,
      116,
      0,
      0,
      1527,
      288,
      1,
      0,
      0,
      0,
      1528,
      1529,
      5,
      115,
      0,
      0,
      1529,
      1530,
      5,
      117,
      0,
      0,
      1530,
      1531,
      5,
      98,
      0,
      0,
      1531,
      1532,
      5,
      99,
      0,
      0,
      1532,
      1533,
      5,
      108,
      0,
      0,
      1533,
      1534,
      5,
      97,
      0,
      0,
      1534,
      1535,
      5,
      115,
      0,
      0,
      1535,
      1536,
      5,
      115,
      0,
      0,
      1536,
      1537,
      5,
      105,
      0,
      0,
      1537,
      1538,
      5,
      102,
      0,
      0,
      1538,
      1539,
      5,
      105,
      0,
      0,
      1539,
      1540,
      5,
      101,
      0,
      0,
      1540,
      1541,
      5,
      114,
      0,
      0,
      1541,
      290,
      1,
      0,
      0,
      0,
      1542,
      1543,
      5,
      115,
      0,
      0,
      1543,
      1544,
      5,
      117,
      0,
      0,
      1544,
      1545,
      5,
      98,
      0,
      0,
      1545,
      1546,
      5,
      106,
      0,
      0,
      1546,
      1547,
      5,
      101,
      0,
      0,
      1547,
      1548,
      5,
      99,
      0,
      0,
      1548,
      1549,
      5,
      116,
      0,
      0,
      1549,
      292,
      1,
      0,
      0,
      0,
      1550,
      1551,
      5,
      115,
      0,
      0,
      1551,
      1552,
      5,
      117,
      0,
      0,
      1552,
      1553,
      5,
      98,
      0,
      0,
      1553,
      1554,
      5,
      115,
      0,
      0,
      1554,
      1555,
      5,
      101,
      0,
      0,
      1555,
      1556,
      5,
      116,
      0,
      0,
      1556,
      294,
      1,
      0,
      0,
      0,
      1557,
      1558,
      5,
      115,
      0,
      0,
      1558,
      1559,
      5,
      117,
      0,
      0,
      1559,
      1560,
      5,
      98,
      0,
      0,
      1560,
      1561,
      5,
      115,
      0,
      0,
      1561,
      1562,
      5,
      101,
      0,
      0,
      1562,
      1563,
      5,
      116,
      0,
      0,
      1563,
      1564,
      5,
      115,
      0,
      0,
      1564,
      296,
      1,
      0,
      0,
      0,
      1565,
      1566,
      5,
      115,
      0,
      0,
      1566,
      1567,
      5,
      117,
      0,
      0,
      1567,
      1568,
      5,
      98,
      0,
      0,
      1568,
      1569,
      5,
      116,
      0,
      0,
      1569,
      1570,
      5,
      121,
      0,
      0,
      1570,
      1571,
      5,
      112,
      0,
      0,
      1571,
      1572,
      5,
      101,
      0,
      0,
      1572,
      298,
      1,
      0,
      0,
      0,
      1573,
      1574,
      5,
      115,
      0,
      0,
      1574,
      1575,
      5,
      117,
      0,
      0,
      1575,
      1576,
      5,
      99,
      0,
      0,
      1576,
      1577,
      5,
      99,
      0,
      0,
      1577,
      1578,
      5,
      101,
      0,
      0,
      1578,
      1579,
      5,
      115,
      0,
      0,
      1579,
      1580,
      5,
      115,
      0,
      0,
      1580,
      1581,
      5,
      105,
      0,
      0,
      1581,
      1582,
      5,
      111,
      0,
      0,
      1582,
      1583,
      5,
      110,
      0,
      0,
      1583,
      300,
      1,
      0,
      0,
      0,
      1584,
      1585,
      5,
      116,
      0,
      0,
      1585,
      1586,
      5,
      101,
      0,
      0,
      1586,
      1587,
      5,
      114,
      0,
      0,
      1587,
      1588,
      5,
      109,
      0,
      0,
      1588,
      1589,
      5,
      105,
      0,
      0,
      1589,
      1590,
      5,
      110,
      0,
      0,
      1590,
      1591,
      5,
      97,
      0,
      0,
      1591,
      1592,
      5,
      116,
      0,
      0,
      1592,
      1593,
      5,
      101,
      0,
      0,
      1593,
      302,
      1,
      0,
      0,
      0,
      1594,
      1595,
      5,
      116,
      0,
      0,
      1595,
      1596,
      5,
      104,
      0,
      0,
      1596,
      1597,
      5,
      101,
      0,
      0,
      1597,
      1598,
      5,
      110,
      0,
      0,
      1598,
      304,
      1,
      0,
      0,
      0,
      1599,
      1600,
      5,
      116,
      0,
      0,
      1600,
      1601,
      5,
      105,
      0,
      0,
      1601,
      1602,
      5,
      109,
      0,
      0,
      1602,
      1603,
      5,
      101,
      0,
      0,
      1603,
      1604,
      5,
      115,
      0,
      0,
      1604,
      1605,
      5,
      108,
      0,
      0,
      1605,
      1606,
      5,
      105,
      0,
      0,
      1606,
      1607,
      5,
      99,
      0,
      0,
      1607,
      1608,
      5,
      101,
      0,
      0,
      1608,
      306,
      1,
      0,
      0,
      0,
      1609,
      1610,
      5,
      116,
      0,
      0,
      1610,
      1611,
      5,
      111,
      0,
      0,
      1611,
      308,
      1,
      0,
      0,
      0,
      1612,
      1613,
      5,
      116,
      0,
      0,
      1613,
      1614,
      5,
      114,
      0,
      0,
      1614,
      1615,
      5,
      97,
      0,
      0,
      1615,
      1616,
      5,
      110,
      0,
      0,
      1616,
      1617,
      5,
      115,
      0,
      0,
      1617,
      1618,
      5,
      105,
      0,
      0,
      1618,
      1619,
      5,
      116,
      0,
      0,
      1619,
      1620,
      5,
      105,
      0,
      0,
      1620,
      1621,
      5,
      111,
      0,
      0,
      1621,
      1622,
      5,
      110,
      0,
      0,
      1622,
      310,
      1,
      0,
      0,
      0,
      1623,
      1624,
      5,
      116,
      0,
      0,
      1624,
      1625,
      5,
      114,
      0,
      0,
      1625,
      1626,
      5,
      117,
      0,
      0,
      1626,
      1627,
      5,
      101,
      0,
      0,
      1627,
      312,
      1,
      0,
      0,
      0,
      1628,
      1629,
      5,
      116,
      0,
      0,
      1629,
      1630,
      5,
      121,
      0,
      0,
      1630,
      1631,
      5,
      112,
      0,
      0,
      1631,
      1632,
      5,
      101,
      0,
      0,
      1632,
      314,
      1,
      0,
      0,
      0,
      1633,
      1634,
      5,
      116,
      0,
      0,
      1634,
      1635,
      5,
      121,
      0,
      0,
      1635,
      1636,
      5,
      112,
      0,
      0,
      1636,
      1637,
      5,
      101,
      0,
      0,
      1637,
      1638,
      5,
      100,
      0,
      0,
      1638,
      316,
      1,
      0,
      0,
      0,
      1639,
      1640,
      5,
      116,
      0,
      0,
      1640,
      1641,
      5,
      121,
      0,
      0,
      1641,
      1642,
      5,
      112,
      0,
      0,
      1642,
      1643,
      5,
      105,
      0,
      0,
      1643,
      1644,
      5,
      110,
      0,
      0,
      1644,
      1645,
      5,
      103,
      0,
      0,
      1645,
      318,
      1,
      0,
      0,
      0,
      1646,
      1647,
      5,
      117,
      0,
      0,
      1647,
      1648,
      5,
      110,
      0,
      0,
      1648,
      1649,
      5,
      105,
      0,
      0,
      1649,
      1650,
      5,
      111,
      0,
      0,
      1650,
      1651,
      5,
      110,
      0,
      0,
      1651,
      1652,
      5,
      115,
      0,
      0,
      1652,
      320,
      1,
      0,
      0,
      0,
      1653,
      1654,
      5,
      117,
      0,
      0,
      1654,
      1655,
      5,
      110,
      0,
      0,
      1655,
      1656,
      5,
      116,
      0,
      0,
      1656,
      1657,
      5,
      105,
      0,
      0,
      1657,
      1658,
      5,
      108,
      0,
      0,
      1658,
      322,
      1,
      0,
      0,
      0,
      1659,
      1660,
      5,
      117,
      0,
      0,
      1660,
      1661,
      5,
      115,
      0,
      0,
      1661,
      1662,
      5,
      101,
      0,
      0,
      1662,
      324,
      1,
      0,
      0,
      0,
      1663,
      1664,
      5,
      118,
      0,
      0,
      1664,
      1665,
      5,
      97,
      0,
      0,
      1665,
      1666,
      5,
      114,
      0,
      0,
      1666,
      326,
      1,
      0,
      0,
      0,
      1667,
      1668,
      5,
      118,
      0,
      0,
      1668,
      1669,
      5,
      97,
      0,
      0,
      1669,
      1670,
      5,
      114,
      0,
      0,
      1670,
      1671,
      5,
      105,
      0,
      0,
      1671,
      1672,
      5,
      97,
      0,
      0,
      1672,
      1673,
      5,
      110,
      0,
      0,
      1673,
      1674,
      5,
      116,
      0,
      0,
      1674,
      328,
      1,
      0,
      0,
      0,
      1675,
      1676,
      5,
      118,
      0,
      0,
      1676,
      1677,
      5,
      97,
      0,
      0,
      1677,
      1678,
      5,
      114,
      0,
      0,
      1678,
      1679,
      5,
      105,
      0,
      0,
      1679,
      1680,
      5,
      97,
      0,
      0,
      1680,
      1681,
      5,
      116,
      0,
      0,
      1681,
      1682,
      5,
      105,
      0,
      0,
      1682,
      1683,
      5,
      111,
      0,
      0,
      1683,
      1684,
      5,
      110,
      0,
      0,
      1684,
      330,
      1,
      0,
      0,
      0,
      1685,
      1686,
      5,
      118,
      0,
      0,
      1686,
      1687,
      5,
      101,
      0,
      0,
      1687,
      1688,
      5,
      114,
      0,
      0,
      1688,
      1689,
      5,
      105,
      0,
      0,
      1689,
      1690,
      5,
      102,
      0,
      0,
      1690,
      1691,
      5,
      105,
      0,
      0,
      1691,
      1692,
      5,
      99,
      0,
      0,
      1692,
      1693,
      5,
      97,
      0,
      0,
      1693,
      1694,
      5,
      116,
      0,
      0,
      1694,
      1695,
      5,
      105,
      0,
      0,
      1695,
      1696,
      5,
      111,
      0,
      0,
      1696,
      1697,
      5,
      110,
      0,
      0,
      1697,
      332,
      1,
      0,
      0,
      0,
      1698,
      1699,
      5,
      118,
      0,
      0,
      1699,
      1700,
      5,
      101,
      0,
      0,
      1700,
      1701,
      5,
      114,
      0,
      0,
      1701,
      1702,
      5,
      105,
      0,
      0,
      1702,
      1703,
      5,
      102,
      0,
      0,
      1703,
      1704,
      5,
      121,
      0,
      0,
      1704,
      334,
      1,
      0,
      0,
      0,
      1705,
      1706,
      5,
      118,
      0,
      0,
      1706,
      1707,
      5,
      105,
      0,
      0,
      1707,
      1708,
      5,
      97,
      0,
      0,
      1708,
      336,
      1,
      0,
      0,
      0,
      1709,
      1710,
      5,
      118,
      0,
      0,
      1710,
      1711,
      5,
      105,
      0,
      0,
      1711,
      1712,
      5,
      101,
      0,
      0,
      1712,
      1713,
      5,
      119,
      0,
      0,
      1713,
      338,
      1,
      0,
      0,
      0,
      1714,
      1715,
      5,
      118,
      0,
      0,
      1715,
      1716,
      5,
      105,
      0,
      0,
      1716,
      1717,
      5,
      101,
      0,
      0,
      1717,
      1718,
      5,
      119,
      0,
      0,
      1718,
      1719,
      5,
      112,
      0,
      0,
      1719,
      1720,
      5,
      111,
      0,
      0,
      1720,
      1721,
      5,
      105,
      0,
      0,
      1721,
      1722,
      5,
      110,
      0,
      0,
      1722,
      1723,
      5,
      116,
      0,
      0,
      1723,
      340,
      1,
      0,
      0,
      0,
      1724,
      1725,
      5,
      119,
      0,
      0,
      1725,
      1726,
      5,
      104,
      0,
      0,
      1726,
      1727,
      5,
      101,
      0,
      0,
      1727,
      1728,
      5,
      110,
      0,
      0,
      1728,
      342,
      1,
      0,
      0,
      0,
      1729,
      1730,
      5,
      119,
      0,
      0,
      1730,
      1731,
      5,
      104,
      0,
      0,
      1731,
      1732,
      5,
      105,
      0,
      0,
      1732,
      1733,
      5,
      108,
      0,
      0,
      1733,
      1734,
      5,
      101,
      0,
      0,
      1734,
      344,
      1,
      0,
      0,
      0,
      1735,
      1736,
      5,
      120,
      0,
      0,
      1736,
      1737,
      5,
      111,
      0,
      0,
      1737,
      1738,
      5,
      114,
      0,
      0,
      1738,
      346,
      1,
      0,
      0,
      0,
      1739,
      1740,
      5,
      33,
      0,
      0,
      1740,
      1741,
      5,
      61,
      0,
      0,
      1741,
      1742,
      5,
      61,
      0,
      0,
      1742,
      348,
      1,
      0,
      0,
      0,
      1743,
      1744,
      5,
      58,
      0,
      0,
      1744,
      1745,
      5,
      58,
      0,
      0,
      1745,
      1746,
      5,
      62,
      0,
      0,
      1746,
      350,
      1,
      0,
      0,
      0,
      1747,
      1748,
      5,
      58,
      0,
      0,
      1748,
      1749,
      5,
      62,
      0,
      0,
      1749,
      1750,
      5,
      62,
      0,
      0,
      1750,
      352,
      1,
      0,
      0,
      0,
      1751,
      1752,
      5,
      61,
      0,
      0,
      1752,
      1753,
      5,
      61,
      0,
      0,
      1753,
      1754,
      5,
      61,
      0,
      0,
      1754,
      354,
      1,
      0,
      0,
      0,
      1755,
      1756,
      5,
      33,
      0,
      0,
      1756,
      1757,
      5,
      61,
      0,
      0,
      1757,
      356,
      1,
      0,
      0,
      0,
      1758,
      1759,
      5,
      42,
      0,
      0,
      1759,
      1760,
      5,
      42,
      0,
      0,
      1760,
      358,
      1,
      0,
      0,
      0,
      1761,
      1762,
      5,
      45,
      0,
      0,
      1762,
      1763,
      5,
      62,
      0,
      0,
      1763,
      360,
      1,
      0,
      0,
      0,
      1764,
      1765,
      5,
      46,
      0,
      0,
      1765,
      1766,
      5,
      46,
      0,
      0,
      1766,
      362,
      1,
      0,
      0,
      0,
      1767,
      1768,
      5,
      46,
      0,
      0,
      1768,
      1769,
      5,
      63,
      0,
      0,
      1769,
      364,
      1,
      0,
      0,
      0,
      1770,
      1771,
      5,
      58,
      0,
      0,
      1771,
      1772,
      5,
      58,
      0,
      0,
      1772,
      366,
      1,
      0,
      0,
      0,
      1773,
      1774,
      5,
      58,
      0,
      0,
      1774,
      1775,
      5,
      61,
      0,
      0,
      1775,
      368,
      1,
      0,
      0,
      0,
      1776,
      1777,
      5,
      58,
      0,
      0,
      1777,
      1778,
      5,
      62,
      0,
      0,
      1778,
      370,
      1,
      0,
      0,
      0,
      1779,
      1780,
      5,
      60,
      0,
      0,
      1780,
      1781,
      5,
      61,
      0,
      0,
      1781,
      372,
      1,
      0,
      0,
      0,
      1782,
      1783,
      5,
      61,
      0,
      0,
      1783,
      1784,
      5,
      61,
      0,
      0,
      1784,
      374,
      1,
      0,
      0,
      0,
      1785,
      1786,
      5,
      61,
      0,
      0,
      1786,
      1787,
      5,
      62,
      0,
      0,
      1787,
      376,
      1,
      0,
      0,
      0,
      1788,
      1789,
      5,
      62,
      0,
      0,
      1789,
      1790,
      5,
      61,
      0,
      0,
      1790,
      378,
      1,
      0,
      0,
      0,
      1791,
      1792,
      5,
      63,
      0,
      0,
      1792,
      1793,
      5,
      63,
      0,
      0,
      1793,
      380,
      1,
      0,
      0,
      0,
      1794,
      1795,
      5,
      64,
      0,
      0,
      1795,
      1796,
      5,
      64,
      0,
      0,
      1796,
      382,
      1,
      0,
      0,
      0,
      1797,
      1798,
      5,
      35,
      0,
      0,
      1798,
      384,
      1,
      0,
      0,
      0,
      1799,
      1800,
      5,
      36,
      0,
      0,
      1800,
      386,
      1,
      0,
      0,
      0,
      1801,
      1802,
      5,
      37,
      0,
      0,
      1802,
      388,
      1,
      0,
      0,
      0,
      1803,
      1804,
      5,
      38,
      0,
      0,
      1804,
      390,
      1,
      0,
      0,
      0,
      1805,
      1806,
      5,
      40,
      0,
      0,
      1806,
      392,
      1,
      0,
      0,
      0,
      1807,
      1808,
      5,
      41,
      0,
      0,
      1808,
      394,
      1,
      0,
      0,
      0,
      1809,
      1810,
      5,
      42,
      0,
      0,
      1810,
      396,
      1,
      0,
      0,
      0,
      1811,
      1812,
      5,
      43,
      0,
      0,
      1812,
      398,
      1,
      0,
      0,
      0,
      1813,
      1814,
      5,
      44,
      0,
      0,
      1814,
      400,
      1,
      0,
      0,
      0,
      1815,
      1816,
      5,
      45,
      0,
      0,
      1816,
      402,
      1,
      0,
      0,
      0,
      1817,
      1818,
      5,
      46,
      0,
      0,
      1818,
      404,
      1,
      0,
      0,
      0,
      1819,
      1820,
      5,
      47,
      0,
      0,
      1820,
      406,
      1,
      0,
      0,
      0,
      1821,
      1822,
      5,
      58,
      0,
      0,
      1822,
      408,
      1,
      0,
      0,
      0,
      1823,
      1824,
      5,
      59,
      0,
      0,
      1824,
      410,
      1,
      0,
      0,
      0,
      1825,
      1826,
      5,
      60,
      0,
      0,
      1826,
      412,
      1,
      0,
      0,
      0,
      1827,
      1828,
      5,
      61,
      0,
      0,
      1828,
      414,
      1,
      0,
      0,
      0,
      1829,
      1830,
      5,
      62,
      0,
      0,
      1830,
      416,
      1,
      0,
      0,
      0,
      1831,
      1832,
      5,
      63,
      0,
      0,
      1832,
      418,
      1,
      0,
      0,
      0,
      1833,
      1834,
      5,
      64,
      0,
      0,
      1834,
      420,
      1,
      0,
      0,
      0,
      1835,
      1836,
      5,
      91,
      0,
      0,
      1836,
      422,
      1,
      0,
      0,
      0,
      1837,
      1838,
      5,
      93,
      0,
      0,
      1838,
      424,
      1,
      0,
      0,
      0,
      1839,
      1840,
      5,
      94,
      0,
      0,
      1840,
      426,
      1,
      0,
      0,
      0,
      1841,
      1842,
      5,
      123,
      0,
      0,
      1842,
      428,
      1,
      0,
      0,
      0,
      1843,
      1844,
      5,
      124,
      0,
      0,
      1844,
      430,
      1,
      0,
      0,
      0,
      1845,
      1846,
      5,
      125,
      0,
      0,
      1846,
      432,
      1,
      0,
      0,
      0,
      1847,
      1848,
      5,
      126,
      0,
      0,
      1848,
      434,
      1,
      0,
      0,
      0,
      1849,
      1853,
      7,
      0,
      0,
      0,
      1850,
      1852,
      7,
      1,
      0,
      0,
      1851,
      1850,
      1,
      0,
      0,
      0,
      1852,
      1855,
      1,
      0,
      0,
      0,
      1853,
      1851,
      1,
      0,
      0,
      0,
      1853,
      1854,
      1,
      0,
      0,
      0,
      1854,
      436,
      1,
      0,
      0,
      0,
      1855,
      1853,
      1,
      0,
      0,
      0,
      1856,
      1862,
      5,
      39,
      0,
      0,
      1857,
      1858,
      5,
      92,
      0,
      0,
      1858,
      1861,
      9,
      0,
      0,
      0,
      1859,
      1861,
      8,
      2,
      0,
      0,
      1860,
      1857,
      1,
      0,
      0,
      0,
      1860,
      1859,
      1,
      0,
      0,
      0,
      1861,
      1864,
      1,
      0,
      0,
      0,
      1862,
      1860,
      1,
      0,
      0,
      0,
      1862,
      1863,
      1,
      0,
      0,
      0,
      1863,
      1865,
      1,
      0,
      0,
      0,
      1864,
      1862,
      1,
      0,
      0,
      0,
      1865,
      1866,
      5,
      39,
      0,
      0,
      1866,
      438,
      1,
      0,
      0,
      0,
      1867,
      1873,
      5,
      34,
      0,
      0,
      1868,
      1869,
      5,
      92,
      0,
      0,
      1869,
      1872,
      9,
      0,
      0,
      0,
      1870,
      1872,
      8,
      3,
      0,
      0,
      1871,
      1868,
      1,
      0,
      0,
      0,
      1871,
      1870,
      1,
      0,
      0,
      0,
      1872,
      1875,
      1,
      0,
      0,
      0,
      1873,
      1871,
      1,
      0,
      0,
      0,
      1873,
      1874,
      1,
      0,
      0,
      0,
      1874,
      1876,
      1,
      0,
      0,
      0,
      1875,
      1873,
      1,
      0,
      0,
      0,
      1876,
      1877,
      5,
      34,
      0,
      0,
      1877,
      440,
      1,
      0,
      0,
      0,
      1878,
      1880,
      7,
      4,
      0,
      0,
      1879,
      1878,
      1,
      0,
      0,
      0,
      1880,
      1881,
      1,
      0,
      0,
      0,
      1881,
      1879,
      1,
      0,
      0,
      0,
      1881,
      1882,
      1,
      0,
      0,
      0,
      1882,
      442,
      1,
      0,
      0,
      0,
      1883,
      1885,
      7,
      4,
      0,
      0,
      1884,
      1883,
      1,
      0,
      0,
      0,
      1885,
      1888,
      1,
      0,
      0,
      0,
      1886,
      1884,
      1,
      0,
      0,
      0,
      1886,
      1887,
      1,
      0,
      0,
      0,
      1887,
      1889,
      1,
      0,
      0,
      0,
      1888,
      1886,
      1,
      0,
      0,
      0,
      1889,
      1891,
      5,
      46,
      0,
      0,
      1890,
      1892,
      7,
      4,
      0,
      0,
      1891,
      1890,
      1,
      0,
      0,
      0,
      1892,
      1893,
      1,
      0,
      0,
      0,
      1893,
      1891,
      1,
      0,
      0,
      0,
      1893,
      1894,
      1,
      0,
      0,
      0,
      1894,
      1904,
      1,
      0,
      0,
      0,
      1895,
      1897,
      7,
      5,
      0,
      0,
      1896,
      1898,
      7,
      6,
      0,
      0,
      1897,
      1896,
      1,
      0,
      0,
      0,
      1897,
      1898,
      1,
      0,
      0,
      0,
      1898,
      1900,
      1,
      0,
      0,
      0,
      1899,
      1901,
      7,
      4,
      0,
      0,
      1900,
      1899,
      1,
      0,
      0,
      0,
      1901,
      1902,
      1,
      0,
      0,
      0,
      1902,
      1900,
      1,
      0,
      0,
      0,
      1902,
      1903,
      1,
      0,
      0,
      0,
      1903,
      1905,
      1,
      0,
      0,
      0,
      1904,
      1895,
      1,
      0,
      0,
      0,
      1904,
      1905,
      1,
      0,
      0,
      0,
      1905,
      1921,
      1,
      0,
      0,
      0,
      1906,
      1908,
      7,
      4,
      0,
      0,
      1907,
      1906,
      1,
      0,
      0,
      0,
      1908,
      1909,
      1,
      0,
      0,
      0,
      1909,
      1907,
      1,
      0,
      0,
      0,
      1909,
      1910,
      1,
      0,
      0,
      0,
      1910,
      1911,
      1,
      0,
      0,
      0,
      1911,
      1913,
      7,
      5,
      0,
      0,
      1912,
      1914,
      7,
      6,
      0,
      0,
      1913,
      1912,
      1,
      0,
      0,
      0,
      1913,
      1914,
      1,
      0,
      0,
      0,
      1914,
      1916,
      1,
      0,
      0,
      0,
      1915,
      1917,
      7,
      4,
      0,
      0,
      1916,
      1915,
      1,
      0,
      0,
      0,
      1917,
      1918,
      1,
      0,
      0,
      0,
      1918,
      1916,
      1,
      0,
      0,
      0,
      1918,
      1919,
      1,
      0,
      0,
      0,
      1919,
      1921,
      1,
      0,
      0,
      0,
      1920,
      1886,
      1,
      0,
      0,
      0,
      1920,
      1907,
      1,
      0,
      0,
      0,
      1921,
      444,
      1,
      0,
      0,
      0,
      1922,
      1923,
      5,
      47,
      0,
      0,
      1923,
      1924,
      5,
      42,
      0,
      0,
      1924,
      1928,
      1,
      0,
      0,
      0,
      1925,
      1927,
      9,
      0,
      0,
      0,
      1926,
      1925,
      1,
      0,
      0,
      0,
      1927,
      1930,
      1,
      0,
      0,
      0,
      1928,
      1929,
      1,
      0,
      0,
      0,
      1928,
      1926,
      1,
      0,
      0,
      0,
      1929,
      1931,
      1,
      0,
      0,
      0,
      1930,
      1928,
      1,
      0,
      0,
      0,
      1931,
      1932,
      5,
      42,
      0,
      0,
      1932,
      1946,
      5,
      47,
      0,
      0,
      1933,
      1934,
      5,
      47,
      0,
      0,
      1934,
      1935,
      5,
      47,
      0,
      0,
      1935,
      1936,
      5,
      42,
      0,
      0,
      1936,
      1940,
      1,
      0,
      0,
      0,
      1937,
      1939,
      9,
      0,
      0,
      0,
      1938,
      1937,
      1,
      0,
      0,
      0,
      1939,
      1942,
      1,
      0,
      0,
      0,
      1940,
      1941,
      1,
      0,
      0,
      0,
      1940,
      1938,
      1,
      0,
      0,
      0,
      1941,
      1943,
      1,
      0,
      0,
      0,
      1942,
      1940,
      1,
      0,
      0,
      0,
      1943,
      1944,
      5,
      42,
      0,
      0,
      1944,
      1946,
      5,
      47,
      0,
      0,
      1945,
      1922,
      1,
      0,
      0,
      0,
      1945,
      1933,
      1,
      0,
      0,
      0,
      1946,
      446,
      1,
      0,
      0,
      0,
      1947,
      1948,
      5,
      47,
      0,
      0,
      1948,
      1949,
      5,
      47,
      0,
      0,
      1949,
      1950,
      1,
      0,
      0,
      0,
      1950,
      1954,
      8,
      7,
      0,
      0,
      1951,
      1953,
      8,
      8,
      0,
      0,
      1952,
      1951,
      1,
      0,
      0,
      0,
      1953,
      1956,
      1,
      0,
      0,
      0,
      1954,
      1952,
      1,
      0,
      0,
      0,
      1954,
      1955,
      1,
      0,
      0,
      0,
      1955,
      1957,
      1,
      0,
      0,
      0,
      1956,
      1954,
      1,
      0,
      0,
      0,
      1957,
      1958,
      6,
      223,
      0,
      0,
      1958,
      448,
      1,
      0,
      0,
      0,
      1959,
      1960,
      5,
      47,
      0,
      0,
      1960,
      1961,
      5,
      47,
      0,
      0,
      1961,
      1962,
      1,
      0,
      0,
      0,
      1962,
      1963,
      6,
      224,
      0,
      0,
      1963,
      450,
      1,
      0,
      0,
      0,
      1964,
      1966,
      7,
      9,
      0,
      0,
      1965,
      1964,
      1,
      0,
      0,
      0,
      1966,
      1967,
      1,
      0,
      0,
      0,
      1967,
      1965,
      1,
      0,
      0,
      0,
      1967,
      1968,
      1,
      0,
      0,
      0,
      1968,
      1969,
      1,
      0,
      0,
      0,
      1969,
      1970,
      6,
      225,
      0,
      0,
      1970,
      452,
      1,
      0,
      0,
      0,
      21,
      0,
      1853,
      1860,
      1862,
      1871,
      1873,
      1881,
      1886,
      1893,
      1897,
      1902,
      1904,
      1909,
      1913,
      1918,
      1920,
      1928,
      1940,
      1945,
      1954,
      1967,
      1,
      6,
      0,
      0
    ];
    static __ATN;
    static get _ATN() {
      if (!_SysMLv2Lexer.__ATN) {
        _SysMLv2Lexer.__ATN = new ATNDeserializer().deserialize(_SysMLv2Lexer._serializedATN);
      }
      return _SysMLv2Lexer.__ATN;
    }
    static vocabulary = new Vocabulary(_SysMLv2Lexer.literalNames, _SysMLv2Lexer.symbolicNames, []);
    get vocabulary() {
      return _SysMLv2Lexer.vocabulary;
    }
    static decisionsToDFA = _SysMLv2Lexer._ATN.decisionToState.map((ds, index2) => new DFA(ds, index2));
  };

  // server/src/generated/SysMLv2Parser.ts
  var SysMLv2Parser = class _SysMLv2Parser extends Parser {
    static ABOUT = 1;
    static ABSTRACT = 2;
    static ACCEPT = 3;
    static ACTION = 4;
    static ACTOR = 5;
    static AFTER = 6;
    static ALIAS = 7;
    static ALL = 8;
    static ALLOCATE = 9;
    static ALLOCATION = 10;
    static ANALYSIS = 11;
    static AND = 12;
    static AS = 13;
    static ASSERT = 14;
    static ASSIGN = 15;
    static ASSOC = 16;
    static ASSUME = 17;
    static AT = 18;
    static ATTRIBUTE = 19;
    static BEHAVIOR = 20;
    static BIND = 21;
    static BINDING = 22;
    static BOOL = 23;
    static BY = 24;
    static CALC = 25;
    static CASE = 26;
    static CHAINS = 27;
    static CLASS = 28;
    static CLASSIFIER = 29;
    static COMMENT = 30;
    static COMPOSITE = 31;
    static CONCERN = 32;
    static CONJUGATE = 33;
    static CONJUGATES = 34;
    static CONJUGATION = 35;
    static CONNECT = 36;
    static CONNECTION = 37;
    static CONNECTOR = 38;
    static CONST = 39;
    static CONSTANT = 40;
    static CONSTRAINT = 41;
    static CROSSES = 42;
    static DATATYPE = 43;
    static DECIDE = 44;
    static DEF = 45;
    static DEFAULT = 46;
    static DEFINED = 47;
    static DEPENDENCY = 48;
    static DERIVED = 49;
    static DIFFERENCES = 50;
    static DISJOINING = 51;
    static DISJOINT = 52;
    static DO = 53;
    static DOC = 54;
    static ELSE = 55;
    static END = 56;
    static ENTRY = 57;
    static ENUM = 58;
    static EVENT = 59;
    static EXHIBIT = 60;
    static EXIT = 61;
    static EXPOSE = 62;
    static EXPR = 63;
    static FALSE = 64;
    static FEATURE = 65;
    static FEATURED = 66;
    static FEATURING = 67;
    static FILTER = 68;
    static FIRST = 69;
    static FLOW = 70;
    static FOR = 71;
    static FORK = 72;
    static FRAME = 73;
    static FROM = 74;
    static FUNCTION = 75;
    static HASTYPE = 76;
    static IF = 77;
    static IMPLIES = 78;
    static IMPORT = 79;
    static IN = 80;
    static INCLUDE = 81;
    static INDIVIDUAL = 82;
    static INOUT = 83;
    static INTERACTION = 84;
    static INTERFACE = 85;
    static INTERSECTS = 86;
    static INV = 87;
    static INVERSE = 88;
    static INVERTING = 89;
    static ISTYPE = 90;
    static ITEM = 91;
    static JOIN = 92;
    static LANGUAGE = 93;
    static LIBRARY = 94;
    static LOCALE = 95;
    static LOOP = 96;
    static MEMBER = 97;
    static MERGE = 98;
    static MESSAGE = 99;
    static META = 100;
    static METACLASS = 101;
    static METADATA = 102;
    static MULTIPLICITY = 103;
    static NAMESPACE = 104;
    static NEW = 105;
    static NONUNIQUE = 106;
    static NOT = 107;
    static NULL = 108;
    static OBJECTIVE = 109;
    static OCCURRENCE = 110;
    static OF = 111;
    static OR = 112;
    static ORDERED = 113;
    static OUT = 114;
    static PACKAGE = 115;
    static PARALLEL = 116;
    static PART = 117;
    static PERFORM = 118;
    static PORT = 119;
    static PORTION = 120;
    static PREDICATE = 121;
    static PRIVATE = 122;
    static PROTECTED = 123;
    static PUBLIC = 124;
    static REDEFINES = 125;
    static REDEFINITION = 126;
    static REF = 127;
    static REFERENCES = 128;
    static RENDER = 129;
    static RENDERING = 130;
    static REP = 131;
    static REQUIRE = 132;
    static REQUIREMENT = 133;
    static RETURN = 134;
    static SATISFY = 135;
    static SEND = 136;
    static SNAPSHOT = 137;
    static SPECIALIZATION = 138;
    static SPECIALIZES = 139;
    static STAKEHOLDER = 140;
    static STANDARD = 141;
    static STATE = 142;
    static STEP = 143;
    static STRUCT = 144;
    static SUBCLASSIFIER = 145;
    static SUBJECT = 146;
    static SUBSET = 147;
    static SUBSETS = 148;
    static SUBTYPE = 149;
    static SUCCESSION = 150;
    static TERMINATE = 151;
    static THEN = 152;
    static TIMESLICE = 153;
    static TO = 154;
    static TRANSITION = 155;
    static TRUE = 156;
    static TYPE = 157;
    static TYPED = 158;
    static TYPING = 159;
    static UNIONS = 160;
    static UNTIL = 161;
    static USE = 162;
    static VAR = 163;
    static VARIANT = 164;
    static VARIATION = 165;
    static VERIFICATION = 166;
    static VERIFY = 167;
    static VIA = 168;
    static VIEW = 169;
    static VIEWPOINT = 170;
    static WHEN = 171;
    static WHILE = 172;
    static XOR = 173;
    static BANG_EQ_EQ = 174;
    static COLON_COLON_GT = 175;
    static COLON_GT_GT = 176;
    static EQ_EQ_EQ = 177;
    static BANG_EQ = 178;
    static STAR_STAR = 179;
    static ARROW = 180;
    static DOT_DOT = 181;
    static DOT_QUESTION = 182;
    static COLON_COLON = 183;
    static COLON_EQ = 184;
    static COLON_GT = 185;
    static LE = 186;
    static EQ_EQ = 187;
    static FAT_ARROW = 188;
    static GE = 189;
    static QUESTION_QUESTION = 190;
    static AT_AT = 191;
    static HASH = 192;
    static DOLLAR = 193;
    static PERCENT = 194;
    static AMP = 195;
    static LPAREN = 196;
    static RPAREN = 197;
    static STAR = 198;
    static PLUS = 199;
    static COMMA = 200;
    static MINUS = 201;
    static DOT = 202;
    static SLASH = 203;
    static COLON = 204;
    static SEMI = 205;
    static LT = 206;
    static EQ = 207;
    static GT = 208;
    static QUESTION = 209;
    static AT_SIGN = 210;
    static LBRACK = 211;
    static RBRACK = 212;
    static CARET = 213;
    static LBRACE = 214;
    static PIPE = 215;
    static RBRACE = 216;
    static TILDE = 217;
    static IDENTIFIER = 218;
    static STRING = 219;
    static DOUBLE_STRING = 220;
    static INTEGER = 221;
    static REAL = 222;
    static REGULAR_COMMENT = 223;
    static SINGLE_LINE_NOTE = 224;
    static BARE_LINE_COMMENT = 225;
    static WS = 226;
    static RULE_ownedExpression = 0;
    static RULE_typeReference = 1;
    static RULE_sequenceExpressionList = 2;
    static RULE_baseExpression = 3;
    static RULE_nullExpression = 4;
    static RULE_featureReferenceExpression = 5;
    static RULE_constructorExpression = 6;
    static RULE_bodyExpression = 7;
    static RULE_argumentList = 8;
    static RULE_positionalArgumentList = 9;
    static RULE_namedArgumentList = 10;
    static RULE_namedArgument = 11;
    static RULE_literalExpression = 12;
    static RULE_literalBoolean = 13;
    static RULE_literalString = 14;
    static RULE_literalInteger = 15;
    static RULE_literalReal = 16;
    static RULE_literalInfinity = 17;
    static RULE_argumentMember = 18;
    static RULE_argumentExpressionMember = 19;
    static RULE_name = 20;
    static RULE_unreservedKeyword = 21;
    static RULE_identification = 22;
    static RULE_relationshipBody = 23;
    static RULE_relationshipOwnedElement = 24;
    static RULE_ownedRelatedElement = 25;
    static RULE_dependency = 26;
    static RULE_annotation = 27;
    static RULE_ownedAnnotation = 28;
    static RULE_annotatingElement = 29;
    static RULE_comment = 30;
    static RULE_documentation = 31;
    static RULE_textualRepresentation = 32;
    static RULE_rootNamespace = 33;
    static RULE_namespace = 34;
    static RULE_namespaceDeclaration = 35;
    static RULE_namespaceBody = 36;
    static RULE_namespaceBodyElement = 37;
    static RULE_memberPrefix = 38;
    static RULE_visibilityIndicator = 39;
    static RULE_namespaceMember = 40;
    static RULE_nonFeatureMember = 41;
    static RULE_namespaceFeatureMember = 42;
    static RULE_aliasMember = 43;
    static RULE_qualifiedName = 44;
    static RULE_importRule = 45;
    static RULE_importDeclaration = 46;
    static RULE_membershipImport = 47;
    static RULE_namespaceImport = 48;
    static RULE_filterPackage = 49;
    static RULE_filterPackageMember = 50;
    static RULE_memberElement = 51;
    static RULE_nonFeatureElement = 52;
    static RULE_featureElement = 53;
    static RULE_type = 54;
    static RULE_typePrefix = 55;
    static RULE_typeDeclaration = 56;
    static RULE_specializationPart = 57;
    static RULE_conjugationPart = 58;
    static RULE_typeRelationshipPart = 59;
    static RULE_disjoiningPart = 60;
    static RULE_unioningPart = 61;
    static RULE_intersectingPart = 62;
    static RULE_differencingPart = 63;
    static RULE_typeBody = 64;
    static RULE_typeBodyElement = 65;
    static RULE_specialization = 66;
    static RULE_ownedSpecialization = 67;
    static RULE_specificType = 68;
    static RULE_generalType = 69;
    static RULE_conjugation = 70;
    static RULE_ownedConjugation = 71;
    static RULE_disjoining = 72;
    static RULE_ownedDisjoining = 73;
    static RULE_unioning = 74;
    static RULE_intersecting = 75;
    static RULE_differencing = 76;
    static RULE_featureMember = 77;
    static RULE_typeFeatureMember = 78;
    static RULE_ownedFeatureMember = 79;
    static RULE_classifier = 80;
    static RULE_classifierDeclaration = 81;
    static RULE_superclassingPart = 82;
    static RULE_subclassification = 83;
    static RULE_ownedSubclassification = 84;
    static RULE_feature = 85;
    static RULE_endFeaturePrefix = 86;
    static RULE_basicFeaturePrefix = 87;
    static RULE_featurePrefix = 88;
    static RULE_ownedCrossFeatureMember = 89;
    static RULE_ownedCrossFeature = 90;
    static RULE_featureDirection = 91;
    static RULE_featureDeclaration = 92;
    static RULE_featureIdentification = 93;
    static RULE_featureRelationshipPart = 94;
    static RULE_chainingPart = 95;
    static RULE_invertingPart = 96;
    static RULE_typeFeaturingPart = 97;
    static RULE_featureSpecializationPart = 98;
    static RULE_multiplicityPart = 99;
    static RULE_featureSpecialization = 100;
    static RULE_typings = 101;
    static RULE_typedBy = 102;
    static RULE_subsettings = 103;
    static RULE_subsets = 104;
    static RULE_references = 105;
    static RULE_crosses = 106;
    static RULE_redefinitions = 107;
    static RULE_redefines = 108;
    static RULE_featureTyping = 109;
    static RULE_ownedFeatureTyping = 110;
    static RULE_subsetting = 111;
    static RULE_ownedSubsetting = 112;
    static RULE_ownedReferenceSubsetting = 113;
    static RULE_ownedCrossSubsetting = 114;
    static RULE_redefinition = 115;
    static RULE_ownedRedefinition = 116;
    static RULE_featureInverting = 117;
    static RULE_ownedFeatureInverting = 118;
    static RULE_typeFeaturing = 119;
    static RULE_ownedTypeFeaturing = 120;
    static RULE_dataType = 121;
    static RULE_class = 122;
    static RULE_structure = 123;
    static RULE_association = 124;
    static RULE_associationStructure = 125;
    static RULE_connector = 126;
    static RULE_connectorDeclaration = 127;
    static RULE_binaryConnectorDeclaration = 128;
    static RULE_naryConnectorDeclaration = 129;
    static RULE_connectorEndMember = 130;
    static RULE_connectorEnd = 131;
    static RULE_ownedCrossMultiplicityMember = 132;
    static RULE_ownedCrossMultiplicity = 133;
    static RULE_bindingConnector = 134;
    static RULE_bindingConnectorDeclaration = 135;
    static RULE_succession = 136;
    static RULE_successionDeclaration = 137;
    static RULE_behavior = 138;
    static RULE_step = 139;
    static RULE_function = 140;
    static RULE_functionBody = 141;
    static RULE_functionBodyPart = 142;
    static RULE_returnFeatureMember = 143;
    static RULE_resultExpressionMember = 144;
    static RULE_expression = 145;
    static RULE_predicate = 146;
    static RULE_booleanExpression = 147;
    static RULE_invariant = 148;
    static RULE_featureChainMember = 149;
    static RULE_interaction = 150;
    static RULE_flow = 151;
    static RULE_successionFlow = 152;
    static RULE_flowDeclaration = 153;
    static RULE_payloadFeatureMember = 154;
    static RULE_payloadFeature = 155;
    static RULE_payloadFeatureSpecializationPart = 156;
    static RULE_flowEndMember = 157;
    static RULE_flowEnd = 158;
    static RULE_valuePart = 159;
    static RULE_featureValue = 160;
    static RULE_multiplicity = 161;
    static RULE_multiplicitySubset = 162;
    static RULE_multiplicityRange = 163;
    static RULE_ownedMultiplicity = 164;
    static RULE_ownedMultiplicityRange = 165;
    static RULE_multiplicityBounds = 166;
    static RULE_multiplicityExpressionMember = 167;
    static RULE_metaclass = 168;
    static RULE_prefixMetadataAnnotation = 169;
    static RULE_prefixMetadataMember = 170;
    static RULE_prefixMetadataFeature = 171;
    static RULE_metadataFeature = 172;
    static RULE_metadataFeatureDeclaration = 173;
    static RULE_metadataBody = 174;
    static RULE_metadataBodyElement = 175;
    static RULE_metadataBodyFeatureMember = 176;
    static RULE_metadataBodyFeature = 177;
    static RULE_package = 178;
    static RULE_libraryPackage = 179;
    static RULE_packageDeclaration = 180;
    static RULE_packageBody = 181;
    static RULE_elementFilterMember = 182;
    static RULE_dependencyDeclaration = 183;
    static RULE_annotatingMember = 184;
    static RULE_packageBodyElement = 185;
    static RULE_packageMember = 186;
    static RULE_definitionElement = 187;
    static RULE_usageElement = 188;
    static RULE_basicDefinitionPrefix = 189;
    static RULE_definitionExtensionKeyword = 190;
    static RULE_definitionPrefix = 191;
    static RULE_definition = 192;
    static RULE_definitionDeclaration = 193;
    static RULE_definitionBody = 194;
    static RULE_definitionBodyItem = 195;
    static RULE_definitionBodyItemContent = 196;
    static RULE_definitionMember = 197;
    static RULE_variantUsageMember = 198;
    static RULE_nonOccurrenceUsageMember = 199;
    static RULE_structureUsageMember = 200;
    static RULE_behaviorUsageMember = 201;
    static RULE_refPrefix = 202;
    static RULE_basicUsagePrefix = 203;
    static RULE_endUsagePrefix = 204;
    static RULE_usageExtensionKeyword = 205;
    static RULE_unextendedUsagePrefix = 206;
    static RULE_usagePrefix = 207;
    static RULE_usage = 208;
    static RULE_usageDeclaration = 209;
    static RULE_usageCompletion = 210;
    static RULE_usageBody = 211;
    static RULE_defaultReferenceUsage = 212;
    static RULE_referenceUsage = 213;
    static RULE_endFeatureUsage = 214;
    static RULE_variantReference = 215;
    static RULE_nonOccurrenceUsageElement = 216;
    static RULE_endOccurrenceUsageElement = 217;
    static RULE_occurrenceUsageElement = 218;
    static RULE_structureUsageElement = 219;
    static RULE_behaviorUsageElement = 220;
    static RULE_variantUsageElement = 221;
    static RULE_subclassificationPart = 222;
    static RULE_attributeDefinition = 223;
    static RULE_attributeUsage = 224;
    static RULE_enumerationDefinition = 225;
    static RULE_enumerationBody = 226;
    static RULE_enumerationUsageMember = 227;
    static RULE_enumeratedValue = 228;
    static RULE_enumerationUsage = 229;
    static RULE_occurrenceDefinitionPrefix = 230;
    static RULE_occurrenceDefinition = 231;
    static RULE_individualDefinition = 232;
    static RULE_emptyMultiplicityMember = 233;
    static RULE_occurrenceUsagePrefix = 234;
    static RULE_occurrenceUsage = 235;
    static RULE_individualUsage = 236;
    static RULE_portionUsage = 237;
    static RULE_portionKind = 238;
    static RULE_eventOccurrenceUsage = 239;
    static RULE_sourceSuccessionMember = 240;
    static RULE_sourceSuccession = 241;
    static RULE_sourceEndMember = 242;
    static RULE_sourceEnd = 243;
    static RULE_itemDefinition = 244;
    static RULE_itemUsage = 245;
    static RULE_partDefinition = 246;
    static RULE_partUsage = 247;
    static RULE_portDefinition = 248;
    static RULE_conjugatedPortDefinitionMember = 249;
    static RULE_conjugatedPortDefinition = 250;
    static RULE_portUsage = 251;
    static RULE_conjugatedPortTyping = 252;
    static RULE_connectionDefinition = 253;
    static RULE_connectionUsage = 254;
    static RULE_connectorPart = 255;
    static RULE_binaryConnectorPart = 256;
    static RULE_naryConnectorPart = 257;
    static RULE_bindingConnectorAsUsage = 258;
    static RULE_successionAsUsage = 259;
    static RULE_interfaceDefinition = 260;
    static RULE_interfaceBody = 261;
    static RULE_interfaceBodyItem = 262;
    static RULE_interfaceNonOccurrenceUsageMember = 263;
    static RULE_interfaceNonOccurrenceUsageElement = 264;
    static RULE_interfaceOccurrenceUsageMember = 265;
    static RULE_interfaceOccurrenceUsageElement = 266;
    static RULE_defaultInterfaceEnd = 267;
    static RULE_interfaceUsage = 268;
    static RULE_interfaceUsageDeclaration = 269;
    static RULE_interfacePart = 270;
    static RULE_binaryInterfacePart = 271;
    static RULE_naryInterfacePart = 272;
    static RULE_interfaceEndMember = 273;
    static RULE_interfaceEnd = 274;
    static RULE_allocationDefinition = 275;
    static RULE_allocationUsage = 276;
    static RULE_allocationUsageDeclaration = 277;
    static RULE_flowDefinition = 278;
    static RULE_message = 279;
    static RULE_messageDeclaration = 280;
    static RULE_messageEventMember = 281;
    static RULE_messageEvent = 282;
    static RULE_flowUsage = 283;
    static RULE_successionFlowUsage = 284;
    static RULE_flowPayloadFeatureMember = 285;
    static RULE_flowPayloadFeature = 286;
    static RULE_actionDefinition = 287;
    static RULE_actionBody = 288;
    static RULE_actionBodyItem = 289;
    static RULE_nonBehaviorBodyItem = 290;
    static RULE_actionBehaviorMember = 291;
    static RULE_initialNodeMember = 292;
    static RULE_actionNodeMember = 293;
    static RULE_actionTargetSuccessionMember = 294;
    static RULE_guardedSuccessionMember = 295;
    static RULE_actionUsage = 296;
    static RULE_actionUsageDeclaration = 297;
    static RULE_performActionUsage = 298;
    static RULE_performActionUsageDeclaration = 299;
    static RULE_actionNode = 300;
    static RULE_actionNodeUsageDeclaration = 301;
    static RULE_actionNodePrefix = 302;
    static RULE_controlNode = 303;
    static RULE_controlNodePrefix = 304;
    static RULE_mergeNode = 305;
    static RULE_decisionNode = 306;
    static RULE_joinNode = 307;
    static RULE_forkNode = 308;
    static RULE_acceptNode = 309;
    static RULE_acceptNodeDeclaration = 310;
    static RULE_acceptParameterPart = 311;
    static RULE_payloadParameterMember = 312;
    static RULE_payloadParameter = 313;
    static RULE_triggerValuePart = 314;
    static RULE_triggerFeatureValue = 315;
    static RULE_triggerExpression = 316;
    static RULE_sendNode = 317;
    static RULE_sendNodeDeclaration = 318;
    static RULE_senderReceiverPart = 319;
    static RULE_nodeParameterMember = 320;
    static RULE_nodeParameter = 321;
    static RULE_featureBinding = 322;
    static RULE_emptyParameterMember = 323;
    static RULE_assignmentNode = 324;
    static RULE_assignmentNodeDeclaration = 325;
    static RULE_assignmentTargetMember = 326;
    static RULE_assignmentTargetParameter = 327;
    static RULE_assignmentTargetBinding = 328;
    static RULE_terminateNode = 329;
    static RULE_ifNode = 330;
    static RULE_expressionParameterMember = 331;
    static RULE_actionBodyParameterMember = 332;
    static RULE_actionBodyParameter = 333;
    static RULE_ifNodeParameterMember = 334;
    static RULE_whileLoopNode = 335;
    static RULE_forLoopNode = 336;
    static RULE_forVariableDeclarationMember = 337;
    static RULE_actionTargetSuccession = 338;
    static RULE_targetSuccession = 339;
    static RULE_guardedTargetSuccession = 340;
    static RULE_defaultTargetSuccession = 341;
    static RULE_guardedSuccession = 342;
    static RULE_stateDefinition = 343;
    static RULE_stateDefBody = 344;
    static RULE_stateBodyItem = 345;
    static RULE_entryActionMember = 346;
    static RULE_doActionMember = 347;
    static RULE_exitActionMember = 348;
    static RULE_entryTransitionMember = 349;
    static RULE_stateActionUsage = 350;
    static RULE_statePerformActionUsage = 351;
    static RULE_stateAcceptActionUsage = 352;
    static RULE_stateSendActionUsage = 353;
    static RULE_stateAssignmentActionUsage = 354;
    static RULE_transitionUsageMember = 355;
    static RULE_targetTransitionUsageMember = 356;
    static RULE_stateUsage = 357;
    static RULE_stateUsageBody = 358;
    static RULE_exhibitStateUsage = 359;
    static RULE_transitionUsage = 360;
    static RULE_targetTransitionUsage = 361;
    static RULE_triggerActionMember = 362;
    static RULE_triggerAction = 363;
    static RULE_guardExpressionMember = 364;
    static RULE_effectBehaviorMember = 365;
    static RULE_effectBehaviorUsage = 366;
    static RULE_transitionPerformActionUsage = 367;
    static RULE_transitionAcceptActionUsage = 368;
    static RULE_transitionSendActionUsage = 369;
    static RULE_transitionAssignmentActionUsage = 370;
    static RULE_transitionSuccessionMember = 371;
    static RULE_transitionSuccession = 372;
    static RULE_emptyEndMember = 373;
    static RULE_calculationDefinition = 374;
    static RULE_calculationUsage = 375;
    static RULE_calculationBody = 376;
    static RULE_calculationBodyPart = 377;
    static RULE_calculationBodyItem = 378;
    static RULE_returnParameterMember = 379;
    static RULE_constraintDefinition = 380;
    static RULE_constraintUsage = 381;
    static RULE_assertConstraintUsage = 382;
    static RULE_constraintUsageDeclaration = 383;
    static RULE_requirementDefinition = 384;
    static RULE_requirementBody = 385;
    static RULE_requirementBodyItem = 386;
    static RULE_subjectMember = 387;
    static RULE_subjectUsage = 388;
    static RULE_requirementConstraintMember = 389;
    static RULE_requirementKind = 390;
    static RULE_requirementConstraintUsage = 391;
    static RULE_framedConcernMember = 392;
    static RULE_framedConcernUsage = 393;
    static RULE_actorMember = 394;
    static RULE_actorUsage = 395;
    static RULE_stakeholderMember = 396;
    static RULE_stakeholderUsage = 397;
    static RULE_requirementUsage = 398;
    static RULE_satisfyRequirementUsage = 399;
    static RULE_satisfactionSubjectMember = 400;
    static RULE_satisfactionParameter = 401;
    static RULE_satisfactionFeatureValue = 402;
    static RULE_satisfactionReferenceExpression = 403;
    static RULE_concernDefinition = 404;
    static RULE_concernUsage = 405;
    static RULE_caseDefinition = 406;
    static RULE_caseUsage = 407;
    static RULE_caseBody = 408;
    static RULE_caseBodyItem = 409;
    static RULE_objectiveMember = 410;
    static RULE_objectiveRequirementUsage = 411;
    static RULE_analysisCaseDefinition = 412;
    static RULE_analysisCaseUsage = 413;
    static RULE_verificationCaseDefinition = 414;
    static RULE_verificationCaseUsage = 415;
    static RULE_requirementVerificationMember = 416;
    static RULE_requirementVerificationUsage = 417;
    static RULE_useCaseDefinition = 418;
    static RULE_useCaseUsage = 419;
    static RULE_includeUseCaseUsage = 420;
    static RULE_viewDefinition = 421;
    static RULE_viewDefinitionBody = 422;
    static RULE_viewDefinitionBodyItem = 423;
    static RULE_viewRenderingMember = 424;
    static RULE_viewRenderingUsage = 425;
    static RULE_viewUsage = 426;
    static RULE_viewBody = 427;
    static RULE_viewBodyItem = 428;
    static RULE_expose = 429;
    static RULE_membershipExpose = 430;
    static RULE_namespaceExpose = 431;
    static RULE_viewpointDefinition = 432;
    static RULE_viewpointUsage = 433;
    static RULE_renderingDefinition = 434;
    static RULE_renderingUsage = 435;
    static RULE_metadataDefinition = 436;
    static RULE_prefixMetadataUsage = 437;
    static RULE_metadataBodyUsageMember = 438;
    static RULE_metadataBodyUsage = 439;
    static RULE_extendedDefinition = 440;
    static RULE_extendedUsage = 441;
    static RULE_filterPackageImportDeclaration = 442;
    static RULE_namespaceImportDirect = 443;
    static RULE_calculationUsageDeclaration = 444;
    static RULE_emptyActionUsage_ = 445;
    static RULE_emptyFeature_ = 446;
    static RULE_emptyMultiplicity_ = 447;
    static RULE_emptyUsage_ = 448;
    static RULE_filterPackageImport = 449;
    static RULE_nonFeatureChainPrimaryExpression = 450;
    static RULE_portConjugation = 451;
    static literalNames = [
      null,
      "'about'",
      "'abstract'",
      "'accept'",
      "'action'",
      "'actor'",
      "'after'",
      "'alias'",
      "'all'",
      "'allocate'",
      "'allocation'",
      "'analysis'",
      "'and'",
      "'as'",
      "'assert'",
      "'assign'",
      "'assoc'",
      "'assume'",
      "'at'",
      "'attribute'",
      "'behavior'",
      "'bind'",
      "'binding'",
      "'bool'",
      "'by'",
      "'calc'",
      "'case'",
      "'chains'",
      "'class'",
      "'classifier'",
      "'comment'",
      "'composite'",
      "'concern'",
      "'conjugate'",
      "'conjugates'",
      "'conjugation'",
      "'connect'",
      "'connection'",
      "'connector'",
      "'const'",
      "'constant'",
      "'constraint'",
      "'crosses'",
      "'datatype'",
      "'decide'",
      "'def'",
      "'default'",
      "'defined'",
      "'dependency'",
      "'derived'",
      "'differences'",
      "'disjoining'",
      "'disjoint'",
      "'do'",
      "'doc'",
      "'else'",
      "'end'",
      "'entry'",
      "'enum'",
      "'event'",
      "'exhibit'",
      "'exit'",
      "'expose'",
      "'expr'",
      "'false'",
      "'feature'",
      "'featured'",
      "'featuring'",
      "'filter'",
      "'first'",
      "'flow'",
      "'for'",
      "'fork'",
      "'frame'",
      "'from'",
      "'function'",
      "'hastype'",
      "'if'",
      "'implies'",
      "'import'",
      "'in'",
      "'include'",
      "'individual'",
      "'inout'",
      "'interaction'",
      "'interface'",
      "'intersects'",
      "'inv'",
      "'inverse'",
      "'inverting'",
      "'istype'",
      "'item'",
      "'join'",
      "'language'",
      "'library'",
      "'locale'",
      "'loop'",
      "'member'",
      "'merge'",
      "'message'",
      "'meta'",
      "'metaclass'",
      "'metadata'",
      "'multiplicity'",
      "'namespace'",
      "'new'",
      "'nonunique'",
      "'not'",
      "'null'",
      "'objective'",
      "'occurrence'",
      "'of'",
      "'or'",
      "'ordered'",
      "'out'",
      "'package'",
      "'parallel'",
      "'part'",
      "'perform'",
      "'port'",
      "'portion'",
      "'predicate'",
      "'private'",
      "'protected'",
      "'public'",
      "'redefines'",
      "'redefinition'",
      "'ref'",
      "'references'",
      "'render'",
      "'rendering'",
      "'rep'",
      "'require'",
      "'requirement'",
      "'return'",
      "'satisfy'",
      "'send'",
      "'snapshot'",
      "'specialization'",
      "'specializes'",
      "'stakeholder'",
      "'standard'",
      "'state'",
      "'step'",
      "'struct'",
      "'subclassifier'",
      "'subject'",
      "'subset'",
      "'subsets'",
      "'subtype'",
      "'succession'",
      "'terminate'",
      "'then'",
      "'timeslice'",
      "'to'",
      "'transition'",
      "'true'",
      "'type'",
      "'typed'",
      "'typing'",
      "'unions'",
      "'until'",
      "'use'",
      "'var'",
      "'variant'",
      "'variation'",
      "'verification'",
      "'verify'",
      "'via'",
      "'view'",
      "'viewpoint'",
      "'when'",
      "'while'",
      "'xor'",
      "'!=='",
      "'::>'",
      "':>>'",
      "'==='",
      "'!='",
      "'**'",
      "'->'",
      "'..'",
      "'.?'",
      "'::'",
      "':='",
      "':>'",
      "'<='",
      "'=='",
      "'=>'",
      "'>='",
      "'??'",
      "'@@'",
      "'#'",
      "'$'",
      "'%'",
      "'&'",
      "'('",
      "')'",
      "'*'",
      "'+'",
      "','",
      "'-'",
      "'.'",
      "'/'",
      "':'",
      "';'",
      "'<'",
      "'='",
      "'>'",
      "'?'",
      "'@'",
      "'['",
      "']'",
      "'^'",
      "'{'",
      "'|'",
      "'}'",
      "'~'",
      null,
      null,
      null,
      null,
      null,
      null,
      null,
      "'//'"
    ];
    static symbolicNames = [
      null,
      "ABOUT",
      "ABSTRACT",
      "ACCEPT",
      "ACTION",
      "ACTOR",
      "AFTER",
      "ALIAS",
      "ALL",
      "ALLOCATE",
      "ALLOCATION",
      "ANALYSIS",
      "AND",
      "AS",
      "ASSERT",
      "ASSIGN",
      "ASSOC",
      "ASSUME",
      "AT",
      "ATTRIBUTE",
      "BEHAVIOR",
      "BIND",
      "BINDING",
      "BOOL",
      "BY",
      "CALC",
      "CASE",
      "CHAINS",
      "CLASS",
      "CLASSIFIER",
      "COMMENT",
      "COMPOSITE",
      "CONCERN",
      "CONJUGATE",
      "CONJUGATES",
      "CONJUGATION",
      "CONNECT",
      "CONNECTION",
      "CONNECTOR",
      "CONST",
      "CONSTANT",
      "CONSTRAINT",
      "CROSSES",
      "DATATYPE",
      "DECIDE",
      "DEF",
      "DEFAULT",
      "DEFINED",
      "DEPENDENCY",
      "DERIVED",
      "DIFFERENCES",
      "DISJOINING",
      "DISJOINT",
      "DO",
      "DOC",
      "ELSE",
      "END",
      "ENTRY",
      "ENUM",
      "EVENT",
      "EXHIBIT",
      "EXIT",
      "EXPOSE",
      "EXPR",
      "FALSE",
      "FEATURE",
      "FEATURED",
      "FEATURING",
      "FILTER",
      "FIRST",
      "FLOW",
      "FOR",
      "FORK",
      "FRAME",
      "FROM",
      "FUNCTION",
      "HASTYPE",
      "IF",
      "IMPLIES",
      "IMPORT",
      "IN",
      "INCLUDE",
      "INDIVIDUAL",
      "INOUT",
      "INTERACTION",
      "INTERFACE",
      "INTERSECTS",
      "INV",
      "INVERSE",
      "INVERTING",
      "ISTYPE",
      "ITEM",
      "JOIN",
      "LANGUAGE",
      "LIBRARY",
      "LOCALE",
      "LOOP",
      "MEMBER",
      "MERGE",
      "MESSAGE",
      "META",
      "METACLASS",
      "METADATA",
      "MULTIPLICITY",
      "NAMESPACE",
      "NEW",
      "NONUNIQUE",
      "NOT",
      "NULL",
      "OBJECTIVE",
      "OCCURRENCE",
      "OF",
      "OR",
      "ORDERED",
      "OUT",
      "PACKAGE",
      "PARALLEL",
      "PART",
      "PERFORM",
      "PORT",
      "PORTION",
      "PREDICATE",
      "PRIVATE",
      "PROTECTED",
      "PUBLIC",
      "REDEFINES",
      "REDEFINITION",
      "REF",
      "REFERENCES",
      "RENDER",
      "RENDERING",
      "REP",
      "REQUIRE",
      "REQUIREMENT",
      "RETURN",
      "SATISFY",
      "SEND",
      "SNAPSHOT",
      "SPECIALIZATION",
      "SPECIALIZES",
      "STAKEHOLDER",
      "STANDARD",
      "STATE",
      "STEP",
      "STRUCT",
      "SUBCLASSIFIER",
      "SUBJECT",
      "SUBSET",
      "SUBSETS",
      "SUBTYPE",
      "SUCCESSION",
      "TERMINATE",
      "THEN",
      "TIMESLICE",
      "TO",
      "TRANSITION",
      "TRUE",
      "TYPE",
      "TYPED",
      "TYPING",
      "UNIONS",
      "UNTIL",
      "USE",
      "VAR",
      "VARIANT",
      "VARIATION",
      "VERIFICATION",
      "VERIFY",
      "VIA",
      "VIEW",
      "VIEWPOINT",
      "WHEN",
      "WHILE",
      "XOR",
      "BANG_EQ_EQ",
      "COLON_COLON_GT",
      "COLON_GT_GT",
      "EQ_EQ_EQ",
      "BANG_EQ",
      "STAR_STAR",
      "ARROW",
      "DOT_DOT",
      "DOT_QUESTION",
      "COLON_COLON",
      "COLON_EQ",
      "COLON_GT",
      "LE",
      "EQ_EQ",
      "FAT_ARROW",
      "GE",
      "QUESTION_QUESTION",
      "AT_AT",
      "HASH",
      "DOLLAR",
      "PERCENT",
      "AMP",
      "LPAREN",
      "RPAREN",
      "STAR",
      "PLUS",
      "COMMA",
      "MINUS",
      "DOT",
      "SLASH",
      "COLON",
      "SEMI",
      "LT",
      "EQ",
      "GT",
      "QUESTION",
      "AT_SIGN",
      "LBRACK",
      "RBRACK",
      "CARET",
      "LBRACE",
      "PIPE",
      "RBRACE",
      "TILDE",
      "IDENTIFIER",
      "STRING",
      "DOUBLE_STRING",
      "INTEGER",
      "REAL",
      "REGULAR_COMMENT",
      "SINGLE_LINE_NOTE",
      "BARE_LINE_COMMENT",
      "WS"
    ];
    static ruleNames = [
      "ownedExpression",
      "typeReference",
      "sequenceExpressionList",
      "baseExpression",
      "nullExpression",
      "featureReferenceExpression",
      "constructorExpression",
      "bodyExpression",
      "argumentList",
      "positionalArgumentList",
      "namedArgumentList",
      "namedArgument",
      "literalExpression",
      "literalBoolean",
      "literalString",
      "literalInteger",
      "literalReal",
      "literalInfinity",
      "argumentMember",
      "argumentExpressionMember",
      "name",
      "unreservedKeyword",
      "identification",
      "relationshipBody",
      "relationshipOwnedElement",
      "ownedRelatedElement",
      "dependency",
      "annotation",
      "ownedAnnotation",
      "annotatingElement",
      "comment",
      "documentation",
      "textualRepresentation",
      "rootNamespace",
      "namespace",
      "namespaceDeclaration",
      "namespaceBody",
      "namespaceBodyElement",
      "memberPrefix",
      "visibilityIndicator",
      "namespaceMember",
      "nonFeatureMember",
      "namespaceFeatureMember",
      "aliasMember",
      "qualifiedName",
      "importRule",
      "importDeclaration",
      "membershipImport",
      "namespaceImport",
      "filterPackage",
      "filterPackageMember",
      "memberElement",
      "nonFeatureElement",
      "featureElement",
      "type",
      "typePrefix",
      "typeDeclaration",
      "specializationPart",
      "conjugationPart",
      "typeRelationshipPart",
      "disjoiningPart",
      "unioningPart",
      "intersectingPart",
      "differencingPart",
      "typeBody",
      "typeBodyElement",
      "specialization",
      "ownedSpecialization",
      "specificType",
      "generalType",
      "conjugation",
      "ownedConjugation",
      "disjoining",
      "ownedDisjoining",
      "unioning",
      "intersecting",
      "differencing",
      "featureMember",
      "typeFeatureMember",
      "ownedFeatureMember",
      "classifier",
      "classifierDeclaration",
      "superclassingPart",
      "subclassification",
      "ownedSubclassification",
      "feature",
      "endFeaturePrefix",
      "basicFeaturePrefix",
      "featurePrefix",
      "ownedCrossFeatureMember",
      "ownedCrossFeature",
      "featureDirection",
      "featureDeclaration",
      "featureIdentification",
      "featureRelationshipPart",
      "chainingPart",
      "invertingPart",
      "typeFeaturingPart",
      "featureSpecializationPart",
      "multiplicityPart",
      "featureSpecialization",
      "typings",
      "typedBy",
      "subsettings",
      "subsets",
      "references",
      "crosses",
      "redefinitions",
      "redefines",
      "featureTyping",
      "ownedFeatureTyping",
      "subsetting",
      "ownedSubsetting",
      "ownedReferenceSubsetting",
      "ownedCrossSubsetting",
      "redefinition",
      "ownedRedefinition",
      "featureInverting",
      "ownedFeatureInverting",
      "typeFeaturing",
      "ownedTypeFeaturing",
      "dataType",
      "class",
      "structure",
      "association",
      "associationStructure",
      "connector",
      "connectorDeclaration",
      "binaryConnectorDeclaration",
      "naryConnectorDeclaration",
      "connectorEndMember",
      "connectorEnd",
      "ownedCrossMultiplicityMember",
      "ownedCrossMultiplicity",
      "bindingConnector",
      "bindingConnectorDeclaration",
      "succession",
      "successionDeclaration",
      "behavior",
      "step",
      "function",
      "functionBody",
      "functionBodyPart",
      "returnFeatureMember",
      "resultExpressionMember",
      "expression",
      "predicate",
      "booleanExpression",
      "invariant",
      "featureChainMember",
      "interaction",
      "flow",
      "successionFlow",
      "flowDeclaration",
      "payloadFeatureMember",
      "payloadFeature",
      "payloadFeatureSpecializationPart",
      "flowEndMember",
      "flowEnd",
      "valuePart",
      "featureValue",
      "multiplicity",
      "multiplicitySubset",
      "multiplicityRange",
      "ownedMultiplicity",
      "ownedMultiplicityRange",
      "multiplicityBounds",
      "multiplicityExpressionMember",
      "metaclass",
      "prefixMetadataAnnotation",
      "prefixMetadataMember",
      "prefixMetadataFeature",
      "metadataFeature",
      "metadataFeatureDeclaration",
      "metadataBody",
      "metadataBodyElement",
      "metadataBodyFeatureMember",
      "metadataBodyFeature",
      "package",
      "libraryPackage",
      "packageDeclaration",
      "packageBody",
      "elementFilterMember",
      "dependencyDeclaration",
      "annotatingMember",
      "packageBodyElement",
      "packageMember",
      "definitionElement",
      "usageElement",
      "basicDefinitionPrefix",
      "definitionExtensionKeyword",
      "definitionPrefix",
      "definition",
      "definitionDeclaration",
      "definitionBody",
      "definitionBodyItem",
      "definitionBodyItemContent",
      "definitionMember",
      "variantUsageMember",
      "nonOccurrenceUsageMember",
      "structureUsageMember",
      "behaviorUsageMember",
      "refPrefix",
      "basicUsagePrefix",
      "endUsagePrefix",
      "usageExtensionKeyword",
      "unextendedUsagePrefix",
      "usagePrefix",
      "usage",
      "usageDeclaration",
      "usageCompletion",
      "usageBody",
      "defaultReferenceUsage",
      "referenceUsage",
      "endFeatureUsage",
      "variantReference",
      "nonOccurrenceUsageElement",
      "endOccurrenceUsageElement",
      "occurrenceUsageElement",
      "structureUsageElement",
      "behaviorUsageElement",
      "variantUsageElement",
      "subclassificationPart",
      "attributeDefinition",
      "attributeUsage",
      "enumerationDefinition",
      "enumerationBody",
      "enumerationUsageMember",
      "enumeratedValue",
      "enumerationUsage",
      "occurrenceDefinitionPrefix",
      "occurrenceDefinition",
      "individualDefinition",
      "emptyMultiplicityMember",
      "occurrenceUsagePrefix",
      "occurrenceUsage",
      "individualUsage",
      "portionUsage",
      "portionKind",
      "eventOccurrenceUsage",
      "sourceSuccessionMember",
      "sourceSuccession",
      "sourceEndMember",
      "sourceEnd",
      "itemDefinition",
      "itemUsage",
      "partDefinition",
      "partUsage",
      "portDefinition",
      "conjugatedPortDefinitionMember",
      "conjugatedPortDefinition",
      "portUsage",
      "conjugatedPortTyping",
      "connectionDefinition",
      "connectionUsage",
      "connectorPart",
      "binaryConnectorPart",
      "naryConnectorPart",
      "bindingConnectorAsUsage",
      "successionAsUsage",
      "interfaceDefinition",
      "interfaceBody",
      "interfaceBodyItem",
      "interfaceNonOccurrenceUsageMember",
      "interfaceNonOccurrenceUsageElement",
      "interfaceOccurrenceUsageMember",
      "interfaceOccurrenceUsageElement",
      "defaultInterfaceEnd",
      "interfaceUsage",
      "interfaceUsageDeclaration",
      "interfacePart",
      "binaryInterfacePart",
      "naryInterfacePart",
      "interfaceEndMember",
      "interfaceEnd",
      "allocationDefinition",
      "allocationUsage",
      "allocationUsageDeclaration",
      "flowDefinition",
      "message",
      "messageDeclaration",
      "messageEventMember",
      "messageEvent",
      "flowUsage",
      "successionFlowUsage",
      "flowPayloadFeatureMember",
      "flowPayloadFeature",
      "actionDefinition",
      "actionBody",
      "actionBodyItem",
      "nonBehaviorBodyItem",
      "actionBehaviorMember",
      "initialNodeMember",
      "actionNodeMember",
      "actionTargetSuccessionMember",
      "guardedSuccessionMember",
      "actionUsage",
      "actionUsageDeclaration",
      "performActionUsage",
      "performActionUsageDeclaration",
      "actionNode",
      "actionNodeUsageDeclaration",
      "actionNodePrefix",
      "controlNode",
      "controlNodePrefix",
      "mergeNode",
      "decisionNode",
      "joinNode",
      "forkNode",
      "acceptNode",
      "acceptNodeDeclaration",
      "acceptParameterPart",
      "payloadParameterMember",
      "payloadParameter",
      "triggerValuePart",
      "triggerFeatureValue",
      "triggerExpression",
      "sendNode",
      "sendNodeDeclaration",
      "senderReceiverPart",
      "nodeParameterMember",
      "nodeParameter",
      "featureBinding",
      "emptyParameterMember",
      "assignmentNode",
      "assignmentNodeDeclaration",
      "assignmentTargetMember",
      "assignmentTargetParameter",
      "assignmentTargetBinding",
      "terminateNode",
      "ifNode",
      "expressionParameterMember",
      "actionBodyParameterMember",
      "actionBodyParameter",
      "ifNodeParameterMember",
      "whileLoopNode",
      "forLoopNode",
      "forVariableDeclarationMember",
      "actionTargetSuccession",
      "targetSuccession",
      "guardedTargetSuccession",
      "defaultTargetSuccession",
      "guardedSuccession",
      "stateDefinition",
      "stateDefBody",
      "stateBodyItem",
      "entryActionMember",
      "doActionMember",
      "exitActionMember",
      "entryTransitionMember",
      "stateActionUsage",
      "statePerformActionUsage",
      "stateAcceptActionUsage",
      "stateSendActionUsage",
      "stateAssignmentActionUsage",
      "transitionUsageMember",
      "targetTransitionUsageMember",
      "stateUsage",
      "stateUsageBody",
      "exhibitStateUsage",
      "transitionUsage",
      "targetTransitionUsage",
      "triggerActionMember",
      "triggerAction",
      "guardExpressionMember",
      "effectBehaviorMember",
      "effectBehaviorUsage",
      "transitionPerformActionUsage",
      "transitionAcceptActionUsage",
      "transitionSendActionUsage",
      "transitionAssignmentActionUsage",
      "transitionSuccessionMember",
      "transitionSuccession",
      "emptyEndMember",
      "calculationDefinition",
      "calculationUsage",
      "calculationBody",
      "calculationBodyPart",
      "calculationBodyItem",
      "returnParameterMember",
      "constraintDefinition",
      "constraintUsage",
      "assertConstraintUsage",
      "constraintUsageDeclaration",
      "requirementDefinition",
      "requirementBody",
      "requirementBodyItem",
      "subjectMember",
      "subjectUsage",
      "requirementConstraintMember",
      "requirementKind",
      "requirementConstraintUsage",
      "framedConcernMember",
      "framedConcernUsage",
      "actorMember",
      "actorUsage",
      "stakeholderMember",
      "stakeholderUsage",
      "requirementUsage",
      "satisfyRequirementUsage",
      "satisfactionSubjectMember",
      "satisfactionParameter",
      "satisfactionFeatureValue",
      "satisfactionReferenceExpression",
      "concernDefinition",
      "concernUsage",
      "caseDefinition",
      "caseUsage",
      "caseBody",
      "caseBodyItem",
      "objectiveMember",
      "objectiveRequirementUsage",
      "analysisCaseDefinition",
      "analysisCaseUsage",
      "verificationCaseDefinition",
      "verificationCaseUsage",
      "requirementVerificationMember",
      "requirementVerificationUsage",
      "useCaseDefinition",
      "useCaseUsage",
      "includeUseCaseUsage",
      "viewDefinition",
      "viewDefinitionBody",
      "viewDefinitionBodyItem",
      "viewRenderingMember",
      "viewRenderingUsage",
      "viewUsage",
      "viewBody",
      "viewBodyItem",
      "expose",
      "membershipExpose",
      "namespaceExpose",
      "viewpointDefinition",
      "viewpointUsage",
      "renderingDefinition",
      "renderingUsage",
      "metadataDefinition",
      "prefixMetadataUsage",
      "metadataBodyUsageMember",
      "metadataBodyUsage",
      "extendedDefinition",
      "extendedUsage",
      "filterPackageImportDeclaration",
      "namespaceImportDirect",
      "calculationUsageDeclaration",
      "emptyActionUsage_",
      "emptyFeature_",
      "emptyMultiplicity_",
      "emptyUsage_",
      "filterPackageImport",
      "nonFeatureChainPrimaryExpression",
      "portConjugation"
    ];
    get grammarFileName() {
      return "SysMLv2Parser.g4";
    }
    get literalNames() {
      return _SysMLv2Parser.literalNames;
    }
    get symbolicNames() {
      return _SysMLv2Parser.symbolicNames;
    }
    get ruleNames() {
      return _SysMLv2Parser.ruleNames;
    }
    get serializedATN() {
      return _SysMLv2Parser._serializedATN;
    }
    createFailedPredicateException(predicate, message) {
      return new FailedPredicateException(this, predicate, message);
    }
    constructor(input) {
      super(input);
      this.interpreter = new ParserATNSimulator(this, _SysMLv2Parser._ATN, _SysMLv2Parser.decisionsToDFA, new PredictionContextCache());
    }
    ownedExpression(_p) {
      if (_p === void 0) {
        _p = 0;
      }
      let parentContext = this.context;
      let parentState = this.state;
      let localContext = new OwnedExpressionContext(this.context, parentState);
      let previousContext = localContext;
      let _startState = 0;
      this.enterRecursionRule(localContext, 0, _SysMLv2Parser.RULE_ownedExpression, _p);
      let _la;
      try {
        let alternative;
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 919;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.IF:
              {
                this.state = 905;
                this.match(_SysMLv2Parser.IF);
                this.state = 906;
                this.ownedExpression(0);
                this.state = 907;
                this.match(_SysMLv2Parser.QUESTION);
                this.state = 908;
                this.ownedExpression(0);
                this.state = 909;
                this.match(_SysMLv2Parser.ELSE);
                this.state = 910;
                this.ownedExpression(28);
              }
              break;
            case _SysMLv2Parser.NOT:
            case _SysMLv2Parser.PLUS:
            case _SysMLv2Parser.MINUS:
            case _SysMLv2Parser.TILDE:
              {
                this.state = 912;
                _la = this.tokenStream.LA(1);
                if (!(_la === 107 || (_la - 199 & ~31) === 0 && (1 << _la - 199 & 262149) !== 0)) {
                  this.errorHandler.recoverInline(this);
                } else {
                  this.errorHandler.reportMatch(this);
                  this.consume();
                }
                this.state = 913;
                this.ownedExpression(14);
              }
              break;
            case _SysMLv2Parser.AT_AT:
            case _SysMLv2Parser.AT_SIGN:
              {
                this.state = 914;
                _la = this.tokenStream.LA(1);
                if (!(_la === 191 || _la === 210)) {
                  this.errorHandler.recoverInline(this);
                } else {
                  this.errorHandler.reportMatch(this);
                  this.consume();
                }
                this.state = 915;
                this.typeReference();
              }
              break;
            case _SysMLv2Parser.ALL:
              {
                this.state = 916;
                this.match(_SysMLv2Parser.ALL);
                this.state = 917;
                this.typeReference();
              }
              break;
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.FALSE:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.NEW:
            case _SysMLv2Parser.NULL:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.TRUE:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.DOLLAR:
            case _SysMLv2Parser.LPAREN:
            case _SysMLv2Parser.STAR:
            case _SysMLv2Parser.LBRACE:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
            case _SysMLv2Parser.DOUBLE_STRING:
            case _SysMLv2Parser.INTEGER:
            case _SysMLv2Parser.REAL:
            case _SysMLv2Parser.REGULAR_COMMENT:
              {
                this.state = 918;
                this.baseExpression();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.context.stop = this.tokenStream.LT(-1);
          this.state = 1002;
          this.errorHandler.sync(this);
          alternative = this.interpreter.adaptivePredict(this.tokenStream, 5, this.context);
          while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
            if (alternative === 1) {
              if (this.parseListeners != null) {
                this.triggerExitRuleEvent();
              }
              previousContext = localContext;
              {
                this.state = 1e3;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context)) {
                  case 1:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 921;
                      if (!this.precpred(this.context, 27)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 27)");
                      }
                      this.state = 922;
                      this.match(_SysMLv2Parser.QUESTION_QUESTION);
                      this.state = 923;
                      this.ownedExpression(28);
                    }
                    break;
                  case 2:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 924;
                      if (!this.precpred(this.context, 26)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 26)");
                      }
                      this.state = 925;
                      this.match(_SysMLv2Parser.IMPLIES);
                      this.state = 926;
                      this.ownedExpression(27);
                    }
                    break;
                  case 3:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 927;
                      if (!this.precpred(this.context, 25)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 25)");
                      }
                      this.state = 928;
                      this.match(_SysMLv2Parser.OR);
                      this.state = 929;
                      this.ownedExpression(26);
                    }
                    break;
                  case 4:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 930;
                      if (!this.precpred(this.context, 24)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 24)");
                      }
                      this.state = 931;
                      this.match(_SysMLv2Parser.AND);
                      this.state = 932;
                      this.ownedExpression(25);
                    }
                    break;
                  case 5:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 933;
                      if (!this.precpred(this.context, 23)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 23)");
                      }
                      this.state = 934;
                      this.match(_SysMLv2Parser.XOR);
                      this.state = 935;
                      this.ownedExpression(24);
                    }
                    break;
                  case 6:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 936;
                      if (!this.precpred(this.context, 22)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 22)");
                      }
                      this.state = 937;
                      this.match(_SysMLv2Parser.PIPE);
                      this.state = 938;
                      this.ownedExpression(23);
                    }
                    break;
                  case 7:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 939;
                      if (!this.precpred(this.context, 21)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 21)");
                      }
                      this.state = 940;
                      this.match(_SysMLv2Parser.AMP);
                      this.state = 941;
                      this.ownedExpression(22);
                    }
                    break;
                  case 8:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 942;
                      if (!this.precpred(this.context, 20)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 20)");
                      }
                      this.state = 943;
                      _la = this.tokenStream.LA(1);
                      if (!((_la - 174 & ~31) === 0 && (1 << _la - 174 & 8217) !== 0)) {
                        this.errorHandler.recoverInline(this);
                      } else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                      }
                      this.state = 944;
                      this.ownedExpression(21);
                    }
                    break;
                  case 9:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 945;
                      if (!this.precpred(this.context, 19)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 19)");
                      }
                      this.state = 946;
                      _la = this.tokenStream.LA(1);
                      if (!((_la - 186 & ~31) === 0 && (1 << _la - 186 & 5242889) !== 0)) {
                        this.errorHandler.recoverInline(this);
                      } else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                      }
                      this.state = 947;
                      this.ownedExpression(20);
                    }
                    break;
                  case 10:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 948;
                      if (!this.precpred(this.context, 18)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 18)");
                      }
                      this.state = 949;
                      this.match(_SysMLv2Parser.DOT_DOT);
                      this.state = 950;
                      this.ownedExpression(19);
                    }
                    break;
                  case 11:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 951;
                      if (!this.precpred(this.context, 17)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 17)");
                      }
                      this.state = 952;
                      _la = this.tokenStream.LA(1);
                      if (!(_la === 199 || _la === 201)) {
                        this.errorHandler.recoverInline(this);
                      } else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                      }
                      this.state = 953;
                      this.ownedExpression(18);
                    }
                    break;
                  case 12:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 954;
                      if (!this.precpred(this.context, 16)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 16)");
                      }
                      this.state = 955;
                      _la = this.tokenStream.LA(1);
                      if (!((_la - 194 & ~31) === 0 && (1 << _la - 194 & 529) !== 0)) {
                        this.errorHandler.recoverInline(this);
                      } else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                      }
                      this.state = 956;
                      this.ownedExpression(17);
                    }
                    break;
                  case 13:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 957;
                      if (!this.precpred(this.context, 15)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 15)");
                      }
                      this.state = 958;
                      _la = this.tokenStream.LA(1);
                      if (!(_la === 179 || _la === 213)) {
                        this.errorHandler.recoverInline(this);
                      } else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                      }
                      this.state = 959;
                      this.ownedExpression(15);
                    }
                    break;
                  case 14:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 960;
                      if (!this.precpred(this.context, 12)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 12)");
                      }
                      this.state = 961;
                      _la = this.tokenStream.LA(1);
                      if (!(_la === 76 || _la === 90 || _la === 210)) {
                        this.errorHandler.recoverInline(this);
                      } else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                      }
                      this.state = 962;
                      this.typeReference();
                    }
                    break;
                  case 15:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 963;
                      if (!this.precpred(this.context, 11)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 11)");
                      }
                      this.state = 964;
                      this.match(_SysMLv2Parser.AS);
                      this.state = 965;
                      this.typeReference();
                    }
                    break;
                  case 16:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 966;
                      if (!this.precpred(this.context, 10)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 10)");
                      }
                      this.state = 967;
                      this.match(_SysMLv2Parser.AT_AT);
                      this.state = 968;
                      this.typeReference();
                    }
                    break;
                  case 17:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 969;
                      if (!this.precpred(this.context, 9)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 9)");
                      }
                      this.state = 970;
                      this.match(_SysMLv2Parser.META);
                      this.state = 971;
                      this.typeReference();
                    }
                    break;
                  case 18:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 972;
                      if (!this.precpred(this.context, 8)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 8)");
                      }
                      this.state = 973;
                      this.match(_SysMLv2Parser.LBRACK);
                      this.state = 975;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                      if (_la === 8 || _la === 20 || (_la - 42 & ~31) === 0 && (1 << _la - 42 & 12582913) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 1414791685) !== 0 || (_la - 107 & ~31) === 0 && (1 << _la - 107 & 16387) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1073153) !== 0 || (_la - 191 & ~31) === 0 && (1 << _la - 191 & 4236772773) !== 0 || _la === 223) {
                        {
                          this.state = 974;
                          this.sequenceExpressionList();
                        }
                      }
                      this.state = 977;
                      this.match(_SysMLv2Parser.RBRACK);
                    }
                    break;
                  case 19:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 978;
                      if (!this.precpred(this.context, 7)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 7)");
                      }
                      this.state = 979;
                      this.match(_SysMLv2Parser.HASH);
                      this.state = 980;
                      this.match(_SysMLv2Parser.LPAREN);
                      this.state = 982;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                      if (_la === 8 || _la === 20 || (_la - 42 & ~31) === 0 && (1 << _la - 42 & 12582913) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 1414791685) !== 0 || (_la - 107 & ~31) === 0 && (1 << _la - 107 & 16387) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1073153) !== 0 || (_la - 191 & ~31) === 0 && (1 << _la - 191 & 4236772773) !== 0 || _la === 223) {
                        {
                          this.state = 981;
                          this.sequenceExpressionList();
                        }
                      }
                      this.state = 984;
                      this.match(_SysMLv2Parser.RPAREN);
                    }
                    break;
                  case 20:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 985;
                      if (!this.precpred(this.context, 6)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 6)");
                      }
                      this.state = 986;
                      this.argumentList();
                    }
                    break;
                  case 21:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 987;
                      if (!this.precpred(this.context, 5)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 5)");
                      }
                      this.state = 988;
                      this.match(_SysMLv2Parser.DOT);
                      this.state = 989;
                      this.qualifiedName();
                    }
                    break;
                  case 22:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 990;
                      if (!this.precpred(this.context, 4)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 4)");
                      }
                      this.state = 991;
                      this.match(_SysMLv2Parser.DOT_QUESTION);
                      this.state = 992;
                      this.bodyExpression();
                    }
                    break;
                  case 23:
                    {
                      localContext = new OwnedExpressionContext(parentContext, parentState);
                      this.pushNewRecursionContext(localContext, _startState, _SysMLv2Parser.RULE_ownedExpression);
                      this.state = 993;
                      if (!this.precpred(this.context, 3)) {
                        throw this.createFailedPredicateException("this.precpred(this.context, 3)");
                      }
                      this.state = 994;
                      this.match(_SysMLv2Parser.ARROW);
                      this.state = 995;
                      this.qualifiedName();
                      this.state = 998;
                      this.errorHandler.sync(this);
                      switch (this.tokenStream.LA(1)) {
                        case _SysMLv2Parser.LBRACE:
                          {
                            this.state = 996;
                            this.bodyExpression();
                          }
                          break;
                        case _SysMLv2Parser.LPAREN:
                          {
                            this.state = 997;
                            this.argumentList();
                          }
                          break;
                        default:
                          throw new NoViableAltException(this);
                      }
                    }
                    break;
                }
              }
            }
            this.state = 1004;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 5, this.context);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.unrollRecursionContexts(parentContext);
      }
      return localContext;
    }
    typeReference() {
      let localContext = new TypeReferenceContext(this.context, this.state);
      this.enterRule(localContext, 2, _SysMLv2Parser.RULE_typeReference);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1005;
          this.qualifiedName();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    sequenceExpressionList() {
      let localContext = new SequenceExpressionListContext(this.context, this.state);
      this.enterRule(localContext, 4, _SysMLv2Parser.RULE_sequenceExpressionList);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1007;
          this.ownedExpression(0);
          this.state = 1012;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1008;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1009;
                this.ownedExpression(0);
              }
            }
            this.state = 1014;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    baseExpression() {
      let localContext = new BaseExpressionContext(this.context, this.state);
      this.enterRule(localContext, 6, _SysMLv2Parser.RULE_baseExpression);
      let _la;
      try {
        this.state = 1036;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 9, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1015;
              this.nullExpression();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1016;
              this.match(_SysMLv2Parser.REGULAR_COMMENT);
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1017;
              this.literalExpression();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1018;
              this.qualifiedName();
              this.state = 1022;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 7, this.context)) {
                case 1:
                  {
                    this.state = 1019;
                    this.argumentList();
                  }
                  break;
                case 2:
                  {
                    this.state = 1020;
                    this.match(_SysMLv2Parser.DOT);
                    this.state = 1021;
                    this.match(_SysMLv2Parser.METADATA);
                  }
                  break;
              }
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 1024;
              this.constructorExpression();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 1025;
              this.bodyExpression();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 1026;
              this.match(_SysMLv2Parser.LPAREN);
              this.state = 1027;
              this.match(_SysMLv2Parser.AS);
              this.state = 1028;
              this.typeReference();
              this.state = 1029;
              this.match(_SysMLv2Parser.RPAREN);
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 1031;
              this.match(_SysMLv2Parser.LPAREN);
              this.state = 1033;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 8 || _la === 20 || (_la - 42 & ~31) === 0 && (1 << _la - 42 & 12582913) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 1414791685) !== 0 || (_la - 107 & ~31) === 0 && (1 << _la - 107 & 16387) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1073153) !== 0 || (_la - 191 & ~31) === 0 && (1 << _la - 191 & 4236772773) !== 0 || _la === 223) {
                {
                  this.state = 1032;
                  this.sequenceExpressionList();
                }
              }
              this.state = 1035;
              this.match(_SysMLv2Parser.RPAREN);
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nullExpression() {
      let localContext = new NullExpressionContext(this.context, this.state);
      this.enterRule(localContext, 8, _SysMLv2Parser.RULE_nullExpression);
      try {
        this.state = 1041;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.NULL:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1038;
              this.match(_SysMLv2Parser.NULL);
            }
            break;
          case _SysMLv2Parser.LPAREN:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1039;
              this.match(_SysMLv2Parser.LPAREN);
              this.state = 1040;
              this.match(_SysMLv2Parser.RPAREN);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureReferenceExpression() {
      let localContext = new FeatureReferenceExpressionContext(this.context, this.state);
      this.enterRule(localContext, 10, _SysMLv2Parser.RULE_featureReferenceExpression);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1043;
          this.qualifiedName();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    constructorExpression() {
      let localContext = new ConstructorExpressionContext(this.context, this.state);
      this.enterRule(localContext, 12, _SysMLv2Parser.RULE_constructorExpression);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1045;
          this.match(_SysMLv2Parser.NEW);
          this.state = 1046;
          this.qualifiedName();
          this.state = 1047;
          this.argumentList();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    bodyExpression() {
      let localContext = new BodyExpressionContext(this.context, this.state);
      this.enterRule(localContext, 14, _SysMLv2Parser.RULE_bodyExpression);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1049;
          this.match(_SysMLv2Parser.LBRACE);
          this.state = 1050;
          this.functionBodyPart();
          this.state = 1051;
          this.match(_SysMLv2Parser.RBRACE);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    argumentList() {
      let localContext = new ArgumentListContext(this.context, this.state);
      this.enterRule(localContext, 16, _SysMLv2Parser.RULE_argumentList);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1053;
          this.match(_SysMLv2Parser.LPAREN);
          this.state = 1056;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 11, this.context)) {
            case 1:
              {
                this.state = 1054;
                this.positionalArgumentList();
              }
              break;
            case 2:
              {
                this.state = 1055;
                this.namedArgumentList();
              }
              break;
          }
          this.state = 1058;
          this.match(_SysMLv2Parser.RPAREN);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    positionalArgumentList() {
      let localContext = new PositionalArgumentListContext(this.context, this.state);
      this.enterRule(localContext, 18, _SysMLv2Parser.RULE_positionalArgumentList);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1060;
          this.ownedExpression(0);
          this.state = 1065;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1061;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1062;
                this.ownedExpression(0);
              }
            }
            this.state = 1067;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namedArgumentList() {
      let localContext = new NamedArgumentListContext(this.context, this.state);
      this.enterRule(localContext, 20, _SysMLv2Parser.RULE_namedArgumentList);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1068;
          this.namedArgument();
          this.state = 1073;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1069;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1070;
                this.namedArgument();
              }
            }
            this.state = 1075;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namedArgument() {
      let localContext = new NamedArgumentContext(this.context, this.state);
      this.enterRule(localContext, 22, _SysMLv2Parser.RULE_namedArgument);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1076;
          this.qualifiedName();
          this.state = 1077;
          this.match(_SysMLv2Parser.EQ);
          this.state = 1078;
          this.ownedExpression(0);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    literalExpression() {
      let localContext = new LiteralExpressionContext(this.context, this.state);
      this.enterRule(localContext, 24, _SysMLv2Parser.RULE_literalExpression);
      try {
        this.state = 1085;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.FALSE:
          case _SysMLv2Parser.TRUE:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1080;
              this.literalBoolean();
            }
            break;
          case _SysMLv2Parser.DOUBLE_STRING:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1081;
              this.literalString();
            }
            break;
          case _SysMLv2Parser.INTEGER:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1082;
              this.literalInteger();
            }
            break;
          case _SysMLv2Parser.REAL:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1083;
              this.literalReal();
            }
            break;
          case _SysMLv2Parser.STAR:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 1084;
              this.literalInfinity();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    literalBoolean() {
      let localContext = new LiteralBooleanContext(this.context, this.state);
      this.enterRule(localContext, 26, _SysMLv2Parser.RULE_literalBoolean);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1087;
          _la = this.tokenStream.LA(1);
          if (!(_la === 64 || _la === 156)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    literalString() {
      let localContext = new LiteralStringContext(this.context, this.state);
      this.enterRule(localContext, 28, _SysMLv2Parser.RULE_literalString);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1089;
          this.match(_SysMLv2Parser.DOUBLE_STRING);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    literalInteger() {
      let localContext = new LiteralIntegerContext(this.context, this.state);
      this.enterRule(localContext, 30, _SysMLv2Parser.RULE_literalInteger);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1091;
          this.match(_SysMLv2Parser.INTEGER);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    literalReal() {
      let localContext = new LiteralRealContext(this.context, this.state);
      this.enterRule(localContext, 32, _SysMLv2Parser.RULE_literalReal);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1093;
          this.match(_SysMLv2Parser.REAL);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    literalInfinity() {
      let localContext = new LiteralInfinityContext(this.context, this.state);
      this.enterRule(localContext, 34, _SysMLv2Parser.RULE_literalInfinity);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1095;
          this.match(_SysMLv2Parser.STAR);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    argumentMember() {
      let localContext = new ArgumentMemberContext(this.context, this.state);
      this.enterRule(localContext, 36, _SysMLv2Parser.RULE_argumentMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1097;
          this.ownedExpression(0);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    argumentExpressionMember() {
      let localContext = new ArgumentExpressionMemberContext(this.context, this.state);
      this.enterRule(localContext, 38, _SysMLv2Parser.RULE_argumentExpressionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1099;
          this.ownedExpression(0);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    name() {
      let localContext = new NameContext(this.context, this.state);
      this.enterRule(localContext, 40, _SysMLv2Parser.RULE_name);
      try {
        this.state = 1104;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.IDENTIFIER:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1101;
              this.match(_SysMLv2Parser.IDENTIFIER);
            }
            break;
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1102;
              this.match(_SysMLv2Parser.STRING);
            }
            break;
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1103;
              this.unreservedKeyword();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    unreservedKeyword() {
      let localContext = new UnreservedKeywordContext(this.context, this.state);
      this.enterRule(localContext, 42, _SysMLv2Parser.RULE_unreservedKeyword);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1106;
          _la = this.tokenStream.LA(1);
          if (!(_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    identification() {
      let localContext = new IdentificationContext(this.context, this.state);
      this.enterRule(localContext, 44, _SysMLv2Parser.RULE_identification);
      try {
        this.state = 1118;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 16, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1108;
              this.match(_SysMLv2Parser.LT);
              this.state = 1109;
              this.name();
              this.state = 1110;
              this.match(_SysMLv2Parser.GT);
              this.state = 1111;
              this.name();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1113;
              this.match(_SysMLv2Parser.LT);
              this.state = 1114;
              this.name();
              this.state = 1115;
              this.match(_SysMLv2Parser.GT);
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1117;
              this.name();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    relationshipBody() {
      let localContext = new RelationshipBodyContext(this.context, this.state);
      this.enterRule(localContext, 46, _SysMLv2Parser.RULE_relationshipBody);
      let _la;
      try {
        this.state = 1137;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 19, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1120;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1121;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 1125;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 4040229124) !== 0 || (_la - 33 & ~31) === 0 && (1 << _la - 33 & 1085130343) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1909228581) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 4052157169) !== 0 || (_la - 131 & ~31) === 0 && (1 << _la - 131 & 470774913) !== 0 || (_la - 163 & ~31) === 0 && (1 << _la - 163 & 1648373761) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 581829) !== 0) {
                {
                  {
                    this.state = 1122;
                    this.relationshipOwnedElement();
                  }
                }
                this.state = 1127;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 1128;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1129;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 1133;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while (_la === 30 || _la === 54 || (_la - 93 & ~31) === 0 && (1 << _la - 93 & 517) !== 0 || _la === 131 || (_la - 192 & ~31) === 0 && (1 << _la - 192 & 2147745793) !== 0) {
                {
                  {
                    this.state = 1130;
                    this.ownedAnnotation();
                  }
                }
                this.state = 1135;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 1136;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    relationshipOwnedElement() {
      let localContext = new RelationshipOwnedElementContext(this.context, this.state);
      this.enterRule(localContext, 48, _SysMLv2Parser.RULE_relationshipOwnedElement);
      try {
        this.state = 1141;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 20, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1139;
              this.ownedRelatedElement();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1140;
              this.ownedAnnotation();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedRelatedElement() {
      let localContext = new OwnedRelatedElementContext(this.context, this.state);
      this.enterRule(localContext, 50, _SysMLv2Parser.RULE_ownedRelatedElement);
      try {
        this.state = 1145;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 21, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1143;
              this.nonFeatureElement();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1144;
              this.featureElement();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    dependency() {
      let localContext = new DependencyContext(this.context, this.state);
      this.enterRule(localContext, 52, _SysMLv2Parser.RULE_dependency);
      let _la;
      try {
        this.state = 1189;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 28, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1150;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while (_la === 192) {
                {
                  {
                    this.state = 1147;
                    this.prefixMetadataAnnotation();
                  }
                }
                this.state = 1152;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 1153;
              this.match(_SysMLv2Parser.DEPENDENCY);
              this.state = 1158;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 24, this.context)) {
                case 1:
                  {
                    this.state = 1155;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                      {
                        this.state = 1154;
                        this.identification();
                      }
                    }
                    this.state = 1157;
                    this.match(_SysMLv2Parser.FROM);
                  }
                  break;
              }
              this.state = 1160;
              this.qualifiedName();
              this.state = 1165;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while (_la === 200) {
                {
                  {
                    this.state = 1161;
                    this.match(_SysMLv2Parser.COMMA);
                    this.state = 1162;
                    this.qualifiedName();
                  }
                }
                this.state = 1167;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 1168;
              this.match(_SysMLv2Parser.TO);
              this.state = 1169;
              this.qualifiedName();
              this.state = 1174;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while (_la === 200) {
                {
                  {
                    this.state = 1170;
                    this.match(_SysMLv2Parser.COMMA);
                    this.state = 1171;
                    this.qualifiedName();
                  }
                }
                this.state = 1176;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 1177;
              this.relationshipBody();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1182;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while (_la === 192) {
                {
                  {
                    this.state = 1179;
                    this.prefixMetadataAnnotation();
                  }
                }
                this.state = 1184;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 1185;
              this.match(_SysMLv2Parser.DEPENDENCY);
              this.state = 1186;
              this.dependencyDeclaration();
              this.state = 1187;
              this.relationshipBody();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    annotation() {
      let localContext = new AnnotationContext(this.context, this.state);
      this.enterRule(localContext, 54, _SysMLv2Parser.RULE_annotation);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1191;
          this.qualifiedName();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedAnnotation() {
      let localContext = new OwnedAnnotationContext(this.context, this.state);
      this.enterRule(localContext, 56, _SysMLv2Parser.RULE_ownedAnnotation);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1193;
          this.annotatingElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    annotatingElement() {
      let localContext = new AnnotatingElementContext(this.context, this.state);
      this.enterRule(localContext, 58, _SysMLv2Parser.RULE_annotatingElement);
      try {
        this.state = 1199;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.COMMENT:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.REGULAR_COMMENT:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1195;
              this.comment();
            }
            break;
          case _SysMLv2Parser.DOC:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1196;
              this.documentation();
            }
            break;
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.REP:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1197;
              this.textualRepresentation();
            }
            break;
          case _SysMLv2Parser.METADATA:
          case _SysMLv2Parser.HASH:
          case _SysMLv2Parser.AT_SIGN:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1198;
              this.metadataFeature();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    comment() {
      let localContext = new CommentContext(this.context, this.state);
      this.enterRule(localContext, 60, _SysMLv2Parser.RULE_comment);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1216;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 30) {
            {
              this.state = 1201;
              this.match(_SysMLv2Parser.COMMENT);
              this.state = 1203;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 30, this.context)) {
                case 1:
                  {
                    this.state = 1202;
                    this.identification();
                  }
                  break;
              }
              this.state = 1214;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 1) {
                {
                  this.state = 1205;
                  this.match(_SysMLv2Parser.ABOUT);
                  this.state = 1206;
                  this.annotation();
                  this.state = 1211;
                  this.errorHandler.sync(this);
                  _la = this.tokenStream.LA(1);
                  while (_la === 200) {
                    {
                      {
                        this.state = 1207;
                        this.match(_SysMLv2Parser.COMMA);
                        this.state = 1208;
                        this.annotation();
                      }
                    }
                    this.state = 1213;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                  }
                }
              }
            }
          }
          this.state = 1220;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 95) {
            {
              this.state = 1218;
              this.match(_SysMLv2Parser.LOCALE);
              this.state = 1219;
              this.match(_SysMLv2Parser.DOUBLE_STRING);
            }
          }
          this.state = 1222;
          this.match(_SysMLv2Parser.REGULAR_COMMENT);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    documentation() {
      let localContext = new DocumentationContext(this.context, this.state);
      this.enterRule(localContext, 62, _SysMLv2Parser.RULE_documentation);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1224;
          this.match(_SysMLv2Parser.DOC);
          this.state = 1226;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 35, this.context)) {
            case 1:
              {
                this.state = 1225;
                this.identification();
              }
              break;
          }
          this.state = 1230;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 95) {
            {
              this.state = 1228;
              this.match(_SysMLv2Parser.LOCALE);
              this.state = 1229;
              this.match(_SysMLv2Parser.DOUBLE_STRING);
            }
          }
          this.state = 1232;
          this.match(_SysMLv2Parser.REGULAR_COMMENT);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    textualRepresentation() {
      let localContext = new TextualRepresentationContext(this.context, this.state);
      this.enterRule(localContext, 64, _SysMLv2Parser.RULE_textualRepresentation);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1238;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 131) {
            {
              this.state = 1234;
              this.match(_SysMLv2Parser.REP);
              this.state = 1236;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 37, this.context)) {
                case 1:
                  {
                    this.state = 1235;
                    this.identification();
                  }
                  break;
              }
            }
          }
          this.state = 1240;
          this.match(_SysMLv2Parser.LANGUAGE);
          this.state = 1241;
          this.match(_SysMLv2Parser.DOUBLE_STRING);
          this.state = 1242;
          this.match(_SysMLv2Parser.REGULAR_COMMENT);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    rootNamespace() {
      let localContext = new RootNamespaceContext(this.context, this.state);
      this.enterRule(localContext, 66, _SysMLv2Parser.RULE_rootNamespace);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1247;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while ((_la & ~31) === 0 && (1 << _la & 1182289556) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490981169) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1948238905) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127797) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 412367019) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153458587) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
            {
              {
                this.state = 1244;
                this.packageBodyElement();
              }
            }
            this.state = 1249;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 1250;
          this.match(_SysMLv2Parser.EOF);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespace() {
      let localContext = new NamespaceContext(this.context, this.state);
      this.enterRule(localContext, 68, _SysMLv2Parser.RULE_namespace);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1255;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 1252;
                this.prefixMetadataMember();
              }
            }
            this.state = 1257;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 1258;
          this.namespaceDeclaration();
          this.state = 1259;
          this.namespaceBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespaceDeclaration() {
      let localContext = new NamespaceDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 70, _SysMLv2Parser.RULE_namespaceDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1261;
          this.match(_SysMLv2Parser.NAMESPACE);
          this.state = 1263;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
            {
              this.state = 1262;
              this.identification();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespaceBody() {
      let localContext = new NamespaceBodyContext(this.context, this.state);
      this.enterRule(localContext, 72, _SysMLv2Parser.RULE_namespaceBody);
      let _la;
      try {
        this.state = 1274;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1265;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1266;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 1270;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 4040229252) !== 0 || (_la - 33 & ~31) === 0 && (1 << _la - 33 & 1085130343) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1909244965) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 4287038193) !== 0 || (_la - 131 & ~31) === 0 && (1 << _la - 131 & 470774913) !== 0 || (_la - 163 & ~31) === 0 && (1 << _la - 163 & 1648373761) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 581829) !== 0) {
                {
                  {
                    this.state = 1267;
                    this.namespaceBodyElement();
                  }
                }
                this.state = 1272;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 1273;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespaceBodyElement() {
      let localContext = new NamespaceBodyElementContext(this.context, this.state);
      this.enterRule(localContext, 74, _SysMLv2Parser.RULE_namespaceBodyElement);
      try {
        this.state = 1279;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 44, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1276;
              this.namespaceMember();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1277;
              this.aliasMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1278;
              this.importRule();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    memberPrefix() {
      let localContext = new MemberPrefixContext(this.context, this.state);
      this.enterRule(localContext, 76, _SysMLv2Parser.RULE_memberPrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1282;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 122 & ~31) === 0 && (1 << _la - 122 & 7) !== 0) {
            {
              this.state = 1281;
              this.visibilityIndicator();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    visibilityIndicator() {
      let localContext = new VisibilityIndicatorContext(this.context, this.state);
      this.enterRule(localContext, 78, _SysMLv2Parser.RULE_visibilityIndicator);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1284;
          _la = this.tokenStream.LA(1);
          if (!((_la - 122 & ~31) === 0 && (1 << _la - 122 & 7) !== 0)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespaceMember() {
      let localContext = new NamespaceMemberContext(this.context, this.state);
      this.enterRule(localContext, 80, _SysMLv2Parser.RULE_namespaceMember);
      try {
        this.state = 1288;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 46, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1286;
              this.nonFeatureMember();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1287;
              this.namespaceFeatureMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nonFeatureMember() {
      let localContext = new NonFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 82, _SysMLv2Parser.RULE_nonFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1290;
          this.memberPrefix();
          this.state = 1291;
          this.memberElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespaceFeatureMember() {
      let localContext = new NamespaceFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 84, _SysMLv2Parser.RULE_namespaceFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1293;
          this.memberPrefix();
          this.state = 1294;
          this.featureElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    aliasMember() {
      let localContext = new AliasMemberContext(this.context, this.state);
      this.enterRule(localContext, 86, _SysMLv2Parser.RULE_aliasMember);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1296;
          this.memberPrefix();
          this.state = 1297;
          this.match(_SysMLv2Parser.ALIAS);
          this.state = 1302;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 206) {
            {
              this.state = 1298;
              this.match(_SysMLv2Parser.LT);
              this.state = 1299;
              this.name();
              this.state = 1300;
              this.match(_SysMLv2Parser.GT);
            }
          }
          this.state = 1305;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || _la === 218 || _la === 219) {
            {
              this.state = 1304;
              this.name();
            }
          }
          this.state = 1307;
          this.match(_SysMLv2Parser.FOR);
          this.state = 1308;
          this.qualifiedName();
          this.state = 1309;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    qualifiedName() {
      let localContext = new QualifiedNameContext(this.context, this.state);
      this.enterRule(localContext, 88, _SysMLv2Parser.RULE_qualifiedName);
      let _la;
      try {
        let alternative;
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1313;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 193) {
            {
              this.state = 1311;
              this.match(_SysMLv2Parser.DOLLAR);
              this.state = 1312;
              this.match(_SysMLv2Parser.COLON_COLON);
            }
          }
          this.state = 1320;
          this.errorHandler.sync(this);
          alternative = this.interpreter.adaptivePredict(this.tokenStream, 50, this.context);
          while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
            if (alternative === 1) {
              {
                {
                  this.state = 1315;
                  this.name();
                  this.state = 1316;
                  this.match(_SysMLv2Parser.COLON_COLON);
                }
              }
            }
            this.state = 1322;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 50, this.context);
          }
          this.state = 1323;
          this.name();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    importRule() {
      let localContext = new ImportRuleContext(this.context, this.state);
      this.enterRule(localContext, 90, _SysMLv2Parser.RULE_importRule);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1326;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 122 & ~31) === 0 && (1 << _la - 122 & 7) !== 0) {
            {
              this.state = 1325;
              this.visibilityIndicator();
            }
          }
          this.state = 1328;
          this.match(_SysMLv2Parser.IMPORT);
          this.state = 1330;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 8) {
            {
              this.state = 1329;
              this.match(_SysMLv2Parser.ALL);
            }
          }
          this.state = 1332;
          this.importDeclaration();
          this.state = 1333;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    importDeclaration() {
      let localContext = new ImportDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 92, _SysMLv2Parser.RULE_importDeclaration);
      try {
        this.state = 1337;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 53, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1335;
              this.membershipImport();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1336;
              this.namespaceImport();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    membershipImport() {
      let localContext = new MembershipImportContext(this.context, this.state);
      this.enterRule(localContext, 94, _SysMLv2Parser.RULE_membershipImport);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1339;
          this.qualifiedName();
          this.state = 1342;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 183) {
            {
              this.state = 1340;
              this.match(_SysMLv2Parser.COLON_COLON);
              this.state = 1341;
              this.match(_SysMLv2Parser.STAR_STAR);
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespaceImport() {
      let localContext = new NamespaceImportContext(this.context, this.state);
      this.enterRule(localContext, 96, _SysMLv2Parser.RULE_namespaceImport);
      let _la;
      try {
        this.state = 1352;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 56, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1344;
              this.qualifiedName();
              this.state = 1345;
              this.match(_SysMLv2Parser.COLON_COLON);
              this.state = 1346;
              this.match(_SysMLv2Parser.STAR);
              this.state = 1349;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 183) {
                {
                  this.state = 1347;
                  this.match(_SysMLv2Parser.COLON_COLON);
                  this.state = 1348;
                  this.match(_SysMLv2Parser.STAR_STAR);
                }
              }
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1351;
              this.filterPackage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    filterPackage() {
      let localContext = new FilterPackageContext(this.context, this.state);
      this.enterRule(localContext, 98, _SysMLv2Parser.RULE_filterPackage);
      let _la;
      try {
        this.state = 1366;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 59, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1354;
              this.filterPackageImportDeclaration();
              this.state = 1356;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              do {
                {
                  {
                    this.state = 1355;
                    this.filterPackageMember();
                  }
                }
                this.state = 1358;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              } while (_la === 211);
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1360;
              this.filterPackageImport();
              this.state = 1362;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              do {
                {
                  {
                    this.state = 1361;
                    this.filterPackageMember();
                  }
                }
                this.state = 1364;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              } while (_la === 211);
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    filterPackageMember() {
      let localContext = new FilterPackageMemberContext(this.context, this.state);
      this.enterRule(localContext, 100, _SysMLv2Parser.RULE_filterPackageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1368;
          this.match(_SysMLv2Parser.LBRACK);
          this.state = 1369;
          this.ownedExpression(0);
          this.state = 1370;
          this.match(_SysMLv2Parser.RBRACK);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    memberElement() {
      let localContext = new MemberElementContext(this.context, this.state);
      this.enterRule(localContext, 102, _SysMLv2Parser.RULE_memberElement);
      try {
        this.state = 1374;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 60, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1372;
              this.annotatingElement();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1373;
              this.nonFeatureElement();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nonFeatureElement() {
      let localContext = new NonFeatureElementContext(this.context, this.state);
      this.enterRule(localContext, 104, _SysMLv2Parser.RULE_nonFeatureElement);
      try {
        this.state = 1402;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 61, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1376;
              this.dependency();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1377;
              this.namespace();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1378;
              this.type_();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1379;
              this.classifier();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 1380;
              this.dataType();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 1381;
              this.class_();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 1382;
              this.structure();
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 1383;
              this.metaclass();
            }
            break;
          case 9:
            this.enterOuterAlt(localContext, 9);
            {
              this.state = 1384;
              this.association();
            }
            break;
          case 10:
            this.enterOuterAlt(localContext, 10);
            {
              this.state = 1385;
              this.associationStructure();
            }
            break;
          case 11:
            this.enterOuterAlt(localContext, 11);
            {
              this.state = 1386;
              this.interaction();
            }
            break;
          case 12:
            this.enterOuterAlt(localContext, 12);
            {
              this.state = 1387;
              this.behavior();
            }
            break;
          case 13:
            this.enterOuterAlt(localContext, 13);
            {
              this.state = 1388;
              this.function_();
            }
            break;
          case 14:
            this.enterOuterAlt(localContext, 14);
            {
              this.state = 1389;
              this.predicate();
            }
            break;
          case 15:
            this.enterOuterAlt(localContext, 15);
            {
              this.state = 1390;
              this.multiplicity();
            }
            break;
          case 16:
            this.enterOuterAlt(localContext, 16);
            {
              this.state = 1391;
              this.package_();
            }
            break;
          case 17:
            this.enterOuterAlt(localContext, 17);
            {
              this.state = 1392;
              this.libraryPackage();
            }
            break;
          case 18:
            this.enterOuterAlt(localContext, 18);
            {
              this.state = 1393;
              this.specialization();
            }
            break;
          case 19:
            this.enterOuterAlt(localContext, 19);
            {
              this.state = 1394;
              this.conjugation();
            }
            break;
          case 20:
            this.enterOuterAlt(localContext, 20);
            {
              this.state = 1395;
              this.subclassification();
            }
            break;
          case 21:
            this.enterOuterAlt(localContext, 21);
            {
              this.state = 1396;
              this.disjoining();
            }
            break;
          case 22:
            this.enterOuterAlt(localContext, 22);
            {
              this.state = 1397;
              this.featureInverting();
            }
            break;
          case 23:
            this.enterOuterAlt(localContext, 23);
            {
              this.state = 1398;
              this.featureTyping();
            }
            break;
          case 24:
            this.enterOuterAlt(localContext, 24);
            {
              this.state = 1399;
              this.subsetting();
            }
            break;
          case 25:
            this.enterOuterAlt(localContext, 25);
            {
              this.state = 1400;
              this.redefinition();
            }
            break;
          case 26:
            this.enterOuterAlt(localContext, 26);
            {
              this.state = 1401;
              this.typeFeaturing();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureElement() {
      let localContext = new FeatureElementContext(this.context, this.state);
      this.enterRule(localContext, 106, _SysMLv2Parser.RULE_featureElement);
      try {
        this.state = 1414;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 62, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1404;
              this.feature();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1405;
              this.step();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1406;
              this.expression();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1407;
              this.booleanExpression();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 1408;
              this.invariant();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 1409;
              this.connector();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 1410;
              this.bindingConnector();
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 1411;
              this.succession();
            }
            break;
          case 9:
            this.enterOuterAlt(localContext, 9);
            {
              this.state = 1412;
              this.flow();
            }
            break;
          case 10:
            this.enterOuterAlt(localContext, 10);
            {
              this.state = 1413;
              this.successionFlow();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    type_() {
      let localContext = new TypeContext(this.context, this.state);
      this.enterRule(localContext, 108, _SysMLv2Parser.RULE_type);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1416;
          this.typePrefix();
          this.state = 1417;
          this.match(_SysMLv2Parser.TYPE);
          this.state = 1418;
          this.typeDeclaration();
          this.state = 1419;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typePrefix() {
      let localContext = new TypePrefixContext(this.context, this.state);
      this.enterRule(localContext, 110, _SysMLv2Parser.RULE_typePrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1422;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 2) {
            {
              this.state = 1421;
              this.match(_SysMLv2Parser.ABSTRACT);
            }
          }
          this.state = 1427;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 1424;
                this.prefixMetadataMember();
              }
            }
            this.state = 1429;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typeDeclaration() {
      let localContext = new TypeDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 112, _SysMLv2Parser.RULE_typeDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1431;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 8) {
            {
              this.state = 1430;
              this.match(_SysMLv2Parser.ALL);
            }
          }
          this.state = 1434;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
            {
              this.state = 1433;
              this.identification();
            }
          }
          this.state = 1437;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 211) {
            {
              this.state = 1436;
              this.ownedMultiplicity();
            }
          }
          this.state = 1441;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          do {
            {
              this.state = 1441;
              this.errorHandler.sync(this);
              switch (this.tokenStream.LA(1)) {
                case _SysMLv2Parser.SPECIALIZES:
                case _SysMLv2Parser.COLON_GT:
                  {
                    this.state = 1439;
                    this.specializationPart();
                  }
                  break;
                case _SysMLv2Parser.CONJUGATES:
                case _SysMLv2Parser.TILDE:
                  {
                    this.state = 1440;
                    this.conjugationPart();
                  }
                  break;
                default:
                  throw new NoViableAltException(this);
              }
            }
            this.state = 1443;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          } while (_la === 34 || _la === 139 || _la === 185 || _la === 217);
          this.state = 1448;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 50 || _la === 52 || _la === 86 || _la === 160) {
            {
              {
                this.state = 1445;
                this.typeRelationshipPart();
              }
            }
            this.state = 1450;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    specializationPart() {
      let localContext = new SpecializationPartContext(this.context, this.state);
      this.enterRule(localContext, 114, _SysMLv2Parser.RULE_specializationPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1451;
          _la = this.tokenStream.LA(1);
          if (!(_la === 139 || _la === 185)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1452;
          this.ownedSpecialization();
          this.state = 1457;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1453;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1454;
                this.ownedSpecialization();
              }
            }
            this.state = 1459;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    conjugationPart() {
      let localContext = new ConjugationPartContext(this.context, this.state);
      this.enterRule(localContext, 116, _SysMLv2Parser.RULE_conjugationPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1460;
          _la = this.tokenStream.LA(1);
          if (!(_la === 34 || _la === 217)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1461;
          this.ownedConjugation();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typeRelationshipPart() {
      let localContext = new TypeRelationshipPartContext(this.context, this.state);
      this.enterRule(localContext, 118, _SysMLv2Parser.RULE_typeRelationshipPart);
      try {
        this.state = 1467;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.DISJOINT:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1463;
              this.disjoiningPart();
            }
            break;
          case _SysMLv2Parser.UNIONS:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1464;
              this.unioningPart();
            }
            break;
          case _SysMLv2Parser.INTERSECTS:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1465;
              this.intersectingPart();
            }
            break;
          case _SysMLv2Parser.DIFFERENCES:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1466;
              this.differencingPart();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    disjoiningPart() {
      let localContext = new DisjoiningPartContext(this.context, this.state);
      this.enterRule(localContext, 120, _SysMLv2Parser.RULE_disjoiningPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1469;
          this.match(_SysMLv2Parser.DISJOINT);
          this.state = 1470;
          this.match(_SysMLv2Parser.FROM);
          this.state = 1471;
          this.ownedDisjoining();
          this.state = 1476;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1472;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1473;
                this.ownedDisjoining();
              }
            }
            this.state = 1478;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    unioningPart() {
      let localContext = new UnioningPartContext(this.context, this.state);
      this.enterRule(localContext, 122, _SysMLv2Parser.RULE_unioningPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1479;
          this.match(_SysMLv2Parser.UNIONS);
          this.state = 1480;
          this.unioning();
          this.state = 1485;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1481;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1482;
                this.unioning();
              }
            }
            this.state = 1487;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    intersectingPart() {
      let localContext = new IntersectingPartContext(this.context, this.state);
      this.enterRule(localContext, 124, _SysMLv2Parser.RULE_intersectingPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1488;
          this.match(_SysMLv2Parser.INTERSECTS);
          this.state = 1489;
          this.intersecting();
          this.state = 1494;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1490;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1491;
                this.intersecting();
              }
            }
            this.state = 1496;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    differencingPart() {
      let localContext = new DifferencingPartContext(this.context, this.state);
      this.enterRule(localContext, 126, _SysMLv2Parser.RULE_differencingPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1497;
          this.match(_SysMLv2Parser.DIFFERENCES);
          this.state = 1498;
          this.differencing();
          this.state = 1503;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1499;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1500;
                this.differencing();
              }
            }
            this.state = 1505;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typeBody() {
      let localContext = new TypeBodyContext(this.context, this.state);
      this.enterRule(localContext, 128, _SysMLv2Parser.RULE_typeBody);
      let _la;
      try {
        this.state = 1515;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1506;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1507;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 1511;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 4040229252) !== 0 || (_la - 33 & ~31) === 0 && (1 << _la - 33 & 1085130343) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1909244965) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 4287038193) !== 0 || (_la - 131 & ~31) === 0 && (1 << _la - 131 & 470774913) !== 0 || (_la - 163 & ~31) === 0 && (1 << _la - 163 & 1648373761) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 581829) !== 0) {
                {
                  {
                    this.state = 1508;
                    this.typeBodyElement();
                  }
                }
                this.state = 1513;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 1514;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typeBodyElement() {
      let localContext = new TypeBodyElementContext(this.context, this.state);
      this.enterRule(localContext, 130, _SysMLv2Parser.RULE_typeBodyElement);
      try {
        this.state = 1521;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 79, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1517;
              this.nonFeatureMember();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1518;
              this.featureMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1519;
              this.aliasMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1520;
              this.importRule();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    specialization() {
      let localContext = new SpecializationContext(this.context, this.state);
      this.enterRule(localContext, 132, _SysMLv2Parser.RULE_specialization);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1527;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 138) {
            {
              this.state = 1523;
              this.match(_SysMLv2Parser.SPECIALIZATION);
              this.state = 1525;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                {
                  this.state = 1524;
                  this.identification();
                }
              }
            }
          }
          this.state = 1529;
          this.match(_SysMLv2Parser.SUBTYPE);
          this.state = 1530;
          this.specificType();
          this.state = 1531;
          _la = this.tokenStream.LA(1);
          if (!(_la === 139 || _la === 185)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1532;
          this.generalType();
          this.state = 1533;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedSpecialization() {
      let localContext = new OwnedSpecializationContext(this.context, this.state);
      this.enterRule(localContext, 134, _SysMLv2Parser.RULE_ownedSpecialization);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1535;
          this.generalType();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    specificType() {
      let localContext = new SpecificTypeContext(this.context, this.state);
      this.enterRule(localContext, 136, _SysMLv2Parser.RULE_specificType);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1537;
          this.qualifiedName();
          this.state = 1542;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1538;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1539;
                this.qualifiedName();
              }
            }
            this.state = 1544;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    generalType() {
      let localContext = new GeneralTypeContext(this.context, this.state);
      this.enterRule(localContext, 138, _SysMLv2Parser.RULE_generalType);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1545;
          this.qualifiedName();
          this.state = 1550;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1546;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1547;
                this.qualifiedName();
              }
            }
            this.state = 1552;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    conjugation() {
      let localContext = new ConjugationContext(this.context, this.state);
      this.enterRule(localContext, 140, _SysMLv2Parser.RULE_conjugation);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1557;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 35) {
            {
              this.state = 1553;
              this.match(_SysMLv2Parser.CONJUGATION);
              this.state = 1555;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                {
                  this.state = 1554;
                  this.identification();
                }
              }
            }
          }
          this.state = 1559;
          this.match(_SysMLv2Parser.CONJUGATE);
          this.state = 1560;
          this.qualifiedName();
          this.state = 1565;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1561;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1562;
                this.qualifiedName();
              }
            }
            this.state = 1567;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 1568;
          _la = this.tokenStream.LA(1);
          if (!(_la === 34 || _la === 217)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1569;
          this.qualifiedName();
          this.state = 1574;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1570;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1571;
                this.qualifiedName();
              }
            }
            this.state = 1576;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 1577;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedConjugation() {
      let localContext = new OwnedConjugationContext(this.context, this.state);
      this.enterRule(localContext, 142, _SysMLv2Parser.RULE_ownedConjugation);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1579;
          this.qualifiedName();
          this.state = 1584;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1580;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1581;
                this.qualifiedName();
              }
            }
            this.state = 1586;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    disjoining() {
      let localContext = new DisjoiningContext(this.context, this.state);
      this.enterRule(localContext, 144, _SysMLv2Parser.RULE_disjoining);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1591;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 51) {
            {
              this.state = 1587;
              this.match(_SysMLv2Parser.DISJOINING);
              this.state = 1589;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                {
                  this.state = 1588;
                  this.identification();
                }
              }
            }
          }
          this.state = 1593;
          this.match(_SysMLv2Parser.DISJOINT);
          this.state = 1594;
          this.qualifiedName();
          this.state = 1599;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1595;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1596;
                this.qualifiedName();
              }
            }
            this.state = 1601;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 1602;
          this.match(_SysMLv2Parser.FROM);
          this.state = 1603;
          this.qualifiedName();
          this.state = 1608;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1604;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1605;
                this.qualifiedName();
              }
            }
            this.state = 1610;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 1611;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedDisjoining() {
      let localContext = new OwnedDisjoiningContext(this.context, this.state);
      this.enterRule(localContext, 146, _SysMLv2Parser.RULE_ownedDisjoining);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1613;
          this.qualifiedName();
          this.state = 1618;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1614;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1615;
                this.qualifiedName();
              }
            }
            this.state = 1620;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    unioning() {
      let localContext = new UnioningContext(this.context, this.state);
      this.enterRule(localContext, 148, _SysMLv2Parser.RULE_unioning);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1621;
          this.qualifiedName();
          this.state = 1626;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1622;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1623;
                this.qualifiedName();
              }
            }
            this.state = 1628;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    intersecting() {
      let localContext = new IntersectingContext(this.context, this.state);
      this.enterRule(localContext, 150, _SysMLv2Parser.RULE_intersecting);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1629;
          this.qualifiedName();
          this.state = 1634;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1630;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1631;
                this.qualifiedName();
              }
            }
            this.state = 1636;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    differencing() {
      let localContext = new DifferencingContext(this.context, this.state);
      this.enterRule(localContext, 152, _SysMLv2Parser.RULE_differencing);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1637;
          this.qualifiedName();
          this.state = 1642;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1638;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1639;
                this.qualifiedName();
              }
            }
            this.state = 1644;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureMember() {
      let localContext = new FeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 154, _SysMLv2Parser.RULE_featureMember);
      try {
        this.state = 1647;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1645;
              this.typeFeatureMember();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1646;
              this.ownedFeatureMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typeFeatureMember() {
      let localContext = new TypeFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 156, _SysMLv2Parser.RULE_typeFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1649;
          this.memberPrefix();
          this.state = 1650;
          this.match(_SysMLv2Parser.MEMBER);
          this.state = 1651;
          this.featureElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedFeatureMember() {
      let localContext = new OwnedFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 158, _SysMLv2Parser.RULE_ownedFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1653;
          this.memberPrefix();
          this.state = 1654;
          this.featureElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    classifier() {
      let localContext = new ClassifierContext(this.context, this.state);
      this.enterRule(localContext, 160, _SysMLv2Parser.RULE_classifier);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1656;
          this.typePrefix();
          this.state = 1657;
          this.match(_SysMLv2Parser.CLASSIFIER);
          this.state = 1658;
          this.classifierDeclaration();
          this.state = 1659;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    classifierDeclaration() {
      let localContext = new ClassifierDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 162, _SysMLv2Parser.RULE_classifierDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1662;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 8) {
            {
              this.state = 1661;
              this.match(_SysMLv2Parser.ALL);
            }
          }
          this.state = 1665;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
            {
              this.state = 1664;
              this.identification();
            }
          }
          this.state = 1668;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 211) {
            {
              this.state = 1667;
              this.ownedMultiplicity();
            }
          }
          this.state = 1672;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.SPECIALIZES:
            case _SysMLv2Parser.COLON_GT:
              {
                this.state = 1670;
                this.superclassingPart();
              }
              break;
            case _SysMLv2Parser.CONJUGATES:
            case _SysMLv2Parser.TILDE:
              {
                this.state = 1671;
                this.conjugationPart();
              }
              break;
            case _SysMLv2Parser.DIFFERENCES:
            case _SysMLv2Parser.DISJOINT:
            case _SysMLv2Parser.INTERSECTS:
            case _SysMLv2Parser.UNIONS:
            case _SysMLv2Parser.SEMI:
            case _SysMLv2Parser.LBRACE:
              break;
            default:
              break;
          }
          this.state = 1677;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 50 || _la === 52 || _la === 86 || _la === 160) {
            {
              {
                this.state = 1674;
                this.typeRelationshipPart();
              }
            }
            this.state = 1679;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    superclassingPart() {
      let localContext = new SuperclassingPartContext(this.context, this.state);
      this.enterRule(localContext, 164, _SysMLv2Parser.RULE_superclassingPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1680;
          _la = this.tokenStream.LA(1);
          if (!(_la === 139 || _la === 185)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1681;
          this.ownedSubclassification();
          this.state = 1686;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1682;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1683;
                this.ownedSubclassification();
              }
            }
            this.state = 1688;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    subclassification() {
      let localContext = new SubclassificationContext(this.context, this.state);
      this.enterRule(localContext, 166, _SysMLv2Parser.RULE_subclassification);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1693;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 138) {
            {
              this.state = 1689;
              this.match(_SysMLv2Parser.SPECIALIZATION);
              this.state = 1691;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                {
                  this.state = 1690;
                  this.identification();
                }
              }
            }
          }
          this.state = 1695;
          this.match(_SysMLv2Parser.SUBCLASSIFIER);
          this.state = 1696;
          this.qualifiedName();
          this.state = 1697;
          _la = this.tokenStream.LA(1);
          if (!(_la === 139 || _la === 185)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1698;
          this.qualifiedName();
          this.state = 1699;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedSubclassification() {
      let localContext = new OwnedSubclassificationContext(this.context, this.state);
      this.enterRule(localContext, 168, _SysMLv2Parser.RULE_ownedSubclassification);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1701;
          this.qualifiedName();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    feature() {
      let localContext = new FeatureContext(this.context, this.state);
      this.enterRule(localContext, 170, _SysMLv2Parser.RULE_feature);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1720;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 110, this.context)) {
            case 1:
              {
                this.state = 1703;
                this.featurePrefix();
                this.state = 1706;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                  case _SysMLv2Parser.FEATURE:
                    {
                      this.state = 1704;
                      this.match(_SysMLv2Parser.FEATURE);
                    }
                    break;
                  case _SysMLv2Parser.HASH:
                    {
                      this.state = 1705;
                      this.prefixMetadataMember();
                    }
                    break;
                  default:
                    throw new NoViableAltException(this);
                }
                this.state = 1709;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 8 || _la === 20 || (_la - 34 & ~31) === 0 && (1 << _la - 34 & 2147492097) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 2488533505) !== 0 || (_la - 113 & ~31) === 0 && (1 << _la - 113 & 1073778945) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402687489) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 69730313) !== 0 || (_la - 217 & ~31) === 0 && (1 << _la - 217 & 7) !== 0) {
                  {
                    this.state = 1708;
                    this.featureDeclaration();
                  }
                }
              }
              break;
            case 2:
              {
                this.state = 1713;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 108, this.context)) {
                  case 1:
                    {
                      this.state = 1711;
                      this.endFeaturePrefix();
                    }
                    break;
                  case 2:
                    {
                      this.state = 1712;
                      this.basicFeaturePrefix();
                    }
                    break;
                }
                this.state = 1716;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 127) {
                  {
                    this.state = 1715;
                    this.match(_SysMLv2Parser.REF);
                  }
                }
                this.state = 1718;
                this.featureDeclaration();
              }
              break;
          }
          this.state = 1723;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 1722;
              this.valuePart();
            }
          }
          this.state = 1725;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    endFeaturePrefix() {
      let localContext = new EndFeaturePrefixContext(this.context, this.state);
      this.enterRule(localContext, 172, _SysMLv2Parser.RULE_endFeaturePrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1728;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 39) {
            {
              this.state = 1727;
              this.match(_SysMLv2Parser.CONST);
            }
          }
          this.state = 1730;
          this.match(_SysMLv2Parser.END);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    basicFeaturePrefix() {
      let localContext = new BasicFeaturePrefixContext(this.context, this.state);
      this.enterRule(localContext, 174, _SysMLv2Parser.RULE_basicFeaturePrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1733;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 80 || _la === 83 || _la === 114) {
            {
              this.state = 1732;
              this.featureDirection();
            }
          }
          this.state = 1736;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 49) {
            {
              this.state = 1735;
              this.match(_SysMLv2Parser.DERIVED);
            }
          }
          this.state = 1739;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 2) {
            {
              this.state = 1738;
              this.match(_SysMLv2Parser.ABSTRACT);
            }
          }
          this.state = 1742;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 31 || _la === 120) {
            {
              this.state = 1741;
              _la = this.tokenStream.LA(1);
              if (!(_la === 31 || _la === 120)) {
                this.errorHandler.recoverInline(this);
              } else {
                this.errorHandler.reportMatch(this);
                this.consume();
              }
            }
          }
          this.state = 1745;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 117, this.context)) {
            case 1:
              {
                this.state = 1744;
                _la = this.tokenStream.LA(1);
                if (!(_la === 39 || _la === 163)) {
                  this.errorHandler.recoverInline(this);
                } else {
                  this.errorHandler.reportMatch(this);
                  this.consume();
                }
              }
              break;
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featurePrefix() {
      let localContext = new FeaturePrefixContext(this.context, this.state);
      this.enterRule(localContext, 176, _SysMLv2Parser.RULE_featurePrefix);
      try {
        let alternative;
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1751;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 118, this.context)) {
            case 1:
              {
                this.state = 1747;
                this.endFeaturePrefix();
                this.state = 1748;
                this.ownedCrossFeatureMember();
              }
              break;
            case 2:
              {
                this.state = 1750;
                this.basicFeaturePrefix();
              }
              break;
          }
          this.state = 1756;
          this.errorHandler.sync(this);
          alternative = this.interpreter.adaptivePredict(this.tokenStream, 119, this.context);
          while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
            if (alternative === 1) {
              {
                {
                  this.state = 1753;
                  this.prefixMetadataMember();
                }
              }
            }
            this.state = 1758;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 119, this.context);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedCrossFeatureMember() {
      let localContext = new OwnedCrossFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 178, _SysMLv2Parser.RULE_ownedCrossFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1759;
          this.ownedCrossFeature();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedCrossFeature() {
      let localContext = new OwnedCrossFeatureContext(this.context, this.state);
      this.enterRule(localContext, 180, _SysMLv2Parser.RULE_ownedCrossFeature);
      try {
        this.state = 1768;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 121, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1761;
              this.basicFeaturePrefix();
              this.state = 1762;
              this.featureDeclaration();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1764;
              this.basicUsagePrefix();
              this.state = 1766;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 120, this.context)) {
                case 1:
                  {
                    this.state = 1765;
                    this.usageDeclaration();
                  }
                  break;
              }
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureDirection() {
      let localContext = new FeatureDirectionContext(this.context, this.state);
      this.enterRule(localContext, 182, _SysMLv2Parser.RULE_featureDirection);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1770;
          _la = this.tokenStream.LA(1);
          if (!(_la === 80 || _la === 83 || _la === 114)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureDeclaration() {
      let localContext = new FeatureDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 184, _SysMLv2Parser.RULE_featureDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1773;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 8) {
            {
              this.state = 1772;
              this.match(_SysMLv2Parser.ALL);
            }
          }
          this.state = 1782;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 124, this.context)) {
            case 1:
              {
                this.state = 1775;
                this.featureIdentification();
                this.state = 1778;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 123, this.context)) {
                  case 1:
                    {
                      this.state = 1776;
                      this.featureSpecializationPart();
                    }
                    break;
                  case 2:
                    {
                      this.state = 1777;
                      this.conjugationPart();
                    }
                    break;
                }
              }
              break;
            case 2:
              {
                this.state = 1780;
                this.featureSpecializationPart();
              }
              break;
            case 3:
              {
                this.state = 1781;
                this.conjugationPart();
              }
              break;
          }
          this.state = 1787;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while ((_la - 27 & ~31) === 0 && (1 << _la - 27 & 41943041) !== 0 || (_la - 66 & ~31) === 0 && (1 << _la - 66 & 5242881) !== 0 || _la === 160) {
            {
              {
                this.state = 1784;
                this.featureRelationshipPart();
              }
            }
            this.state = 1789;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureIdentification() {
      let localContext = new FeatureIdentificationContext(this.context, this.state);
      this.enterRule(localContext, 186, _SysMLv2Parser.RULE_featureIdentification);
      try {
        this.state = 1797;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.LT:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1790;
              this.match(_SysMLv2Parser.LT);
              this.state = 1791;
              this.name();
              this.state = 1792;
              this.match(_SysMLv2Parser.GT);
              this.state = 1794;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 126, this.context)) {
                case 1:
                  {
                    this.state = 1793;
                    this.name();
                  }
                  break;
              }
            }
            break;
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
          case _SysMLv2Parser.IDENTIFIER:
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1796;
              this.name();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureRelationshipPart() {
      let localContext = new FeatureRelationshipPartContext(this.context, this.state);
      this.enterRule(localContext, 188, _SysMLv2Parser.RULE_featureRelationshipPart);
      try {
        this.state = 1803;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.DIFFERENCES:
          case _SysMLv2Parser.DISJOINT:
          case _SysMLv2Parser.INTERSECTS:
          case _SysMLv2Parser.UNIONS:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1799;
              this.typeRelationshipPart();
            }
            break;
          case _SysMLv2Parser.CHAINS:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1800;
              this.chainingPart();
            }
            break;
          case _SysMLv2Parser.INVERSE:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1801;
              this.invertingPart();
            }
            break;
          case _SysMLv2Parser.FEATURED:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1802;
              this.typeFeaturingPart();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    chainingPart() {
      let localContext = new ChainingPartContext(this.context, this.state);
      this.enterRule(localContext, 190, _SysMLv2Parser.RULE_chainingPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1805;
          this.match(_SysMLv2Parser.CHAINS);
          this.state = 1806;
          this.qualifiedName();
          this.state = 1811;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1807;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1808;
                this.qualifiedName();
              }
            }
            this.state = 1813;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    invertingPart() {
      let localContext = new InvertingPartContext(this.context, this.state);
      this.enterRule(localContext, 192, _SysMLv2Parser.RULE_invertingPart);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1814;
          this.match(_SysMLv2Parser.INVERSE);
          this.state = 1815;
          this.match(_SysMLv2Parser.OF);
          this.state = 1816;
          this.ownedFeatureInverting();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typeFeaturingPart() {
      let localContext = new TypeFeaturingPartContext(this.context, this.state);
      this.enterRule(localContext, 194, _SysMLv2Parser.RULE_typeFeaturingPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1818;
          this.match(_SysMLv2Parser.FEATURED);
          this.state = 1819;
          this.match(_SysMLv2Parser.BY);
          this.state = 1820;
          this.ownedTypeFeaturing();
          this.state = 1825;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1821;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1822;
                this.ownedTypeFeaturing();
              }
            }
            this.state = 1827;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureSpecializationPart() {
      let localContext = new FeatureSpecializationPartContext(this.context, this.state);
      this.enterRule(localContext, 196, _SysMLv2Parser.RULE_featureSpecializationPart);
      try {
        let alternative;
        this.state = 1849;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.DEFINED:
          case _SysMLv2Parser.REDEFINES:
          case _SysMLv2Parser.REFERENCES:
          case _SysMLv2Parser.SUBSETS:
          case _SysMLv2Parser.TYPED:
          case _SysMLv2Parser.COLON_COLON_GT:
          case _SysMLv2Parser.COLON_GT_GT:
          case _SysMLv2Parser.COLON_GT:
          case _SysMLv2Parser.FAT_ARROW:
          case _SysMLv2Parser.COLON:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1829;
              this.errorHandler.sync(this);
              alternative = 1;
              do {
                switch (alternative) {
                  case 1:
                    {
                      {
                        this.state = 1828;
                        this.featureSpecialization();
                      }
                    }
                    break;
                  default:
                    throw new NoViableAltException(this);
                }
                this.state = 1831;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 131, this.context);
              } while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER);
              this.state = 1834;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 132, this.context)) {
                case 1:
                  {
                    this.state = 1833;
                    this.multiplicityPart();
                  }
                  break;
              }
              this.state = 1839;
              this.errorHandler.sync(this);
              alternative = this.interpreter.adaptivePredict(this.tokenStream, 133, this.context);
              while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                  {
                    {
                      this.state = 1836;
                      this.featureSpecialization();
                    }
                  }
                }
                this.state = 1841;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 133, this.context);
              }
            }
            break;
          case _SysMLv2Parser.NONUNIQUE:
          case _SysMLv2Parser.ORDERED:
          case _SysMLv2Parser.LBRACK:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1842;
              this.multiplicityPart();
              this.state = 1846;
              this.errorHandler.sync(this);
              alternative = this.interpreter.adaptivePredict(this.tokenStream, 134, this.context);
              while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                  {
                    {
                      this.state = 1843;
                      this.featureSpecialization();
                    }
                  }
                }
                this.state = 1848;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 134, this.context);
              }
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    multiplicityPart() {
      let localContext = new MultiplicityPartContext(this.context, this.state);
      this.enterRule(localContext, 198, _SysMLv2Parser.RULE_multiplicityPart);
      try {
        this.state = 1872;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.LBRACK:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1851;
              this.ownedMultiplicity();
              this.state = 1860;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 138, this.context)) {
                case 1:
                  {
                    this.state = 1852;
                    this.match(_SysMLv2Parser.ORDERED);
                    this.state = 1854;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 136, this.context)) {
                      case 1:
                        {
                          this.state = 1853;
                          this.match(_SysMLv2Parser.NONUNIQUE);
                        }
                        break;
                    }
                  }
                  break;
                case 2:
                  {
                    this.state = 1856;
                    this.match(_SysMLv2Parser.NONUNIQUE);
                    this.state = 1858;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 137, this.context)) {
                      case 1:
                        {
                          this.state = 1857;
                          this.match(_SysMLv2Parser.ORDERED);
                        }
                        break;
                    }
                  }
                  break;
              }
            }
            break;
          case _SysMLv2Parser.NONUNIQUE:
          case _SysMLv2Parser.ORDERED:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1870;
              this.errorHandler.sync(this);
              switch (this.tokenStream.LA(1)) {
                case _SysMLv2Parser.ORDERED:
                  {
                    this.state = 1862;
                    this.match(_SysMLv2Parser.ORDERED);
                    this.state = 1864;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 139, this.context)) {
                      case 1:
                        {
                          this.state = 1863;
                          this.match(_SysMLv2Parser.NONUNIQUE);
                        }
                        break;
                    }
                  }
                  break;
                case _SysMLv2Parser.NONUNIQUE:
                  {
                    this.state = 1866;
                    this.match(_SysMLv2Parser.NONUNIQUE);
                    this.state = 1868;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 140, this.context)) {
                      case 1:
                        {
                          this.state = 1867;
                          this.match(_SysMLv2Parser.ORDERED);
                        }
                        break;
                    }
                  }
                  break;
                default:
                  throw new NoViableAltException(this);
              }
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureSpecialization() {
      let localContext = new FeatureSpecializationContext(this.context, this.state);
      this.enterRule(localContext, 200, _SysMLv2Parser.RULE_featureSpecialization);
      try {
        this.state = 1879;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.DEFINED:
          case _SysMLv2Parser.TYPED:
          case _SysMLv2Parser.COLON:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1874;
              this.typings();
            }
            break;
          case _SysMLv2Parser.SUBSETS:
          case _SysMLv2Parser.COLON_GT:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1875;
              this.subsettings();
            }
            break;
          case _SysMLv2Parser.REFERENCES:
          case _SysMLv2Parser.COLON_COLON_GT:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1876;
              this.references();
            }
            break;
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FAT_ARROW:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 1877;
              this.crosses();
            }
            break;
          case _SysMLv2Parser.REDEFINES:
          case _SysMLv2Parser.COLON_GT_GT:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 1878;
              this.redefinitions();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typings() {
      let localContext = new TypingsContext(this.context, this.state);
      this.enterRule(localContext, 202, _SysMLv2Parser.RULE_typings);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1881;
          this.typedBy();
          this.state = 1886;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1882;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1883;
                this.featureTyping();
              }
            }
            this.state = 1888;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typedBy() {
      let localContext = new TypedByContext(this.context, this.state);
      this.enterRule(localContext, 204, _SysMLv2Parser.RULE_typedBy);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1894;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.COLON:
              {
                this.state = 1889;
                this.match(_SysMLv2Parser.COLON);
              }
              break;
            case _SysMLv2Parser.TYPED:
              {
                this.state = 1890;
                this.match(_SysMLv2Parser.TYPED);
                this.state = 1891;
                this.match(_SysMLv2Parser.BY);
              }
              break;
            case _SysMLv2Parser.DEFINED:
              {
                this.state = 1892;
                this.match(_SysMLv2Parser.DEFINED);
                this.state = 1893;
                this.match(_SysMLv2Parser.BY);
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 1896;
          this.featureTyping();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    subsettings() {
      let localContext = new SubsettingsContext(this.context, this.state);
      this.enterRule(localContext, 206, _SysMLv2Parser.RULE_subsettings);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1898;
          this.subsets();
          this.state = 1903;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1899;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1900;
                this.ownedSubsetting();
              }
            }
            this.state = 1905;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    subsets() {
      let localContext = new SubsetsContext(this.context, this.state);
      this.enterRule(localContext, 208, _SysMLv2Parser.RULE_subsets);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1906;
          _la = this.tokenStream.LA(1);
          if (!(_la === 148 || _la === 185)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1907;
          this.ownedSubsetting();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    references() {
      let localContext = new ReferencesContext(this.context, this.state);
      this.enterRule(localContext, 210, _SysMLv2Parser.RULE_references);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1909;
          _la = this.tokenStream.LA(1);
          if (!(_la === 128 || _la === 175)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1910;
          this.ownedReferenceSubsetting();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    crosses() {
      let localContext = new CrossesContext(this.context, this.state);
      this.enterRule(localContext, 212, _SysMLv2Parser.RULE_crosses);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1912;
          _la = this.tokenStream.LA(1);
          if (!(_la === 42 || _la === 188)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1913;
          this.ownedCrossSubsetting();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    redefinitions() {
      let localContext = new RedefinitionsContext(this.context, this.state);
      this.enterRule(localContext, 214, _SysMLv2Parser.RULE_redefinitions);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1915;
          this.redefines();
          this.state = 1920;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 1916;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 1917;
                this.ownedRedefinition();
              }
            }
            this.state = 1922;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    redefines() {
      let localContext = new RedefinesContext(this.context, this.state);
      this.enterRule(localContext, 216, _SysMLv2Parser.RULE_redefines);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1923;
          _la = this.tokenStream.LA(1);
          if (!(_la === 125 || _la === 176)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1924;
          this.ownedRedefinition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureTyping() {
      let localContext = new FeatureTypingContext(this.context, this.state);
      this.enterRule(localContext, 218, _SysMLv2Parser.RULE_featureTyping);
      let _la;
      try {
        this.state = 1944;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SPECIALIZATION:
          case _SysMLv2Parser.TYPING:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 1930;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 138) {
                {
                  this.state = 1926;
                  this.match(_SysMLv2Parser.SPECIALIZATION);
                  this.state = 1928;
                  this.errorHandler.sync(this);
                  _la = this.tokenStream.LA(1);
                  if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                    {
                      this.state = 1927;
                      this.identification();
                    }
                  }
                }
              }
              this.state = 1932;
              this.match(_SysMLv2Parser.TYPING);
              this.state = 1933;
              this.qualifiedName();
              this.state = 1937;
              this.errorHandler.sync(this);
              switch (this.tokenStream.LA(1)) {
                case _SysMLv2Parser.COLON:
                  {
                    this.state = 1934;
                    this.match(_SysMLv2Parser.COLON);
                  }
                  break;
                case _SysMLv2Parser.TYPED:
                  {
                    this.state = 1935;
                    this.match(_SysMLv2Parser.TYPED);
                    this.state = 1936;
                    this.match(_SysMLv2Parser.BY);
                  }
                  break;
                default:
                  throw new NoViableAltException(this);
              }
              this.state = 1939;
              this.generalType();
              this.state = 1940;
              this.relationshipBody();
            }
            break;
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
          case _SysMLv2Parser.DOLLAR:
          case _SysMLv2Parser.IDENTIFIER:
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 1942;
              this.ownedFeatureTyping();
            }
            break;
          case _SysMLv2Parser.TILDE:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 1943;
              this.conjugatedPortTyping();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedFeatureTyping() {
      let localContext = new OwnedFeatureTypingContext(this.context, this.state);
      this.enterRule(localContext, 220, _SysMLv2Parser.RULE_ownedFeatureTyping);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1946;
          this.qualifiedName();
          this.state = 1951;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1947;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1948;
                this.qualifiedName();
              }
            }
            this.state = 1953;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    subsetting() {
      let localContext = new SubsettingContext(this.context, this.state);
      this.enterRule(localContext, 222, _SysMLv2Parser.RULE_subsetting);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1958;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 138) {
            {
              this.state = 1954;
              this.match(_SysMLv2Parser.SPECIALIZATION);
              this.state = 1956;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                {
                  this.state = 1955;
                  this.identification();
                }
              }
            }
          }
          this.state = 1960;
          this.match(_SysMLv2Parser.SUBSET);
          this.state = 1961;
          this.specificType();
          this.state = 1962;
          _la = this.tokenStream.LA(1);
          if (!(_la === 148 || _la === 185)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1963;
          this.generalType();
          this.state = 1964;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedSubsetting() {
      let localContext = new OwnedSubsettingContext(this.context, this.state);
      this.enterRule(localContext, 224, _SysMLv2Parser.RULE_ownedSubsetting);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1966;
          this.qualifiedName();
          this.state = 1971;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1967;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1968;
                this.qualifiedName();
              }
            }
            this.state = 1973;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedReferenceSubsetting() {
      let localContext = new OwnedReferenceSubsettingContext(this.context, this.state);
      this.enterRule(localContext, 226, _SysMLv2Parser.RULE_ownedReferenceSubsetting);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1974;
          this.qualifiedName();
          this.state = 1979;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1975;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1976;
                this.qualifiedName();
              }
            }
            this.state = 1981;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedCrossSubsetting() {
      let localContext = new OwnedCrossSubsettingContext(this.context, this.state);
      this.enterRule(localContext, 228, _SysMLv2Parser.RULE_ownedCrossSubsetting);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1982;
          this.qualifiedName();
          this.state = 1987;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 1983;
                this.match(_SysMLv2Parser.DOT);
                this.state = 1984;
                this.qualifiedName();
              }
            }
            this.state = 1989;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    redefinition() {
      let localContext = new RedefinitionContext(this.context, this.state);
      this.enterRule(localContext, 230, _SysMLv2Parser.RULE_redefinition);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 1994;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 138) {
            {
              this.state = 1990;
              this.match(_SysMLv2Parser.SPECIALIZATION);
              this.state = 1992;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                {
                  this.state = 1991;
                  this.identification();
                }
              }
            }
          }
          this.state = 1996;
          this.match(_SysMLv2Parser.REDEFINITION);
          this.state = 1997;
          this.specificType();
          this.state = 1998;
          _la = this.tokenStream.LA(1);
          if (!(_la === 125 || _la === 176)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 1999;
          this.generalType();
          this.state = 2e3;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedRedefinition() {
      let localContext = new OwnedRedefinitionContext(this.context, this.state);
      this.enterRule(localContext, 232, _SysMLv2Parser.RULE_ownedRedefinition);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2002;
          this.qualifiedName();
          this.state = 2007;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 2003;
                this.match(_SysMLv2Parser.DOT);
                this.state = 2004;
                this.qualifiedName();
              }
            }
            this.state = 2009;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureInverting() {
      let localContext = new FeatureInvertingContext(this.context, this.state);
      this.enterRule(localContext, 234, _SysMLv2Parser.RULE_featureInverting);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2014;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 89) {
            {
              this.state = 2010;
              this.match(_SysMLv2Parser.INVERTING);
              this.state = 2012;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                {
                  this.state = 2011;
                  this.identification();
                }
              }
            }
          }
          this.state = 2016;
          this.match(_SysMLv2Parser.INVERSE);
          this.state = 2017;
          this.qualifiedName();
          this.state = 2022;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 2018;
                this.match(_SysMLv2Parser.DOT);
                this.state = 2019;
                this.qualifiedName();
              }
            }
            this.state = 2024;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2025;
          this.match(_SysMLv2Parser.OF);
          this.state = 2026;
          this.qualifiedName();
          this.state = 2031;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 2027;
                this.match(_SysMLv2Parser.DOT);
                this.state = 2028;
                this.qualifiedName();
              }
            }
            this.state = 2033;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2034;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedFeatureInverting() {
      let localContext = new OwnedFeatureInvertingContext(this.context, this.state);
      this.enterRule(localContext, 236, _SysMLv2Parser.RULE_ownedFeatureInverting);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2036;
          this.qualifiedName();
          this.state = 2041;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 2037;
                this.match(_SysMLv2Parser.DOT);
                this.state = 2038;
                this.qualifiedName();
              }
            }
            this.state = 2043;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    typeFeaturing() {
      let localContext = new TypeFeaturingContext(this.context, this.state);
      this.enterRule(localContext, 238, _SysMLv2Parser.RULE_typeFeaturing);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2044;
          this.match(_SysMLv2Parser.FEATURING);
          this.state = 2049;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 167, this.context)) {
            case 1:
              {
                this.state = 2046;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                  {
                    this.state = 2045;
                    this.identification();
                  }
                }
                this.state = 2048;
                this.match(_SysMLv2Parser.OF);
              }
              break;
          }
          this.state = 2051;
          this.qualifiedName();
          this.state = 2052;
          this.match(_SysMLv2Parser.BY);
          this.state = 2053;
          this.qualifiedName();
          this.state = 2054;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedTypeFeaturing() {
      let localContext = new OwnedTypeFeaturingContext(this.context, this.state);
      this.enterRule(localContext, 240, _SysMLv2Parser.RULE_ownedTypeFeaturing);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2056;
          this.qualifiedName();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    dataType() {
      let localContext = new DataTypeContext(this.context, this.state);
      this.enterRule(localContext, 242, _SysMLv2Parser.RULE_dataType);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2058;
          this.typePrefix();
          this.state = 2059;
          this.match(_SysMLv2Parser.DATATYPE);
          this.state = 2060;
          this.classifierDeclaration();
          this.state = 2061;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    class_() {
      let localContext = new ClassContext(this.context, this.state);
      this.enterRule(localContext, 244, _SysMLv2Parser.RULE_class);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2063;
          this.typePrefix();
          this.state = 2064;
          this.match(_SysMLv2Parser.CLASS);
          this.state = 2065;
          this.classifierDeclaration();
          this.state = 2066;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    structure() {
      let localContext = new StructureContext(this.context, this.state);
      this.enterRule(localContext, 246, _SysMLv2Parser.RULE_structure);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2068;
          this.typePrefix();
          this.state = 2069;
          this.match(_SysMLv2Parser.STRUCT);
          this.state = 2070;
          this.classifierDeclaration();
          this.state = 2071;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    association() {
      let localContext = new AssociationContext(this.context, this.state);
      this.enterRule(localContext, 248, _SysMLv2Parser.RULE_association);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2073;
          this.typePrefix();
          this.state = 2074;
          this.match(_SysMLv2Parser.ASSOC);
          this.state = 2075;
          this.classifierDeclaration();
          this.state = 2076;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    associationStructure() {
      let localContext = new AssociationStructureContext(this.context, this.state);
      this.enterRule(localContext, 250, _SysMLv2Parser.RULE_associationStructure);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2078;
          this.typePrefix();
          this.state = 2079;
          this.match(_SysMLv2Parser.ASSOC);
          this.state = 2080;
          this.match(_SysMLv2Parser.STRUCT);
          this.state = 2081;
          this.classifierDeclaration();
          this.state = 2082;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    connector() {
      let localContext = new ConnectorContext(this.context, this.state);
      this.enterRule(localContext, 252, _SysMLv2Parser.RULE_connector);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2084;
          this.featurePrefix();
          this.state = 2085;
          this.match(_SysMLv2Parser.CONNECTOR);
          this.state = 2093;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 170, this.context)) {
            case 1:
              {
                this.state = 2087;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 8 || _la === 20 || (_la - 34 & ~31) === 0 && (1 << _la - 34 & 2147492097) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 2488533505) !== 0 || (_la - 113 & ~31) === 0 && (1 << _la - 113 & 1073778945) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402687489) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 69730313) !== 0 || (_la - 217 & ~31) === 0 && (1 << _la - 217 & 7) !== 0) {
                  {
                    this.state = 2086;
                    this.featureDeclaration();
                  }
                }
                this.state = 2090;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 46 || _la === 184 || _la === 207) {
                  {
                    this.state = 2089;
                    this.valuePart();
                  }
                }
              }
              break;
            case 2:
              {
                this.state = 2092;
                this.connectorDeclaration();
              }
              break;
          }
          this.state = 2095;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    connectorDeclaration() {
      let localContext = new ConnectorDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 254, _SysMLv2Parser.RULE_connectorDeclaration);
      try {
        this.state = 2099;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 171, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2097;
              this.binaryConnectorDeclaration();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2098;
              this.naryConnectorDeclaration();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    binaryConnectorDeclaration() {
      let localContext = new BinaryConnectorDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 256, _SysMLv2Parser.RULE_binaryConnectorDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2109;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 174, this.context)) {
            case 1:
              {
                this.state = 2102;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 8 || _la === 20 || (_la - 34 & ~31) === 0 && (1 << _la - 34 & 2147492097) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 2488533505) !== 0 || (_la - 113 & ~31) === 0 && (1 << _la - 113 & 1073778945) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402687489) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 69730313) !== 0 || (_la - 217 & ~31) === 0 && (1 << _la - 217 & 7) !== 0) {
                  {
                    this.state = 2101;
                    this.featureDeclaration();
                  }
                }
                this.state = 2104;
                this.match(_SysMLv2Parser.FROM);
              }
              break;
            case 2:
              {
                this.state = 2105;
                this.match(_SysMLv2Parser.ALL);
                this.state = 2107;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 74) {
                  {
                    this.state = 2106;
                    this.match(_SysMLv2Parser.FROM);
                  }
                }
              }
              break;
          }
          this.state = 2111;
          this.connectorEndMember();
          this.state = 2112;
          this.match(_SysMLv2Parser.TO);
          this.state = 2113;
          this.connectorEndMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    naryConnectorDeclaration() {
      let localContext = new NaryConnectorDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 258, _SysMLv2Parser.RULE_naryConnectorDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2116;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 8 || _la === 20 || (_la - 34 & ~31) === 0 && (1 << _la - 34 & 2147492097) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 2488533505) !== 0 || (_la - 113 & ~31) === 0 && (1 << _la - 113 & 1073778945) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402687489) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 69730313) !== 0 || (_la - 217 & ~31) === 0 && (1 << _la - 217 & 7) !== 0) {
            {
              this.state = 2115;
              this.featureDeclaration();
            }
          }
          this.state = 2118;
          this.match(_SysMLv2Parser.LPAREN);
          this.state = 2119;
          this.connectorEndMember();
          this.state = 2120;
          this.match(_SysMLv2Parser.COMMA);
          this.state = 2121;
          this.connectorEndMember();
          this.state = 2126;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 2122;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 2123;
                this.connectorEndMember();
              }
            }
            this.state = 2128;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2129;
          this.match(_SysMLv2Parser.RPAREN);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    connectorEndMember() {
      let localContext = new ConnectorEndMemberContext(this.context, this.state);
      this.enterRule(localContext, 260, _SysMLv2Parser.RULE_connectorEndMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2131;
          this.connectorEnd();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    connectorEnd() {
      let localContext = new ConnectorEndContext(this.context, this.state);
      this.enterRule(localContext, 262, _SysMLv2Parser.RULE_connectorEnd);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2134;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 211) {
            {
              this.state = 2133;
              this.ownedCrossMultiplicityMember();
            }
          }
          this.state = 2139;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 178, this.context)) {
            case 1:
              {
                this.state = 2136;
                this.name();
                this.state = 2137;
                _la = this.tokenStream.LA(1);
                if (!(_la === 128 || _la === 175)) {
                  this.errorHandler.recoverInline(this);
                } else {
                  this.errorHandler.reportMatch(this);
                  this.consume();
                }
              }
              break;
          }
          this.state = 2141;
          this.ownedReferenceSubsetting();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedCrossMultiplicityMember() {
      let localContext = new OwnedCrossMultiplicityMemberContext(this.context, this.state);
      this.enterRule(localContext, 264, _SysMLv2Parser.RULE_ownedCrossMultiplicityMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2143;
          this.ownedCrossMultiplicity();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedCrossMultiplicity() {
      let localContext = new OwnedCrossMultiplicityContext(this.context, this.state);
      this.enterRule(localContext, 266, _SysMLv2Parser.RULE_ownedCrossMultiplicity);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2145;
          this.ownedMultiplicity();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    bindingConnector() {
      let localContext = new BindingConnectorContext(this.context, this.state);
      this.enterRule(localContext, 268, _SysMLv2Parser.RULE_bindingConnector);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2147;
          this.featurePrefix();
          this.state = 2148;
          this.match(_SysMLv2Parser.BINDING);
          this.state = 2149;
          this.bindingConnectorDeclaration();
          this.state = 2150;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    bindingConnectorDeclaration() {
      let localContext = new BindingConnectorDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 270, _SysMLv2Parser.RULE_bindingConnectorDeclaration);
      let _la;
      try {
        this.state = 2172;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 183, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2152;
              this.featureDeclaration();
              this.state = 2158;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 111) {
                {
                  this.state = 2153;
                  this.match(_SysMLv2Parser.OF);
                  this.state = 2154;
                  this.connectorEndMember();
                  this.state = 2155;
                  this.match(_SysMLv2Parser.EQ);
                  this.state = 2156;
                  this.connectorEndMember();
                }
              }
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2161;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 8) {
                {
                  this.state = 2160;
                  this.match(_SysMLv2Parser.ALL);
                }
              }
              this.state = 2170;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16793681) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 193 & ~31) === 0 && (1 << _la - 193 & 100925441) !== 0) {
                {
                  this.state = 2164;
                  this.errorHandler.sync(this);
                  _la = this.tokenStream.LA(1);
                  if (_la === 111) {
                    {
                      this.state = 2163;
                      this.match(_SysMLv2Parser.OF);
                    }
                  }
                  this.state = 2166;
                  this.connectorEndMember();
                  this.state = 2167;
                  this.match(_SysMLv2Parser.EQ);
                  this.state = 2168;
                  this.connectorEndMember();
                }
              }
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    succession() {
      let localContext = new SuccessionContext(this.context, this.state);
      this.enterRule(localContext, 272, _SysMLv2Parser.RULE_succession);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2174;
          this.featurePrefix();
          this.state = 2175;
          this.match(_SysMLv2Parser.SUCCESSION);
          this.state = 2176;
          this.successionDeclaration();
          this.state = 2177;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    successionDeclaration() {
      let localContext = new SuccessionDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 274, _SysMLv2Parser.RULE_successionDeclaration);
      let _la;
      try {
        this.state = 2199;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 188, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2179;
              this.featureDeclaration();
              this.state = 2185;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 69) {
                {
                  this.state = 2180;
                  this.match(_SysMLv2Parser.FIRST);
                  this.state = 2181;
                  this.connectorEndMember();
                  this.state = 2182;
                  this.match(_SysMLv2Parser.THEN);
                  this.state = 2183;
                  this.connectorEndMember();
                }
              }
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2188;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 8) {
                {
                  this.state = 2187;
                  this.match(_SysMLv2Parser.ALL);
                }
              }
              this.state = 2197;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702609) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 193 & ~31) === 0 && (1 << _la - 193 & 100925441) !== 0) {
                {
                  this.state = 2191;
                  this.errorHandler.sync(this);
                  _la = this.tokenStream.LA(1);
                  if (_la === 69) {
                    {
                      this.state = 2190;
                      this.match(_SysMLv2Parser.FIRST);
                    }
                  }
                  this.state = 2193;
                  this.connectorEndMember();
                  this.state = 2194;
                  this.match(_SysMLv2Parser.THEN);
                  this.state = 2195;
                  this.connectorEndMember();
                }
              }
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    behavior() {
      let localContext = new BehaviorContext(this.context, this.state);
      this.enterRule(localContext, 276, _SysMLv2Parser.RULE_behavior);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2201;
          this.typePrefix();
          this.state = 2202;
          this.match(_SysMLv2Parser.BEHAVIOR);
          this.state = 2203;
          this.classifierDeclaration();
          this.state = 2204;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    step() {
      let localContext = new StepContext(this.context, this.state);
      this.enterRule(localContext, 278, _SysMLv2Parser.RULE_step);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2206;
          this.featurePrefix();
          this.state = 2207;
          this.match(_SysMLv2Parser.STEP);
          this.state = 2208;
          this.featureDeclaration();
          this.state = 2210;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 2209;
              this.valuePart();
            }
          }
          this.state = 2212;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    function_() {
      let localContext = new FunctionContext(this.context, this.state);
      this.enterRule(localContext, 280, _SysMLv2Parser.RULE_function);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2214;
          this.typePrefix();
          this.state = 2215;
          this.match(_SysMLv2Parser.FUNCTION);
          this.state = 2216;
          this.classifierDeclaration();
          this.state = 2217;
          this.functionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    functionBody() {
      let localContext = new FunctionBodyContext(this.context, this.state);
      this.enterRule(localContext, 282, _SysMLv2Parser.RULE_functionBody);
      try {
        this.state = 2224;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2219;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2220;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 2221;
              this.functionBodyPart();
              this.state = 2222;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    functionBodyPart() {
      let localContext = new FunctionBodyPartContext(this.context, this.state);
      this.enterRule(localContext, 284, _SysMLv2Parser.RULE_functionBodyPart);
      let _la;
      try {
        let alternative;
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2231;
          this.errorHandler.sync(this);
          alternative = this.interpreter.adaptivePredict(this.tokenStream, 192, this.context);
          while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
            if (alternative === 1) {
              {
                this.state = 2229;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 191, this.context)) {
                  case 1:
                    {
                      this.state = 2226;
                      this.definitionBodyItem();
                    }
                    break;
                  case 2:
                    {
                      this.state = 2227;
                      this.typeBodyElement();
                    }
                    break;
                  case 3:
                    {
                      this.state = 2228;
                      this.returnFeatureMember();
                    }
                    break;
                }
              }
            }
            this.state = 2233;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 192, this.context);
          }
          this.state = 2235;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 8 || _la === 20 || (_la - 42 & ~31) === 0 && (1 << _la - 42 & 12582913) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 1414791685) !== 0 || (_la - 107 & ~31) === 0 && (1 << _la - 107 & 245763) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1073153) !== 0 || (_la - 191 & ~31) === 0 && (1 << _la - 191 & 4236772773) !== 0 || _la === 223) {
            {
              this.state = 2234;
              this.resultExpressionMember();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    returnFeatureMember() {
      let localContext = new ReturnFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 286, _SysMLv2Parser.RULE_returnFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2237;
          this.memberPrefix();
          this.state = 2238;
          this.match(_SysMLv2Parser.RETURN);
          this.state = 2239;
          this.featureElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    resultExpressionMember() {
      let localContext = new ResultExpressionMemberContext(this.context, this.state);
      this.enterRule(localContext, 288, _SysMLv2Parser.RULE_resultExpressionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2241;
          this.memberPrefix();
          this.state = 2242;
          this.ownedExpression(0);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    expression() {
      let localContext = new ExpressionContext(this.context, this.state);
      this.enterRule(localContext, 290, _SysMLv2Parser.RULE_expression);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2244;
          this.featurePrefix();
          this.state = 2245;
          this.match(_SysMLv2Parser.EXPR);
          this.state = 2246;
          this.featureDeclaration();
          this.state = 2248;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 2247;
              this.valuePart();
            }
          }
          this.state = 2250;
          this.functionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    predicate() {
      let localContext = new PredicateContext(this.context, this.state);
      this.enterRule(localContext, 292, _SysMLv2Parser.RULE_predicate);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2252;
          this.typePrefix();
          this.state = 2253;
          this.match(_SysMLv2Parser.PREDICATE);
          this.state = 2254;
          this.classifierDeclaration();
          this.state = 2255;
          this.functionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    booleanExpression() {
      let localContext = new BooleanExpressionContext(this.context, this.state);
      this.enterRule(localContext, 294, _SysMLv2Parser.RULE_booleanExpression);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2257;
          this.featurePrefix();
          this.state = 2258;
          this.match(_SysMLv2Parser.BOOL);
          this.state = 2259;
          this.featureDeclaration();
          this.state = 2261;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 2260;
              this.valuePart();
            }
          }
          this.state = 2263;
          this.functionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    invariant() {
      let localContext = new InvariantContext(this.context, this.state);
      this.enterRule(localContext, 296, _SysMLv2Parser.RULE_invariant);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2265;
          this.featurePrefix();
          this.state = 2266;
          this.match(_SysMLv2Parser.INV);
          this.state = 2268;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 64 || _la === 156) {
            {
              this.state = 2267;
              _la = this.tokenStream.LA(1);
              if (!(_la === 64 || _la === 156)) {
                this.errorHandler.recoverInline(this);
              } else {
                this.errorHandler.reportMatch(this);
                this.consume();
              }
            }
          }
          this.state = 2270;
          this.featureDeclaration();
          this.state = 2272;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 2271;
              this.valuePart();
            }
          }
          this.state = 2274;
          this.functionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureChainMember() {
      let localContext = new FeatureChainMemberContext(this.context, this.state);
      this.enterRule(localContext, 298, _SysMLv2Parser.RULE_featureChainMember);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2276;
          this.qualifiedName();
          this.state = 2281;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 2277;
                this.match(_SysMLv2Parser.DOT);
                this.state = 2278;
                this.qualifiedName();
              }
            }
            this.state = 2283;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interaction() {
      let localContext = new InteractionContext(this.context, this.state);
      this.enterRule(localContext, 300, _SysMLv2Parser.RULE_interaction);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2284;
          this.typePrefix();
          this.state = 2285;
          this.match(_SysMLv2Parser.INTERACTION);
          this.state = 2286;
          this.classifierDeclaration();
          this.state = 2287;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    flow() {
      let localContext = new FlowContext(this.context, this.state);
      this.enterRule(localContext, 302, _SysMLv2Parser.RULE_flow);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2289;
          this.featurePrefix();
          this.state = 2290;
          this.match(_SysMLv2Parser.FLOW);
          this.state = 2291;
          this.flowDeclaration();
          this.state = 2292;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    successionFlow() {
      let localContext = new SuccessionFlowContext(this.context, this.state);
      this.enterRule(localContext, 304, _SysMLv2Parser.RULE_successionFlow);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2294;
          this.featurePrefix();
          this.state = 2295;
          this.match(_SysMLv2Parser.SUCCESSION);
          this.state = 2296;
          this.match(_SysMLv2Parser.FLOW);
          this.state = 2297;
          this.flowDeclaration();
          this.state = 2298;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    flowDeclaration() {
      let localContext = new FlowDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 306, _SysMLv2Parser.RULE_flowDeclaration);
      let _la;
      try {
        this.state = 2339;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 207, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2300;
              this.featureDeclaration();
              this.state = 2302;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 46 || _la === 184 || _la === 207) {
                {
                  this.state = 2301;
                  this.valuePart();
                }
              }
              this.state = 2306;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 111) {
                {
                  this.state = 2304;
                  this.match(_SysMLv2Parser.OF);
                  this.state = 2305;
                  this.payloadFeatureMember();
                }
              }
              this.state = 2313;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 74) {
                {
                  this.state = 2308;
                  this.match(_SysMLv2Parser.FROM);
                  this.state = 2309;
                  this.flowEndMember();
                  this.state = 2310;
                  this.match(_SysMLv2Parser.TO);
                  this.state = 2311;
                  this.flowEndMember();
                }
              }
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2316;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 8) {
                {
                  this.state = 2315;
                  this.match(_SysMLv2Parser.ALL);
                }
              }
              this.state = 2318;
              this.flowEndMember();
              this.state = 2319;
              this.match(_SysMLv2Parser.TO);
              this.state = 2320;
              this.flowEndMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2323;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                {
                  this.state = 2322;
                  this.usageDeclaration();
                }
              }
              this.state = 2326;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 46 || _la === 184 || _la === 207) {
                {
                  this.state = 2325;
                  this.valuePart();
                }
              }
              this.state = 2330;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 111) {
                {
                  this.state = 2328;
                  this.match(_SysMLv2Parser.OF);
                  this.state = 2329;
                  this.flowPayloadFeatureMember();
                }
              }
              this.state = 2337;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 74) {
                {
                  this.state = 2332;
                  this.match(_SysMLv2Parser.FROM);
                  this.state = 2333;
                  this.flowEndMember();
                  this.state = 2334;
                  this.match(_SysMLv2Parser.TO);
                  this.state = 2335;
                  this.flowEndMember();
                }
              }
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    payloadFeatureMember() {
      let localContext = new PayloadFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 308, _SysMLv2Parser.RULE_payloadFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2341;
          this.payloadFeature();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    payloadFeature() {
      let localContext = new PayloadFeatureContext(this.context, this.state);
      this.enterRule(localContext, 310, _SysMLv2Parser.RULE_payloadFeature);
      let _la;
      try {
        this.state = 2362;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 213, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2344;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                {
                  this.state = 2343;
                  this.identification();
                }
              }
              this.state = 2346;
              this.valuePart();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2348;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 209, this.context)) {
                case 1:
                  {
                    this.state = 2347;
                    this.identification();
                  }
                  break;
              }
              this.state = 2350;
              this.payloadFeatureSpecializationPart();
              this.state = 2352;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 46 || _la === 184 || _la === 207) {
                {
                  this.state = 2351;
                  this.valuePart();
                }
              }
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2354;
              this.ownedFeatureTyping();
              this.state = 2356;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 211) {
                {
                  this.state = 2355;
                  this.ownedMultiplicity();
                }
              }
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2358;
              this.ownedMultiplicity();
              this.state = 2360;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 193 & ~31) === 0 && (1 << _la - 193 & 100663297) !== 0) {
                {
                  this.state = 2359;
                  this.ownedFeatureTyping();
                }
              }
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    payloadFeatureSpecializationPart() {
      let localContext = new PayloadFeatureSpecializationPartContext(this.context, this.state);
      this.enterRule(localContext, 312, _SysMLv2Parser.RULE_payloadFeatureSpecializationPart);
      let _la;
      try {
        let alternative;
        this.state = 2384;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.DEFINED:
          case _SysMLv2Parser.REDEFINES:
          case _SysMLv2Parser.REFERENCES:
          case _SysMLv2Parser.SUBSETS:
          case _SysMLv2Parser.TYPED:
          case _SysMLv2Parser.COLON_COLON_GT:
          case _SysMLv2Parser.COLON_GT_GT:
          case _SysMLv2Parser.COLON_GT:
          case _SysMLv2Parser.FAT_ARROW:
          case _SysMLv2Parser.COLON:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2365;
              this.errorHandler.sync(this);
              alternative = 1;
              do {
                switch (alternative) {
                  case 1:
                    {
                      {
                        this.state = 2364;
                        this.featureSpecialization();
                      }
                    }
                    break;
                  default:
                    throw new NoViableAltException(this);
                }
                this.state = 2367;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 214, this.context);
              } while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER);
              this.state = 2370;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 106 || _la === 113 || _la === 211) {
                {
                  this.state = 2369;
                  this.multiplicityPart();
                }
              }
              this.state = 2375;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while (_la === 42 || _la === 47 || (_la - 125 & ~31) === 0 && (1 << _la - 125 & 8388617) !== 0 || (_la - 158 & ~31) === 0 && (1 << _la - 158 & 1208352769) !== 0 || _la === 204) {
                {
                  {
                    this.state = 2372;
                    this.featureSpecialization();
                  }
                }
                this.state = 2377;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
            }
            break;
          case _SysMLv2Parser.NONUNIQUE:
          case _SysMLv2Parser.ORDERED:
          case _SysMLv2Parser.LBRACK:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2378;
              this.multiplicityPart();
              this.state = 2380;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              do {
                {
                  {
                    this.state = 2379;
                    this.featureSpecialization();
                  }
                }
                this.state = 2382;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              } while (_la === 42 || _la === 47 || (_la - 125 & ~31) === 0 && (1 << _la - 125 & 8388617) !== 0 || (_la - 158 & ~31) === 0 && (1 << _la - 158 & 1208352769) !== 0 || _la === 204);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    flowEndMember() {
      let localContext = new FlowEndMemberContext(this.context, this.state);
      this.enterRule(localContext, 314, _SysMLv2Parser.RULE_flowEndMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2386;
          this.flowEnd();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    flowEnd() {
      let localContext = new FlowEndContext(this.context, this.state);
      this.enterRule(localContext, 316, _SysMLv2Parser.RULE_flowEnd);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2388;
          this.qualifiedName();
          this.state = 2393;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 202) {
            {
              {
                this.state = 2389;
                this.match(_SysMLv2Parser.DOT);
                this.state = 2390;
                this.qualifiedName();
              }
            }
            this.state = 2395;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    valuePart() {
      let localContext = new ValuePartContext(this.context, this.state);
      this.enterRule(localContext, 318, _SysMLv2Parser.RULE_valuePart);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2396;
          this.featureValue();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureValue() {
      let localContext = new FeatureValueContext(this.context, this.state);
      this.enterRule(localContext, 320, _SysMLv2Parser.RULE_featureValue);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2404;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.EQ:
              {
                this.state = 2398;
                this.match(_SysMLv2Parser.EQ);
              }
              break;
            case _SysMLv2Parser.COLON_EQ:
              {
                this.state = 2399;
                this.match(_SysMLv2Parser.COLON_EQ);
              }
              break;
            case _SysMLv2Parser.DEFAULT:
              {
                this.state = 2400;
                this.match(_SysMLv2Parser.DEFAULT);
                this.state = 2402;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 184 || _la === 207) {
                  {
                    this.state = 2401;
                    _la = this.tokenStream.LA(1);
                    if (!(_la === 184 || _la === 207)) {
                      this.errorHandler.recoverInline(this);
                    } else {
                      this.errorHandler.reportMatch(this);
                      this.consume();
                    }
                  }
                }
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 2406;
          this.ownedExpression(0);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    multiplicity() {
      let localContext = new MultiplicityContext(this.context, this.state);
      this.enterRule(localContext, 322, _SysMLv2Parser.RULE_multiplicity);
      try {
        this.state = 2410;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 222, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2408;
              this.multiplicitySubset();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2409;
              this.multiplicityRange();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    multiplicitySubset() {
      let localContext = new MultiplicitySubsetContext(this.context, this.state);
      this.enterRule(localContext, 324, _SysMLv2Parser.RULE_multiplicitySubset);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2412;
          this.match(_SysMLv2Parser.MULTIPLICITY);
          this.state = 2414;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
            {
              this.state = 2413;
              this.identification();
            }
          }
          this.state = 2416;
          this.subsets();
          this.state = 2417;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    multiplicityRange() {
      let localContext = new MultiplicityRangeContext(this.context, this.state);
      this.enterRule(localContext, 326, _SysMLv2Parser.RULE_multiplicityRange);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2419;
          this.match(_SysMLv2Parser.MULTIPLICITY);
          this.state = 2421;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
            {
              this.state = 2420;
              this.identification();
            }
          }
          this.state = 2423;
          this.multiplicityBounds();
          this.state = 2424;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedMultiplicity() {
      let localContext = new OwnedMultiplicityContext(this.context, this.state);
      this.enterRule(localContext, 328, _SysMLv2Parser.RULE_ownedMultiplicity);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2426;
          this.ownedMultiplicityRange();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ownedMultiplicityRange() {
      let localContext = new OwnedMultiplicityRangeContext(this.context, this.state);
      this.enterRule(localContext, 330, _SysMLv2Parser.RULE_ownedMultiplicityRange);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2428;
          this.multiplicityBounds();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    multiplicityBounds() {
      let localContext = new MultiplicityBoundsContext(this.context, this.state);
      this.enterRule(localContext, 332, _SysMLv2Parser.RULE_multiplicityBounds);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2430;
          this.match(_SysMLv2Parser.LBRACK);
          this.state = 2434;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 225, this.context)) {
            case 1:
              {
                this.state = 2431;
                this.multiplicityExpressionMember();
                this.state = 2432;
                this.match(_SysMLv2Parser.DOT_DOT);
              }
              break;
          }
          this.state = 2436;
          this.multiplicityExpressionMember();
          this.state = 2437;
          this.match(_SysMLv2Parser.RBRACK);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    multiplicityExpressionMember() {
      let localContext = new MultiplicityExpressionMemberContext(this.context, this.state);
      this.enterRule(localContext, 334, _SysMLv2Parser.RULE_multiplicityExpressionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2441;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.FALSE:
            case _SysMLv2Parser.TRUE:
            case _SysMLv2Parser.STAR:
            case _SysMLv2Parser.DOUBLE_STRING:
            case _SysMLv2Parser.INTEGER:
            case _SysMLv2Parser.REAL:
              {
                this.state = 2439;
                this.literalExpression();
              }
              break;
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.DOLLAR:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
              {
                this.state = 2440;
                this.featureReferenceExpression();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metaclass() {
      let localContext = new MetaclassContext(this.context, this.state);
      this.enterRule(localContext, 336, _SysMLv2Parser.RULE_metaclass);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2443;
          this.typePrefix();
          this.state = 2444;
          this.match(_SysMLv2Parser.METACLASS);
          this.state = 2445;
          this.classifierDeclaration();
          this.state = 2446;
          this.typeBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    prefixMetadataAnnotation() {
      let localContext = new PrefixMetadataAnnotationContext(this.context, this.state);
      this.enterRule(localContext, 338, _SysMLv2Parser.RULE_prefixMetadataAnnotation);
      try {
        this.state = 2452;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 227, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2448;
              this.match(_SysMLv2Parser.HASH);
              this.state = 2449;
              this.prefixMetadataFeature();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2450;
              this.match(_SysMLv2Parser.HASH);
              this.state = 2451;
              this.prefixMetadataUsage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    prefixMetadataMember() {
      let localContext = new PrefixMetadataMemberContext(this.context, this.state);
      this.enterRule(localContext, 340, _SysMLv2Parser.RULE_prefixMetadataMember);
      try {
        this.state = 2458;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 228, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2454;
              this.match(_SysMLv2Parser.HASH);
              this.state = 2455;
              this.prefixMetadataFeature();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2456;
              this.match(_SysMLv2Parser.HASH);
              this.state = 2457;
              this.prefixMetadataUsage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    prefixMetadataFeature() {
      let localContext = new PrefixMetadataFeatureContext(this.context, this.state);
      this.enterRule(localContext, 342, _SysMLv2Parser.RULE_prefixMetadataFeature);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2460;
          this.ownedFeatureTyping();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataFeature() {
      let localContext = new MetadataFeatureContext(this.context, this.state);
      this.enterRule(localContext, 344, _SysMLv2Parser.RULE_metadataFeature);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2465;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2462;
                this.prefixMetadataMember();
              }
            }
            this.state = 2467;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2468;
          _la = this.tokenStream.LA(1);
          if (!(_la === 102 || _la === 210)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 2469;
          this.metadataFeatureDeclaration();
          this.state = 2479;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 1) {
            {
              this.state = 2470;
              this.match(_SysMLv2Parser.ABOUT);
              this.state = 2471;
              this.annotation();
              this.state = 2476;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while (_la === 200) {
                {
                  {
                    this.state = 2472;
                    this.match(_SysMLv2Parser.COMMA);
                    this.state = 2473;
                    this.annotation();
                  }
                }
                this.state = 2478;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
            }
          }
          this.state = 2481;
          this.metadataBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataFeatureDeclaration() {
      let localContext = new MetadataFeatureDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 346, _SysMLv2Parser.RULE_metadataFeatureDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2491;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 234, this.context)) {
            case 1:
              {
                this.state = 2484;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                  {
                    this.state = 2483;
                    this.identification();
                  }
                }
                this.state = 2489;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                  case _SysMLv2Parser.COLON:
                    {
                      this.state = 2486;
                      this.match(_SysMLv2Parser.COLON);
                    }
                    break;
                  case _SysMLv2Parser.TYPED:
                    {
                      this.state = 2487;
                      this.match(_SysMLv2Parser.TYPED);
                      this.state = 2488;
                      this.match(_SysMLv2Parser.BY);
                    }
                    break;
                  default:
                    throw new NoViableAltException(this);
                }
              }
              break;
          }
          this.state = 2493;
          this.ownedFeatureTyping();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataBody() {
      let localContext = new MetadataBodyContext(this.context, this.state);
      this.enterRule(localContext, 348, _SysMLv2Parser.RULE_metadataBody);
      let _la;
      try {
        this.state = 2515;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 238, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2495;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2496;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 2500;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1880162436) !== 0 || (_la - 33 & ~31) === 0 && (1 << _la - 33 & 2917893) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1904755717) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 1057226993) !== 0 || (_la - 131 & ~31) === 0 && (1 << _la - 131 & 335901825) !== 0 || (_la - 163 & ~31) === 0 && (1 << _la - 163 & 1610620929) !== 0 || (_la - 210 & ~31) === 0 && (1 << _la - 210 & 9089) !== 0) {
                {
                  {
                    this.state = 2497;
                    this.metadataBodyElement();
                  }
                }
                this.state = 2502;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 2503;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2504;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 2511;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1175981204) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 71370273) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1947878433) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 1599348849) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 134232075) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 3221242267) !== 0 || (_la - 210 & ~31) === 0 && (1 << _la - 210 & 8961) !== 0) {
                {
                  this.state = 2509;
                  this.errorHandler.sync(this);
                  switch (this.interpreter.adaptivePredict(this.tokenStream, 236, this.context)) {
                    case 1:
                      {
                        this.state = 2505;
                        this.definitionMember();
                      }
                      break;
                    case 2:
                      {
                        this.state = 2506;
                        this.metadataBodyUsageMember();
                      }
                      break;
                    case 3:
                      {
                        this.state = 2507;
                        this.aliasMember();
                      }
                      break;
                    case 4:
                      {
                        this.state = 2508;
                        this.importRule();
                      }
                      break;
                  }
                }
                this.state = 2513;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 2514;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataBodyElement() {
      let localContext = new MetadataBodyElementContext(this.context, this.state);
      this.enterRule(localContext, 350, _SysMLv2Parser.RULE_metadataBodyElement);
      try {
        this.state = 2521;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 239, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2517;
              this.nonFeatureMember();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2518;
              this.metadataBodyFeatureMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2519;
              this.aliasMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2520;
              this.importRule();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataBodyFeatureMember() {
      let localContext = new MetadataBodyFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 352, _SysMLv2Parser.RULE_metadataBodyFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2523;
          this.metadataBodyFeature();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataBodyFeature() {
      let localContext = new MetadataBodyFeatureContext(this.context, this.state);
      this.enterRule(localContext, 354, _SysMLv2Parser.RULE_metadataBodyFeature);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2526;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 240, this.context)) {
            case 1:
              {
                this.state = 2525;
                this.match(_SysMLv2Parser.FEATURE);
              }
              break;
          }
          this.state = 2529;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 125 || _la === 176) {
            {
              this.state = 2528;
              _la = this.tokenStream.LA(1);
              if (!(_la === 125 || _la === 176)) {
                this.errorHandler.recoverInline(this);
              } else {
                this.errorHandler.reportMatch(this);
                this.consume();
              }
            }
          }
          this.state = 2531;
          this.ownedRedefinition();
          this.state = 2533;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
            {
              this.state = 2532;
              this.featureSpecializationPart();
            }
          }
          this.state = 2536;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 2535;
              this.valuePart();
            }
          }
          this.state = 2538;
          this.metadataBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    package_() {
      let localContext = new PackageContext(this.context, this.state);
      this.enterRule(localContext, 356, _SysMLv2Parser.RULE_package);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2543;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2540;
                this.prefixMetadataMember();
              }
            }
            this.state = 2545;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2546;
          this.packageDeclaration();
          this.state = 2547;
          this.packageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    libraryPackage() {
      let localContext = new LibraryPackageContext(this.context, this.state);
      this.enterRule(localContext, 358, _SysMLv2Parser.RULE_libraryPackage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2550;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 141) {
            {
              this.state = 2549;
              this.match(_SysMLv2Parser.STANDARD);
            }
          }
          this.state = 2552;
          this.match(_SysMLv2Parser.LIBRARY);
          this.state = 2556;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2553;
                this.prefixMetadataMember();
              }
            }
            this.state = 2558;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2559;
          this.packageDeclaration();
          this.state = 2560;
          this.packageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    packageDeclaration() {
      let localContext = new PackageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 360, _SysMLv2Parser.RULE_packageDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2562;
          this.match(_SysMLv2Parser.PACKAGE);
          this.state = 2564;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
            {
              this.state = 2563;
              this.identification();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    packageBody() {
      let localContext = new PackageBodyContext(this.context, this.state);
      this.enterRule(localContext, 362, _SysMLv2Parser.RULE_packageBody);
      let _la;
      try {
        this.state = 2575;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2566;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2567;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 2571;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182289556) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490981169) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1948238905) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127797) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 412367019) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153458587) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 2568;
                    this.packageBodyElement();
                  }
                }
                this.state = 2573;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 2574;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    elementFilterMember() {
      let localContext = new ElementFilterMemberContext(this.context, this.state);
      this.enterRule(localContext, 364, _SysMLv2Parser.RULE_elementFilterMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2577;
          this.memberPrefix();
          this.state = 2578;
          this.match(_SysMLv2Parser.FILTER);
          this.state = 2579;
          this.ownedExpression(0);
          this.state = 2580;
          this.match(_SysMLv2Parser.SEMI);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    dependencyDeclaration() {
      let localContext = new DependencyDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 366, _SysMLv2Parser.RULE_dependencyDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2586;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 251, this.context)) {
            case 1:
              {
                this.state = 2583;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
                  {
                    this.state = 2582;
                    this.identification();
                  }
                }
                this.state = 2585;
                this.match(_SysMLv2Parser.FROM);
              }
              break;
          }
          this.state = 2588;
          this.qualifiedName();
          this.state = 2593;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 2589;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 2590;
                this.qualifiedName();
              }
            }
            this.state = 2595;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2596;
          this.match(_SysMLv2Parser.TO);
          this.state = 2597;
          this.qualifiedName();
          this.state = 2602;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 2598;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 2599;
                this.qualifiedName();
              }
            }
            this.state = 2604;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    annotatingMember() {
      let localContext = new AnnotatingMemberContext(this.context, this.state);
      this.enterRule(localContext, 368, _SysMLv2Parser.RULE_annotatingMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2605;
          this.annotatingElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    packageBodyElement() {
      let localContext = new PackageBodyElementContext(this.context, this.state);
      this.enterRule(localContext, 370, _SysMLv2Parser.RULE_packageBodyElement);
      try {
        this.state = 2611;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 254, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2607;
              this.packageMember();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2608;
              this.elementFilterMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2609;
              this.aliasMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2610;
              this.importRule();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    packageMember() {
      let localContext = new PackageMemberContext(this.context, this.state);
      this.enterRule(localContext, 372, _SysMLv2Parser.RULE_packageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2613;
          this.memberPrefix();
          this.state = 2616;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 255, this.context)) {
            case 1:
              {
                this.state = 2614;
                this.definitionElement();
              }
              break;
            case 2:
              {
                this.state = 2615;
                this.usageElement();
              }
              break;
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definitionElement() {
      let localContext = new DefinitionElementContext(this.context, this.state);
      this.enterRule(localContext, 374, _SysMLv2Parser.RULE_definitionElement);
      try {
        this.state = 2648;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 256, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2618;
              this.package_();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2619;
              this.libraryPackage();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2620;
              this.annotatingElement();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2621;
              this.dependency();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 2622;
              this.attributeDefinition();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 2623;
              this.enumerationDefinition();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 2624;
              this.occurrenceDefinition();
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 2625;
              this.individualDefinition();
            }
            break;
          case 9:
            this.enterOuterAlt(localContext, 9);
            {
              this.state = 2626;
              this.itemDefinition();
            }
            break;
          case 10:
            this.enterOuterAlt(localContext, 10);
            {
              this.state = 2627;
              this.partDefinition();
            }
            break;
          case 11:
            this.enterOuterAlt(localContext, 11);
            {
              this.state = 2628;
              this.connectionDefinition();
            }
            break;
          case 12:
            this.enterOuterAlt(localContext, 12);
            {
              this.state = 2629;
              this.flowDefinition();
            }
            break;
          case 13:
            this.enterOuterAlt(localContext, 13);
            {
              this.state = 2630;
              this.interfaceDefinition();
            }
            break;
          case 14:
            this.enterOuterAlt(localContext, 14);
            {
              this.state = 2631;
              this.portDefinition();
            }
            break;
          case 15:
            this.enterOuterAlt(localContext, 15);
            {
              this.state = 2632;
              this.actionDefinition();
            }
            break;
          case 16:
            this.enterOuterAlt(localContext, 16);
            {
              this.state = 2633;
              this.calculationDefinition();
            }
            break;
          case 17:
            this.enterOuterAlt(localContext, 17);
            {
              this.state = 2634;
              this.stateDefinition();
            }
            break;
          case 18:
            this.enterOuterAlt(localContext, 18);
            {
              this.state = 2635;
              this.constraintDefinition();
            }
            break;
          case 19:
            this.enterOuterAlt(localContext, 19);
            {
              this.state = 2636;
              this.requirementDefinition();
            }
            break;
          case 20:
            this.enterOuterAlt(localContext, 20);
            {
              this.state = 2637;
              this.concernDefinition();
            }
            break;
          case 21:
            this.enterOuterAlt(localContext, 21);
            {
              this.state = 2638;
              this.caseDefinition();
            }
            break;
          case 22:
            this.enterOuterAlt(localContext, 22);
            {
              this.state = 2639;
              this.analysisCaseDefinition();
            }
            break;
          case 23:
            this.enterOuterAlt(localContext, 23);
            {
              this.state = 2640;
              this.verificationCaseDefinition();
            }
            break;
          case 24:
            this.enterOuterAlt(localContext, 24);
            {
              this.state = 2641;
              this.useCaseDefinition();
            }
            break;
          case 25:
            this.enterOuterAlt(localContext, 25);
            {
              this.state = 2642;
              this.viewDefinition();
            }
            break;
          case 26:
            this.enterOuterAlt(localContext, 26);
            {
              this.state = 2643;
              this.viewpointDefinition();
            }
            break;
          case 27:
            this.enterOuterAlt(localContext, 27);
            {
              this.state = 2644;
              this.renderingDefinition();
            }
            break;
          case 28:
            this.enterOuterAlt(localContext, 28);
            {
              this.state = 2645;
              this.metadataDefinition();
            }
            break;
          case 29:
            this.enterOuterAlt(localContext, 29);
            {
              this.state = 2646;
              this.allocationDefinition();
            }
            break;
          case 30:
            this.enterOuterAlt(localContext, 30);
            {
              this.state = 2647;
              this.extendedDefinition();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    usageElement() {
      let localContext = new UsageElementContext(this.context, this.state);
      this.enterRule(localContext, 376, _SysMLv2Parser.RULE_usageElement);
      try {
        this.state = 2652;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 257, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2650;
              this.nonOccurrenceUsageElement();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2651;
              this.occurrenceUsageElement();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    basicDefinitionPrefix() {
      let localContext = new BasicDefinitionPrefixContext(this.context, this.state);
      this.enterRule(localContext, 378, _SysMLv2Parser.RULE_basicDefinitionPrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2654;
          _la = this.tokenStream.LA(1);
          if (!(_la === 2 || _la === 165)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definitionExtensionKeyword() {
      let localContext = new DefinitionExtensionKeywordContext(this.context, this.state);
      this.enterRule(localContext, 380, _SysMLv2Parser.RULE_definitionExtensionKeyword);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2656;
          this.prefixMetadataMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definitionPrefix() {
      let localContext = new DefinitionPrefixContext(this.context, this.state);
      this.enterRule(localContext, 382, _SysMLv2Parser.RULE_definitionPrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2659;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 2 || _la === 165) {
            {
              this.state = 2658;
              this.basicDefinitionPrefix();
            }
          }
          this.state = 2664;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2661;
                this.definitionExtensionKeyword();
              }
            }
            this.state = 2666;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definition() {
      let localContext = new DefinitionContext(this.context, this.state);
      this.enterRule(localContext, 384, _SysMLv2Parser.RULE_definition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2667;
          this.definitionDeclaration();
          this.state = 2668;
          this.definitionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definitionDeclaration() {
      let localContext = new DefinitionDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 386, _SysMLv2Parser.RULE_definitionDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2671;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || (_la - 206 & ~31) === 0 && (1 << _la - 206 & 12289) !== 0) {
            {
              this.state = 2670;
              this.identification();
            }
          }
          this.state = 2674;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 139 || _la === 185) {
            {
              this.state = 2673;
              this.subclassificationPart();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definitionBody() {
      let localContext = new DefinitionBodyContext(this.context, this.state);
      this.enterRule(localContext, 388, _SysMLv2Parser.RULE_definitionBody);
      let _la;
      try {
        this.state = 2685;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2676;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2677;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 2681;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182289556) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490981169) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1948238897) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127797) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 416561323) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153458591) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 2678;
                    this.definitionBodyItem();
                  }
                }
                this.state = 2683;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 2684;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definitionBodyItem() {
      let localContext = new DefinitionBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 390, _SysMLv2Parser.RULE_definitionBodyItem);
      let _la;
      try {
        this.state = 2703;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 266, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2687;
              this.importRule();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2688;
              this.memberPrefix();
              this.state = 2689;
              this.definitionBodyItemContent();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2692;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 152) {
                {
                  this.state = 2691;
                  this.sourceSuccessionMember();
                }
              }
              this.state = 2694;
              this.memberPrefix();
              this.state = 2695;
              this.endOccurrenceUsageElement();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2698;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 152) {
                {
                  this.state = 2697;
                  this.sourceSuccessionMember();
                }
              }
              this.state = 2700;
              this.memberPrefix();
              this.state = 2701;
              this.occurrenceUsageElement();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definitionBodyItemContent() {
      let localContext = new DefinitionBodyItemContentContext(this.context, this.state);
      this.enterRule(localContext, 392, _SysMLv2Parser.RULE_definitionBodyItemContent);
      let _la;
      try {
        this.state = 2723;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 269, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2705;
              this.match(_SysMLv2Parser.ALIAS);
              this.state = 2710;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 206) {
                {
                  this.state = 2706;
                  this.match(_SysMLv2Parser.LT);
                  this.state = 2707;
                  this.name();
                  this.state = 2708;
                  this.match(_SysMLv2Parser.GT);
                }
              }
              this.state = 2713;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || _la === 218 || _la === 219) {
                {
                  this.state = 2712;
                  this.name();
                }
              }
              this.state = 2715;
              this.match(_SysMLv2Parser.FOR);
              this.state = 2716;
              this.qualifiedName();
              this.state = 2717;
              this.relationshipBody();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2719;
              this.match(_SysMLv2Parser.VARIANT);
              this.state = 2720;
              this.variantUsageElement();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2721;
              this.definitionElement();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2722;
              this.nonOccurrenceUsageElement();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    definitionMember() {
      let localContext = new DefinitionMemberContext(this.context, this.state);
      this.enterRule(localContext, 394, _SysMLv2Parser.RULE_definitionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2725;
          this.memberPrefix();
          this.state = 2726;
          this.definitionElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    variantUsageMember() {
      let localContext = new VariantUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 396, _SysMLv2Parser.RULE_variantUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2728;
          this.memberPrefix();
          this.state = 2729;
          this.match(_SysMLv2Parser.VARIANT);
          this.state = 2730;
          this.variantUsageElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nonOccurrenceUsageMember() {
      let localContext = new NonOccurrenceUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 398, _SysMLv2Parser.RULE_nonOccurrenceUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2732;
          this.memberPrefix();
          this.state = 2733;
          this.nonOccurrenceUsageElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    structureUsageMember() {
      let localContext = new StructureUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 400, _SysMLv2Parser.RULE_structureUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2735;
          this.memberPrefix();
          this.state = 2736;
          this.structureUsageElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    behaviorUsageMember() {
      let localContext = new BehaviorUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 402, _SysMLv2Parser.RULE_behaviorUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2738;
          this.memberPrefix();
          this.state = 2739;
          this.behaviorUsageElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    refPrefix() {
      let localContext = new RefPrefixContext(this.context, this.state);
      this.enterRule(localContext, 404, _SysMLv2Parser.RULE_refPrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2742;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 80 || _la === 83 || _la === 114) {
            {
              this.state = 2741;
              this.featureDirection();
            }
          }
          this.state = 2745;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 49) {
            {
              this.state = 2744;
              this.match(_SysMLv2Parser.DERIVED);
            }
          }
          this.state = 2748;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 2 || _la === 165) {
            {
              this.state = 2747;
              _la = this.tokenStream.LA(1);
              if (!(_la === 2 || _la === 165)) {
                this.errorHandler.recoverInline(this);
              } else {
                this.errorHandler.reportMatch(this);
                this.consume();
              }
            }
          }
          this.state = 2751;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 40) {
            {
              this.state = 2750;
              this.match(_SysMLv2Parser.CONSTANT);
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    basicUsagePrefix() {
      let localContext = new BasicUsagePrefixContext(this.context, this.state);
      this.enterRule(localContext, 406, _SysMLv2Parser.RULE_basicUsagePrefix);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2753;
          this.refPrefix();
          this.state = 2755;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 274, this.context)) {
            case 1:
              {
                this.state = 2754;
                this.match(_SysMLv2Parser.REF);
              }
              break;
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    endUsagePrefix() {
      let localContext = new EndUsagePrefixContext(this.context, this.state);
      this.enterRule(localContext, 408, _SysMLv2Parser.RULE_endUsagePrefix);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2757;
          this.match(_SysMLv2Parser.END);
          this.state = 2758;
          this.ownedCrossFeatureMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    usageExtensionKeyword() {
      let localContext = new UsageExtensionKeywordContext(this.context, this.state);
      this.enterRule(localContext, 410, _SysMLv2Parser.RULE_usageExtensionKeyword);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2760;
          this.prefixMetadataMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    unextendedUsagePrefix() {
      let localContext = new UnextendedUsagePrefixContext(this.context, this.state);
      this.enterRule(localContext, 412, _SysMLv2Parser.RULE_unextendedUsagePrefix);
      try {
        this.state = 2764;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.END:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2762;
              this.endUsagePrefix();
            }
            break;
          case _SysMLv2Parser.ABSTRACT:
          case _SysMLv2Parser.ATTRIBUTE:
          case _SysMLv2Parser.BIND:
          case _SysMLv2Parser.BINDING:
          case _SysMLv2Parser.CONSTANT:
          case _SysMLv2Parser.DERIVED:
          case _SysMLv2Parser.ENUM:
          case _SysMLv2Parser.FIRST:
          case _SysMLv2Parser.IN:
          case _SysMLv2Parser.INOUT:
          case _SysMLv2Parser.OUT:
          case _SysMLv2Parser.REF:
          case _SysMLv2Parser.SUCCESSION:
          case _SysMLv2Parser.VARIATION:
          case _SysMLv2Parser.HASH:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2763;
              this.basicUsagePrefix();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    usagePrefix() {
      let localContext = new UsagePrefixContext(this.context, this.state);
      this.enterRule(localContext, 414, _SysMLv2Parser.RULE_usagePrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2766;
          this.unextendedUsagePrefix();
          this.state = 2770;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2767;
                this.usageExtensionKeyword();
              }
            }
            this.state = 2772;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    usage() {
      let localContext = new UsageContext(this.context, this.state);
      this.enterRule(localContext, 416, _SysMLv2Parser.RULE_usage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2774;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 2773;
              this.usageDeclaration();
            }
          }
          this.state = 2776;
          this.usageCompletion();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    usageDeclaration() {
      let localContext = new UsageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 418, _SysMLv2Parser.RULE_usageDeclaration);
      try {
        this.state = 2783;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 279, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2778;
              this.identification();
              this.state = 2780;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 278, this.context)) {
                case 1:
                  {
                    this.state = 2779;
                    this.featureSpecializationPart();
                  }
                  break;
              }
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2782;
              this.featureSpecializationPart();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    usageCompletion() {
      let localContext = new UsageCompletionContext(this.context, this.state);
      this.enterRule(localContext, 420, _SysMLv2Parser.RULE_usageCompletion);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2786;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 2785;
              this.valuePart();
            }
          }
          this.state = 2788;
          this.usageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    usageBody() {
      let localContext = new UsageBodyContext(this.context, this.state);
      this.enterRule(localContext, 422, _SysMLv2Parser.RULE_usageBody);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2790;
          this.definitionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    defaultReferenceUsage() {
      let localContext = new DefaultReferenceUsageContext(this.context, this.state);
      this.enterRule(localContext, 424, _SysMLv2Parser.RULE_defaultReferenceUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2792;
          this.refPrefix();
          this.state = 2793;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    referenceUsage() {
      let localContext = new ReferenceUsageContext(this.context, this.state);
      this.enterRule(localContext, 426, _SysMLv2Parser.RULE_referenceUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2797;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.END:
              {
                this.state = 2795;
                this.endUsagePrefix();
              }
              break;
            case _SysMLv2Parser.ABSTRACT:
            case _SysMLv2Parser.CONSTANT:
            case _SysMLv2Parser.DERIVED:
            case _SysMLv2Parser.IN:
            case _SysMLv2Parser.INOUT:
            case _SysMLv2Parser.OUT:
            case _SysMLv2Parser.REF:
            case _SysMLv2Parser.VARIATION:
              {
                this.state = 2796;
                this.refPrefix();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 2799;
          this.match(_SysMLv2Parser.REF);
          this.state = 2800;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    endFeatureUsage() {
      let localContext = new EndFeatureUsageContext(this.context, this.state);
      this.enterRule(localContext, 428, _SysMLv2Parser.RULE_endFeatureUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2802;
          this.endUsagePrefix();
          this.state = 2803;
          this.featureDeclaration();
          this.state = 2804;
          this.usageCompletion();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    variantReference() {
      let localContext = new VariantReferenceContext(this.context, this.state);
      this.enterRule(localContext, 430, _SysMLv2Parser.RULE_variantReference);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2806;
          this.ownedReferenceSubsetting();
          this.state = 2810;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 42 || _la === 47 || (_la - 125 & ~31) === 0 && (1 << _la - 125 & 8388617) !== 0 || (_la - 158 & ~31) === 0 && (1 << _la - 158 & 1208352769) !== 0 || _la === 204) {
            {
              {
                this.state = 2807;
                this.featureSpecialization();
              }
            }
            this.state = 2812;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2813;
          this.usageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nonOccurrenceUsageElement() {
      let localContext = new NonOccurrenceUsageElementContext(this.context, this.state);
      this.enterRule(localContext, 432, _SysMLv2Parser.RULE_nonOccurrenceUsageElement);
      try {
        this.state = 2823;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 283, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2815;
              this.referenceUsage();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2816;
              this.endFeatureUsage();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2817;
              this.attributeUsage();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2818;
              this.enumerationUsage();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 2819;
              this.bindingConnectorAsUsage();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 2820;
              this.successionAsUsage();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 2821;
              this.extendedUsage();
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 2822;
              this.defaultReferenceUsage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    endOccurrenceUsageElement() {
      let localContext = new EndOccurrenceUsageElementContext(this.context, this.state);
      this.enterRule(localContext, 434, _SysMLv2Parser.RULE_endOccurrenceUsageElement);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2825;
          this.match(_SysMLv2Parser.END);
          this.state = 2827;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 20 || _la === 42 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 16777297) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1064961) !== 0 || _la === 218 || _la === 219) {
            {
              this.state = 2826;
              this.name();
            }
          }
          this.state = 2830;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 211) {
            {
              this.state = 2829;
              this.ownedCrossMultiplicityMember();
            }
          }
          this.state = 2833;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 106) {
            {
              this.state = 2832;
              this.match(_SysMLv2Parser.NONUNIQUE);
            }
          }
          this.state = 2835;
          this.occurrenceUsageElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    occurrenceUsageElement() {
      let localContext = new OccurrenceUsageElementContext(this.context, this.state);
      this.enterRule(localContext, 436, _SysMLv2Parser.RULE_occurrenceUsageElement);
      try {
        this.state = 2839;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 287, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2837;
              this.structureUsageElement();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2838;
              this.behaviorUsageElement();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    structureUsageElement() {
      let localContext = new StructureUsageElementContext(this.context, this.state);
      this.enterRule(localContext, 438, _SysMLv2Parser.RULE_structureUsageElement);
      try {
        this.state = 2856;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 288, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2841;
              this.occurrenceUsage();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2842;
              this.individualUsage();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2843;
              this.portionUsage();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2844;
              this.eventOccurrenceUsage();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 2845;
              this.itemUsage();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 2846;
              this.partUsage();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 2847;
              this.viewUsage();
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 2848;
              this.renderingUsage();
            }
            break;
          case 9:
            this.enterOuterAlt(localContext, 9);
            {
              this.state = 2849;
              this.portUsage();
            }
            break;
          case 10:
            this.enterOuterAlt(localContext, 10);
            {
              this.state = 2850;
              this.connectionUsage();
            }
            break;
          case 11:
            this.enterOuterAlt(localContext, 11);
            {
              this.state = 2851;
              this.interfaceUsage();
            }
            break;
          case 12:
            this.enterOuterAlt(localContext, 12);
            {
              this.state = 2852;
              this.allocationUsage();
            }
            break;
          case 13:
            this.enterOuterAlt(localContext, 13);
            {
              this.state = 2853;
              this.message();
            }
            break;
          case 14:
            this.enterOuterAlt(localContext, 14);
            {
              this.state = 2854;
              this.flowUsage();
            }
            break;
          case 15:
            this.enterOuterAlt(localContext, 15);
            {
              this.state = 2855;
              this.successionFlowUsage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    behaviorUsageElement() {
      let localContext = new BehaviorUsageElementContext(this.context, this.state);
      this.enterRule(localContext, 440, _SysMLv2Parser.RULE_behaviorUsageElement);
      try {
        this.state = 2874;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 289, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2858;
              this.actionUsage();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2859;
              this.calculationUsage();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2860;
              this.stateUsage();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2861;
              this.constraintUsage();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 2862;
              this.requirementUsage();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 2863;
              this.concernUsage();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 2864;
              this.caseUsage();
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 2865;
              this.analysisCaseUsage();
            }
            break;
          case 9:
            this.enterOuterAlt(localContext, 9);
            {
              this.state = 2866;
              this.verificationCaseUsage();
            }
            break;
          case 10:
            this.enterOuterAlt(localContext, 10);
            {
              this.state = 2867;
              this.useCaseUsage();
            }
            break;
          case 11:
            this.enterOuterAlt(localContext, 11);
            {
              this.state = 2868;
              this.viewpointUsage();
            }
            break;
          case 12:
            this.enterOuterAlt(localContext, 12);
            {
              this.state = 2869;
              this.performActionUsage();
            }
            break;
          case 13:
            this.enterOuterAlt(localContext, 13);
            {
              this.state = 2870;
              this.exhibitStateUsage();
            }
            break;
          case 14:
            this.enterOuterAlt(localContext, 14);
            {
              this.state = 2871;
              this.includeUseCaseUsage();
            }
            break;
          case 15:
            this.enterOuterAlt(localContext, 15);
            {
              this.state = 2872;
              this.assertConstraintUsage();
            }
            break;
          case 16:
            this.enterOuterAlt(localContext, 16);
            {
              this.state = 2873;
              this.satisfyRequirementUsage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    variantUsageElement() {
      let localContext = new VariantUsageElementContext(this.context, this.state);
      this.enterRule(localContext, 442, _SysMLv2Parser.RULE_variantUsageElement);
      try {
        this.state = 2897;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 290, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2876;
              this.variantReference();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2877;
              this.referenceUsage();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 2878;
              this.attributeUsage();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 2879;
              this.bindingConnectorAsUsage();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 2880;
              this.successionAsUsage();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 2881;
              this.occurrenceUsage();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 2882;
              this.individualUsage();
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 2883;
              this.portionUsage();
            }
            break;
          case 9:
            this.enterOuterAlt(localContext, 9);
            {
              this.state = 2884;
              this.eventOccurrenceUsage();
            }
            break;
          case 10:
            this.enterOuterAlt(localContext, 10);
            {
              this.state = 2885;
              this.itemUsage();
            }
            break;
          case 11:
            this.enterOuterAlt(localContext, 11);
            {
              this.state = 2886;
              this.partUsage();
            }
            break;
          case 12:
            this.enterOuterAlt(localContext, 12);
            {
              this.state = 2887;
              this.viewUsage();
            }
            break;
          case 13:
            this.enterOuterAlt(localContext, 13);
            {
              this.state = 2888;
              this.renderingUsage();
            }
            break;
          case 14:
            this.enterOuterAlt(localContext, 14);
            {
              this.state = 2889;
              this.portUsage();
            }
            break;
          case 15:
            this.enterOuterAlt(localContext, 15);
            {
              this.state = 2890;
              this.connectionUsage();
            }
            break;
          case 16:
            this.enterOuterAlt(localContext, 16);
            {
              this.state = 2891;
              this.interfaceUsage();
            }
            break;
          case 17:
            this.enterOuterAlt(localContext, 17);
            {
              this.state = 2892;
              this.allocationUsage();
            }
            break;
          case 18:
            this.enterOuterAlt(localContext, 18);
            {
              this.state = 2893;
              this.message();
            }
            break;
          case 19:
            this.enterOuterAlt(localContext, 19);
            {
              this.state = 2894;
              this.flowUsage();
            }
            break;
          case 20:
            this.enterOuterAlt(localContext, 20);
            {
              this.state = 2895;
              this.successionFlowUsage();
            }
            break;
          case 21:
            this.enterOuterAlt(localContext, 21);
            {
              this.state = 2896;
              this.behaviorUsageElement();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    subclassificationPart() {
      let localContext = new SubclassificationPartContext(this.context, this.state);
      this.enterRule(localContext, 444, _SysMLv2Parser.RULE_subclassificationPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2899;
          _la = this.tokenStream.LA(1);
          if (!(_la === 139 || _la === 185)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
          this.state = 2900;
          this.ownedSubclassification();
          this.state = 2905;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 2901;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 2902;
                this.ownedSubclassification();
              }
            }
            this.state = 2907;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    attributeDefinition() {
      let localContext = new AttributeDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 446, _SysMLv2Parser.RULE_attributeDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2908;
          this.definitionPrefix();
          this.state = 2909;
          this.match(_SysMLv2Parser.ATTRIBUTE);
          this.state = 2910;
          this.match(_SysMLv2Parser.DEF);
          this.state = 2911;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    attributeUsage() {
      let localContext = new AttributeUsageContext(this.context, this.state);
      this.enterRule(localContext, 448, _SysMLv2Parser.RULE_attributeUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2913;
          this.usagePrefix();
          this.state = 2914;
          this.match(_SysMLv2Parser.ATTRIBUTE);
          this.state = 2915;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    enumerationDefinition() {
      let localContext = new EnumerationDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 450, _SysMLv2Parser.RULE_enumerationDefinition);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2920;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2917;
                this.definitionExtensionKeyword();
              }
            }
            this.state = 2922;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2923;
          this.match(_SysMLv2Parser.ENUM);
          this.state = 2924;
          this.match(_SysMLv2Parser.DEF);
          this.state = 2925;
          this.definitionDeclaration();
          this.state = 2926;
          this.enumerationBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    enumerationBody() {
      let localContext = new EnumerationBodyContext(this.context, this.state);
      this.enterRule(localContext, 452, _SysMLv2Parser.RULE_enumerationBody);
      let _la;
      try {
        this.state = 2938;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 2928;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 2929;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 2934;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 205521921) !== 0 || (_la - 54 & ~31) === 0 && (1 << _la - 54 & 1075841041) !== 0 || (_la - 93 & ~31) === 0 && (1 << _la - 93 & 4027590421) !== 0 || (_la - 125 & ~31) === 0 && (1 << _la - 125 & 8650825) !== 0 || (_la - 157 & ~31) === 0 && (1 << _la - 157 & 2550923331) !== 0 || (_la - 192 & ~31) === 0 && (1 << _la - 192 & 2353852417) !== 0) {
                {
                  this.state = 2932;
                  this.errorHandler.sync(this);
                  switch (this.interpreter.adaptivePredict(this.tokenStream, 293, this.context)) {
                    case 1:
                      {
                        this.state = 2930;
                        this.annotatingMember();
                      }
                      break;
                    case 2:
                      {
                        this.state = 2931;
                        this.enumerationUsageMember();
                      }
                      break;
                  }
                }
                this.state = 2936;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 2937;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    enumerationUsageMember() {
      let localContext = new EnumerationUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 454, _SysMLv2Parser.RULE_enumerationUsageMember);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2943;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2940;
                this.prefixMetadataMember();
              }
            }
            this.state = 2945;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2946;
          this.memberPrefix();
          this.state = 2947;
          this.enumeratedValue();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    enumeratedValue() {
      let localContext = new EnumeratedValueContext(this.context, this.state);
      this.enterRule(localContext, 456, _SysMLv2Parser.RULE_enumeratedValue);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2950;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 58) {
            {
              this.state = 2949;
              this.match(_SysMLv2Parser.ENUM);
            }
          }
          this.state = 2952;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    enumerationUsage() {
      let localContext = new EnumerationUsageContext(this.context, this.state);
      this.enterRule(localContext, 458, _SysMLv2Parser.RULE_enumerationUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2954;
          this.usagePrefix();
          this.state = 2955;
          this.match(_SysMLv2Parser.ENUM);
          this.state = 2956;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    occurrenceDefinitionPrefix() {
      let localContext = new OccurrenceDefinitionPrefixContext(this.context, this.state);
      this.enterRule(localContext, 460, _SysMLv2Parser.RULE_occurrenceDefinitionPrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2959;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 2 || _la === 165) {
            {
              this.state = 2958;
              this.basicDefinitionPrefix();
            }
          }
          this.state = 2963;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 82) {
            {
              this.state = 2961;
              this.match(_SysMLv2Parser.INDIVIDUAL);
              this.state = 2962;
              this.emptyMultiplicityMember();
            }
          }
          this.state = 2968;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2965;
                this.definitionExtensionKeyword();
              }
            }
            this.state = 2970;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    occurrenceDefinition() {
      let localContext = new OccurrenceDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 462, _SysMLv2Parser.RULE_occurrenceDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2971;
          this.occurrenceDefinitionPrefix();
          this.state = 2972;
          this.match(_SysMLv2Parser.OCCURRENCE);
          this.state = 2973;
          this.match(_SysMLv2Parser.DEF);
          this.state = 2974;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    individualDefinition() {
      let localContext = new IndividualDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 464, _SysMLv2Parser.RULE_individualDefinition);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2977;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 2 || _la === 165) {
            {
              this.state = 2976;
              this.basicDefinitionPrefix();
            }
          }
          this.state = 2979;
          this.match(_SysMLv2Parser.INDIVIDUAL);
          this.state = 2983;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2980;
                this.definitionExtensionKeyword();
              }
            }
            this.state = 2985;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 2986;
          this.match(_SysMLv2Parser.DEF);
          this.state = 2987;
          this.definition();
          this.state = 2988;
          this.emptyMultiplicityMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    emptyMultiplicityMember() {
      let localContext = new EmptyMultiplicityMemberContext(this.context, this.state);
      this.enterRule(localContext, 466, _SysMLv2Parser.RULE_emptyMultiplicityMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2990;
          this.emptyMultiplicity_();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    occurrenceUsagePrefix() {
      let localContext = new OccurrenceUsagePrefixContext(this.context, this.state);
      this.enterRule(localContext, 468, _SysMLv2Parser.RULE_occurrenceUsagePrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 2992;
          this.basicUsagePrefix();
          this.state = 2994;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 82) {
            {
              this.state = 2993;
              this.match(_SysMLv2Parser.INDIVIDUAL);
            }
          }
          this.state = 2997;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 137 || _la === 153) {
            {
              this.state = 2996;
              this.portionKind();
            }
          }
          this.state = 3002;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 2999;
                this.usageExtensionKeyword();
              }
            }
            this.state = 3004;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    occurrenceUsage() {
      let localContext = new OccurrenceUsageContext(this.context, this.state);
      this.enterRule(localContext, 470, _SysMLv2Parser.RULE_occurrenceUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3005;
          this.occurrenceUsagePrefix();
          this.state = 3006;
          this.match(_SysMLv2Parser.OCCURRENCE);
          this.state = 3007;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    individualUsage() {
      let localContext = new IndividualUsageContext(this.context, this.state);
      this.enterRule(localContext, 472, _SysMLv2Parser.RULE_individualUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3009;
          this.basicUsagePrefix();
          this.state = 3010;
          this.match(_SysMLv2Parser.INDIVIDUAL);
          this.state = 3014;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 3011;
                this.usageExtensionKeyword();
              }
            }
            this.state = 3016;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 3017;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    portionUsage() {
      let localContext = new PortionUsageContext(this.context, this.state);
      this.enterRule(localContext, 474, _SysMLv2Parser.RULE_portionUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3019;
          this.basicUsagePrefix();
          this.state = 3021;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 82) {
            {
              this.state = 3020;
              this.match(_SysMLv2Parser.INDIVIDUAL);
            }
          }
          this.state = 3023;
          this.portionKind();
          this.state = 3027;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 3024;
                this.usageExtensionKeyword();
              }
            }
            this.state = 3029;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 3030;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    portionKind() {
      let localContext = new PortionKindContext(this.context, this.state);
      this.enterRule(localContext, 476, _SysMLv2Parser.RULE_portionKind);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3032;
          _la = this.tokenStream.LA(1);
          if (!(_la === 137 || _la === 153)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    eventOccurrenceUsage() {
      let localContext = new EventOccurrenceUsageContext(this.context, this.state);
      this.enterRule(localContext, 478, _SysMLv2Parser.RULE_eventOccurrenceUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3034;
          this.occurrenceUsagePrefix();
          this.state = 3035;
          this.match(_SysMLv2Parser.EVENT);
          this.state = 3044;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.DOLLAR:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
              {
                this.state = 3036;
                this.ownedReferenceSubsetting();
                this.state = 3038;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                  {
                    this.state = 3037;
                    this.featureSpecializationPart();
                  }
                }
              }
              break;
            case _SysMLv2Parser.OCCURRENCE:
              {
                this.state = 3040;
                this.match(_SysMLv2Parser.OCCURRENCE);
                this.state = 3042;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                  {
                    this.state = 3041;
                    this.usageDeclaration();
                  }
                }
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 3046;
          this.usageCompletion();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    sourceSuccessionMember() {
      let localContext = new SourceSuccessionMemberContext(this.context, this.state);
      this.enterRule(localContext, 480, _SysMLv2Parser.RULE_sourceSuccessionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3048;
          this.match(_SysMLv2Parser.THEN);
          this.state = 3049;
          this.sourceSuccession();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    sourceSuccession() {
      let localContext = new SourceSuccessionContext(this.context, this.state);
      this.enterRule(localContext, 482, _SysMLv2Parser.RULE_sourceSuccession);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3051;
          this.sourceEndMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    sourceEndMember() {
      let localContext = new SourceEndMemberContext(this.context, this.state);
      this.enterRule(localContext, 484, _SysMLv2Parser.RULE_sourceEndMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3053;
          this.sourceEnd();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    sourceEnd() {
      let localContext = new SourceEndContext(this.context, this.state);
      this.enterRule(localContext, 486, _SysMLv2Parser.RULE_sourceEnd);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3056;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 312, this.context)) {
            case 1:
              {
                this.state = 3055;
                this.ownedMultiplicity();
              }
              break;
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    itemDefinition() {
      let localContext = new ItemDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 488, _SysMLv2Parser.RULE_itemDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3058;
          this.occurrenceDefinitionPrefix();
          this.state = 3059;
          this.match(_SysMLv2Parser.ITEM);
          this.state = 3060;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3061;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    itemUsage() {
      let localContext = new ItemUsageContext(this.context, this.state);
      this.enterRule(localContext, 490, _SysMLv2Parser.RULE_itemUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3063;
          this.occurrenceUsagePrefix();
          this.state = 3064;
          this.match(_SysMLv2Parser.ITEM);
          this.state = 3065;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    partDefinition() {
      let localContext = new PartDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 492, _SysMLv2Parser.RULE_partDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3067;
          this.occurrenceDefinitionPrefix();
          this.state = 3068;
          this.match(_SysMLv2Parser.PART);
          this.state = 3069;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3070;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    partUsage() {
      let localContext = new PartUsageContext(this.context, this.state);
      this.enterRule(localContext, 494, _SysMLv2Parser.RULE_partUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3072;
          this.occurrenceUsagePrefix();
          this.state = 3073;
          this.match(_SysMLv2Parser.PART);
          this.state = 3074;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    portDefinition() {
      let localContext = new PortDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 496, _SysMLv2Parser.RULE_portDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3076;
          this.definitionPrefix();
          this.state = 3077;
          this.match(_SysMLv2Parser.PORT);
          this.state = 3078;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3079;
          this.definition();
          this.state = 3080;
          this.conjugatedPortDefinitionMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    conjugatedPortDefinitionMember() {
      let localContext = new ConjugatedPortDefinitionMemberContext(this.context, this.state);
      this.enterRule(localContext, 498, _SysMLv2Parser.RULE_conjugatedPortDefinitionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3082;
          this.conjugatedPortDefinition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    conjugatedPortDefinition() {
      let localContext = new ConjugatedPortDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 500, _SysMLv2Parser.RULE_conjugatedPortDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3084;
          this.portConjugation();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    portUsage() {
      let localContext = new PortUsageContext(this.context, this.state);
      this.enterRule(localContext, 502, _SysMLv2Parser.RULE_portUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3086;
          this.occurrenceUsagePrefix();
          this.state = 3087;
          this.match(_SysMLv2Parser.PORT);
          this.state = 3088;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    conjugatedPortTyping() {
      let localContext = new ConjugatedPortTypingContext(this.context, this.state);
      this.enterRule(localContext, 504, _SysMLv2Parser.RULE_conjugatedPortTyping);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3090;
          this.match(_SysMLv2Parser.TILDE);
          this.state = 3091;
          this.qualifiedName();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    connectionDefinition() {
      let localContext = new ConnectionDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 506, _SysMLv2Parser.RULE_connectionDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3093;
          this.occurrenceDefinitionPrefix();
          this.state = 3094;
          this.match(_SysMLv2Parser.CONNECTION);
          this.state = 3095;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3096;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    connectionUsage() {
      let localContext = new ConnectionUsageContext(this.context, this.state);
      this.enterRule(localContext, 508, _SysMLv2Parser.RULE_connectionUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3098;
          this.occurrenceUsagePrefix();
          this.state = 3112;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.CONNECTION:
              {
                this.state = 3099;
                this.match(_SysMLv2Parser.CONNECTION);
                this.state = 3101;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                  {
                    this.state = 3100;
                    this.usageDeclaration();
                  }
                }
                this.state = 3104;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 46 || _la === 184 || _la === 207) {
                  {
                    this.state = 3103;
                    this.valuePart();
                  }
                }
                this.state = 3108;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 36) {
                  {
                    this.state = 3106;
                    this.match(_SysMLv2Parser.CONNECT);
                    this.state = 3107;
                    this.connectorPart();
                  }
                }
              }
              break;
            case _SysMLv2Parser.CONNECT:
              {
                this.state = 3110;
                this.match(_SysMLv2Parser.CONNECT);
                this.state = 3111;
                this.connectorPart();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 3114;
          this.usageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    connectorPart() {
      let localContext = new ConnectorPartContext(this.context, this.state);
      this.enterRule(localContext, 510, _SysMLv2Parser.RULE_connectorPart);
      try {
        this.state = 3118;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
          case _SysMLv2Parser.DOLLAR:
          case _SysMLv2Parser.LBRACK:
          case _SysMLv2Parser.IDENTIFIER:
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3116;
              this.binaryConnectorPart();
            }
            break;
          case _SysMLv2Parser.LPAREN:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3117;
              this.naryConnectorPart();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    binaryConnectorPart() {
      let localContext = new BinaryConnectorPartContext(this.context, this.state);
      this.enterRule(localContext, 512, _SysMLv2Parser.RULE_binaryConnectorPart);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3120;
          this.connectorEndMember();
          this.state = 3121;
          this.match(_SysMLv2Parser.TO);
          this.state = 3122;
          this.connectorEndMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    naryConnectorPart() {
      let localContext = new NaryConnectorPartContext(this.context, this.state);
      this.enterRule(localContext, 514, _SysMLv2Parser.RULE_naryConnectorPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3124;
          this.match(_SysMLv2Parser.LPAREN);
          this.state = 3125;
          this.connectorEndMember();
          this.state = 3126;
          this.match(_SysMLv2Parser.COMMA);
          this.state = 3127;
          this.connectorEndMember();
          this.state = 3132;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 3128;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 3129;
                this.connectorEndMember();
              }
            }
            this.state = 3134;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 3135;
          this.match(_SysMLv2Parser.RPAREN);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    bindingConnectorAsUsage() {
      let localContext = new BindingConnectorAsUsageContext(this.context, this.state);
      this.enterRule(localContext, 516, _SysMLv2Parser.RULE_bindingConnectorAsUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3137;
          this.usagePrefix();
          this.state = 3142;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 22) {
            {
              this.state = 3138;
              this.match(_SysMLv2Parser.BINDING);
              this.state = 3140;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                {
                  this.state = 3139;
                  this.usageDeclaration();
                }
              }
            }
          }
          this.state = 3144;
          this.match(_SysMLv2Parser.BIND);
          this.state = 3145;
          this.connectorEndMember();
          this.state = 3146;
          this.match(_SysMLv2Parser.EQ);
          this.state = 3147;
          this.connectorEndMember();
          this.state = 3148;
          this.usageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    successionAsUsage() {
      let localContext = new SuccessionAsUsageContext(this.context, this.state);
      this.enterRule(localContext, 518, _SysMLv2Parser.RULE_successionAsUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3150;
          this.usagePrefix();
          this.state = 3155;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 150) {
            {
              this.state = 3151;
              this.match(_SysMLv2Parser.SUCCESSION);
              this.state = 3153;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                {
                  this.state = 3152;
                  this.usageDeclaration();
                }
              }
            }
          }
          this.state = 3157;
          this.match(_SysMLv2Parser.FIRST);
          this.state = 3158;
          this.connectorEndMember();
          this.state = 3159;
          this.match(_SysMLv2Parser.THEN);
          this.state = 3160;
          this.connectorEndMember();
          this.state = 3161;
          this.usageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceDefinition() {
      let localContext = new InterfaceDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 520, _SysMLv2Parser.RULE_interfaceDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3163;
          this.occurrenceDefinitionPrefix();
          this.state = 3164;
          this.match(_SysMLv2Parser.INTERFACE);
          this.state = 3165;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3166;
          this.definitionDeclaration();
          this.state = 3167;
          this.interfaceBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceBody() {
      let localContext = new InterfaceBodyContext(this.context, this.state);
      this.enterRule(localContext, 522, _SysMLv2Parser.RULE_interfaceBody);
      let _la;
      try {
        this.state = 3178;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3169;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3170;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3174;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1181240980) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490930993) !== 0 || (_la - 69 & ~31) === 0 && (1 << _la - 69 & 1195473923) !== 0 || (_la - 102 & ~31) === 0 && (1 << _la - 102 & 2993926433) !== 0 || (_la - 135 & ~31) === 0 && (1 << _la - 135 & 3892740293) !== 0 || (_la - 169 & ~31) === 0 && (1 << _la - 169 & 8388611) !== 0 || _la === 210 || _la === 223) {
                {
                  {
                    this.state = 3171;
                    this.interfaceBodyItem();
                  }
                }
                this.state = 3176;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 3177;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceBodyItem() {
      let localContext = new InterfaceBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 524, _SysMLv2Parser.RULE_interfaceBodyItem);
      let _la;
      try {
        this.state = 3189;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 326, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3180;
              this.definitionMember();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3181;
              this.variantUsageMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3182;
              this.interfaceNonOccurrenceUsageMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3184;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 152) {
                {
                  this.state = 3183;
                  this.sourceSuccessionMember();
                }
              }
              this.state = 3186;
              this.interfaceOccurrenceUsageMember();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 3187;
              this.aliasMember();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 3188;
              this.importRule();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceNonOccurrenceUsageMember() {
      let localContext = new InterfaceNonOccurrenceUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 526, _SysMLv2Parser.RULE_interfaceNonOccurrenceUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3191;
          this.memberPrefix();
          this.state = 3192;
          this.interfaceNonOccurrenceUsageElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceNonOccurrenceUsageElement() {
      let localContext = new InterfaceNonOccurrenceUsageElementContext(this.context, this.state);
      this.enterRule(localContext, 528, _SysMLv2Parser.RULE_interfaceNonOccurrenceUsageElement);
      try {
        this.state = 3199;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 327, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3194;
              this.referenceUsage();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3195;
              this.attributeUsage();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3196;
              this.enumerationUsage();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3197;
              this.bindingConnectorAsUsage();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 3198;
              this.successionAsUsage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceOccurrenceUsageMember() {
      let localContext = new InterfaceOccurrenceUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 530, _SysMLv2Parser.RULE_interfaceOccurrenceUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3201;
          this.memberPrefix();
          this.state = 3202;
          this.interfaceOccurrenceUsageElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceOccurrenceUsageElement() {
      let localContext = new InterfaceOccurrenceUsageElementContext(this.context, this.state);
      this.enterRule(localContext, 532, _SysMLv2Parser.RULE_interfaceOccurrenceUsageElement);
      try {
        this.state = 3208;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 328, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3204;
              this.defaultInterfaceEnd();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3205;
              this.endOccurrenceUsageElement();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3206;
              this.structureUsageElement();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3207;
              this.behaviorUsageElement();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    defaultInterfaceEnd() {
      let localContext = new DefaultInterfaceEndContext(this.context, this.state);
      this.enterRule(localContext, 534, _SysMLv2Parser.RULE_defaultInterfaceEnd);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3210;
          this.match(_SysMLv2Parser.END);
          this.state = 3211;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceUsage() {
      let localContext = new InterfaceUsageContext(this.context, this.state);
      this.enterRule(localContext, 536, _SysMLv2Parser.RULE_interfaceUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3213;
          this.occurrenceUsagePrefix();
          this.state = 3214;
          this.match(_SysMLv2Parser.INTERFACE);
          this.state = 3215;
          this.interfaceUsageDeclaration();
          this.state = 3216;
          this.interfaceBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceUsageDeclaration() {
      let localContext = new InterfaceUsageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 538, _SysMLv2Parser.RULE_interfaceUsageDeclaration);
      let _la;
      try {
        this.state = 3229;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 332, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3219;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                {
                  this.state = 3218;
                  this.usageDeclaration();
                }
              }
              this.state = 3222;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 46 || _la === 184 || _la === 207) {
                {
                  this.state = 3221;
                  this.valuePart();
                }
              }
              this.state = 3226;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 36) {
                {
                  this.state = 3224;
                  this.match(_SysMLv2Parser.CONNECT);
                  this.state = 3225;
                  this.interfacePart();
                }
              }
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3228;
              this.interfacePart();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfacePart() {
      let localContext = new InterfacePartContext(this.context, this.state);
      this.enterRule(localContext, 540, _SysMLv2Parser.RULE_interfacePart);
      try {
        this.state = 3233;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
          case _SysMLv2Parser.DOLLAR:
          case _SysMLv2Parser.LBRACK:
          case _SysMLv2Parser.IDENTIFIER:
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3231;
              this.binaryInterfacePart();
            }
            break;
          case _SysMLv2Parser.LPAREN:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3232;
              this.naryInterfacePart();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    binaryInterfacePart() {
      let localContext = new BinaryInterfacePartContext(this.context, this.state);
      this.enterRule(localContext, 542, _SysMLv2Parser.RULE_binaryInterfacePart);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3235;
          this.interfaceEndMember();
          this.state = 3236;
          this.match(_SysMLv2Parser.TO);
          this.state = 3237;
          this.interfaceEndMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    naryInterfacePart() {
      let localContext = new NaryInterfacePartContext(this.context, this.state);
      this.enterRule(localContext, 544, _SysMLv2Parser.RULE_naryInterfacePart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3239;
          this.match(_SysMLv2Parser.LPAREN);
          this.state = 3240;
          this.interfaceEndMember();
          this.state = 3241;
          this.match(_SysMLv2Parser.COMMA);
          this.state = 3242;
          this.interfaceEndMember();
          this.state = 3247;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 200) {
            {
              {
                this.state = 3243;
                this.match(_SysMLv2Parser.COMMA);
                this.state = 3244;
                this.interfaceEndMember();
              }
            }
            this.state = 3249;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 3250;
          this.match(_SysMLv2Parser.RPAREN);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceEndMember() {
      let localContext = new InterfaceEndMemberContext(this.context, this.state);
      this.enterRule(localContext, 546, _SysMLv2Parser.RULE_interfaceEndMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3252;
          this.interfaceEnd();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    interfaceEnd() {
      let localContext = new InterfaceEndContext(this.context, this.state);
      this.enterRule(localContext, 548, _SysMLv2Parser.RULE_interfaceEnd);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3255;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 211) {
            {
              this.state = 3254;
              this.ownedCrossMultiplicityMember();
            }
          }
          this.state = 3260;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 336, this.context)) {
            case 1:
              {
                this.state = 3257;
                this.name();
                this.state = 3258;
                _la = this.tokenStream.LA(1);
                if (!(_la === 128 || _la === 175)) {
                  this.errorHandler.recoverInline(this);
                } else {
                  this.errorHandler.reportMatch(this);
                  this.consume();
                }
              }
              break;
          }
          this.state = 3262;
          this.ownedReferenceSubsetting();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    allocationDefinition() {
      let localContext = new AllocationDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 550, _SysMLv2Parser.RULE_allocationDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3264;
          this.occurrenceDefinitionPrefix();
          this.state = 3265;
          this.match(_SysMLv2Parser.ALLOCATION);
          this.state = 3266;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3267;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    allocationUsage() {
      let localContext = new AllocationUsageContext(this.context, this.state);
      this.enterRule(localContext, 552, _SysMLv2Parser.RULE_allocationUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3269;
          this.occurrenceUsagePrefix();
          this.state = 3270;
          this.allocationUsageDeclaration();
          this.state = 3271;
          this.usageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    allocationUsageDeclaration() {
      let localContext = new AllocationUsageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 554, _SysMLv2Parser.RULE_allocationUsageDeclaration);
      let _la;
      try {
        this.state = 3283;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.ALLOCATION:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3273;
              this.match(_SysMLv2Parser.ALLOCATION);
              this.state = 3275;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                {
                  this.state = 3274;
                  this.usageDeclaration();
                }
              }
              this.state = 3279;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 9) {
                {
                  this.state = 3277;
                  this.match(_SysMLv2Parser.ALLOCATE);
                  this.state = 3278;
                  this.connectorPart();
                }
              }
            }
            break;
          case _SysMLv2Parser.ALLOCATE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3281;
              this.match(_SysMLv2Parser.ALLOCATE);
              this.state = 3282;
              this.connectorPart();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    flowDefinition() {
      let localContext = new FlowDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 556, _SysMLv2Parser.RULE_flowDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3285;
          this.occurrenceDefinitionPrefix();
          this.state = 3286;
          this.match(_SysMLv2Parser.FLOW);
          this.state = 3287;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3288;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    message() {
      let localContext = new MessageContext(this.context, this.state);
      this.enterRule(localContext, 558, _SysMLv2Parser.RULE_message);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3290;
          this.occurrenceUsagePrefix();
          this.state = 3291;
          this.match(_SysMLv2Parser.MESSAGE);
          this.state = 3292;
          this.messageDeclaration();
          this.state = 3293;
          this.definitionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    messageDeclaration() {
      let localContext = new MessageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 560, _SysMLv2Parser.RULE_messageDeclaration);
      let _la;
      try {
        this.state = 3316;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 344, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3296;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                {
                  this.state = 3295;
                  this.usageDeclaration();
                }
              }
              this.state = 3299;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 46 || _la === 184 || _la === 207) {
                {
                  this.state = 3298;
                  this.valuePart();
                }
              }
              this.state = 3303;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 111) {
                {
                  this.state = 3301;
                  this.match(_SysMLv2Parser.OF);
                  this.state = 3302;
                  this.flowPayloadFeatureMember();
                }
              }
              this.state = 3310;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 74) {
                {
                  this.state = 3305;
                  this.match(_SysMLv2Parser.FROM);
                  this.state = 3306;
                  this.messageEventMember();
                  this.state = 3307;
                  this.match(_SysMLv2Parser.TO);
                  this.state = 3308;
                  this.messageEventMember();
                }
              }
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3312;
              this.messageEventMember();
              this.state = 3313;
              this.match(_SysMLv2Parser.TO);
              this.state = 3314;
              this.messageEventMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    messageEventMember() {
      let localContext = new MessageEventMemberContext(this.context, this.state);
      this.enterRule(localContext, 562, _SysMLv2Parser.RULE_messageEventMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3318;
          this.messageEvent();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    messageEvent() {
      let localContext = new MessageEventContext(this.context, this.state);
      this.enterRule(localContext, 564, _SysMLv2Parser.RULE_messageEvent);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3320;
          this.ownedReferenceSubsetting();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    flowUsage() {
      let localContext = new FlowUsageContext(this.context, this.state);
      this.enterRule(localContext, 566, _SysMLv2Parser.RULE_flowUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3322;
          this.occurrenceUsagePrefix();
          this.state = 3323;
          this.match(_SysMLv2Parser.FLOW);
          this.state = 3324;
          this.flowDeclaration();
          this.state = 3325;
          this.definitionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    successionFlowUsage() {
      let localContext = new SuccessionFlowUsageContext(this.context, this.state);
      this.enterRule(localContext, 568, _SysMLv2Parser.RULE_successionFlowUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3327;
          this.occurrenceUsagePrefix();
          this.state = 3328;
          this.match(_SysMLv2Parser.SUCCESSION);
          this.state = 3329;
          this.match(_SysMLv2Parser.FLOW);
          this.state = 3330;
          this.flowDeclaration();
          this.state = 3331;
          this.definitionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    flowPayloadFeatureMember() {
      let localContext = new FlowPayloadFeatureMemberContext(this.context, this.state);
      this.enterRule(localContext, 570, _SysMLv2Parser.RULE_flowPayloadFeatureMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3333;
          this.flowPayloadFeature();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    flowPayloadFeature() {
      let localContext = new FlowPayloadFeatureContext(this.context, this.state);
      this.enterRule(localContext, 572, _SysMLv2Parser.RULE_flowPayloadFeature);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3335;
          this.payloadFeature();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionDefinition() {
      let localContext = new ActionDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 574, _SysMLv2Parser.RULE_actionDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3337;
          this.occurrenceDefinitionPrefix();
          this.state = 3338;
          this.match(_SysMLv2Parser.ACTION);
          this.state = 3339;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3340;
          this.definitionDeclaration();
          this.state = 3341;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionBody() {
      let localContext = new ActionBodyContext(this.context, this.state);
      this.enterRule(localContext, 576, _SysMLv2Parser.RULE_actionBody);
      let _la;
      try {
        this.state = 3352;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3343;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3344;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3348;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182322332) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490985265) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 4229944561) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127799) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 418658539) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153459615) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 3345;
                    this.actionBodyItem();
                  }
                }
                this.state = 3350;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 3351;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionBodyItem() {
      let localContext = new ActionBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 578, _SysMLv2Parser.RULE_actionBodyItem);
      let _la;
      try {
        let alternative;
        this.state = 3373;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 350, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3354;
              this.nonBehaviorBodyItem();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3355;
              this.initialNodeMember();
              this.state = 3359;
              this.errorHandler.sync(this);
              alternative = this.interpreter.adaptivePredict(this.tokenStream, 347, this.context);
              while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                  {
                    {
                      this.state = 3356;
                      this.actionTargetSuccessionMember();
                    }
                  }
                }
                this.state = 3361;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 347, this.context);
              }
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3363;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 152) {
                {
                  this.state = 3362;
                  this.sourceSuccessionMember();
                }
              }
              this.state = 3365;
              this.actionBehaviorMember();
              this.state = 3369;
              this.errorHandler.sync(this);
              alternative = this.interpreter.adaptivePredict(this.tokenStream, 349, this.context);
              while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                  {
                    {
                      this.state = 3366;
                      this.actionTargetSuccessionMember();
                    }
                  }
                }
                this.state = 3371;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 349, this.context);
              }
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3372;
              this.guardedSuccessionMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nonBehaviorBodyItem() {
      let localContext = new NonBehaviorBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 580, _SysMLv2Parser.RULE_nonBehaviorBodyItem);
      let _la;
      try {
        this.state = 3384;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 352, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3375;
              this.importRule();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3376;
              this.aliasMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3377;
              this.definitionMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3378;
              this.variantUsageMember();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 3379;
              this.nonOccurrenceUsageMember();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 3381;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 152) {
                {
                  this.state = 3380;
                  this.sourceSuccessionMember();
                }
              }
              this.state = 3383;
              this.structureUsageMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionBehaviorMember() {
      let localContext = new ActionBehaviorMemberContext(this.context, this.state);
      this.enterRule(localContext, 582, _SysMLv2Parser.RULE_actionBehaviorMember);
      try {
        this.state = 3388;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 353, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3386;
              this.actionNodeMember();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3387;
              this.behaviorUsageMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    initialNodeMember() {
      let localContext = new InitialNodeMemberContext(this.context, this.state);
      this.enterRule(localContext, 584, _SysMLv2Parser.RULE_initialNodeMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3390;
          this.memberPrefix();
          this.state = 3391;
          this.match(_SysMLv2Parser.FIRST);
          this.state = 3392;
          this.qualifiedName();
          this.state = 3393;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionNodeMember() {
      let localContext = new ActionNodeMemberContext(this.context, this.state);
      this.enterRule(localContext, 586, _SysMLv2Parser.RULE_actionNodeMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3395;
          this.memberPrefix();
          this.state = 3396;
          this.actionNode();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionTargetSuccessionMember() {
      let localContext = new ActionTargetSuccessionMemberContext(this.context, this.state);
      this.enterRule(localContext, 588, _SysMLv2Parser.RULE_actionTargetSuccessionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3398;
          this.memberPrefix();
          this.state = 3399;
          this.actionTargetSuccession();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    guardedSuccessionMember() {
      let localContext = new GuardedSuccessionMemberContext(this.context, this.state);
      this.enterRule(localContext, 590, _SysMLv2Parser.RULE_guardedSuccessionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3401;
          this.memberPrefix();
          this.state = 3402;
          this.guardedSuccession();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionUsage() {
      let localContext = new ActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 592, _SysMLv2Parser.RULE_actionUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3404;
          this.occurrenceUsagePrefix();
          this.state = 3405;
          this.match(_SysMLv2Parser.ACTION);
          this.state = 3406;
          this.actionUsageDeclaration();
          this.state = 3407;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionUsageDeclaration() {
      let localContext = new ActionUsageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 594, _SysMLv2Parser.RULE_actionUsageDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3410;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 3409;
              this.usageDeclaration();
            }
          }
          this.state = 3413;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 3412;
              this.valuePart();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    performActionUsage() {
      let localContext = new PerformActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 596, _SysMLv2Parser.RULE_performActionUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3415;
          this.occurrenceUsagePrefix();
          this.state = 3416;
          this.match(_SysMLv2Parser.PERFORM);
          this.state = 3417;
          this.performActionUsageDeclaration();
          this.state = 3418;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    performActionUsageDeclaration() {
      let localContext = new PerformActionUsageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 598, _SysMLv2Parser.RULE_performActionUsageDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3428;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.DOLLAR:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
              {
                this.state = 3420;
                this.ownedReferenceSubsetting();
                this.state = 3422;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                  {
                    this.state = 3421;
                    this.featureSpecializationPart();
                  }
                }
              }
              break;
            case _SysMLv2Parser.ACTION:
              {
                this.state = 3424;
                this.match(_SysMLv2Parser.ACTION);
                this.state = 3426;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                  {
                    this.state = 3425;
                    this.usageDeclaration();
                  }
                }
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 3431;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 3430;
              this.valuePart();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionNode() {
      let localContext = new ActionNodeContext(this.context, this.state);
      this.enterRule(localContext, 600, _SysMLv2Parser.RULE_actionNode);
      try {
        this.state = 3441;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 360, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3433;
              this.controlNode();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3434;
              this.sendNode();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3435;
              this.acceptNode();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3436;
              this.assignmentNode();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 3437;
              this.terminateNode();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 3438;
              this.ifNode();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 3439;
              this.whileLoopNode();
            }
            break;
          case 8:
            this.enterOuterAlt(localContext, 8);
            {
              this.state = 3440;
              this.forLoopNode();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionNodeUsageDeclaration() {
      let localContext = new ActionNodeUsageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 602, _SysMLv2Parser.RULE_actionNodeUsageDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3443;
          this.match(_SysMLv2Parser.ACTION);
          this.state = 3445;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 3444;
              this.usageDeclaration();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionNodePrefix() {
      let localContext = new ActionNodePrefixContext(this.context, this.state);
      this.enterRule(localContext, 604, _SysMLv2Parser.RULE_actionNodePrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3447;
          this.occurrenceUsagePrefix();
          this.state = 3449;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 4) {
            {
              this.state = 3448;
              this.actionNodeUsageDeclaration();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    controlNode() {
      let localContext = new ControlNodeContext(this.context, this.state);
      this.enterRule(localContext, 606, _SysMLv2Parser.RULE_controlNode);
      try {
        this.state = 3455;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 363, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3451;
              this.mergeNode();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3452;
              this.decisionNode();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3453;
              this.joinNode();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3454;
              this.forkNode();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    controlNodePrefix() {
      let localContext = new ControlNodePrefixContext(this.context, this.state);
      this.enterRule(localContext, 608, _SysMLv2Parser.RULE_controlNodePrefix);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3457;
          this.refPrefix();
          this.state = 3459;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 82) {
            {
              this.state = 3458;
              this.match(_SysMLv2Parser.INDIVIDUAL);
            }
          }
          this.state = 3462;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 137 || _la === 153) {
            {
              this.state = 3461;
              this.portionKind();
            }
          }
          this.state = 3467;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 3464;
                this.usageExtensionKeyword();
              }
            }
            this.state = 3469;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    mergeNode() {
      let localContext = new MergeNodeContext(this.context, this.state);
      this.enterRule(localContext, 610, _SysMLv2Parser.RULE_mergeNode);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3470;
          this.controlNodePrefix();
          this.state = 3471;
          this.match(_SysMLv2Parser.MERGE);
          this.state = 3473;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 3472;
              this.usageDeclaration();
            }
          }
          this.state = 3475;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    decisionNode() {
      let localContext = new DecisionNodeContext(this.context, this.state);
      this.enterRule(localContext, 612, _SysMLv2Parser.RULE_decisionNode);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3477;
          this.controlNodePrefix();
          this.state = 3478;
          this.match(_SysMLv2Parser.DECIDE);
          this.state = 3480;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 3479;
              this.usageDeclaration();
            }
          }
          this.state = 3482;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    joinNode() {
      let localContext = new JoinNodeContext(this.context, this.state);
      this.enterRule(localContext, 614, _SysMLv2Parser.RULE_joinNode);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3484;
          this.controlNodePrefix();
          this.state = 3485;
          this.match(_SysMLv2Parser.JOIN);
          this.state = 3487;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 3486;
              this.usageDeclaration();
            }
          }
          this.state = 3489;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    forkNode() {
      let localContext = new ForkNodeContext(this.context, this.state);
      this.enterRule(localContext, 616, _SysMLv2Parser.RULE_forkNode);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3491;
          this.controlNodePrefix();
          this.state = 3492;
          this.match(_SysMLv2Parser.FORK);
          this.state = 3494;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 3493;
              this.usageDeclaration();
            }
          }
          this.state = 3496;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    acceptNode() {
      let localContext = new AcceptNodeContext(this.context, this.state);
      this.enterRule(localContext, 618, _SysMLv2Parser.RULE_acceptNode);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3498;
          this.occurrenceUsagePrefix();
          this.state = 3499;
          this.acceptNodeDeclaration();
          this.state = 3500;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    acceptNodeDeclaration() {
      let localContext = new AcceptNodeDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 620, _SysMLv2Parser.RULE_acceptNodeDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3503;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 4) {
            {
              this.state = 3502;
              this.actionNodeUsageDeclaration();
            }
          }
          this.state = 3505;
          this.match(_SysMLv2Parser.ACCEPT);
          this.state = 3506;
          this.acceptParameterPart();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    acceptParameterPart() {
      let localContext = new AcceptParameterPartContext(this.context, this.state);
      this.enterRule(localContext, 622, _SysMLv2Parser.RULE_acceptParameterPart);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3508;
          this.payloadParameterMember();
          this.state = 3511;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 168) {
            {
              this.state = 3509;
              this.match(_SysMLv2Parser.VIA);
              this.state = 3510;
              this.nodeParameterMember();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    payloadParameterMember() {
      let localContext = new PayloadParameterMemberContext(this.context, this.state);
      this.enterRule(localContext, 624, _SysMLv2Parser.RULE_payloadParameterMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3513;
          this.payloadParameter();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    payloadParameter() {
      let localContext = new PayloadParameterContext(this.context, this.state);
      this.enterRule(localContext, 626, _SysMLv2Parser.RULE_payloadParameter);
      let _la;
      try {
        this.state = 3523;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 375, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3515;
              this.payloadFeature();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3517;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 373, this.context)) {
                case 1:
                  {
                    this.state = 3516;
                    this.identification();
                  }
                  break;
              }
              this.state = 3520;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                {
                  this.state = 3519;
                  this.payloadFeatureSpecializationPart();
                }
              }
              this.state = 3522;
              this.triggerValuePart();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    triggerValuePart() {
      let localContext = new TriggerValuePartContext(this.context, this.state);
      this.enterRule(localContext, 628, _SysMLv2Parser.RULE_triggerValuePart);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3525;
          this.triggerFeatureValue();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    triggerFeatureValue() {
      let localContext = new TriggerFeatureValueContext(this.context, this.state);
      this.enterRule(localContext, 630, _SysMLv2Parser.RULE_triggerFeatureValue);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3527;
          this.triggerExpression();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    triggerExpression() {
      let localContext = new TriggerExpressionContext(this.context, this.state);
      this.enterRule(localContext, 632, _SysMLv2Parser.RULE_triggerExpression);
      let _la;
      try {
        this.state = 3533;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.AFTER:
          case _SysMLv2Parser.AT:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3529;
              _la = this.tokenStream.LA(1);
              if (!(_la === 6 || _la === 18)) {
                this.errorHandler.recoverInline(this);
              } else {
                this.errorHandler.reportMatch(this);
                this.consume();
              }
              this.state = 3530;
              this.argumentMember();
            }
            break;
          case _SysMLv2Parser.WHEN:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3531;
              this.match(_SysMLv2Parser.WHEN);
              this.state = 3532;
              this.argumentExpressionMember();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    sendNode() {
      let localContext = new SendNodeContext(this.context, this.state);
      this.enterRule(localContext, 634, _SysMLv2Parser.RULE_sendNode);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3535;
          this.occurrenceUsagePrefix();
          this.state = 3538;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.ACTION:
              {
                this.state = 3536;
                this.actionNodeUsageDeclaration();
              }
              break;
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.DEFAULT:
            case _SysMLv2Parser.DEFINED:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.NONUNIQUE:
            case _SysMLv2Parser.ORDERED:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.REDEFINES:
            case _SysMLv2Parser.REFERENCES:
            case _SysMLv2Parser.SEND:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.SUBSETS:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.TYPED:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.COLON_COLON_GT:
            case _SysMLv2Parser.COLON_GT_GT:
            case _SysMLv2Parser.COLON_EQ:
            case _SysMLv2Parser.COLON_GT:
            case _SysMLv2Parser.FAT_ARROW:
            case _SysMLv2Parser.COLON:
            case _SysMLv2Parser.LT:
            case _SysMLv2Parser.EQ:
            case _SysMLv2Parser.LBRACK:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
              {
                this.state = 3537;
                this.actionUsageDeclaration();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 3540;
          this.match(_SysMLv2Parser.SEND);
          this.state = 3549;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 380, this.context)) {
            case 1:
              {
                this.state = 3541;
                this.nodeParameterMember();
                this.state = 3543;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 154 || _la === 168) {
                  {
                    this.state = 3542;
                    this.senderReceiverPart();
                  }
                }
              }
              break;
            case 2:
              {
                this.state = 3545;
                this.emptyParameterMember();
                this.state = 3547;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 154 || _la === 168) {
                  {
                    this.state = 3546;
                    this.senderReceiverPart();
                  }
                }
              }
              break;
          }
          this.state = 3551;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    sendNodeDeclaration() {
      let localContext = new SendNodeDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 636, _SysMLv2Parser.RULE_sendNodeDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3554;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 4) {
            {
              this.state = 3553;
              this.actionNodeUsageDeclaration();
            }
          }
          this.state = 3556;
          this.match(_SysMLv2Parser.SEND);
          this.state = 3557;
          this.nodeParameterMember();
          this.state = 3559;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 154 || _la === 168) {
            {
              this.state = 3558;
              this.senderReceiverPart();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    senderReceiverPart() {
      let localContext = new SenderReceiverPartContext(this.context, this.state);
      this.enterRule(localContext, 638, _SysMLv2Parser.RULE_senderReceiverPart);
      let _la;
      try {
        this.state = 3571;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.VIA:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3561;
              this.match(_SysMLv2Parser.VIA);
              this.state = 3562;
              this.nodeParameterMember();
              this.state = 3565;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 154) {
                {
                  this.state = 3563;
                  this.match(_SysMLv2Parser.TO);
                  this.state = 3564;
                  this.nodeParameterMember();
                }
              }
            }
            break;
          case _SysMLv2Parser.TO:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3567;
              this.emptyParameterMember();
              this.state = 3568;
              this.match(_SysMLv2Parser.TO);
              this.state = 3569;
              this.nodeParameterMember();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nodeParameterMember() {
      let localContext = new NodeParameterMemberContext(this.context, this.state);
      this.enterRule(localContext, 640, _SysMLv2Parser.RULE_nodeParameterMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3573;
          this.nodeParameter();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nodeParameter() {
      let localContext = new NodeParameterContext(this.context, this.state);
      this.enterRule(localContext, 642, _SysMLv2Parser.RULE_nodeParameter);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3575;
          this.featureBinding();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    featureBinding() {
      let localContext = new FeatureBindingContext(this.context, this.state);
      this.enterRule(localContext, 644, _SysMLv2Parser.RULE_featureBinding);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3577;
          this.ownedExpression(0);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    emptyParameterMember() {
      let localContext = new EmptyParameterMemberContext(this.context, this.state);
      this.enterRule(localContext, 646, _SysMLv2Parser.RULE_emptyParameterMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3579;
          this.emptyUsage_();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    assignmentNode() {
      let localContext = new AssignmentNodeContext(this.context, this.state);
      this.enterRule(localContext, 648, _SysMLv2Parser.RULE_assignmentNode);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3581;
          this.occurrenceUsagePrefix();
          this.state = 3582;
          this.assignmentNodeDeclaration();
          this.state = 3583;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    assignmentNodeDeclaration() {
      let localContext = new AssignmentNodeDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 650, _SysMLv2Parser.RULE_assignmentNodeDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3586;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 4) {
            {
              this.state = 3585;
              this.actionNodeUsageDeclaration();
            }
          }
          this.state = 3588;
          this.match(_SysMLv2Parser.ASSIGN);
          this.state = 3589;
          this.assignmentTargetMember();
          this.state = 3590;
          this.featureChainMember();
          this.state = 3591;
          this.match(_SysMLv2Parser.COLON_EQ);
          this.state = 3592;
          this.nodeParameterMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    assignmentTargetMember() {
      let localContext = new AssignmentTargetMemberContext(this.context, this.state);
      this.enterRule(localContext, 652, _SysMLv2Parser.RULE_assignmentTargetMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3594;
          this.assignmentTargetParameter();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    assignmentTargetParameter() {
      let localContext = new AssignmentTargetParameterContext(this.context, this.state);
      this.enterRule(localContext, 654, _SysMLv2Parser.RULE_assignmentTargetParameter);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3599;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 386, this.context)) {
            case 1:
              {
                this.state = 3596;
                this.assignmentTargetBinding();
                this.state = 3597;
                this.match(_SysMLv2Parser.DOT);
              }
              break;
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    assignmentTargetBinding() {
      let localContext = new AssignmentTargetBindingContext(this.context, this.state);
      this.enterRule(localContext, 656, _SysMLv2Parser.RULE_assignmentTargetBinding);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3601;
          this.nonFeatureChainPrimaryExpression();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    terminateNode() {
      let localContext = new TerminateNodeContext(this.context, this.state);
      this.enterRule(localContext, 658, _SysMLv2Parser.RULE_terminateNode);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3603;
          this.occurrenceUsagePrefix();
          this.state = 3605;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 4) {
            {
              this.state = 3604;
              this.actionNodeUsageDeclaration();
            }
          }
          this.state = 3607;
          this.match(_SysMLv2Parser.TERMINATE);
          this.state = 3609;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 388, this.context)) {
            case 1:
              {
                this.state = 3608;
                this.nodeParameterMember();
              }
              break;
          }
          this.state = 3611;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ifNode() {
      let localContext = new IfNodeContext(this.context, this.state);
      this.enterRule(localContext, 660, _SysMLv2Parser.RULE_ifNode);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3613;
          this.actionNodePrefix();
          this.state = 3614;
          this.match(_SysMLv2Parser.IF);
          this.state = 3615;
          this.expressionParameterMember();
          this.state = 3616;
          this.actionBodyParameterMember();
          this.state = 3622;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 390, this.context)) {
            case 1:
              {
                this.state = 3617;
                this.match(_SysMLv2Parser.ELSE);
                this.state = 3620;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 389, this.context)) {
                  case 1:
                    {
                      this.state = 3618;
                      this.actionBodyParameterMember();
                    }
                    break;
                  case 2:
                    {
                      this.state = 3619;
                      this.ifNodeParameterMember();
                    }
                    break;
                }
              }
              break;
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    expressionParameterMember() {
      let localContext = new ExpressionParameterMemberContext(this.context, this.state);
      this.enterRule(localContext, 662, _SysMLv2Parser.RULE_expressionParameterMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3624;
          this.ownedExpression(0);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionBodyParameterMember() {
      let localContext = new ActionBodyParameterMemberContext(this.context, this.state);
      this.enterRule(localContext, 664, _SysMLv2Parser.RULE_actionBodyParameterMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3626;
          this.actionBodyParameter();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionBodyParameter() {
      let localContext = new ActionBodyParameterContext(this.context, this.state);
      this.enterRule(localContext, 666, _SysMLv2Parser.RULE_actionBodyParameter);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3632;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 4) {
            {
              this.state = 3628;
              this.match(_SysMLv2Parser.ACTION);
              this.state = 3630;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                {
                  this.state = 3629;
                  this.usageDeclaration();
                }
              }
            }
          }
          this.state = 3634;
          this.match(_SysMLv2Parser.LBRACE);
          this.state = 3638;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while ((_la & ~31) === 0 && (1 << _la & 1182322332) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490985265) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 4229944561) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127799) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 418658539) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153459615) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
            {
              {
                this.state = 3635;
                this.actionBodyItem();
              }
            }
            this.state = 3640;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 3641;
          this.match(_SysMLv2Parser.RBRACE);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    ifNodeParameterMember() {
      let localContext = new IfNodeParameterMemberContext(this.context, this.state);
      this.enterRule(localContext, 668, _SysMLv2Parser.RULE_ifNodeParameterMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3643;
          this.ifNode();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    whileLoopNode() {
      let localContext = new WhileLoopNodeContext(this.context, this.state);
      this.enterRule(localContext, 670, _SysMLv2Parser.RULE_whileLoopNode);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3645;
          this.actionNodePrefix();
          this.state = 3650;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.WHILE:
              {
                this.state = 3646;
                this.match(_SysMLv2Parser.WHILE);
                this.state = 3647;
                this.expressionParameterMember();
              }
              break;
            case _SysMLv2Parser.LOOP:
              {
                this.state = 3648;
                this.match(_SysMLv2Parser.LOOP);
                this.state = 3649;
                this.emptyParameterMember();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 3652;
          this.actionBodyParameterMember();
          this.state = 3657;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 161) {
            {
              this.state = 3653;
              this.match(_SysMLv2Parser.UNTIL);
              this.state = 3654;
              this.expressionParameterMember();
              this.state = 3655;
              this.match(_SysMLv2Parser.SEMI);
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    forLoopNode() {
      let localContext = new ForLoopNodeContext(this.context, this.state);
      this.enterRule(localContext, 672, _SysMLv2Parser.RULE_forLoopNode);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3659;
          this.actionNodePrefix();
          this.state = 3660;
          this.match(_SysMLv2Parser.FOR);
          this.state = 3661;
          this.forVariableDeclarationMember();
          this.state = 3662;
          this.match(_SysMLv2Parser.IN);
          this.state = 3663;
          this.nodeParameterMember();
          this.state = 3664;
          this.actionBodyParameterMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    forVariableDeclarationMember() {
      let localContext = new ForVariableDeclarationMemberContext(this.context, this.state);
      this.enterRule(localContext, 674, _SysMLv2Parser.RULE_forVariableDeclarationMember);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3667;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 3666;
              this.usageDeclaration();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actionTargetSuccession() {
      let localContext = new ActionTargetSuccessionContext(this.context, this.state);
      this.enterRule(localContext, 676, _SysMLv2Parser.RULE_actionTargetSuccession);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3672;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.THEN:
            case _SysMLv2Parser.LBRACK:
              {
                this.state = 3669;
                this.targetSuccession();
              }
              break;
            case _SysMLv2Parser.IF:
              {
                this.state = 3670;
                this.guardedTargetSuccession();
              }
              break;
            case _SysMLv2Parser.ELSE:
              {
                this.state = 3671;
                this.defaultTargetSuccession();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 3674;
          this.usageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    targetSuccession() {
      let localContext = new TargetSuccessionContext(this.context, this.state);
      this.enterRule(localContext, 678, _SysMLv2Parser.RULE_targetSuccession);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3676;
          this.sourceEndMember();
          this.state = 3677;
          this.match(_SysMLv2Parser.THEN);
          this.state = 3678;
          this.connectorEndMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    guardedTargetSuccession() {
      let localContext = new GuardedTargetSuccessionContext(this.context, this.state);
      this.enterRule(localContext, 680, _SysMLv2Parser.RULE_guardedTargetSuccession);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3680;
          this.guardExpressionMember();
          this.state = 3681;
          this.match(_SysMLv2Parser.THEN);
          this.state = 3682;
          this.transitionSuccessionMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    defaultTargetSuccession() {
      let localContext = new DefaultTargetSuccessionContext(this.context, this.state);
      this.enterRule(localContext, 682, _SysMLv2Parser.RULE_defaultTargetSuccession);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3684;
          this.match(_SysMLv2Parser.ELSE);
          this.state = 3685;
          this.transitionSuccessionMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    guardedSuccession() {
      let localContext = new GuardedSuccessionContext(this.context, this.state);
      this.enterRule(localContext, 684, _SysMLv2Parser.RULE_guardedSuccession);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3691;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 150) {
            {
              this.state = 3687;
              this.match(_SysMLv2Parser.SUCCESSION);
              this.state = 3689;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                {
                  this.state = 3688;
                  this.usageDeclaration();
                }
              }
            }
          }
          this.state = 3693;
          this.match(_SysMLv2Parser.FIRST);
          this.state = 3694;
          this.featureChainMember();
          this.state = 3695;
          this.guardExpressionMember();
          this.state = 3696;
          this.match(_SysMLv2Parser.THEN);
          this.state = 3697;
          this.transitionSuccessionMember();
          this.state = 3698;
          this.usageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateDefinition() {
      let localContext = new StateDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 686, _SysMLv2Parser.RULE_stateDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3700;
          this.occurrenceDefinitionPrefix();
          this.state = 3701;
          this.match(_SysMLv2Parser.STATE);
          this.state = 3702;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3703;
          this.definitionDeclaration();
          this.state = 3704;
          this.stateDefBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateDefBody() {
      let localContext = new StateDefBodyContext(this.context, this.state);
      this.enterRule(localContext, 688, _SysMLv2Parser.RULE_stateDefBody);
      let _la;
      try {
        this.state = 3718;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3706;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.PARALLEL:
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3708;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 116) {
                {
                  this.state = 3707;
                  this.match(_SysMLv2Parser.PARALLEL);
                }
              }
              this.state = 3710;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3714;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182289556) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 1063503665) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1948238897) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127797) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 450115755) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153458591) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 3711;
                    this.stateBodyItem();
                  }
                }
                this.state = 3716;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 3717;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateBodyItem() {
      let localContext = new StateBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 690, _SysMLv2Parser.RULE_stateBodyItem);
      let _la;
      try {
        let alternative;
        this.state = 3741;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 406, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3720;
              this.nonBehaviorBodyItem();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3722;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 152) {
                {
                  this.state = 3721;
                  this.sourceSuccessionMember();
                }
              }
              this.state = 3724;
              this.behaviorUsageMember();
              this.state = 3728;
              this.errorHandler.sync(this);
              alternative = this.interpreter.adaptivePredict(this.tokenStream, 404, this.context);
              while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                  {
                    {
                      this.state = 3725;
                      this.targetTransitionUsageMember();
                    }
                  }
                }
                this.state = 3730;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 404, this.context);
              }
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3731;
              this.transitionUsageMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3732;
              this.entryActionMember();
              this.state = 3736;
              this.errorHandler.sync(this);
              alternative = this.interpreter.adaptivePredict(this.tokenStream, 405, this.context);
              while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                  {
                    {
                      this.state = 3733;
                      this.entryTransitionMember();
                    }
                  }
                }
                this.state = 3738;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 405, this.context);
              }
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 3739;
              this.doActionMember();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 3740;
              this.exitActionMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    entryActionMember() {
      let localContext = new EntryActionMemberContext(this.context, this.state);
      this.enterRule(localContext, 692, _SysMLv2Parser.RULE_entryActionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3743;
          this.memberPrefix();
          this.state = 3744;
          this.match(_SysMLv2Parser.ENTRY);
          this.state = 3745;
          this.stateActionUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    doActionMember() {
      let localContext = new DoActionMemberContext(this.context, this.state);
      this.enterRule(localContext, 694, _SysMLv2Parser.RULE_doActionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3747;
          this.memberPrefix();
          this.state = 3748;
          this.match(_SysMLv2Parser.DO);
          this.state = 3749;
          this.stateActionUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    exitActionMember() {
      let localContext = new ExitActionMemberContext(this.context, this.state);
      this.enterRule(localContext, 696, _SysMLv2Parser.RULE_exitActionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3751;
          this.memberPrefix();
          this.state = 3752;
          this.match(_SysMLv2Parser.EXIT);
          this.state = 3753;
          this.stateActionUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    entryTransitionMember() {
      let localContext = new EntryTransitionMemberContext(this.context, this.state);
      this.enterRule(localContext, 698, _SysMLv2Parser.RULE_entryTransitionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3755;
          this.memberPrefix();
          this.state = 3759;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.IF:
              {
                this.state = 3756;
                this.guardedTargetSuccession();
              }
              break;
            case _SysMLv2Parser.THEN:
              {
                this.state = 3757;
                this.match(_SysMLv2Parser.THEN);
                this.state = 3758;
                this.transitionSuccessionMember();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 3761;
          this.match(_SysMLv2Parser.SEMI);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateActionUsage() {
      let localContext = new StateActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 700, _SysMLv2Parser.RULE_stateActionUsage);
      try {
        this.state = 3770;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 408, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3763;
              this.emptyActionUsage_();
              this.state = 3764;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3766;
              this.statePerformActionUsage();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3767;
              this.stateAcceptActionUsage();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3768;
              this.stateSendActionUsage();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 3769;
              this.stateAssignmentActionUsage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    statePerformActionUsage() {
      let localContext = new StatePerformActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 702, _SysMLv2Parser.RULE_statePerformActionUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3772;
          this.performActionUsageDeclaration();
          this.state = 3773;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateAcceptActionUsage() {
      let localContext = new StateAcceptActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 704, _SysMLv2Parser.RULE_stateAcceptActionUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3775;
          this.acceptNodeDeclaration();
          this.state = 3776;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateSendActionUsage() {
      let localContext = new StateSendActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 706, _SysMLv2Parser.RULE_stateSendActionUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3778;
          this.sendNodeDeclaration();
          this.state = 3779;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateAssignmentActionUsage() {
      let localContext = new StateAssignmentActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 708, _SysMLv2Parser.RULE_stateAssignmentActionUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3781;
          this.assignmentNodeDeclaration();
          this.state = 3782;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    transitionUsageMember() {
      let localContext = new TransitionUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 710, _SysMLv2Parser.RULE_transitionUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3784;
          this.memberPrefix();
          this.state = 3785;
          this.transitionUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    targetTransitionUsageMember() {
      let localContext = new TargetTransitionUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 712, _SysMLv2Parser.RULE_targetTransitionUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3787;
          this.memberPrefix();
          this.state = 3788;
          this.targetTransitionUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateUsage() {
      let localContext = new StateUsageContext(this.context, this.state);
      this.enterRule(localContext, 714, _SysMLv2Parser.RULE_stateUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3790;
          this.occurrenceUsagePrefix();
          this.state = 3791;
          this.match(_SysMLv2Parser.STATE);
          this.state = 3792;
          this.actionUsageDeclaration();
          this.state = 3793;
          this.stateUsageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stateUsageBody() {
      let localContext = new StateUsageBodyContext(this.context, this.state);
      this.enterRule(localContext, 716, _SysMLv2Parser.RULE_stateUsageBody);
      let _la;
      try {
        this.state = 3807;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3795;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.PARALLEL:
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3797;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 116) {
                {
                  this.state = 3796;
                  this.match(_SysMLv2Parser.PARALLEL);
                }
              }
              this.state = 3799;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3803;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182289556) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 1063503665) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1948238897) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127797) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 450115755) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153458591) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 3800;
                    this.stateBodyItem();
                  }
                }
                this.state = 3805;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 3806;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    exhibitStateUsage() {
      let localContext = new ExhibitStateUsageContext(this.context, this.state);
      this.enterRule(localContext, 718, _SysMLv2Parser.RULE_exhibitStateUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3809;
          this.occurrenceUsagePrefix();
          this.state = 3810;
          this.match(_SysMLv2Parser.EXHIBIT);
          this.state = 3819;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.DOLLAR:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
              {
                this.state = 3811;
                this.ownedReferenceSubsetting();
                this.state = 3813;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                  {
                    this.state = 3812;
                    this.featureSpecializationPart();
                  }
                }
              }
              break;
            case _SysMLv2Parser.STATE:
              {
                this.state = 3815;
                this.match(_SysMLv2Parser.STATE);
                this.state = 3817;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                  {
                    this.state = 3816;
                    this.usageDeclaration();
                  }
                }
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 3822;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 3821;
              this.valuePart();
            }
          }
          this.state = 3824;
          this.stateUsageBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    transitionUsage() {
      let localContext = new TransitionUsageContext(this.context, this.state);
      this.enterRule(localContext, 720, _SysMLv2Parser.RULE_transitionUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3826;
          this.match(_SysMLv2Parser.TRANSITION);
          this.state = 3831;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 417, this.context)) {
            case 1:
              {
                this.state = 3828;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                  {
                    this.state = 3827;
                    this.usageDeclaration();
                  }
                }
                this.state = 3830;
                this.match(_SysMLv2Parser.FIRST);
              }
              break;
          }
          this.state = 3833;
          this.featureChainMember();
          this.state = 3834;
          this.emptyParameterMember();
          this.state = 3838;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 3) {
            {
              this.state = 3835;
              this.emptyParameterMember();
              this.state = 3836;
              this.triggerActionMember();
            }
          }
          this.state = 3841;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 77) {
            {
              this.state = 3840;
              this.guardExpressionMember();
            }
          }
          this.state = 3844;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 53) {
            {
              this.state = 3843;
              this.effectBehaviorMember();
            }
          }
          this.state = 3846;
          this.match(_SysMLv2Parser.THEN);
          this.state = 3847;
          this.transitionSuccessionMember();
          this.state = 3848;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    targetTransitionUsage() {
      let localContext = new TargetTransitionUsageContext(this.context, this.state);
      this.enterRule(localContext, 722, _SysMLv2Parser.RULE_targetTransitionUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3850;
          this.emptyParameterMember();
          this.state = 3875;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.TRANSITION:
              {
                this.state = 3851;
                this.match(_SysMLv2Parser.TRANSITION);
                this.state = 3855;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 3) {
                  {
                    this.state = 3852;
                    this.emptyParameterMember();
                    this.state = 3853;
                    this.triggerActionMember();
                  }
                }
                this.state = 3858;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 77) {
                  {
                    this.state = 3857;
                    this.guardExpressionMember();
                  }
                }
                this.state = 3861;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 53) {
                  {
                    this.state = 3860;
                    this.effectBehaviorMember();
                  }
                }
              }
              break;
            case _SysMLv2Parser.ACCEPT:
              {
                this.state = 3863;
                this.emptyParameterMember();
                this.state = 3864;
                this.triggerActionMember();
                this.state = 3866;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 77) {
                  {
                    this.state = 3865;
                    this.guardExpressionMember();
                  }
                }
                this.state = 3869;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 53) {
                  {
                    this.state = 3868;
                    this.effectBehaviorMember();
                  }
                }
              }
              break;
            case _SysMLv2Parser.IF:
              {
                this.state = 3871;
                this.guardExpressionMember();
                this.state = 3873;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 53) {
                  {
                    this.state = 3872;
                    this.effectBehaviorMember();
                  }
                }
              }
              break;
            case _SysMLv2Parser.THEN:
              break;
            default:
              break;
          }
          this.state = 3877;
          this.match(_SysMLv2Parser.THEN);
          this.state = 3878;
          this.transitionSuccessionMember();
          this.state = 3879;
          this.actionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    triggerActionMember() {
      let localContext = new TriggerActionMemberContext(this.context, this.state);
      this.enterRule(localContext, 724, _SysMLv2Parser.RULE_triggerActionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3881;
          this.match(_SysMLv2Parser.ACCEPT);
          this.state = 3882;
          this.triggerAction();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    triggerAction() {
      let localContext = new TriggerActionContext(this.context, this.state);
      this.enterRule(localContext, 726, _SysMLv2Parser.RULE_triggerAction);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3884;
          this.acceptParameterPart();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    guardExpressionMember() {
      let localContext = new GuardExpressionMemberContext(this.context, this.state);
      this.enterRule(localContext, 728, _SysMLv2Parser.RULE_guardExpressionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3886;
          this.match(_SysMLv2Parser.IF);
          this.state = 3887;
          this.ownedExpression(0);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    effectBehaviorMember() {
      let localContext = new EffectBehaviorMemberContext(this.context, this.state);
      this.enterRule(localContext, 730, _SysMLv2Parser.RULE_effectBehaviorMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3889;
          this.match(_SysMLv2Parser.DO);
          this.state = 3890;
          this.effectBehaviorUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    effectBehaviorUsage() {
      let localContext = new EffectBehaviorUsageContext(this.context, this.state);
      this.enterRule(localContext, 732, _SysMLv2Parser.RULE_effectBehaviorUsage);
      try {
        this.state = 3897;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 428, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3892;
              this.emptyActionUsage_();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3893;
              this.transitionPerformActionUsage();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 3894;
              this.transitionAcceptActionUsage();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 3895;
              this.transitionSendActionUsage();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 3896;
              this.transitionAssignmentActionUsage();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    transitionPerformActionUsage() {
      let localContext = new TransitionPerformActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 734, _SysMLv2Parser.RULE_transitionPerformActionUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3899;
          this.performActionUsageDeclaration();
          this.state = 3908;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 214) {
            {
              this.state = 3900;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3904;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182322332) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490985265) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 4229944561) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127799) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 418658539) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153459615) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 3901;
                    this.actionBodyItem();
                  }
                }
                this.state = 3906;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 3907;
              this.match(_SysMLv2Parser.RBRACE);
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    transitionAcceptActionUsage() {
      let localContext = new TransitionAcceptActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 736, _SysMLv2Parser.RULE_transitionAcceptActionUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3910;
          this.acceptNodeDeclaration();
          this.state = 3919;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 214) {
            {
              this.state = 3911;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3915;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182322332) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490985265) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 4229944561) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127799) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 418658539) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153459615) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 3912;
                    this.actionBodyItem();
                  }
                }
                this.state = 3917;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 3918;
              this.match(_SysMLv2Parser.RBRACE);
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    transitionSendActionUsage() {
      let localContext = new TransitionSendActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 738, _SysMLv2Parser.RULE_transitionSendActionUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3921;
          this.sendNodeDeclaration();
          this.state = 3930;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 214) {
            {
              this.state = 3922;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3926;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182322332) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490985265) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 4229944561) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127799) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 418658539) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153459615) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 3923;
                    this.actionBodyItem();
                  }
                }
                this.state = 3928;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 3929;
              this.match(_SysMLv2Parser.RBRACE);
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    transitionAssignmentActionUsage() {
      let localContext = new TransitionAssignmentActionUsageContext(this.context, this.state);
      this.enterRule(localContext, 740, _SysMLv2Parser.RULE_transitionAssignmentActionUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3932;
          this.assignmentNodeDeclaration();
          this.state = 3941;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 214) {
            {
              this.state = 3933;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3937;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182322332) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490985265) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 4229944561) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127799) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 418658539) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153459615) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 3934;
                    this.actionBodyItem();
                  }
                }
                this.state = 3939;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 3940;
              this.match(_SysMLv2Parser.RBRACE);
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    transitionSuccessionMember() {
      let localContext = new TransitionSuccessionMemberContext(this.context, this.state);
      this.enterRule(localContext, 742, _SysMLv2Parser.RULE_transitionSuccessionMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3943;
          this.transitionSuccession();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    transitionSuccession() {
      let localContext = new TransitionSuccessionContext(this.context, this.state);
      this.enterRule(localContext, 744, _SysMLv2Parser.RULE_transitionSuccession);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3945;
          this.emptyEndMember();
          this.state = 3946;
          this.connectorEndMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    emptyEndMember() {
      let localContext = new EmptyEndMemberContext(this.context, this.state);
      this.enterRule(localContext, 746, _SysMLv2Parser.RULE_emptyEndMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3948;
          this.emptyFeature_();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    calculationDefinition() {
      let localContext = new CalculationDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 748, _SysMLv2Parser.RULE_calculationDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3950;
          this.occurrenceDefinitionPrefix();
          this.state = 3951;
          this.match(_SysMLv2Parser.CALC);
          this.state = 3952;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3953;
          this.definitionDeclaration();
          this.state = 3954;
          this.calculationBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    calculationUsage() {
      let localContext = new CalculationUsageContext(this.context, this.state);
      this.enterRule(localContext, 750, _SysMLv2Parser.RULE_calculationUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3956;
          this.occurrenceUsagePrefix();
          this.state = 3957;
          this.match(_SysMLv2Parser.CALC);
          this.state = 3958;
          this.actionUsageDeclaration();
          this.state = 3959;
          this.calculationBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    calculationBody() {
      let localContext = new CalculationBodyContext(this.context, this.state);
      this.enterRule(localContext, 752, _SysMLv2Parser.RULE_calculationBody);
      try {
        this.state = 3966;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3961;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3962;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 3963;
              this.calculationBodyPart();
              this.state = 3964;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    calculationBodyPart() {
      let localContext = new CalculationBodyPartContext(this.context, this.state);
      this.enterRule(localContext, 754, _SysMLv2Parser.RULE_calculationBodyPart);
      let _la;
      try {
        let alternative;
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3971;
          this.errorHandler.sync(this);
          alternative = this.interpreter.adaptivePredict(this.tokenStream, 438, this.context);
          while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
            if (alternative === 1) {
              {
                {
                  this.state = 3968;
                  this.calculationBodyItem();
                }
              }
            }
            this.state = 3973;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 438, this.context);
          }
          this.state = 3975;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 8 || _la === 20 || (_la - 42 & ~31) === 0 && (1 << _la - 42 & 12582913) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 1414791685) !== 0 || (_la - 107 & ~31) === 0 && (1 << _la - 107 & 245763) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1073153) !== 0 || (_la - 191 & ~31) === 0 && (1 << _la - 191 & 4236772773) !== 0 || _la === 223) {
            {
              this.state = 3974;
              this.resultExpressionMember();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    calculationBodyItem() {
      let localContext = new CalculationBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 756, _SysMLv2Parser.RULE_calculationBodyItem);
      try {
        this.state = 3979;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 440, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 3977;
              this.actionBodyItem();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 3978;
              this.returnParameterMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    returnParameterMember() {
      let localContext = new ReturnParameterMemberContext(this.context, this.state);
      this.enterRule(localContext, 758, _SysMLv2Parser.RULE_returnParameterMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3981;
          this.memberPrefix();
          this.state = 3982;
          this.match(_SysMLv2Parser.RETURN);
          this.state = 3983;
          this.usageElement();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    constraintDefinition() {
      let localContext = new ConstraintDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 760, _SysMLv2Parser.RULE_constraintDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3985;
          this.occurrenceDefinitionPrefix();
          this.state = 3986;
          this.match(_SysMLv2Parser.CONSTRAINT);
          this.state = 3987;
          this.match(_SysMLv2Parser.DEF);
          this.state = 3988;
          this.definitionDeclaration();
          this.state = 3989;
          this.calculationBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    constraintUsage() {
      let localContext = new ConstraintUsageContext(this.context, this.state);
      this.enterRule(localContext, 762, _SysMLv2Parser.RULE_constraintUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3991;
          this.occurrenceUsagePrefix();
          this.state = 3992;
          this.match(_SysMLv2Parser.CONSTRAINT);
          this.state = 3993;
          this.constraintUsageDeclaration();
          this.state = 3994;
          this.calculationBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    assertConstraintUsage() {
      let localContext = new AssertConstraintUsageContext(this.context, this.state);
      this.enterRule(localContext, 764, _SysMLv2Parser.RULE_assertConstraintUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 3996;
          this.occurrenceUsagePrefix();
          this.state = 3997;
          this.match(_SysMLv2Parser.ASSERT);
          this.state = 3999;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 107) {
            {
              this.state = 3998;
              this.match(_SysMLv2Parser.NOT);
            }
          }
          this.state = 4007;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.DOLLAR:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
              {
                this.state = 4001;
                this.ownedReferenceSubsetting();
                this.state = 4003;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                  {
                    this.state = 4002;
                    this.featureSpecializationPart();
                  }
                }
              }
              break;
            case _SysMLv2Parser.CONSTRAINT:
              {
                this.state = 4005;
                this.match(_SysMLv2Parser.CONSTRAINT);
                this.state = 4006;
                this.constraintUsageDeclaration();
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 4009;
          this.calculationBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    constraintUsageDeclaration() {
      let localContext = new ConstraintUsageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 766, _SysMLv2Parser.RULE_constraintUsageDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4012;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 4011;
              this.usageDeclaration();
            }
          }
          this.state = 4015;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 4014;
              this.valuePart();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementDefinition() {
      let localContext = new RequirementDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 768, _SysMLv2Parser.RULE_requirementDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4017;
          this.occurrenceDefinitionPrefix();
          this.state = 4018;
          this.match(_SysMLv2Parser.REQUIREMENT);
          this.state = 4019;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4020;
          this.definitionDeclaration();
          this.state = 4021;
          this.requirementBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementBody() {
      let localContext = new RequirementBodyContext(this.context, this.state);
      this.enterRule(localContext, 770, _SysMLv2Parser.RULE_requirementBody);
      let _la;
      try {
        this.state = 4032;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4023;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4024;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 4028;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182420660) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490981169) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1948239153) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127797) !== 0 || (_la - 130 & ~31) === 0 && (1 << _la - 130 & 416627887) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153458623) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 4025;
                    this.requirementBodyItem();
                  }
                }
                this.state = 4030;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 4031;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementBodyItem() {
      let localContext = new RequirementBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 772, _SysMLv2Parser.RULE_requirementBodyItem);
      try {
        this.state = 4041;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 448, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4034;
              this.definitionBodyItem();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4035;
              this.subjectMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 4036;
              this.requirementConstraintMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 4037;
              this.framedConcernMember();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 4038;
              this.requirementVerificationMember();
            }
            break;
          case 6:
            this.enterOuterAlt(localContext, 6);
            {
              this.state = 4039;
              this.actorMember();
            }
            break;
          case 7:
            this.enterOuterAlt(localContext, 7);
            {
              this.state = 4040;
              this.stakeholderMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    subjectMember() {
      let localContext = new SubjectMemberContext(this.context, this.state);
      this.enterRule(localContext, 774, _SysMLv2Parser.RULE_subjectMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4043;
          this.memberPrefix();
          this.state = 4044;
          this.subjectUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    subjectUsage() {
      let localContext = new SubjectUsageContext(this.context, this.state);
      this.enterRule(localContext, 776, _SysMLv2Parser.RULE_subjectUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4046;
          this.match(_SysMLv2Parser.SUBJECT);
          this.state = 4050;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 4047;
                this.usageExtensionKeyword();
              }
            }
            this.state = 4052;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 4053;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementConstraintMember() {
      let localContext = new RequirementConstraintMemberContext(this.context, this.state);
      this.enterRule(localContext, 778, _SysMLv2Parser.RULE_requirementConstraintMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4055;
          this.memberPrefix();
          this.state = 4056;
          this.requirementKind();
          this.state = 4057;
          this.requirementConstraintUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementKind() {
      let localContext = new RequirementKindContext(this.context, this.state);
      this.enterRule(localContext, 780, _SysMLv2Parser.RULE_requirementKind);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4059;
          _la = this.tokenStream.LA(1);
          if (!(_la === 17 || _la === 132)) {
            this.errorHandler.recoverInline(this);
          } else {
            this.errorHandler.reportMatch(this);
            this.consume();
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementConstraintUsage() {
      let localContext = new RequirementConstraintUsageContext(this.context, this.state);
      this.enterRule(localContext, 782, _SysMLv2Parser.RULE_requirementConstraintUsage);
      let _la;
      try {
        this.state = 4084;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
          case _SysMLv2Parser.DOLLAR:
          case _SysMLv2Parser.IDENTIFIER:
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4061;
              this.ownedReferenceSubsetting();
              this.state = 4063;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                {
                  this.state = 4062;
                  this.featureSpecializationPart();
                }
              }
              this.state = 4065;
              this.requirementBody();
            }
            break;
          case _SysMLv2Parser.CONSTRAINT:
          case _SysMLv2Parser.HASH:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4079;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 453, this.context)) {
                case 1:
                  {
                    this.state = 4070;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 192) {
                      {
                        {
                          this.state = 4067;
                          this.usageExtensionKeyword();
                        }
                      }
                      this.state = 4072;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                    }
                    this.state = 4073;
                    this.match(_SysMLv2Parser.CONSTRAINT);
                  }
                  break;
                case 2:
                  {
                    this.state = 4075;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    do {
                      {
                        {
                          this.state = 4074;
                          this.usageExtensionKeyword();
                        }
                      }
                      this.state = 4077;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                    } while (_la === 192);
                  }
                  break;
              }
              this.state = 4081;
              this.constraintUsageDeclaration();
              this.state = 4082;
              this.calculationBody();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    framedConcernMember() {
      let localContext = new FramedConcernMemberContext(this.context, this.state);
      this.enterRule(localContext, 784, _SysMLv2Parser.RULE_framedConcernMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4086;
          this.memberPrefix();
          this.state = 4087;
          this.match(_SysMLv2Parser.FRAME);
          this.state = 4088;
          this.framedConcernUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    framedConcernUsage() {
      let localContext = new FramedConcernUsageContext(this.context, this.state);
      this.enterRule(localContext, 786, _SysMLv2Parser.RULE_framedConcernUsage);
      let _la;
      try {
        this.state = 4113;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
          case _SysMLv2Parser.DOLLAR:
          case _SysMLv2Parser.IDENTIFIER:
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4090;
              this.ownedReferenceSubsetting();
              this.state = 4092;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                {
                  this.state = 4091;
                  this.featureSpecializationPart();
                }
              }
              this.state = 4094;
              this.calculationBody();
            }
            break;
          case _SysMLv2Parser.CONCERN:
          case _SysMLv2Parser.HASH:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4108;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 458, this.context)) {
                case 1:
                  {
                    this.state = 4099;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 192) {
                      {
                        {
                          this.state = 4096;
                          this.usageExtensionKeyword();
                        }
                      }
                      this.state = 4101;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                    }
                    this.state = 4102;
                    this.match(_SysMLv2Parser.CONCERN);
                  }
                  break;
                case 2:
                  {
                    this.state = 4104;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    do {
                      {
                        {
                          this.state = 4103;
                          this.usageExtensionKeyword();
                        }
                      }
                      this.state = 4106;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                    } while (_la === 192);
                  }
                  break;
              }
              this.state = 4110;
              this.calculationUsageDeclaration();
              this.state = 4111;
              this.calculationBody();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actorMember() {
      let localContext = new ActorMemberContext(this.context, this.state);
      this.enterRule(localContext, 788, _SysMLv2Parser.RULE_actorMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4115;
          this.memberPrefix();
          this.state = 4116;
          this.actorUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    actorUsage() {
      let localContext = new ActorUsageContext(this.context, this.state);
      this.enterRule(localContext, 790, _SysMLv2Parser.RULE_actorUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4118;
          this.match(_SysMLv2Parser.ACTOR);
          this.state = 4122;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 4119;
                this.usageExtensionKeyword();
              }
            }
            this.state = 4124;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 4125;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stakeholderMember() {
      let localContext = new StakeholderMemberContext(this.context, this.state);
      this.enterRule(localContext, 792, _SysMLv2Parser.RULE_stakeholderMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4127;
          this.memberPrefix();
          this.state = 4128;
          this.stakeholderUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    stakeholderUsage() {
      let localContext = new StakeholderUsageContext(this.context, this.state);
      this.enterRule(localContext, 794, _SysMLv2Parser.RULE_stakeholderUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4130;
          this.match(_SysMLv2Parser.STAKEHOLDER);
          this.state = 4134;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 4131;
                this.usageExtensionKeyword();
              }
            }
            this.state = 4136;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 4137;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementUsage() {
      let localContext = new RequirementUsageContext(this.context, this.state);
      this.enterRule(localContext, 796, _SysMLv2Parser.RULE_requirementUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4139;
          this.occurrenceUsagePrefix();
          this.state = 4140;
          this.match(_SysMLv2Parser.REQUIREMENT);
          this.state = 4141;
          this.constraintUsageDeclaration();
          this.state = 4142;
          this.requirementBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    satisfyRequirementUsage() {
      let localContext = new SatisfyRequirementUsageContext(this.context, this.state);
      this.enterRule(localContext, 798, _SysMLv2Parser.RULE_satisfyRequirementUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4144;
          this.occurrenceUsagePrefix();
          this.state = 4150;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.ASSERT:
              {
                this.state = 4145;
                this.match(_SysMLv2Parser.ASSERT);
                this.state = 4147;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 107) {
                  {
                    this.state = 4146;
                    this.match(_SysMLv2Parser.NOT);
                  }
                }
              }
              break;
            case _SysMLv2Parser.NOT:
              {
                this.state = 4149;
                this.match(_SysMLv2Parser.NOT);
              }
              break;
            case _SysMLv2Parser.SATISFY:
              break;
            default:
              break;
          }
          this.state = 4152;
          this.match(_SysMLv2Parser.SATISFY);
          this.state = 4161;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.DOLLAR:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
              {
                this.state = 4153;
                this.ownedReferenceSubsetting();
                this.state = 4155;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                  {
                    this.state = 4154;
                    this.featureSpecializationPart();
                  }
                }
              }
              break;
            case _SysMLv2Parser.REQUIREMENT:
              {
                this.state = 4157;
                this.match(_SysMLv2Parser.REQUIREMENT);
                this.state = 4159;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                  {
                    this.state = 4158;
                    this.usageDeclaration();
                  }
                }
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 4164;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 4163;
              this.valuePart();
            }
          }
          this.state = 4168;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 24) {
            {
              this.state = 4166;
              this.match(_SysMLv2Parser.BY);
              this.state = 4167;
              this.satisfactionSubjectMember();
            }
          }
          this.state = 4170;
          this.requirementBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    satisfactionSubjectMember() {
      let localContext = new SatisfactionSubjectMemberContext(this.context, this.state);
      this.enterRule(localContext, 800, _SysMLv2Parser.RULE_satisfactionSubjectMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4172;
          this.satisfactionParameter();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    satisfactionParameter() {
      let localContext = new SatisfactionParameterContext(this.context, this.state);
      this.enterRule(localContext, 802, _SysMLv2Parser.RULE_satisfactionParameter);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4174;
          this.satisfactionFeatureValue();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    satisfactionFeatureValue() {
      let localContext = new SatisfactionFeatureValueContext(this.context, this.state);
      this.enterRule(localContext, 804, _SysMLv2Parser.RULE_satisfactionFeatureValue);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4176;
          this.satisfactionReferenceExpression();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    satisfactionReferenceExpression() {
      let localContext = new SatisfactionReferenceExpressionContext(this.context, this.state);
      this.enterRule(localContext, 806, _SysMLv2Parser.RULE_satisfactionReferenceExpression);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4178;
          this.featureChainMember();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    concernDefinition() {
      let localContext = new ConcernDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 808, _SysMLv2Parser.RULE_concernDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4180;
          this.occurrenceDefinitionPrefix();
          this.state = 4181;
          this.match(_SysMLv2Parser.CONCERN);
          this.state = 4182;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4183;
          this.definitionDeclaration();
          this.state = 4184;
          this.requirementBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    concernUsage() {
      let localContext = new ConcernUsageContext(this.context, this.state);
      this.enterRule(localContext, 810, _SysMLv2Parser.RULE_concernUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4186;
          this.occurrenceUsagePrefix();
          this.state = 4187;
          this.match(_SysMLv2Parser.CONCERN);
          this.state = 4188;
          this.constraintUsageDeclaration();
          this.state = 4189;
          this.requirementBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    caseDefinition() {
      let localContext = new CaseDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 812, _SysMLv2Parser.RULE_caseDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4191;
          this.occurrenceDefinitionPrefix();
          this.state = 4192;
          this.match(_SysMLv2Parser.CASE);
          this.state = 4193;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4194;
          this.definitionDeclaration();
          this.state = 4195;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    caseUsage() {
      let localContext = new CaseUsageContext(this.context, this.state);
      this.enterRule(localContext, 814, _SysMLv2Parser.RULE_caseUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4197;
          this.occurrenceUsagePrefix();
          this.state = 4198;
          this.match(_SysMLv2Parser.CASE);
          this.state = 4199;
          this.constraintUsageDeclaration();
          this.state = 4200;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    caseBody() {
      let localContext = new CaseBodyContext(this.context, this.state);
      this.enterRule(localContext, 816, _SysMLv2Parser.RULE_caseBody);
      let _la;
      try {
        let alternative;
        this.state = 4214;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4202;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4203;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 4207;
              this.errorHandler.sync(this);
              alternative = this.interpreter.adaptivePredict(this.tokenStream, 469, this.context);
              while (alternative !== 2 && alternative !== ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                  {
                    {
                      this.state = 4204;
                      this.caseBodyItem();
                    }
                  }
                }
                this.state = 4209;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 469, this.context);
              }
              this.state = 4211;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 8 || _la === 20 || (_la - 42 & ~31) === 0 && (1 << _la - 42 & 12582913) !== 0 || (_la - 75 & ~31) === 0 && (1 << _la - 75 & 1414791685) !== 0 || (_la - 107 & ~31) === 0 && (1 << _la - 107 & 245763) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1073153) !== 0 || (_la - 191 & ~31) === 0 && (1 << _la - 191 & 4236772773) !== 0 || _la === 223) {
                {
                  this.state = 4210;
                  this.resultExpressionMember();
                }
              }
              this.state = 4213;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    caseBodyItem() {
      let localContext = new CaseBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 818, _SysMLv2Parser.RULE_caseBodyItem);
      try {
        this.state = 4221;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 472, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4216;
              this.actionBodyItem();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4217;
              this.returnParameterMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 4218;
              this.subjectMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 4219;
              this.actorMember();
            }
            break;
          case 5:
            this.enterOuterAlt(localContext, 5);
            {
              this.state = 4220;
              this.objectiveMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    objectiveMember() {
      let localContext = new ObjectiveMemberContext(this.context, this.state);
      this.enterRule(localContext, 820, _SysMLv2Parser.RULE_objectiveMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4223;
          this.memberPrefix();
          this.state = 4224;
          this.match(_SysMLv2Parser.OBJECTIVE);
          this.state = 4225;
          this.objectiveRequirementUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    objectiveRequirementUsage() {
      let localContext = new ObjectiveRequirementUsageContext(this.context, this.state);
      this.enterRule(localContext, 822, _SysMLv2Parser.RULE_objectiveRequirementUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4230;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 4227;
                this.usageExtensionKeyword();
              }
            }
            this.state = 4232;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 4233;
          this.constraintUsageDeclaration();
          this.state = 4234;
          this.requirementBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    analysisCaseDefinition() {
      let localContext = new AnalysisCaseDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 824, _SysMLv2Parser.RULE_analysisCaseDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4236;
          this.occurrenceDefinitionPrefix();
          this.state = 4237;
          this.match(_SysMLv2Parser.ANALYSIS);
          this.state = 4238;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4239;
          this.definitionDeclaration();
          this.state = 4240;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    analysisCaseUsage() {
      let localContext = new AnalysisCaseUsageContext(this.context, this.state);
      this.enterRule(localContext, 826, _SysMLv2Parser.RULE_analysisCaseUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4242;
          this.occurrenceUsagePrefix();
          this.state = 4243;
          this.match(_SysMLv2Parser.ANALYSIS);
          this.state = 4244;
          this.constraintUsageDeclaration();
          this.state = 4245;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    verificationCaseDefinition() {
      let localContext = new VerificationCaseDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 828, _SysMLv2Parser.RULE_verificationCaseDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4247;
          this.occurrenceDefinitionPrefix();
          this.state = 4248;
          this.match(_SysMLv2Parser.VERIFICATION);
          this.state = 4249;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4250;
          this.definitionDeclaration();
          this.state = 4251;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    verificationCaseUsage() {
      let localContext = new VerificationCaseUsageContext(this.context, this.state);
      this.enterRule(localContext, 830, _SysMLv2Parser.RULE_verificationCaseUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4253;
          this.occurrenceUsagePrefix();
          this.state = 4254;
          this.match(_SysMLv2Parser.VERIFICATION);
          this.state = 4255;
          this.constraintUsageDeclaration();
          this.state = 4256;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementVerificationMember() {
      let localContext = new RequirementVerificationMemberContext(this.context, this.state);
      this.enterRule(localContext, 832, _SysMLv2Parser.RULE_requirementVerificationMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4258;
          this.memberPrefix();
          this.state = 4259;
          this.match(_SysMLv2Parser.VERIFY);
          this.state = 4260;
          this.requirementVerificationUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    requirementVerificationUsage() {
      let localContext = new RequirementVerificationUsageContext(this.context, this.state);
      this.enterRule(localContext, 834, _SysMLv2Parser.RULE_requirementVerificationUsage);
      let _la;
      try {
        this.state = 4288;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
          case _SysMLv2Parser.DOLLAR:
          case _SysMLv2Parser.IDENTIFIER:
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4262;
              this.ownedReferenceSubsetting();
              this.state = 4266;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while (_la === 42 || _la === 47 || (_la - 125 & ~31) === 0 && (1 << _la - 125 & 8388617) !== 0 || (_la - 158 & ~31) === 0 && (1 << _la - 158 & 1208352769) !== 0 || _la === 204) {
                {
                  {
                    this.state = 4263;
                    this.featureSpecialization();
                  }
                }
                this.state = 4268;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 4269;
              this.requirementBody();
            }
            break;
          case _SysMLv2Parser.REQUIREMENT:
          case _SysMLv2Parser.HASH:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4283;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 477, this.context)) {
                case 1:
                  {
                    this.state = 4274;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 192) {
                      {
                        {
                          this.state = 4271;
                          this.usageExtensionKeyword();
                        }
                      }
                      this.state = 4276;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                    }
                    this.state = 4277;
                    this.match(_SysMLv2Parser.REQUIREMENT);
                  }
                  break;
                case 2:
                  {
                    this.state = 4279;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    do {
                      {
                        {
                          this.state = 4278;
                          this.usageExtensionKeyword();
                        }
                      }
                      this.state = 4281;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                    } while (_la === 192);
                  }
                  break;
              }
              this.state = 4285;
              this.constraintUsageDeclaration();
              this.state = 4286;
              this.requirementBody();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    useCaseDefinition() {
      let localContext = new UseCaseDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 836, _SysMLv2Parser.RULE_useCaseDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4290;
          this.occurrenceDefinitionPrefix();
          this.state = 4291;
          this.match(_SysMLv2Parser.USE);
          this.state = 4292;
          this.match(_SysMLv2Parser.CASE);
          this.state = 4293;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4294;
          this.definitionDeclaration();
          this.state = 4295;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    useCaseUsage() {
      let localContext = new UseCaseUsageContext(this.context, this.state);
      this.enterRule(localContext, 838, _SysMLv2Parser.RULE_useCaseUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4297;
          this.occurrenceUsagePrefix();
          this.state = 4298;
          this.match(_SysMLv2Parser.USE);
          this.state = 4299;
          this.match(_SysMLv2Parser.CASE);
          this.state = 4300;
          this.constraintUsageDeclaration();
          this.state = 4301;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    includeUseCaseUsage() {
      let localContext = new IncludeUseCaseUsageContext(this.context, this.state);
      this.enterRule(localContext, 840, _SysMLv2Parser.RULE_includeUseCaseUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4303;
          this.occurrenceUsagePrefix();
          this.state = 4304;
          this.match(_SysMLv2Parser.INCLUDE);
          this.state = 4314;
          this.errorHandler.sync(this);
          switch (this.tokenStream.LA(1)) {
            case _SysMLv2Parser.BEHAVIOR:
            case _SysMLv2Parser.CROSSES:
            case _SysMLv2Parser.FEATURE:
            case _SysMLv2Parser.FUNCTION:
            case _SysMLv2Parser.INTERACTION:
            case _SysMLv2Parser.LANGUAGE:
            case _SysMLv2Parser.LOCALE:
            case _SysMLv2Parser.MEMBER:
            case _SysMLv2Parser.METACLASS:
            case _SysMLv2Parser.MULTIPLICITY:
            case _SysMLv2Parser.PREDICATE:
            case _SysMLv2Parser.STEP:
            case _SysMLv2Parser.TYPE:
            case _SysMLv2Parser.VAR:
            case _SysMLv2Parser.DOLLAR:
            case _SysMLv2Parser.IDENTIFIER:
            case _SysMLv2Parser.STRING:
              {
                this.state = 4305;
                this.ownedReferenceSubsetting();
                this.state = 4307;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                  {
                    this.state = 4306;
                    this.featureSpecializationPart();
                  }
                }
              }
              break;
            case _SysMLv2Parser.USE:
              {
                this.state = 4309;
                this.match(_SysMLv2Parser.USE);
                this.state = 4310;
                this.match(_SysMLv2Parser.CASE);
                this.state = 4312;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
                  {
                    this.state = 4311;
                    this.usageDeclaration();
                  }
                }
              }
              break;
            default:
              throw new NoViableAltException(this);
          }
          this.state = 4317;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 4316;
              this.valuePart();
            }
          }
          this.state = 4319;
          this.caseBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewDefinition() {
      let localContext = new ViewDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 842, _SysMLv2Parser.RULE_viewDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4321;
          this.occurrenceDefinitionPrefix();
          this.state = 4322;
          this.match(_SysMLv2Parser.VIEW);
          this.state = 4323;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4324;
          this.definitionDeclaration();
          this.state = 4325;
          this.viewDefinitionBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewDefinitionBody() {
      let localContext = new ViewDefinitionBodyContext(this.context, this.state);
      this.enterRule(localContext, 844, _SysMLv2Parser.RULE_viewDefinitionBody);
      let _la;
      try {
        this.state = 4336;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4327;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4328;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 4332;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182289556) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 490981169) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1948238905) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127797) !== 0 || (_la - 129 & ~31) === 0 && (1 << _la - 129 & 833122647) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153458591) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 4329;
                    this.viewDefinitionBodyItem();
                  }
                }
                this.state = 4334;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 4335;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewDefinitionBodyItem() {
      let localContext = new ViewDefinitionBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 846, _SysMLv2Parser.RULE_viewDefinitionBodyItem);
      try {
        this.state = 4341;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 485, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4338;
              this.definitionBodyItem();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4339;
              this.elementFilterMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 4340;
              this.viewRenderingMember();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewRenderingMember() {
      let localContext = new ViewRenderingMemberContext(this.context, this.state);
      this.enterRule(localContext, 848, _SysMLv2Parser.RULE_viewRenderingMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4343;
          this.memberPrefix();
          this.state = 4344;
          this.match(_SysMLv2Parser.RENDER);
          this.state = 4345;
          this.viewRenderingUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewRenderingUsage() {
      let localContext = new ViewRenderingUsageContext(this.context, this.state);
      this.enterRule(localContext, 850, _SysMLv2Parser.RULE_viewRenderingUsage);
      let _la;
      try {
        this.state = 4368;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.BEHAVIOR:
          case _SysMLv2Parser.CROSSES:
          case _SysMLv2Parser.FEATURE:
          case _SysMLv2Parser.FUNCTION:
          case _SysMLv2Parser.INTERACTION:
          case _SysMLv2Parser.LANGUAGE:
          case _SysMLv2Parser.LOCALE:
          case _SysMLv2Parser.MEMBER:
          case _SysMLv2Parser.METACLASS:
          case _SysMLv2Parser.MULTIPLICITY:
          case _SysMLv2Parser.PREDICATE:
          case _SysMLv2Parser.STEP:
          case _SysMLv2Parser.TYPE:
          case _SysMLv2Parser.VAR:
          case _SysMLv2Parser.DOLLAR:
          case _SysMLv2Parser.IDENTIFIER:
          case _SysMLv2Parser.STRING:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4347;
              this.ownedReferenceSubsetting();
              this.state = 4349;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
                {
                  this.state = 4348;
                  this.featureSpecializationPart();
                }
              }
              this.state = 4351;
              this.usageBody();
            }
            break;
          case _SysMLv2Parser.RENDERING:
          case _SysMLv2Parser.HASH:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4365;
              this.errorHandler.sync(this);
              switch (this.interpreter.adaptivePredict(this.tokenStream, 489, this.context)) {
                case 1:
                  {
                    this.state = 4356;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 192) {
                      {
                        {
                          this.state = 4353;
                          this.usageExtensionKeyword();
                        }
                      }
                      this.state = 4358;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                    }
                    this.state = 4359;
                    this.match(_SysMLv2Parser.RENDERING);
                  }
                  break;
                case 2:
                  {
                    this.state = 4361;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    do {
                      {
                        {
                          this.state = 4360;
                          this.usageExtensionKeyword();
                        }
                      }
                      this.state = 4363;
                      this.errorHandler.sync(this);
                      _la = this.tokenStream.LA(1);
                    } while (_la === 192);
                  }
                  break;
              }
              this.state = 4367;
              this.usage();
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewUsage() {
      let localContext = new ViewUsageContext(this.context, this.state);
      this.enterRule(localContext, 852, _SysMLv2Parser.RULE_viewUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4370;
          this.occurrenceUsagePrefix();
          this.state = 4371;
          this.match(_SysMLv2Parser.VIEW);
          this.state = 4373;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 4372;
              this.usageDeclaration();
            }
          }
          this.state = 4376;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 4375;
              this.valuePart();
            }
          }
          this.state = 4378;
          this.viewBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewBody() {
      let localContext = new ViewBodyContext(this.context, this.state);
      this.enterRule(localContext, 854, _SysMLv2Parser.RULE_viewBody);
      let _la;
      try {
        this.state = 4389;
        this.errorHandler.sync(this);
        switch (this.tokenStream.LA(1)) {
          case _SysMLv2Parser.SEMI:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4380;
              this.match(_SysMLv2Parser.SEMI);
            }
            break;
          case _SysMLv2Parser.LBRACE:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4381;
              this.match(_SysMLv2Parser.LBRACE);
              this.state = 4385;
              this.errorHandler.sync(this);
              _la = this.tokenStream.LA(1);
              while ((_la & ~31) === 0 && (1 << _la & 1182289556) !== 0 || (_la - 32 & ~31) === 0 && (1 << _la - 32 & 1564722993) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1948238905) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 3749127797) !== 0 || (_la - 129 & ~31) === 0 && (1 << _la - 129 & 833122647) !== 0 || (_la - 162 & ~31) === 0 && (1 << _la - 162 & 1153458591) !== 0 || (_la - 204 & ~31) === 0 && (1 << _la - 204 & 574671) !== 0) {
                {
                  {
                    this.state = 4382;
                    this.viewBodyItem();
                  }
                }
                this.state = 4387;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
              }
              this.state = 4388;
              this.match(_SysMLv2Parser.RBRACE);
            }
            break;
          default:
            throw new NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewBodyItem() {
      let localContext = new ViewBodyItemContext(this.context, this.state);
      this.enterRule(localContext, 856, _SysMLv2Parser.RULE_viewBodyItem);
      try {
        this.state = 4395;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 495, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4391;
              this.definitionBodyItem();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4392;
              this.elementFilterMember();
            }
            break;
          case 3:
            this.enterOuterAlt(localContext, 3);
            {
              this.state = 4393;
              this.viewRenderingMember();
            }
            break;
          case 4:
            this.enterOuterAlt(localContext, 4);
            {
              this.state = 4394;
              this.expose();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    expose() {
      let localContext = new ExposeContext(this.context, this.state);
      this.enterRule(localContext, 858, _SysMLv2Parser.RULE_expose);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4397;
          this.match(_SysMLv2Parser.EXPOSE);
          this.state = 4400;
          this.errorHandler.sync(this);
          switch (this.interpreter.adaptivePredict(this.tokenStream, 496, this.context)) {
            case 1:
              {
                this.state = 4398;
                this.membershipExpose();
              }
              break;
            case 2:
              {
                this.state = 4399;
                this.namespaceExpose();
              }
              break;
          }
          this.state = 4402;
          this.relationshipBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    membershipExpose() {
      let localContext = new MembershipExposeContext(this.context, this.state);
      this.enterRule(localContext, 860, _SysMLv2Parser.RULE_membershipExpose);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4404;
          this.membershipImport();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespaceExpose() {
      let localContext = new NamespaceExposeContext(this.context, this.state);
      this.enterRule(localContext, 862, _SysMLv2Parser.RULE_namespaceExpose);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4406;
          this.namespaceImport();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewpointDefinition() {
      let localContext = new ViewpointDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 864, _SysMLv2Parser.RULE_viewpointDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4408;
          this.occurrenceDefinitionPrefix();
          this.state = 4409;
          this.match(_SysMLv2Parser.VIEWPOINT);
          this.state = 4410;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4411;
          this.definitionDeclaration();
          this.state = 4412;
          this.requirementBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    viewpointUsage() {
      let localContext = new ViewpointUsageContext(this.context, this.state);
      this.enterRule(localContext, 866, _SysMLv2Parser.RULE_viewpointUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4414;
          this.occurrenceUsagePrefix();
          this.state = 4415;
          this.match(_SysMLv2Parser.VIEWPOINT);
          this.state = 4416;
          this.constraintUsageDeclaration();
          this.state = 4417;
          this.requirementBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    renderingDefinition() {
      let localContext = new RenderingDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 868, _SysMLv2Parser.RULE_renderingDefinition);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4419;
          this.occurrenceDefinitionPrefix();
          this.state = 4420;
          this.match(_SysMLv2Parser.RENDERING);
          this.state = 4421;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4422;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    renderingUsage() {
      let localContext = new RenderingUsageContext(this.context, this.state);
      this.enterRule(localContext, 870, _SysMLv2Parser.RULE_renderingUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4424;
          this.occurrenceUsagePrefix();
          this.state = 4425;
          this.match(_SysMLv2Parser.RENDERING);
          this.state = 4426;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataDefinition() {
      let localContext = new MetadataDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 872, _SysMLv2Parser.RULE_metadataDefinition);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4429;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 2) {
            {
              this.state = 4428;
              this.match(_SysMLv2Parser.ABSTRACT);
            }
          }
          this.state = 4434;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          while (_la === 192) {
            {
              {
                this.state = 4431;
                this.definitionExtensionKeyword();
              }
            }
            this.state = 4436;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          }
          this.state = 4437;
          this.match(_SysMLv2Parser.METADATA);
          this.state = 4438;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4439;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    prefixMetadataUsage() {
      let localContext = new PrefixMetadataUsageContext(this.context, this.state);
      this.enterRule(localContext, 874, _SysMLv2Parser.RULE_prefixMetadataUsage);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4441;
          this.ownedFeatureTyping();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataBodyUsageMember() {
      let localContext = new MetadataBodyUsageMemberContext(this.context, this.state);
      this.enterRule(localContext, 876, _SysMLv2Parser.RULE_metadataBodyUsageMember);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4443;
          this.metadataBodyUsage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    metadataBodyUsage() {
      let localContext = new MetadataBodyUsageContext(this.context, this.state);
      this.enterRule(localContext, 878, _SysMLv2Parser.RULE_metadataBodyUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4446;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 127) {
            {
              this.state = 4445;
              this.match(_SysMLv2Parser.REF);
            }
          }
          this.state = 4449;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 125 || _la === 176) {
            {
              this.state = 4448;
              _la = this.tokenStream.LA(1);
              if (!(_la === 125 || _la === 176)) {
                this.errorHandler.recoverInline(this);
              } else {
                this.errorHandler.reportMatch(this);
                this.consume();
              }
            }
          }
          this.state = 4451;
          this.ownedRedefinition();
          this.state = 4453;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 42 || _la === 47 || (_la - 106 & ~31) === 0 && (1 << _la - 106 & 4718721) !== 0 || (_la - 148 & ~31) === 0 && (1 << _la - 148 & 402654209) !== 0 || (_la - 185 & ~31) === 0 && (1 << _la - 185 & 67633161) !== 0) {
            {
              this.state = 4452;
              this.featureSpecializationPart();
            }
          }
          this.state = 4456;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 4455;
              this.valuePart();
            }
          }
          this.state = 4458;
          this.metadataBody();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    extendedDefinition() {
      let localContext = new ExtendedDefinitionContext(this.context, this.state);
      this.enterRule(localContext, 880, _SysMLv2Parser.RULE_extendedDefinition);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4461;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 2 || _la === 165) {
            {
              this.state = 4460;
              this.basicDefinitionPrefix();
            }
          }
          this.state = 4464;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          do {
            {
              {
                this.state = 4463;
                this.definitionExtensionKeyword();
              }
            }
            this.state = 4466;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          } while (_la === 192);
          this.state = 4468;
          this.match(_SysMLv2Parser.DEF);
          this.state = 4469;
          this.definition();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    extendedUsage() {
      let localContext = new ExtendedUsageContext(this.context, this.state);
      this.enterRule(localContext, 882, _SysMLv2Parser.RULE_extendedUsage);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4471;
          this.unextendedUsagePrefix();
          this.state = 4473;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          do {
            {
              {
                this.state = 4472;
                this.usageExtensionKeyword();
              }
            }
            this.state = 4475;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
          } while (_la === 192);
          this.state = 4477;
          this.usage();
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    filterPackageImportDeclaration() {
      let localContext = new FilterPackageImportDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 884, _SysMLv2Parser.RULE_filterPackageImportDeclaration);
      try {
        this.state = 4481;
        this.errorHandler.sync(this);
        switch (this.interpreter.adaptivePredict(this.tokenStream, 506, this.context)) {
          case 1:
            this.enterOuterAlt(localContext, 1);
            {
              this.state = 4479;
              this.membershipImport();
            }
            break;
          case 2:
            this.enterOuterAlt(localContext, 2);
            {
              this.state = 4480;
              this.namespaceImportDirect();
            }
            break;
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    namespaceImportDirect() {
      let localContext = new NamespaceImportDirectContext(this.context, this.state);
      this.enterRule(localContext, 886, _SysMLv2Parser.RULE_namespaceImportDirect);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4483;
          this.qualifiedName();
          this.state = 4484;
          this.match(_SysMLv2Parser.COLON_COLON);
          this.state = 4485;
          this.match(_SysMLv2Parser.STAR);
          this.state = 4488;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 183) {
            {
              this.state = 4486;
              this.match(_SysMLv2Parser.COLON_COLON);
              this.state = 4487;
              this.match(_SysMLv2Parser.STAR_STAR);
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    calculationUsageDeclaration() {
      let localContext = new CalculationUsageDeclarationContext(this.context, this.state);
      this.enterRule(localContext, 888, _SysMLv2Parser.RULE_calculationUsageDeclaration);
      let _la;
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4491;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if ((_la - 20 & ~31) === 0 && (1 << _la - 20 & 138412033) !== 0 || (_la - 65 & ~31) === 0 && (1 << _la - 65 & 1342702593) !== 0 || (_la - 97 & ~31) === 0 && (1 << _la - 97 & 2432762449) !== 0 || (_la - 143 & ~31) === 0 && (1 << _la - 143 & 1097761) !== 0 || (_la - 175 & ~31) === 0 && (1 << _la - 175 & 2684363779) !== 0 || (_la - 211 & ~31) === 0 && (1 << _la - 211 & 385) !== 0) {
            {
              this.state = 4490;
              this.usageDeclaration();
            }
          }
          this.state = 4494;
          this.errorHandler.sync(this);
          _la = this.tokenStream.LA(1);
          if (_la === 46 || _la === 184 || _la === 207) {
            {
              this.state = 4493;
              this.valuePart();
            }
          }
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    emptyActionUsage_() {
      let localContext = new EmptyActionUsage_Context(this.context, this.state);
      this.enterRule(localContext, 890, _SysMLv2Parser.RULE_emptyActionUsage_);
      try {
        this.enterOuterAlt(localContext, 1);
        {
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    emptyFeature_() {
      let localContext = new EmptyFeature_Context(this.context, this.state);
      this.enterRule(localContext, 892, _SysMLv2Parser.RULE_emptyFeature_);
      try {
        this.enterOuterAlt(localContext, 1);
        {
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    emptyMultiplicity_() {
      let localContext = new EmptyMultiplicity_Context(this.context, this.state);
      this.enterRule(localContext, 894, _SysMLv2Parser.RULE_emptyMultiplicity_);
      try {
        this.enterOuterAlt(localContext, 1);
        {
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    emptyUsage_() {
      let localContext = new EmptyUsage_Context(this.context, this.state);
      this.enterRule(localContext, 896, _SysMLv2Parser.RULE_emptyUsage_);
      try {
        this.enterOuterAlt(localContext, 1);
        {
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    filterPackageImport() {
      let localContext = new FilterPackageImportContext(this.context, this.state);
      this.enterRule(localContext, 898, _SysMLv2Parser.RULE_filterPackageImport);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4504;
          this.match(_SysMLv2Parser.IDENTIFIER);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    nonFeatureChainPrimaryExpression() {
      let localContext = new NonFeatureChainPrimaryExpressionContext(this.context, this.state);
      this.enterRule(localContext, 900, _SysMLv2Parser.RULE_nonFeatureChainPrimaryExpression);
      try {
        this.enterOuterAlt(localContext, 1);
        {
          this.state = 4506;
          this.match(_SysMLv2Parser.IDENTIFIER);
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    portConjugation() {
      let localContext = new PortConjugationContext(this.context, this.state);
      this.enterRule(localContext, 902, _SysMLv2Parser.RULE_portConjugation);
      try {
        this.enterOuterAlt(localContext, 1);
        {
        }
      } catch (re) {
        if (re instanceof RecognitionException) {
          this.errorHandler.reportError(this, re);
          this.errorHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }
      return localContext;
    }
    sempred(localContext, ruleIndex, predIndex) {
      switch (ruleIndex) {
        case 0:
          return this.ownedExpression_sempred(localContext, predIndex);
      }
      return true;
    }
    ownedExpression_sempred(localContext, predIndex) {
      switch (predIndex) {
        case 0:
          return this.precpred(this.context, 27);
        case 1:
          return this.precpred(this.context, 26);
        case 2:
          return this.precpred(this.context, 25);
        case 3:
          return this.precpred(this.context, 24);
        case 4:
          return this.precpred(this.context, 23);
        case 5:
          return this.precpred(this.context, 22);
        case 6:
          return this.precpred(this.context, 21);
        case 7:
          return this.precpred(this.context, 20);
        case 8:
          return this.precpred(this.context, 19);
        case 9:
          return this.precpred(this.context, 18);
        case 10:
          return this.precpred(this.context, 17);
        case 11:
          return this.precpred(this.context, 16);
        case 12:
          return this.precpred(this.context, 15);
        case 13:
          return this.precpred(this.context, 12);
        case 14:
          return this.precpred(this.context, 11);
        case 15:
          return this.precpred(this.context, 10);
        case 16:
          return this.precpred(this.context, 9);
        case 17:
          return this.precpred(this.context, 8);
        case 18:
          return this.precpred(this.context, 7);
        case 19:
          return this.precpred(this.context, 6);
        case 20:
          return this.precpred(this.context, 5);
        case 21:
          return this.precpred(this.context, 4);
        case 22:
          return this.precpred(this.context, 3);
      }
      return true;
    }
    static _serializedATN = [
      4,
      1,
      226,
      4511,
      2,
      0,
      7,
      0,
      2,
      1,
      7,
      1,
      2,
      2,
      7,
      2,
      2,
      3,
      7,
      3,
      2,
      4,
      7,
      4,
      2,
      5,
      7,
      5,
      2,
      6,
      7,
      6,
      2,
      7,
      7,
      7,
      2,
      8,
      7,
      8,
      2,
      9,
      7,
      9,
      2,
      10,
      7,
      10,
      2,
      11,
      7,
      11,
      2,
      12,
      7,
      12,
      2,
      13,
      7,
      13,
      2,
      14,
      7,
      14,
      2,
      15,
      7,
      15,
      2,
      16,
      7,
      16,
      2,
      17,
      7,
      17,
      2,
      18,
      7,
      18,
      2,
      19,
      7,
      19,
      2,
      20,
      7,
      20,
      2,
      21,
      7,
      21,
      2,
      22,
      7,
      22,
      2,
      23,
      7,
      23,
      2,
      24,
      7,
      24,
      2,
      25,
      7,
      25,
      2,
      26,
      7,
      26,
      2,
      27,
      7,
      27,
      2,
      28,
      7,
      28,
      2,
      29,
      7,
      29,
      2,
      30,
      7,
      30,
      2,
      31,
      7,
      31,
      2,
      32,
      7,
      32,
      2,
      33,
      7,
      33,
      2,
      34,
      7,
      34,
      2,
      35,
      7,
      35,
      2,
      36,
      7,
      36,
      2,
      37,
      7,
      37,
      2,
      38,
      7,
      38,
      2,
      39,
      7,
      39,
      2,
      40,
      7,
      40,
      2,
      41,
      7,
      41,
      2,
      42,
      7,
      42,
      2,
      43,
      7,
      43,
      2,
      44,
      7,
      44,
      2,
      45,
      7,
      45,
      2,
      46,
      7,
      46,
      2,
      47,
      7,
      47,
      2,
      48,
      7,
      48,
      2,
      49,
      7,
      49,
      2,
      50,
      7,
      50,
      2,
      51,
      7,
      51,
      2,
      52,
      7,
      52,
      2,
      53,
      7,
      53,
      2,
      54,
      7,
      54,
      2,
      55,
      7,
      55,
      2,
      56,
      7,
      56,
      2,
      57,
      7,
      57,
      2,
      58,
      7,
      58,
      2,
      59,
      7,
      59,
      2,
      60,
      7,
      60,
      2,
      61,
      7,
      61,
      2,
      62,
      7,
      62,
      2,
      63,
      7,
      63,
      2,
      64,
      7,
      64,
      2,
      65,
      7,
      65,
      2,
      66,
      7,
      66,
      2,
      67,
      7,
      67,
      2,
      68,
      7,
      68,
      2,
      69,
      7,
      69,
      2,
      70,
      7,
      70,
      2,
      71,
      7,
      71,
      2,
      72,
      7,
      72,
      2,
      73,
      7,
      73,
      2,
      74,
      7,
      74,
      2,
      75,
      7,
      75,
      2,
      76,
      7,
      76,
      2,
      77,
      7,
      77,
      2,
      78,
      7,
      78,
      2,
      79,
      7,
      79,
      2,
      80,
      7,
      80,
      2,
      81,
      7,
      81,
      2,
      82,
      7,
      82,
      2,
      83,
      7,
      83,
      2,
      84,
      7,
      84,
      2,
      85,
      7,
      85,
      2,
      86,
      7,
      86,
      2,
      87,
      7,
      87,
      2,
      88,
      7,
      88,
      2,
      89,
      7,
      89,
      2,
      90,
      7,
      90,
      2,
      91,
      7,
      91,
      2,
      92,
      7,
      92,
      2,
      93,
      7,
      93,
      2,
      94,
      7,
      94,
      2,
      95,
      7,
      95,
      2,
      96,
      7,
      96,
      2,
      97,
      7,
      97,
      2,
      98,
      7,
      98,
      2,
      99,
      7,
      99,
      2,
      100,
      7,
      100,
      2,
      101,
      7,
      101,
      2,
      102,
      7,
      102,
      2,
      103,
      7,
      103,
      2,
      104,
      7,
      104,
      2,
      105,
      7,
      105,
      2,
      106,
      7,
      106,
      2,
      107,
      7,
      107,
      2,
      108,
      7,
      108,
      2,
      109,
      7,
      109,
      2,
      110,
      7,
      110,
      2,
      111,
      7,
      111,
      2,
      112,
      7,
      112,
      2,
      113,
      7,
      113,
      2,
      114,
      7,
      114,
      2,
      115,
      7,
      115,
      2,
      116,
      7,
      116,
      2,
      117,
      7,
      117,
      2,
      118,
      7,
      118,
      2,
      119,
      7,
      119,
      2,
      120,
      7,
      120,
      2,
      121,
      7,
      121,
      2,
      122,
      7,
      122,
      2,
      123,
      7,
      123,
      2,
      124,
      7,
      124,
      2,
      125,
      7,
      125,
      2,
      126,
      7,
      126,
      2,
      127,
      7,
      127,
      2,
      128,
      7,
      128,
      2,
      129,
      7,
      129,
      2,
      130,
      7,
      130,
      2,
      131,
      7,
      131,
      2,
      132,
      7,
      132,
      2,
      133,
      7,
      133,
      2,
      134,
      7,
      134,
      2,
      135,
      7,
      135,
      2,
      136,
      7,
      136,
      2,
      137,
      7,
      137,
      2,
      138,
      7,
      138,
      2,
      139,
      7,
      139,
      2,
      140,
      7,
      140,
      2,
      141,
      7,
      141,
      2,
      142,
      7,
      142,
      2,
      143,
      7,
      143,
      2,
      144,
      7,
      144,
      2,
      145,
      7,
      145,
      2,
      146,
      7,
      146,
      2,
      147,
      7,
      147,
      2,
      148,
      7,
      148,
      2,
      149,
      7,
      149,
      2,
      150,
      7,
      150,
      2,
      151,
      7,
      151,
      2,
      152,
      7,
      152,
      2,
      153,
      7,
      153,
      2,
      154,
      7,
      154,
      2,
      155,
      7,
      155,
      2,
      156,
      7,
      156,
      2,
      157,
      7,
      157,
      2,
      158,
      7,
      158,
      2,
      159,
      7,
      159,
      2,
      160,
      7,
      160,
      2,
      161,
      7,
      161,
      2,
      162,
      7,
      162,
      2,
      163,
      7,
      163,
      2,
      164,
      7,
      164,
      2,
      165,
      7,
      165,
      2,
      166,
      7,
      166,
      2,
      167,
      7,
      167,
      2,
      168,
      7,
      168,
      2,
      169,
      7,
      169,
      2,
      170,
      7,
      170,
      2,
      171,
      7,
      171,
      2,
      172,
      7,
      172,
      2,
      173,
      7,
      173,
      2,
      174,
      7,
      174,
      2,
      175,
      7,
      175,
      2,
      176,
      7,
      176,
      2,
      177,
      7,
      177,
      2,
      178,
      7,
      178,
      2,
      179,
      7,
      179,
      2,
      180,
      7,
      180,
      2,
      181,
      7,
      181,
      2,
      182,
      7,
      182,
      2,
      183,
      7,
      183,
      2,
      184,
      7,
      184,
      2,
      185,
      7,
      185,
      2,
      186,
      7,
      186,
      2,
      187,
      7,
      187,
      2,
      188,
      7,
      188,
      2,
      189,
      7,
      189,
      2,
      190,
      7,
      190,
      2,
      191,
      7,
      191,
      2,
      192,
      7,
      192,
      2,
      193,
      7,
      193,
      2,
      194,
      7,
      194,
      2,
      195,
      7,
      195,
      2,
      196,
      7,
      196,
      2,
      197,
      7,
      197,
      2,
      198,
      7,
      198,
      2,
      199,
      7,
      199,
      2,
      200,
      7,
      200,
      2,
      201,
      7,
      201,
      2,
      202,
      7,
      202,
      2,
      203,
      7,
      203,
      2,
      204,
      7,
      204,
      2,
      205,
      7,
      205,
      2,
      206,
      7,
      206,
      2,
      207,
      7,
      207,
      2,
      208,
      7,
      208,
      2,
      209,
      7,
      209,
      2,
      210,
      7,
      210,
      2,
      211,
      7,
      211,
      2,
      212,
      7,
      212,
      2,
      213,
      7,
      213,
      2,
      214,
      7,
      214,
      2,
      215,
      7,
      215,
      2,
      216,
      7,
      216,
      2,
      217,
      7,
      217,
      2,
      218,
      7,
      218,
      2,
      219,
      7,
      219,
      2,
      220,
      7,
      220,
      2,
      221,
      7,
      221,
      2,
      222,
      7,
      222,
      2,
      223,
      7,
      223,
      2,
      224,
      7,
      224,
      2,
      225,
      7,
      225,
      2,
      226,
      7,
      226,
      2,
      227,
      7,
      227,
      2,
      228,
      7,
      228,
      2,
      229,
      7,
      229,
      2,
      230,
      7,
      230,
      2,
      231,
      7,
      231,
      2,
      232,
      7,
      232,
      2,
      233,
      7,
      233,
      2,
      234,
      7,
      234,
      2,
      235,
      7,
      235,
      2,
      236,
      7,
      236,
      2,
      237,
      7,
      237,
      2,
      238,
      7,
      238,
      2,
      239,
      7,
      239,
      2,
      240,
      7,
      240,
      2,
      241,
      7,
      241,
      2,
      242,
      7,
      242,
      2,
      243,
      7,
      243,
      2,
      244,
      7,
      244,
      2,
      245,
      7,
      245,
      2,
      246,
      7,
      246,
      2,
      247,
      7,
      247,
      2,
      248,
      7,
      248,
      2,
      249,
      7,
      249,
      2,
      250,
      7,
      250,
      2,
      251,
      7,
      251,
      2,
      252,
      7,
      252,
      2,
      253,
      7,
      253,
      2,
      254,
      7,
      254,
      2,
      255,
      7,
      255,
      2,
      256,
      7,
      256,
      2,
      257,
      7,
      257,
      2,
      258,
      7,
      258,
      2,
      259,
      7,
      259,
      2,
      260,
      7,
      260,
      2,
      261,
      7,
      261,
      2,
      262,
      7,
      262,
      2,
      263,
      7,
      263,
      2,
      264,
      7,
      264,
      2,
      265,
      7,
      265,
      2,
      266,
      7,
      266,
      2,
      267,
      7,
      267,
      2,
      268,
      7,
      268,
      2,
      269,
      7,
      269,
      2,
      270,
      7,
      270,
      2,
      271,
      7,
      271,
      2,
      272,
      7,
      272,
      2,
      273,
      7,
      273,
      2,
      274,
      7,
      274,
      2,
      275,
      7,
      275,
      2,
      276,
      7,
      276,
      2,
      277,
      7,
      277,
      2,
      278,
      7,
      278,
      2,
      279,
      7,
      279,
      2,
      280,
      7,
      280,
      2,
      281,
      7,
      281,
      2,
      282,
      7,
      282,
      2,
      283,
      7,
      283,
      2,
      284,
      7,
      284,
      2,
      285,
      7,
      285,
      2,
      286,
      7,
      286,
      2,
      287,
      7,
      287,
      2,
      288,
      7,
      288,
      2,
      289,
      7,
      289,
      2,
      290,
      7,
      290,
      2,
      291,
      7,
      291,
      2,
      292,
      7,
      292,
      2,
      293,
      7,
      293,
      2,
      294,
      7,
      294,
      2,
      295,
      7,
      295,
      2,
      296,
      7,
      296,
      2,
      297,
      7,
      297,
      2,
      298,
      7,
      298,
      2,
      299,
      7,
      299,
      2,
      300,
      7,
      300,
      2,
      301,
      7,
      301,
      2,
      302,
      7,
      302,
      2,
      303,
      7,
      303,
      2,
      304,
      7,
      304,
      2,
      305,
      7,
      305,
      2,
      306,
      7,
      306,
      2,
      307,
      7,
      307,
      2,
      308,
      7,
      308,
      2,
      309,
      7,
      309,
      2,
      310,
      7,
      310,
      2,
      311,
      7,
      311,
      2,
      312,
      7,
      312,
      2,
      313,
      7,
      313,
      2,
      314,
      7,
      314,
      2,
      315,
      7,
      315,
      2,
      316,
      7,
      316,
      2,
      317,
      7,
      317,
      2,
      318,
      7,
      318,
      2,
      319,
      7,
      319,
      2,
      320,
      7,
      320,
      2,
      321,
      7,
      321,
      2,
      322,
      7,
      322,
      2,
      323,
      7,
      323,
      2,
      324,
      7,
      324,
      2,
      325,
      7,
      325,
      2,
      326,
      7,
      326,
      2,
      327,
      7,
      327,
      2,
      328,
      7,
      328,
      2,
      329,
      7,
      329,
      2,
      330,
      7,
      330,
      2,
      331,
      7,
      331,
      2,
      332,
      7,
      332,
      2,
      333,
      7,
      333,
      2,
      334,
      7,
      334,
      2,
      335,
      7,
      335,
      2,
      336,
      7,
      336,
      2,
      337,
      7,
      337,
      2,
      338,
      7,
      338,
      2,
      339,
      7,
      339,
      2,
      340,
      7,
      340,
      2,
      341,
      7,
      341,
      2,
      342,
      7,
      342,
      2,
      343,
      7,
      343,
      2,
      344,
      7,
      344,
      2,
      345,
      7,
      345,
      2,
      346,
      7,
      346,
      2,
      347,
      7,
      347,
      2,
      348,
      7,
      348,
      2,
      349,
      7,
      349,
      2,
      350,
      7,
      350,
      2,
      351,
      7,
      351,
      2,
      352,
      7,
      352,
      2,
      353,
      7,
      353,
      2,
      354,
      7,
      354,
      2,
      355,
      7,
      355,
      2,
      356,
      7,
      356,
      2,
      357,
      7,
      357,
      2,
      358,
      7,
      358,
      2,
      359,
      7,
      359,
      2,
      360,
      7,
      360,
      2,
      361,
      7,
      361,
      2,
      362,
      7,
      362,
      2,
      363,
      7,
      363,
      2,
      364,
      7,
      364,
      2,
      365,
      7,
      365,
      2,
      366,
      7,
      366,
      2,
      367,
      7,
      367,
      2,
      368,
      7,
      368,
      2,
      369,
      7,
      369,
      2,
      370,
      7,
      370,
      2,
      371,
      7,
      371,
      2,
      372,
      7,
      372,
      2,
      373,
      7,
      373,
      2,
      374,
      7,
      374,
      2,
      375,
      7,
      375,
      2,
      376,
      7,
      376,
      2,
      377,
      7,
      377,
      2,
      378,
      7,
      378,
      2,
      379,
      7,
      379,
      2,
      380,
      7,
      380,
      2,
      381,
      7,
      381,
      2,
      382,
      7,
      382,
      2,
      383,
      7,
      383,
      2,
      384,
      7,
      384,
      2,
      385,
      7,
      385,
      2,
      386,
      7,
      386,
      2,
      387,
      7,
      387,
      2,
      388,
      7,
      388,
      2,
      389,
      7,
      389,
      2,
      390,
      7,
      390,
      2,
      391,
      7,
      391,
      2,
      392,
      7,
      392,
      2,
      393,
      7,
      393,
      2,
      394,
      7,
      394,
      2,
      395,
      7,
      395,
      2,
      396,
      7,
      396,
      2,
      397,
      7,
      397,
      2,
      398,
      7,
      398,
      2,
      399,
      7,
      399,
      2,
      400,
      7,
      400,
      2,
      401,
      7,
      401,
      2,
      402,
      7,
      402,
      2,
      403,
      7,
      403,
      2,
      404,
      7,
      404,
      2,
      405,
      7,
      405,
      2,
      406,
      7,
      406,
      2,
      407,
      7,
      407,
      2,
      408,
      7,
      408,
      2,
      409,
      7,
      409,
      2,
      410,
      7,
      410,
      2,
      411,
      7,
      411,
      2,
      412,
      7,
      412,
      2,
      413,
      7,
      413,
      2,
      414,
      7,
      414,
      2,
      415,
      7,
      415,
      2,
      416,
      7,
      416,
      2,
      417,
      7,
      417,
      2,
      418,
      7,
      418,
      2,
      419,
      7,
      419,
      2,
      420,
      7,
      420,
      2,
      421,
      7,
      421,
      2,
      422,
      7,
      422,
      2,
      423,
      7,
      423,
      2,
      424,
      7,
      424,
      2,
      425,
      7,
      425,
      2,
      426,
      7,
      426,
      2,
      427,
      7,
      427,
      2,
      428,
      7,
      428,
      2,
      429,
      7,
      429,
      2,
      430,
      7,
      430,
      2,
      431,
      7,
      431,
      2,
      432,
      7,
      432,
      2,
      433,
      7,
      433,
      2,
      434,
      7,
      434,
      2,
      435,
      7,
      435,
      2,
      436,
      7,
      436,
      2,
      437,
      7,
      437,
      2,
      438,
      7,
      438,
      2,
      439,
      7,
      439,
      2,
      440,
      7,
      440,
      2,
      441,
      7,
      441,
      2,
      442,
      7,
      442,
      2,
      443,
      7,
      443,
      2,
      444,
      7,
      444,
      2,
      445,
      7,
      445,
      2,
      446,
      7,
      446,
      2,
      447,
      7,
      447,
      2,
      448,
      7,
      448,
      2,
      449,
      7,
      449,
      2,
      450,
      7,
      450,
      2,
      451,
      7,
      451,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      3,
      0,
      920,
      8,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      3,
      0,
      976,
      8,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      3,
      0,
      983,
      8,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      1,
      0,
      3,
      0,
      999,
      8,
      0,
      5,
      0,
      1001,
      8,
      0,
      10,
      0,
      12,
      0,
      1004,
      9,
      0,
      1,
      1,
      1,
      1,
      1,
      2,
      1,
      2,
      1,
      2,
      5,
      2,
      1011,
      8,
      2,
      10,
      2,
      12,
      2,
      1014,
      9,
      2,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      3,
      3,
      1023,
      8,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      1,
      3,
      3,
      3,
      1034,
      8,
      3,
      1,
      3,
      3,
      3,
      1037,
      8,
      3,
      1,
      4,
      1,
      4,
      1,
      4,
      3,
      4,
      1042,
      8,
      4,
      1,
      5,
      1,
      5,
      1,
      6,
      1,
      6,
      1,
      6,
      1,
      6,
      1,
      7,
      1,
      7,
      1,
      7,
      1,
      7,
      1,
      8,
      1,
      8,
      1,
      8,
      3,
      8,
      1057,
      8,
      8,
      1,
      8,
      1,
      8,
      1,
      9,
      1,
      9,
      1,
      9,
      5,
      9,
      1064,
      8,
      9,
      10,
      9,
      12,
      9,
      1067,
      9,
      9,
      1,
      10,
      1,
      10,
      1,
      10,
      5,
      10,
      1072,
      8,
      10,
      10,
      10,
      12,
      10,
      1075,
      9,
      10,
      1,
      11,
      1,
      11,
      1,
      11,
      1,
      11,
      1,
      12,
      1,
      12,
      1,
      12,
      1,
      12,
      1,
      12,
      3,
      12,
      1086,
      8,
      12,
      1,
      13,
      1,
      13,
      1,
      14,
      1,
      14,
      1,
      15,
      1,
      15,
      1,
      16,
      1,
      16,
      1,
      17,
      1,
      17,
      1,
      18,
      1,
      18,
      1,
      19,
      1,
      19,
      1,
      20,
      1,
      20,
      1,
      20,
      3,
      20,
      1105,
      8,
      20,
      1,
      21,
      1,
      21,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      1,
      22,
      3,
      22,
      1119,
      8,
      22,
      1,
      23,
      1,
      23,
      1,
      23,
      5,
      23,
      1124,
      8,
      23,
      10,
      23,
      12,
      23,
      1127,
      9,
      23,
      1,
      23,
      1,
      23,
      1,
      23,
      5,
      23,
      1132,
      8,
      23,
      10,
      23,
      12,
      23,
      1135,
      9,
      23,
      1,
      23,
      3,
      23,
      1138,
      8,
      23,
      1,
      24,
      1,
      24,
      3,
      24,
      1142,
      8,
      24,
      1,
      25,
      1,
      25,
      3,
      25,
      1146,
      8,
      25,
      1,
      26,
      5,
      26,
      1149,
      8,
      26,
      10,
      26,
      12,
      26,
      1152,
      9,
      26,
      1,
      26,
      1,
      26,
      3,
      26,
      1156,
      8,
      26,
      1,
      26,
      3,
      26,
      1159,
      8,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      5,
      26,
      1164,
      8,
      26,
      10,
      26,
      12,
      26,
      1167,
      9,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      5,
      26,
      1173,
      8,
      26,
      10,
      26,
      12,
      26,
      1176,
      9,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      5,
      26,
      1181,
      8,
      26,
      10,
      26,
      12,
      26,
      1184,
      9,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      1,
      26,
      3,
      26,
      1190,
      8,
      26,
      1,
      27,
      1,
      27,
      1,
      28,
      1,
      28,
      1,
      29,
      1,
      29,
      1,
      29,
      1,
      29,
      3,
      29,
      1200,
      8,
      29,
      1,
      30,
      1,
      30,
      3,
      30,
      1204,
      8,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      1,
      30,
      5,
      30,
      1210,
      8,
      30,
      10,
      30,
      12,
      30,
      1213,
      9,
      30,
      3,
      30,
      1215,
      8,
      30,
      3,
      30,
      1217,
      8,
      30,
      1,
      30,
      1,
      30,
      3,
      30,
      1221,
      8,
      30,
      1,
      30,
      1,
      30,
      1,
      31,
      1,
      31,
      3,
      31,
      1227,
      8,
      31,
      1,
      31,
      1,
      31,
      3,
      31,
      1231,
      8,
      31,
      1,
      31,
      1,
      31,
      1,
      32,
      1,
      32,
      3,
      32,
      1237,
      8,
      32,
      3,
      32,
      1239,
      8,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      32,
      1,
      33,
      5,
      33,
      1246,
      8,
      33,
      10,
      33,
      12,
      33,
      1249,
      9,
      33,
      1,
      33,
      1,
      33,
      1,
      34,
      5,
      34,
      1254,
      8,
      34,
      10,
      34,
      12,
      34,
      1257,
      9,
      34,
      1,
      34,
      1,
      34,
      1,
      34,
      1,
      35,
      1,
      35,
      3,
      35,
      1264,
      8,
      35,
      1,
      36,
      1,
      36,
      1,
      36,
      5,
      36,
      1269,
      8,
      36,
      10,
      36,
      12,
      36,
      1272,
      9,
      36,
      1,
      36,
      3,
      36,
      1275,
      8,
      36,
      1,
      37,
      1,
      37,
      1,
      37,
      3,
      37,
      1280,
      8,
      37,
      1,
      38,
      3,
      38,
      1283,
      8,
      38,
      1,
      39,
      1,
      39,
      1,
      40,
      1,
      40,
      3,
      40,
      1289,
      8,
      40,
      1,
      41,
      1,
      41,
      1,
      41,
      1,
      42,
      1,
      42,
      1,
      42,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      3,
      43,
      1303,
      8,
      43,
      1,
      43,
      3,
      43,
      1306,
      8,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      43,
      1,
      44,
      1,
      44,
      3,
      44,
      1314,
      8,
      44,
      1,
      44,
      1,
      44,
      1,
      44,
      5,
      44,
      1319,
      8,
      44,
      10,
      44,
      12,
      44,
      1322,
      9,
      44,
      1,
      44,
      1,
      44,
      1,
      45,
      3,
      45,
      1327,
      8,
      45,
      1,
      45,
      1,
      45,
      3,
      45,
      1331,
      8,
      45,
      1,
      45,
      1,
      45,
      1,
      45,
      1,
      46,
      1,
      46,
      3,
      46,
      1338,
      8,
      46,
      1,
      47,
      1,
      47,
      1,
      47,
      3,
      47,
      1343,
      8,
      47,
      1,
      48,
      1,
      48,
      1,
      48,
      1,
      48,
      1,
      48,
      3,
      48,
      1350,
      8,
      48,
      1,
      48,
      3,
      48,
      1353,
      8,
      48,
      1,
      49,
      1,
      49,
      4,
      49,
      1357,
      8,
      49,
      11,
      49,
      12,
      49,
      1358,
      1,
      49,
      1,
      49,
      4,
      49,
      1363,
      8,
      49,
      11,
      49,
      12,
      49,
      1364,
      3,
      49,
      1367,
      8,
      49,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      50,
      1,
      51,
      1,
      51,
      3,
      51,
      1375,
      8,
      51,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      1,
      52,
      3,
      52,
      1403,
      8,
      52,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      53,
      1,
      53,
      3,
      53,
      1415,
      8,
      53,
      1,
      54,
      1,
      54,
      1,
      54,
      1,
      54,
      1,
      54,
      1,
      55,
      3,
      55,
      1423,
      8,
      55,
      1,
      55,
      5,
      55,
      1426,
      8,
      55,
      10,
      55,
      12,
      55,
      1429,
      9,
      55,
      1,
      56,
      3,
      56,
      1432,
      8,
      56,
      1,
      56,
      3,
      56,
      1435,
      8,
      56,
      1,
      56,
      3,
      56,
      1438,
      8,
      56,
      1,
      56,
      1,
      56,
      4,
      56,
      1442,
      8,
      56,
      11,
      56,
      12,
      56,
      1443,
      1,
      56,
      5,
      56,
      1447,
      8,
      56,
      10,
      56,
      12,
      56,
      1450,
      9,
      56,
      1,
      57,
      1,
      57,
      1,
      57,
      1,
      57,
      5,
      57,
      1456,
      8,
      57,
      10,
      57,
      12,
      57,
      1459,
      9,
      57,
      1,
      58,
      1,
      58,
      1,
      58,
      1,
      59,
      1,
      59,
      1,
      59,
      1,
      59,
      3,
      59,
      1468,
      8,
      59,
      1,
      60,
      1,
      60,
      1,
      60,
      1,
      60,
      1,
      60,
      5,
      60,
      1475,
      8,
      60,
      10,
      60,
      12,
      60,
      1478,
      9,
      60,
      1,
      61,
      1,
      61,
      1,
      61,
      1,
      61,
      5,
      61,
      1484,
      8,
      61,
      10,
      61,
      12,
      61,
      1487,
      9,
      61,
      1,
      62,
      1,
      62,
      1,
      62,
      1,
      62,
      5,
      62,
      1493,
      8,
      62,
      10,
      62,
      12,
      62,
      1496,
      9,
      62,
      1,
      63,
      1,
      63,
      1,
      63,
      1,
      63,
      5,
      63,
      1502,
      8,
      63,
      10,
      63,
      12,
      63,
      1505,
      9,
      63,
      1,
      64,
      1,
      64,
      1,
      64,
      5,
      64,
      1510,
      8,
      64,
      10,
      64,
      12,
      64,
      1513,
      9,
      64,
      1,
      64,
      3,
      64,
      1516,
      8,
      64,
      1,
      65,
      1,
      65,
      1,
      65,
      1,
      65,
      3,
      65,
      1522,
      8,
      65,
      1,
      66,
      1,
      66,
      3,
      66,
      1526,
      8,
      66,
      3,
      66,
      1528,
      8,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      66,
      1,
      67,
      1,
      67,
      1,
      68,
      1,
      68,
      1,
      68,
      5,
      68,
      1541,
      8,
      68,
      10,
      68,
      12,
      68,
      1544,
      9,
      68,
      1,
      69,
      1,
      69,
      1,
      69,
      5,
      69,
      1549,
      8,
      69,
      10,
      69,
      12,
      69,
      1552,
      9,
      69,
      1,
      70,
      1,
      70,
      3,
      70,
      1556,
      8,
      70,
      3,
      70,
      1558,
      8,
      70,
      1,
      70,
      1,
      70,
      1,
      70,
      1,
      70,
      5,
      70,
      1564,
      8,
      70,
      10,
      70,
      12,
      70,
      1567,
      9,
      70,
      1,
      70,
      1,
      70,
      1,
      70,
      1,
      70,
      5,
      70,
      1573,
      8,
      70,
      10,
      70,
      12,
      70,
      1576,
      9,
      70,
      1,
      70,
      1,
      70,
      1,
      71,
      1,
      71,
      1,
      71,
      5,
      71,
      1583,
      8,
      71,
      10,
      71,
      12,
      71,
      1586,
      9,
      71,
      1,
      72,
      1,
      72,
      3,
      72,
      1590,
      8,
      72,
      3,
      72,
      1592,
      8,
      72,
      1,
      72,
      1,
      72,
      1,
      72,
      1,
      72,
      5,
      72,
      1598,
      8,
      72,
      10,
      72,
      12,
      72,
      1601,
      9,
      72,
      1,
      72,
      1,
      72,
      1,
      72,
      1,
      72,
      5,
      72,
      1607,
      8,
      72,
      10,
      72,
      12,
      72,
      1610,
      9,
      72,
      1,
      72,
      1,
      72,
      1,
      73,
      1,
      73,
      1,
      73,
      5,
      73,
      1617,
      8,
      73,
      10,
      73,
      12,
      73,
      1620,
      9,
      73,
      1,
      74,
      1,
      74,
      1,
      74,
      5,
      74,
      1625,
      8,
      74,
      10,
      74,
      12,
      74,
      1628,
      9,
      74,
      1,
      75,
      1,
      75,
      1,
      75,
      5,
      75,
      1633,
      8,
      75,
      10,
      75,
      12,
      75,
      1636,
      9,
      75,
      1,
      76,
      1,
      76,
      1,
      76,
      5,
      76,
      1641,
      8,
      76,
      10,
      76,
      12,
      76,
      1644,
      9,
      76,
      1,
      77,
      1,
      77,
      3,
      77,
      1648,
      8,
      77,
      1,
      78,
      1,
      78,
      1,
      78,
      1,
      78,
      1,
      79,
      1,
      79,
      1,
      79,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      80,
      1,
      81,
      3,
      81,
      1663,
      8,
      81,
      1,
      81,
      3,
      81,
      1666,
      8,
      81,
      1,
      81,
      3,
      81,
      1669,
      8,
      81,
      1,
      81,
      1,
      81,
      3,
      81,
      1673,
      8,
      81,
      1,
      81,
      5,
      81,
      1676,
      8,
      81,
      10,
      81,
      12,
      81,
      1679,
      9,
      81,
      1,
      82,
      1,
      82,
      1,
      82,
      1,
      82,
      5,
      82,
      1685,
      8,
      82,
      10,
      82,
      12,
      82,
      1688,
      9,
      82,
      1,
      83,
      1,
      83,
      3,
      83,
      1692,
      8,
      83,
      3,
      83,
      1694,
      8,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      83,
      1,
      84,
      1,
      84,
      1,
      85,
      1,
      85,
      1,
      85,
      3,
      85,
      1707,
      8,
      85,
      1,
      85,
      3,
      85,
      1710,
      8,
      85,
      1,
      85,
      1,
      85,
      3,
      85,
      1714,
      8,
      85,
      1,
      85,
      3,
      85,
      1717,
      8,
      85,
      1,
      85,
      1,
      85,
      3,
      85,
      1721,
      8,
      85,
      1,
      85,
      3,
      85,
      1724,
      8,
      85,
      1,
      85,
      1,
      85,
      1,
      86,
      3,
      86,
      1729,
      8,
      86,
      1,
      86,
      1,
      86,
      1,
      87,
      3,
      87,
      1734,
      8,
      87,
      1,
      87,
      3,
      87,
      1737,
      8,
      87,
      1,
      87,
      3,
      87,
      1740,
      8,
      87,
      1,
      87,
      3,
      87,
      1743,
      8,
      87,
      1,
      87,
      3,
      87,
      1746,
      8,
      87,
      1,
      88,
      1,
      88,
      1,
      88,
      1,
      88,
      3,
      88,
      1752,
      8,
      88,
      1,
      88,
      5,
      88,
      1755,
      8,
      88,
      10,
      88,
      12,
      88,
      1758,
      9,
      88,
      1,
      89,
      1,
      89,
      1,
      90,
      1,
      90,
      1,
      90,
      1,
      90,
      1,
      90,
      3,
      90,
      1767,
      8,
      90,
      3,
      90,
      1769,
      8,
      90,
      1,
      91,
      1,
      91,
      1,
      92,
      3,
      92,
      1774,
      8,
      92,
      1,
      92,
      1,
      92,
      1,
      92,
      3,
      92,
      1779,
      8,
      92,
      1,
      92,
      1,
      92,
      3,
      92,
      1783,
      8,
      92,
      1,
      92,
      5,
      92,
      1786,
      8,
      92,
      10,
      92,
      12,
      92,
      1789,
      9,
      92,
      1,
      93,
      1,
      93,
      1,
      93,
      1,
      93,
      3,
      93,
      1795,
      8,
      93,
      1,
      93,
      3,
      93,
      1798,
      8,
      93,
      1,
      94,
      1,
      94,
      1,
      94,
      1,
      94,
      3,
      94,
      1804,
      8,
      94,
      1,
      95,
      1,
      95,
      1,
      95,
      1,
      95,
      5,
      95,
      1810,
      8,
      95,
      10,
      95,
      12,
      95,
      1813,
      9,
      95,
      1,
      96,
      1,
      96,
      1,
      96,
      1,
      96,
      1,
      97,
      1,
      97,
      1,
      97,
      1,
      97,
      1,
      97,
      5,
      97,
      1824,
      8,
      97,
      10,
      97,
      12,
      97,
      1827,
      9,
      97,
      1,
      98,
      4,
      98,
      1830,
      8,
      98,
      11,
      98,
      12,
      98,
      1831,
      1,
      98,
      3,
      98,
      1835,
      8,
      98,
      1,
      98,
      5,
      98,
      1838,
      8,
      98,
      10,
      98,
      12,
      98,
      1841,
      9,
      98,
      1,
      98,
      1,
      98,
      5,
      98,
      1845,
      8,
      98,
      10,
      98,
      12,
      98,
      1848,
      9,
      98,
      3,
      98,
      1850,
      8,
      98,
      1,
      99,
      1,
      99,
      1,
      99,
      3,
      99,
      1855,
      8,
      99,
      1,
      99,
      1,
      99,
      3,
      99,
      1859,
      8,
      99,
      3,
      99,
      1861,
      8,
      99,
      1,
      99,
      1,
      99,
      3,
      99,
      1865,
      8,
      99,
      1,
      99,
      1,
      99,
      3,
      99,
      1869,
      8,
      99,
      3,
      99,
      1871,
      8,
      99,
      3,
      99,
      1873,
      8,
      99,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      1,
      100,
      3,
      100,
      1880,
      8,
      100,
      1,
      101,
      1,
      101,
      1,
      101,
      5,
      101,
      1885,
      8,
      101,
      10,
      101,
      12,
      101,
      1888,
      9,
      101,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      1,
      102,
      3,
      102,
      1895,
      8,
      102,
      1,
      102,
      1,
      102,
      1,
      103,
      1,
      103,
      1,
      103,
      5,
      103,
      1902,
      8,
      103,
      10,
      103,
      12,
      103,
      1905,
      9,
      103,
      1,
      104,
      1,
      104,
      1,
      104,
      1,
      105,
      1,
      105,
      1,
      105,
      1,
      106,
      1,
      106,
      1,
      106,
      1,
      107,
      1,
      107,
      1,
      107,
      5,
      107,
      1919,
      8,
      107,
      10,
      107,
      12,
      107,
      1922,
      9,
      107,
      1,
      108,
      1,
      108,
      1,
      108,
      1,
      109,
      1,
      109,
      3,
      109,
      1929,
      8,
      109,
      3,
      109,
      1931,
      8,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      3,
      109,
      1938,
      8,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      1,
      109,
      3,
      109,
      1945,
      8,
      109,
      1,
      110,
      1,
      110,
      1,
      110,
      5,
      110,
      1950,
      8,
      110,
      10,
      110,
      12,
      110,
      1953,
      9,
      110,
      1,
      111,
      1,
      111,
      3,
      111,
      1957,
      8,
      111,
      3,
      111,
      1959,
      8,
      111,
      1,
      111,
      1,
      111,
      1,
      111,
      1,
      111,
      1,
      111,
      1,
      111,
      1,
      112,
      1,
      112,
      1,
      112,
      5,
      112,
      1970,
      8,
      112,
      10,
      112,
      12,
      112,
      1973,
      9,
      112,
      1,
      113,
      1,
      113,
      1,
      113,
      5,
      113,
      1978,
      8,
      113,
      10,
      113,
      12,
      113,
      1981,
      9,
      113,
      1,
      114,
      1,
      114,
      1,
      114,
      5,
      114,
      1986,
      8,
      114,
      10,
      114,
      12,
      114,
      1989,
      9,
      114,
      1,
      115,
      1,
      115,
      3,
      115,
      1993,
      8,
      115,
      3,
      115,
      1995,
      8,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      115,
      1,
      116,
      1,
      116,
      1,
      116,
      5,
      116,
      2006,
      8,
      116,
      10,
      116,
      12,
      116,
      2009,
      9,
      116,
      1,
      117,
      1,
      117,
      3,
      117,
      2013,
      8,
      117,
      3,
      117,
      2015,
      8,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      5,
      117,
      2021,
      8,
      117,
      10,
      117,
      12,
      117,
      2024,
      9,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      1,
      117,
      5,
      117,
      2030,
      8,
      117,
      10,
      117,
      12,
      117,
      2033,
      9,
      117,
      1,
      117,
      1,
      117,
      1,
      118,
      1,
      118,
      1,
      118,
      5,
      118,
      2040,
      8,
      118,
      10,
      118,
      12,
      118,
      2043,
      9,
      118,
      1,
      119,
      1,
      119,
      3,
      119,
      2047,
      8,
      119,
      1,
      119,
      3,
      119,
      2050,
      8,
      119,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      119,
      1,
      120,
      1,
      120,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      121,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      122,
      1,
      123,
      1,
      123,
      1,
      123,
      1,
      123,
      1,
      123,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      124,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      125,
      1,
      126,
      1,
      126,
      1,
      126,
      3,
      126,
      2088,
      8,
      126,
      1,
      126,
      3,
      126,
      2091,
      8,
      126,
      1,
      126,
      3,
      126,
      2094,
      8,
      126,
      1,
      126,
      1,
      126,
      1,
      127,
      1,
      127,
      3,
      127,
      2100,
      8,
      127,
      1,
      128,
      3,
      128,
      2103,
      8,
      128,
      1,
      128,
      1,
      128,
      1,
      128,
      3,
      128,
      2108,
      8,
      128,
      3,
      128,
      2110,
      8,
      128,
      1,
      128,
      1,
      128,
      1,
      128,
      1,
      128,
      1,
      129,
      3,
      129,
      2117,
      8,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      1,
      129,
      5,
      129,
      2125,
      8,
      129,
      10,
      129,
      12,
      129,
      2128,
      9,
      129,
      1,
      129,
      1,
      129,
      1,
      130,
      1,
      130,
      1,
      131,
      3,
      131,
      2135,
      8,
      131,
      1,
      131,
      1,
      131,
      1,
      131,
      3,
      131,
      2140,
      8,
      131,
      1,
      131,
      1,
      131,
      1,
      132,
      1,
      132,
      1,
      133,
      1,
      133,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      134,
      1,
      135,
      1,
      135,
      1,
      135,
      1,
      135,
      1,
      135,
      1,
      135,
      3,
      135,
      2159,
      8,
      135,
      1,
      135,
      3,
      135,
      2162,
      8,
      135,
      1,
      135,
      3,
      135,
      2165,
      8,
      135,
      1,
      135,
      1,
      135,
      1,
      135,
      1,
      135,
      3,
      135,
      2171,
      8,
      135,
      3,
      135,
      2173,
      8,
      135,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      136,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      3,
      137,
      2186,
      8,
      137,
      1,
      137,
      3,
      137,
      2189,
      8,
      137,
      1,
      137,
      3,
      137,
      2192,
      8,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      1,
      137,
      3,
      137,
      2198,
      8,
      137,
      3,
      137,
      2200,
      8,
      137,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      138,
      1,
      139,
      1,
      139,
      1,
      139,
      1,
      139,
      3,
      139,
      2211,
      8,
      139,
      1,
      139,
      1,
      139,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      140,
      1,
      141,
      1,
      141,
      1,
      141,
      1,
      141,
      1,
      141,
      3,
      141,
      2225,
      8,
      141,
      1,
      142,
      1,
      142,
      1,
      142,
      5,
      142,
      2230,
      8,
      142,
      10,
      142,
      12,
      142,
      2233,
      9,
      142,
      1,
      142,
      3,
      142,
      2236,
      8,
      142,
      1,
      143,
      1,
      143,
      1,
      143,
      1,
      143,
      1,
      144,
      1,
      144,
      1,
      144,
      1,
      145,
      1,
      145,
      1,
      145,
      1,
      145,
      3,
      145,
      2249,
      8,
      145,
      1,
      145,
      1,
      145,
      1,
      146,
      1,
      146,
      1,
      146,
      1,
      146,
      1,
      146,
      1,
      147,
      1,
      147,
      1,
      147,
      1,
      147,
      3,
      147,
      2262,
      8,
      147,
      1,
      147,
      1,
      147,
      1,
      148,
      1,
      148,
      1,
      148,
      3,
      148,
      2269,
      8,
      148,
      1,
      148,
      1,
      148,
      3,
      148,
      2273,
      8,
      148,
      1,
      148,
      1,
      148,
      1,
      149,
      1,
      149,
      1,
      149,
      5,
      149,
      2280,
      8,
      149,
      10,
      149,
      12,
      149,
      2283,
      9,
      149,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      150,
      1,
      151,
      1,
      151,
      1,
      151,
      1,
      151,
      1,
      151,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      152,
      1,
      153,
      1,
      153,
      3,
      153,
      2303,
      8,
      153,
      1,
      153,
      1,
      153,
      3,
      153,
      2307,
      8,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      3,
      153,
      2314,
      8,
      153,
      1,
      153,
      3,
      153,
      2317,
      8,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      3,
      153,
      2324,
      8,
      153,
      1,
      153,
      3,
      153,
      2327,
      8,
      153,
      1,
      153,
      1,
      153,
      3,
      153,
      2331,
      8,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      1,
      153,
      3,
      153,
      2338,
      8,
      153,
      3,
      153,
      2340,
      8,
      153,
      1,
      154,
      1,
      154,
      1,
      155,
      3,
      155,
      2345,
      8,
      155,
      1,
      155,
      1,
      155,
      3,
      155,
      2349,
      8,
      155,
      1,
      155,
      1,
      155,
      3,
      155,
      2353,
      8,
      155,
      1,
      155,
      1,
      155,
      3,
      155,
      2357,
      8,
      155,
      1,
      155,
      1,
      155,
      3,
      155,
      2361,
      8,
      155,
      3,
      155,
      2363,
      8,
      155,
      1,
      156,
      4,
      156,
      2366,
      8,
      156,
      11,
      156,
      12,
      156,
      2367,
      1,
      156,
      3,
      156,
      2371,
      8,
      156,
      1,
      156,
      5,
      156,
      2374,
      8,
      156,
      10,
      156,
      12,
      156,
      2377,
      9,
      156,
      1,
      156,
      1,
      156,
      4,
      156,
      2381,
      8,
      156,
      11,
      156,
      12,
      156,
      2382,
      3,
      156,
      2385,
      8,
      156,
      1,
      157,
      1,
      157,
      1,
      158,
      1,
      158,
      1,
      158,
      5,
      158,
      2392,
      8,
      158,
      10,
      158,
      12,
      158,
      2395,
      9,
      158,
      1,
      159,
      1,
      159,
      1,
      160,
      1,
      160,
      1,
      160,
      1,
      160,
      3,
      160,
      2403,
      8,
      160,
      3,
      160,
      2405,
      8,
      160,
      1,
      160,
      1,
      160,
      1,
      161,
      1,
      161,
      3,
      161,
      2411,
      8,
      161,
      1,
      162,
      1,
      162,
      3,
      162,
      2415,
      8,
      162,
      1,
      162,
      1,
      162,
      1,
      162,
      1,
      163,
      1,
      163,
      3,
      163,
      2422,
      8,
      163,
      1,
      163,
      1,
      163,
      1,
      163,
      1,
      164,
      1,
      164,
      1,
      165,
      1,
      165,
      1,
      166,
      1,
      166,
      1,
      166,
      1,
      166,
      3,
      166,
      2435,
      8,
      166,
      1,
      166,
      1,
      166,
      1,
      166,
      1,
      167,
      1,
      167,
      3,
      167,
      2442,
      8,
      167,
      1,
      168,
      1,
      168,
      1,
      168,
      1,
      168,
      1,
      168,
      1,
      169,
      1,
      169,
      1,
      169,
      1,
      169,
      3,
      169,
      2453,
      8,
      169,
      1,
      170,
      1,
      170,
      1,
      170,
      1,
      170,
      3,
      170,
      2459,
      8,
      170,
      1,
      171,
      1,
      171,
      1,
      172,
      5,
      172,
      2464,
      8,
      172,
      10,
      172,
      12,
      172,
      2467,
      9,
      172,
      1,
      172,
      1,
      172,
      1,
      172,
      1,
      172,
      1,
      172,
      1,
      172,
      5,
      172,
      2475,
      8,
      172,
      10,
      172,
      12,
      172,
      2478,
      9,
      172,
      3,
      172,
      2480,
      8,
      172,
      1,
      172,
      1,
      172,
      1,
      173,
      3,
      173,
      2485,
      8,
      173,
      1,
      173,
      1,
      173,
      1,
      173,
      3,
      173,
      2490,
      8,
      173,
      3,
      173,
      2492,
      8,
      173,
      1,
      173,
      1,
      173,
      1,
      174,
      1,
      174,
      1,
      174,
      5,
      174,
      2499,
      8,
      174,
      10,
      174,
      12,
      174,
      2502,
      9,
      174,
      1,
      174,
      1,
      174,
      1,
      174,
      1,
      174,
      1,
      174,
      1,
      174,
      5,
      174,
      2510,
      8,
      174,
      10,
      174,
      12,
      174,
      2513,
      9,
      174,
      1,
      174,
      3,
      174,
      2516,
      8,
      174,
      1,
      175,
      1,
      175,
      1,
      175,
      1,
      175,
      3,
      175,
      2522,
      8,
      175,
      1,
      176,
      1,
      176,
      1,
      177,
      3,
      177,
      2527,
      8,
      177,
      1,
      177,
      3,
      177,
      2530,
      8,
      177,
      1,
      177,
      1,
      177,
      3,
      177,
      2534,
      8,
      177,
      1,
      177,
      3,
      177,
      2537,
      8,
      177,
      1,
      177,
      1,
      177,
      1,
      178,
      5,
      178,
      2542,
      8,
      178,
      10,
      178,
      12,
      178,
      2545,
      9,
      178,
      1,
      178,
      1,
      178,
      1,
      178,
      1,
      179,
      3,
      179,
      2551,
      8,
      179,
      1,
      179,
      1,
      179,
      5,
      179,
      2555,
      8,
      179,
      10,
      179,
      12,
      179,
      2558,
      9,
      179,
      1,
      179,
      1,
      179,
      1,
      179,
      1,
      180,
      1,
      180,
      3,
      180,
      2565,
      8,
      180,
      1,
      181,
      1,
      181,
      1,
      181,
      5,
      181,
      2570,
      8,
      181,
      10,
      181,
      12,
      181,
      2573,
      9,
      181,
      1,
      181,
      3,
      181,
      2576,
      8,
      181,
      1,
      182,
      1,
      182,
      1,
      182,
      1,
      182,
      1,
      182,
      1,
      183,
      3,
      183,
      2584,
      8,
      183,
      1,
      183,
      3,
      183,
      2587,
      8,
      183,
      1,
      183,
      1,
      183,
      1,
      183,
      5,
      183,
      2592,
      8,
      183,
      10,
      183,
      12,
      183,
      2595,
      9,
      183,
      1,
      183,
      1,
      183,
      1,
      183,
      1,
      183,
      5,
      183,
      2601,
      8,
      183,
      10,
      183,
      12,
      183,
      2604,
      9,
      183,
      1,
      184,
      1,
      184,
      1,
      185,
      1,
      185,
      1,
      185,
      1,
      185,
      3,
      185,
      2612,
      8,
      185,
      1,
      186,
      1,
      186,
      1,
      186,
      3,
      186,
      2617,
      8,
      186,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      1,
      187,
      3,
      187,
      2649,
      8,
      187,
      1,
      188,
      1,
      188,
      3,
      188,
      2653,
      8,
      188,
      1,
      189,
      1,
      189,
      1,
      190,
      1,
      190,
      1,
      191,
      3,
      191,
      2660,
      8,
      191,
      1,
      191,
      5,
      191,
      2663,
      8,
      191,
      10,
      191,
      12,
      191,
      2666,
      9,
      191,
      1,
      192,
      1,
      192,
      1,
      192,
      1,
      193,
      3,
      193,
      2672,
      8,
      193,
      1,
      193,
      3,
      193,
      2675,
      8,
      193,
      1,
      194,
      1,
      194,
      1,
      194,
      5,
      194,
      2680,
      8,
      194,
      10,
      194,
      12,
      194,
      2683,
      9,
      194,
      1,
      194,
      3,
      194,
      2686,
      8,
      194,
      1,
      195,
      1,
      195,
      1,
      195,
      1,
      195,
      1,
      195,
      3,
      195,
      2693,
      8,
      195,
      1,
      195,
      1,
      195,
      1,
      195,
      1,
      195,
      3,
      195,
      2699,
      8,
      195,
      1,
      195,
      1,
      195,
      1,
      195,
      3,
      195,
      2704,
      8,
      195,
      1,
      196,
      1,
      196,
      1,
      196,
      1,
      196,
      1,
      196,
      3,
      196,
      2711,
      8,
      196,
      1,
      196,
      3,
      196,
      2714,
      8,
      196,
      1,
      196,
      1,
      196,
      1,
      196,
      1,
      196,
      1,
      196,
      1,
      196,
      1,
      196,
      1,
      196,
      3,
      196,
      2724,
      8,
      196,
      1,
      197,
      1,
      197,
      1,
      197,
      1,
      198,
      1,
      198,
      1,
      198,
      1,
      198,
      1,
      199,
      1,
      199,
      1,
      199,
      1,
      200,
      1,
      200,
      1,
      200,
      1,
      201,
      1,
      201,
      1,
      201,
      1,
      202,
      3,
      202,
      2743,
      8,
      202,
      1,
      202,
      3,
      202,
      2746,
      8,
      202,
      1,
      202,
      3,
      202,
      2749,
      8,
      202,
      1,
      202,
      3,
      202,
      2752,
      8,
      202,
      1,
      203,
      1,
      203,
      3,
      203,
      2756,
      8,
      203,
      1,
      204,
      1,
      204,
      1,
      204,
      1,
      205,
      1,
      205,
      1,
      206,
      1,
      206,
      3,
      206,
      2765,
      8,
      206,
      1,
      207,
      1,
      207,
      5,
      207,
      2769,
      8,
      207,
      10,
      207,
      12,
      207,
      2772,
      9,
      207,
      1,
      208,
      3,
      208,
      2775,
      8,
      208,
      1,
      208,
      1,
      208,
      1,
      209,
      1,
      209,
      3,
      209,
      2781,
      8,
      209,
      1,
      209,
      3,
      209,
      2784,
      8,
      209,
      1,
      210,
      3,
      210,
      2787,
      8,
      210,
      1,
      210,
      1,
      210,
      1,
      211,
      1,
      211,
      1,
      212,
      1,
      212,
      1,
      212,
      1,
      213,
      1,
      213,
      3,
      213,
      2798,
      8,
      213,
      1,
      213,
      1,
      213,
      1,
      213,
      1,
      214,
      1,
      214,
      1,
      214,
      1,
      214,
      1,
      215,
      1,
      215,
      5,
      215,
      2809,
      8,
      215,
      10,
      215,
      12,
      215,
      2812,
      9,
      215,
      1,
      215,
      1,
      215,
      1,
      216,
      1,
      216,
      1,
      216,
      1,
      216,
      1,
      216,
      1,
      216,
      1,
      216,
      1,
      216,
      3,
      216,
      2824,
      8,
      216,
      1,
      217,
      1,
      217,
      3,
      217,
      2828,
      8,
      217,
      1,
      217,
      3,
      217,
      2831,
      8,
      217,
      1,
      217,
      3,
      217,
      2834,
      8,
      217,
      1,
      217,
      1,
      217,
      1,
      218,
      1,
      218,
      3,
      218,
      2840,
      8,
      218,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      1,
      219,
      3,
      219,
      2857,
      8,
      219,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      1,
      220,
      3,
      220,
      2875,
      8,
      220,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      1,
      221,
      3,
      221,
      2898,
      8,
      221,
      1,
      222,
      1,
      222,
      1,
      222,
      1,
      222,
      5,
      222,
      2904,
      8,
      222,
      10,
      222,
      12,
      222,
      2907,
      9,
      222,
      1,
      223,
      1,
      223,
      1,
      223,
      1,
      223,
      1,
      223,
      1,
      224,
      1,
      224,
      1,
      224,
      1,
      224,
      1,
      225,
      5,
      225,
      2919,
      8,
      225,
      10,
      225,
      12,
      225,
      2922,
      9,
      225,
      1,
      225,
      1,
      225,
      1,
      225,
      1,
      225,
      1,
      225,
      1,
      226,
      1,
      226,
      1,
      226,
      1,
      226,
      5,
      226,
      2933,
      8,
      226,
      10,
      226,
      12,
      226,
      2936,
      9,
      226,
      1,
      226,
      3,
      226,
      2939,
      8,
      226,
      1,
      227,
      5,
      227,
      2942,
      8,
      227,
      10,
      227,
      12,
      227,
      2945,
      9,
      227,
      1,
      227,
      1,
      227,
      1,
      227,
      1,
      228,
      3,
      228,
      2951,
      8,
      228,
      1,
      228,
      1,
      228,
      1,
      229,
      1,
      229,
      1,
      229,
      1,
      229,
      1,
      230,
      3,
      230,
      2960,
      8,
      230,
      1,
      230,
      1,
      230,
      3,
      230,
      2964,
      8,
      230,
      1,
      230,
      5,
      230,
      2967,
      8,
      230,
      10,
      230,
      12,
      230,
      2970,
      9,
      230,
      1,
      231,
      1,
      231,
      1,
      231,
      1,
      231,
      1,
      231,
      1,
      232,
      3,
      232,
      2978,
      8,
      232,
      1,
      232,
      1,
      232,
      5,
      232,
      2982,
      8,
      232,
      10,
      232,
      12,
      232,
      2985,
      9,
      232,
      1,
      232,
      1,
      232,
      1,
      232,
      1,
      232,
      1,
      233,
      1,
      233,
      1,
      234,
      1,
      234,
      3,
      234,
      2995,
      8,
      234,
      1,
      234,
      3,
      234,
      2998,
      8,
      234,
      1,
      234,
      5,
      234,
      3001,
      8,
      234,
      10,
      234,
      12,
      234,
      3004,
      9,
      234,
      1,
      235,
      1,
      235,
      1,
      235,
      1,
      235,
      1,
      236,
      1,
      236,
      1,
      236,
      5,
      236,
      3013,
      8,
      236,
      10,
      236,
      12,
      236,
      3016,
      9,
      236,
      1,
      236,
      1,
      236,
      1,
      237,
      1,
      237,
      3,
      237,
      3022,
      8,
      237,
      1,
      237,
      1,
      237,
      5,
      237,
      3026,
      8,
      237,
      10,
      237,
      12,
      237,
      3029,
      9,
      237,
      1,
      237,
      1,
      237,
      1,
      238,
      1,
      238,
      1,
      239,
      1,
      239,
      1,
      239,
      1,
      239,
      3,
      239,
      3039,
      8,
      239,
      1,
      239,
      1,
      239,
      3,
      239,
      3043,
      8,
      239,
      3,
      239,
      3045,
      8,
      239,
      1,
      239,
      1,
      239,
      1,
      240,
      1,
      240,
      1,
      240,
      1,
      241,
      1,
      241,
      1,
      242,
      1,
      242,
      1,
      243,
      3,
      243,
      3057,
      8,
      243,
      1,
      244,
      1,
      244,
      1,
      244,
      1,
      244,
      1,
      244,
      1,
      245,
      1,
      245,
      1,
      245,
      1,
      245,
      1,
      246,
      1,
      246,
      1,
      246,
      1,
      246,
      1,
      246,
      1,
      247,
      1,
      247,
      1,
      247,
      1,
      247,
      1,
      248,
      1,
      248,
      1,
      248,
      1,
      248,
      1,
      248,
      1,
      248,
      1,
      249,
      1,
      249,
      1,
      250,
      1,
      250,
      1,
      251,
      1,
      251,
      1,
      251,
      1,
      251,
      1,
      252,
      1,
      252,
      1,
      252,
      1,
      253,
      1,
      253,
      1,
      253,
      1,
      253,
      1,
      253,
      1,
      254,
      1,
      254,
      1,
      254,
      3,
      254,
      3102,
      8,
      254,
      1,
      254,
      3,
      254,
      3105,
      8,
      254,
      1,
      254,
      1,
      254,
      3,
      254,
      3109,
      8,
      254,
      1,
      254,
      1,
      254,
      3,
      254,
      3113,
      8,
      254,
      1,
      254,
      1,
      254,
      1,
      255,
      1,
      255,
      3,
      255,
      3119,
      8,
      255,
      1,
      256,
      1,
      256,
      1,
      256,
      1,
      256,
      1,
      257,
      1,
      257,
      1,
      257,
      1,
      257,
      1,
      257,
      1,
      257,
      5,
      257,
      3131,
      8,
      257,
      10,
      257,
      12,
      257,
      3134,
      9,
      257,
      1,
      257,
      1,
      257,
      1,
      258,
      1,
      258,
      1,
      258,
      3,
      258,
      3141,
      8,
      258,
      3,
      258,
      3143,
      8,
      258,
      1,
      258,
      1,
      258,
      1,
      258,
      1,
      258,
      1,
      258,
      1,
      258,
      1,
      259,
      1,
      259,
      1,
      259,
      3,
      259,
      3154,
      8,
      259,
      3,
      259,
      3156,
      8,
      259,
      1,
      259,
      1,
      259,
      1,
      259,
      1,
      259,
      1,
      259,
      1,
      259,
      1,
      260,
      1,
      260,
      1,
      260,
      1,
      260,
      1,
      260,
      1,
      260,
      1,
      261,
      1,
      261,
      1,
      261,
      5,
      261,
      3173,
      8,
      261,
      10,
      261,
      12,
      261,
      3176,
      9,
      261,
      1,
      261,
      3,
      261,
      3179,
      8,
      261,
      1,
      262,
      1,
      262,
      1,
      262,
      1,
      262,
      3,
      262,
      3185,
      8,
      262,
      1,
      262,
      1,
      262,
      1,
      262,
      3,
      262,
      3190,
      8,
      262,
      1,
      263,
      1,
      263,
      1,
      263,
      1,
      264,
      1,
      264,
      1,
      264,
      1,
      264,
      1,
      264,
      3,
      264,
      3200,
      8,
      264,
      1,
      265,
      1,
      265,
      1,
      265,
      1,
      266,
      1,
      266,
      1,
      266,
      1,
      266,
      3,
      266,
      3209,
      8,
      266,
      1,
      267,
      1,
      267,
      1,
      267,
      1,
      268,
      1,
      268,
      1,
      268,
      1,
      268,
      1,
      268,
      1,
      269,
      3,
      269,
      3220,
      8,
      269,
      1,
      269,
      3,
      269,
      3223,
      8,
      269,
      1,
      269,
      1,
      269,
      3,
      269,
      3227,
      8,
      269,
      1,
      269,
      3,
      269,
      3230,
      8,
      269,
      1,
      270,
      1,
      270,
      3,
      270,
      3234,
      8,
      270,
      1,
      271,
      1,
      271,
      1,
      271,
      1,
      271,
      1,
      272,
      1,
      272,
      1,
      272,
      1,
      272,
      1,
      272,
      1,
      272,
      5,
      272,
      3246,
      8,
      272,
      10,
      272,
      12,
      272,
      3249,
      9,
      272,
      1,
      272,
      1,
      272,
      1,
      273,
      1,
      273,
      1,
      274,
      3,
      274,
      3256,
      8,
      274,
      1,
      274,
      1,
      274,
      1,
      274,
      3,
      274,
      3261,
      8,
      274,
      1,
      274,
      1,
      274,
      1,
      275,
      1,
      275,
      1,
      275,
      1,
      275,
      1,
      275,
      1,
      276,
      1,
      276,
      1,
      276,
      1,
      276,
      1,
      277,
      1,
      277,
      3,
      277,
      3276,
      8,
      277,
      1,
      277,
      1,
      277,
      3,
      277,
      3280,
      8,
      277,
      1,
      277,
      1,
      277,
      3,
      277,
      3284,
      8,
      277,
      1,
      278,
      1,
      278,
      1,
      278,
      1,
      278,
      1,
      278,
      1,
      279,
      1,
      279,
      1,
      279,
      1,
      279,
      1,
      279,
      1,
      280,
      3,
      280,
      3297,
      8,
      280,
      1,
      280,
      3,
      280,
      3300,
      8,
      280,
      1,
      280,
      1,
      280,
      3,
      280,
      3304,
      8,
      280,
      1,
      280,
      1,
      280,
      1,
      280,
      1,
      280,
      1,
      280,
      3,
      280,
      3311,
      8,
      280,
      1,
      280,
      1,
      280,
      1,
      280,
      1,
      280,
      3,
      280,
      3317,
      8,
      280,
      1,
      281,
      1,
      281,
      1,
      282,
      1,
      282,
      1,
      283,
      1,
      283,
      1,
      283,
      1,
      283,
      1,
      283,
      1,
      284,
      1,
      284,
      1,
      284,
      1,
      284,
      1,
      284,
      1,
      284,
      1,
      285,
      1,
      285,
      1,
      286,
      1,
      286,
      1,
      287,
      1,
      287,
      1,
      287,
      1,
      287,
      1,
      287,
      1,
      287,
      1,
      288,
      1,
      288,
      1,
      288,
      5,
      288,
      3347,
      8,
      288,
      10,
      288,
      12,
      288,
      3350,
      9,
      288,
      1,
      288,
      3,
      288,
      3353,
      8,
      288,
      1,
      289,
      1,
      289,
      1,
      289,
      5,
      289,
      3358,
      8,
      289,
      10,
      289,
      12,
      289,
      3361,
      9,
      289,
      1,
      289,
      3,
      289,
      3364,
      8,
      289,
      1,
      289,
      1,
      289,
      5,
      289,
      3368,
      8,
      289,
      10,
      289,
      12,
      289,
      3371,
      9,
      289,
      1,
      289,
      3,
      289,
      3374,
      8,
      289,
      1,
      290,
      1,
      290,
      1,
      290,
      1,
      290,
      1,
      290,
      1,
      290,
      3,
      290,
      3382,
      8,
      290,
      1,
      290,
      3,
      290,
      3385,
      8,
      290,
      1,
      291,
      1,
      291,
      3,
      291,
      3389,
      8,
      291,
      1,
      292,
      1,
      292,
      1,
      292,
      1,
      292,
      1,
      292,
      1,
      293,
      1,
      293,
      1,
      293,
      1,
      294,
      1,
      294,
      1,
      294,
      1,
      295,
      1,
      295,
      1,
      295,
      1,
      296,
      1,
      296,
      1,
      296,
      1,
      296,
      1,
      296,
      1,
      297,
      3,
      297,
      3411,
      8,
      297,
      1,
      297,
      3,
      297,
      3414,
      8,
      297,
      1,
      298,
      1,
      298,
      1,
      298,
      1,
      298,
      1,
      298,
      1,
      299,
      1,
      299,
      3,
      299,
      3423,
      8,
      299,
      1,
      299,
      1,
      299,
      3,
      299,
      3427,
      8,
      299,
      3,
      299,
      3429,
      8,
      299,
      1,
      299,
      3,
      299,
      3432,
      8,
      299,
      1,
      300,
      1,
      300,
      1,
      300,
      1,
      300,
      1,
      300,
      1,
      300,
      1,
      300,
      1,
      300,
      3,
      300,
      3442,
      8,
      300,
      1,
      301,
      1,
      301,
      3,
      301,
      3446,
      8,
      301,
      1,
      302,
      1,
      302,
      3,
      302,
      3450,
      8,
      302,
      1,
      303,
      1,
      303,
      1,
      303,
      1,
      303,
      3,
      303,
      3456,
      8,
      303,
      1,
      304,
      1,
      304,
      3,
      304,
      3460,
      8,
      304,
      1,
      304,
      3,
      304,
      3463,
      8,
      304,
      1,
      304,
      5,
      304,
      3466,
      8,
      304,
      10,
      304,
      12,
      304,
      3469,
      9,
      304,
      1,
      305,
      1,
      305,
      1,
      305,
      3,
      305,
      3474,
      8,
      305,
      1,
      305,
      1,
      305,
      1,
      306,
      1,
      306,
      1,
      306,
      3,
      306,
      3481,
      8,
      306,
      1,
      306,
      1,
      306,
      1,
      307,
      1,
      307,
      1,
      307,
      3,
      307,
      3488,
      8,
      307,
      1,
      307,
      1,
      307,
      1,
      308,
      1,
      308,
      1,
      308,
      3,
      308,
      3495,
      8,
      308,
      1,
      308,
      1,
      308,
      1,
      309,
      1,
      309,
      1,
      309,
      1,
      309,
      1,
      310,
      3,
      310,
      3504,
      8,
      310,
      1,
      310,
      1,
      310,
      1,
      310,
      1,
      311,
      1,
      311,
      1,
      311,
      3,
      311,
      3512,
      8,
      311,
      1,
      312,
      1,
      312,
      1,
      313,
      1,
      313,
      3,
      313,
      3518,
      8,
      313,
      1,
      313,
      3,
      313,
      3521,
      8,
      313,
      1,
      313,
      3,
      313,
      3524,
      8,
      313,
      1,
      314,
      1,
      314,
      1,
      315,
      1,
      315,
      1,
      316,
      1,
      316,
      1,
      316,
      1,
      316,
      3,
      316,
      3534,
      8,
      316,
      1,
      317,
      1,
      317,
      1,
      317,
      3,
      317,
      3539,
      8,
      317,
      1,
      317,
      1,
      317,
      1,
      317,
      3,
      317,
      3544,
      8,
      317,
      1,
      317,
      1,
      317,
      3,
      317,
      3548,
      8,
      317,
      3,
      317,
      3550,
      8,
      317,
      1,
      317,
      1,
      317,
      1,
      318,
      3,
      318,
      3555,
      8,
      318,
      1,
      318,
      1,
      318,
      1,
      318,
      3,
      318,
      3560,
      8,
      318,
      1,
      319,
      1,
      319,
      1,
      319,
      1,
      319,
      3,
      319,
      3566,
      8,
      319,
      1,
      319,
      1,
      319,
      1,
      319,
      1,
      319,
      3,
      319,
      3572,
      8,
      319,
      1,
      320,
      1,
      320,
      1,
      321,
      1,
      321,
      1,
      322,
      1,
      322,
      1,
      323,
      1,
      323,
      1,
      324,
      1,
      324,
      1,
      324,
      1,
      324,
      1,
      325,
      3,
      325,
      3587,
      8,
      325,
      1,
      325,
      1,
      325,
      1,
      325,
      1,
      325,
      1,
      325,
      1,
      325,
      1,
      326,
      1,
      326,
      1,
      327,
      1,
      327,
      1,
      327,
      3,
      327,
      3600,
      8,
      327,
      1,
      328,
      1,
      328,
      1,
      329,
      1,
      329,
      3,
      329,
      3606,
      8,
      329,
      1,
      329,
      1,
      329,
      3,
      329,
      3610,
      8,
      329,
      1,
      329,
      1,
      329,
      1,
      330,
      1,
      330,
      1,
      330,
      1,
      330,
      1,
      330,
      1,
      330,
      1,
      330,
      3,
      330,
      3621,
      8,
      330,
      3,
      330,
      3623,
      8,
      330,
      1,
      331,
      1,
      331,
      1,
      332,
      1,
      332,
      1,
      333,
      1,
      333,
      3,
      333,
      3631,
      8,
      333,
      3,
      333,
      3633,
      8,
      333,
      1,
      333,
      1,
      333,
      5,
      333,
      3637,
      8,
      333,
      10,
      333,
      12,
      333,
      3640,
      9,
      333,
      1,
      333,
      1,
      333,
      1,
      334,
      1,
      334,
      1,
      335,
      1,
      335,
      1,
      335,
      1,
      335,
      1,
      335,
      3,
      335,
      3651,
      8,
      335,
      1,
      335,
      1,
      335,
      1,
      335,
      1,
      335,
      1,
      335,
      3,
      335,
      3658,
      8,
      335,
      1,
      336,
      1,
      336,
      1,
      336,
      1,
      336,
      1,
      336,
      1,
      336,
      1,
      336,
      1,
      337,
      3,
      337,
      3668,
      8,
      337,
      1,
      338,
      1,
      338,
      1,
      338,
      3,
      338,
      3673,
      8,
      338,
      1,
      338,
      1,
      338,
      1,
      339,
      1,
      339,
      1,
      339,
      1,
      339,
      1,
      340,
      1,
      340,
      1,
      340,
      1,
      340,
      1,
      341,
      1,
      341,
      1,
      341,
      1,
      342,
      1,
      342,
      3,
      342,
      3690,
      8,
      342,
      3,
      342,
      3692,
      8,
      342,
      1,
      342,
      1,
      342,
      1,
      342,
      1,
      342,
      1,
      342,
      1,
      342,
      1,
      342,
      1,
      343,
      1,
      343,
      1,
      343,
      1,
      343,
      1,
      343,
      1,
      343,
      1,
      344,
      1,
      344,
      3,
      344,
      3709,
      8,
      344,
      1,
      344,
      1,
      344,
      5,
      344,
      3713,
      8,
      344,
      10,
      344,
      12,
      344,
      3716,
      9,
      344,
      1,
      344,
      3,
      344,
      3719,
      8,
      344,
      1,
      345,
      1,
      345,
      3,
      345,
      3723,
      8,
      345,
      1,
      345,
      1,
      345,
      5,
      345,
      3727,
      8,
      345,
      10,
      345,
      12,
      345,
      3730,
      9,
      345,
      1,
      345,
      1,
      345,
      1,
      345,
      5,
      345,
      3735,
      8,
      345,
      10,
      345,
      12,
      345,
      3738,
      9,
      345,
      1,
      345,
      1,
      345,
      3,
      345,
      3742,
      8,
      345,
      1,
      346,
      1,
      346,
      1,
      346,
      1,
      346,
      1,
      347,
      1,
      347,
      1,
      347,
      1,
      347,
      1,
      348,
      1,
      348,
      1,
      348,
      1,
      348,
      1,
      349,
      1,
      349,
      1,
      349,
      1,
      349,
      3,
      349,
      3760,
      8,
      349,
      1,
      349,
      1,
      349,
      1,
      350,
      1,
      350,
      1,
      350,
      1,
      350,
      1,
      350,
      1,
      350,
      1,
      350,
      3,
      350,
      3771,
      8,
      350,
      1,
      351,
      1,
      351,
      1,
      351,
      1,
      352,
      1,
      352,
      1,
      352,
      1,
      353,
      1,
      353,
      1,
      353,
      1,
      354,
      1,
      354,
      1,
      354,
      1,
      355,
      1,
      355,
      1,
      355,
      1,
      356,
      1,
      356,
      1,
      356,
      1,
      357,
      1,
      357,
      1,
      357,
      1,
      357,
      1,
      357,
      1,
      358,
      1,
      358,
      3,
      358,
      3798,
      8,
      358,
      1,
      358,
      1,
      358,
      5,
      358,
      3802,
      8,
      358,
      10,
      358,
      12,
      358,
      3805,
      9,
      358,
      1,
      358,
      3,
      358,
      3808,
      8,
      358,
      1,
      359,
      1,
      359,
      1,
      359,
      1,
      359,
      3,
      359,
      3814,
      8,
      359,
      1,
      359,
      1,
      359,
      3,
      359,
      3818,
      8,
      359,
      3,
      359,
      3820,
      8,
      359,
      1,
      359,
      3,
      359,
      3823,
      8,
      359,
      1,
      359,
      1,
      359,
      1,
      360,
      1,
      360,
      3,
      360,
      3829,
      8,
      360,
      1,
      360,
      3,
      360,
      3832,
      8,
      360,
      1,
      360,
      1,
      360,
      1,
      360,
      1,
      360,
      1,
      360,
      3,
      360,
      3839,
      8,
      360,
      1,
      360,
      3,
      360,
      3842,
      8,
      360,
      1,
      360,
      3,
      360,
      3845,
      8,
      360,
      1,
      360,
      1,
      360,
      1,
      360,
      1,
      360,
      1,
      361,
      1,
      361,
      1,
      361,
      1,
      361,
      1,
      361,
      3,
      361,
      3856,
      8,
      361,
      1,
      361,
      3,
      361,
      3859,
      8,
      361,
      1,
      361,
      3,
      361,
      3862,
      8,
      361,
      1,
      361,
      1,
      361,
      1,
      361,
      3,
      361,
      3867,
      8,
      361,
      1,
      361,
      3,
      361,
      3870,
      8,
      361,
      1,
      361,
      1,
      361,
      3,
      361,
      3874,
      8,
      361,
      3,
      361,
      3876,
      8,
      361,
      1,
      361,
      1,
      361,
      1,
      361,
      1,
      361,
      1,
      362,
      1,
      362,
      1,
      362,
      1,
      363,
      1,
      363,
      1,
      364,
      1,
      364,
      1,
      364,
      1,
      365,
      1,
      365,
      1,
      365,
      1,
      366,
      1,
      366,
      1,
      366,
      1,
      366,
      1,
      366,
      3,
      366,
      3898,
      8,
      366,
      1,
      367,
      1,
      367,
      1,
      367,
      5,
      367,
      3903,
      8,
      367,
      10,
      367,
      12,
      367,
      3906,
      9,
      367,
      1,
      367,
      3,
      367,
      3909,
      8,
      367,
      1,
      368,
      1,
      368,
      1,
      368,
      5,
      368,
      3914,
      8,
      368,
      10,
      368,
      12,
      368,
      3917,
      9,
      368,
      1,
      368,
      3,
      368,
      3920,
      8,
      368,
      1,
      369,
      1,
      369,
      1,
      369,
      5,
      369,
      3925,
      8,
      369,
      10,
      369,
      12,
      369,
      3928,
      9,
      369,
      1,
      369,
      3,
      369,
      3931,
      8,
      369,
      1,
      370,
      1,
      370,
      1,
      370,
      5,
      370,
      3936,
      8,
      370,
      10,
      370,
      12,
      370,
      3939,
      9,
      370,
      1,
      370,
      3,
      370,
      3942,
      8,
      370,
      1,
      371,
      1,
      371,
      1,
      372,
      1,
      372,
      1,
      372,
      1,
      373,
      1,
      373,
      1,
      374,
      1,
      374,
      1,
      374,
      1,
      374,
      1,
      374,
      1,
      374,
      1,
      375,
      1,
      375,
      1,
      375,
      1,
      375,
      1,
      375,
      1,
      376,
      1,
      376,
      1,
      376,
      1,
      376,
      1,
      376,
      3,
      376,
      3967,
      8,
      376,
      1,
      377,
      5,
      377,
      3970,
      8,
      377,
      10,
      377,
      12,
      377,
      3973,
      9,
      377,
      1,
      377,
      3,
      377,
      3976,
      8,
      377,
      1,
      378,
      1,
      378,
      3,
      378,
      3980,
      8,
      378,
      1,
      379,
      1,
      379,
      1,
      379,
      1,
      379,
      1,
      380,
      1,
      380,
      1,
      380,
      1,
      380,
      1,
      380,
      1,
      380,
      1,
      381,
      1,
      381,
      1,
      381,
      1,
      381,
      1,
      381,
      1,
      382,
      1,
      382,
      1,
      382,
      3,
      382,
      4e3,
      8,
      382,
      1,
      382,
      1,
      382,
      3,
      382,
      4004,
      8,
      382,
      1,
      382,
      1,
      382,
      3,
      382,
      4008,
      8,
      382,
      1,
      382,
      1,
      382,
      1,
      383,
      3,
      383,
      4013,
      8,
      383,
      1,
      383,
      3,
      383,
      4016,
      8,
      383,
      1,
      384,
      1,
      384,
      1,
      384,
      1,
      384,
      1,
      384,
      1,
      384,
      1,
      385,
      1,
      385,
      1,
      385,
      5,
      385,
      4027,
      8,
      385,
      10,
      385,
      12,
      385,
      4030,
      9,
      385,
      1,
      385,
      3,
      385,
      4033,
      8,
      385,
      1,
      386,
      1,
      386,
      1,
      386,
      1,
      386,
      1,
      386,
      1,
      386,
      1,
      386,
      3,
      386,
      4042,
      8,
      386,
      1,
      387,
      1,
      387,
      1,
      387,
      1,
      388,
      1,
      388,
      5,
      388,
      4049,
      8,
      388,
      10,
      388,
      12,
      388,
      4052,
      9,
      388,
      1,
      388,
      1,
      388,
      1,
      389,
      1,
      389,
      1,
      389,
      1,
      389,
      1,
      390,
      1,
      390,
      1,
      391,
      1,
      391,
      3,
      391,
      4064,
      8,
      391,
      1,
      391,
      1,
      391,
      1,
      391,
      5,
      391,
      4069,
      8,
      391,
      10,
      391,
      12,
      391,
      4072,
      9,
      391,
      1,
      391,
      1,
      391,
      4,
      391,
      4076,
      8,
      391,
      11,
      391,
      12,
      391,
      4077,
      3,
      391,
      4080,
      8,
      391,
      1,
      391,
      1,
      391,
      1,
      391,
      3,
      391,
      4085,
      8,
      391,
      1,
      392,
      1,
      392,
      1,
      392,
      1,
      392,
      1,
      393,
      1,
      393,
      3,
      393,
      4093,
      8,
      393,
      1,
      393,
      1,
      393,
      1,
      393,
      5,
      393,
      4098,
      8,
      393,
      10,
      393,
      12,
      393,
      4101,
      9,
      393,
      1,
      393,
      1,
      393,
      4,
      393,
      4105,
      8,
      393,
      11,
      393,
      12,
      393,
      4106,
      3,
      393,
      4109,
      8,
      393,
      1,
      393,
      1,
      393,
      1,
      393,
      3,
      393,
      4114,
      8,
      393,
      1,
      394,
      1,
      394,
      1,
      394,
      1,
      395,
      1,
      395,
      5,
      395,
      4121,
      8,
      395,
      10,
      395,
      12,
      395,
      4124,
      9,
      395,
      1,
      395,
      1,
      395,
      1,
      396,
      1,
      396,
      1,
      396,
      1,
      397,
      1,
      397,
      5,
      397,
      4133,
      8,
      397,
      10,
      397,
      12,
      397,
      4136,
      9,
      397,
      1,
      397,
      1,
      397,
      1,
      398,
      1,
      398,
      1,
      398,
      1,
      398,
      1,
      398,
      1,
      399,
      1,
      399,
      1,
      399,
      3,
      399,
      4148,
      8,
      399,
      1,
      399,
      3,
      399,
      4151,
      8,
      399,
      1,
      399,
      1,
      399,
      1,
      399,
      3,
      399,
      4156,
      8,
      399,
      1,
      399,
      1,
      399,
      3,
      399,
      4160,
      8,
      399,
      3,
      399,
      4162,
      8,
      399,
      1,
      399,
      3,
      399,
      4165,
      8,
      399,
      1,
      399,
      1,
      399,
      3,
      399,
      4169,
      8,
      399,
      1,
      399,
      1,
      399,
      1,
      400,
      1,
      400,
      1,
      401,
      1,
      401,
      1,
      402,
      1,
      402,
      1,
      403,
      1,
      403,
      1,
      404,
      1,
      404,
      1,
      404,
      1,
      404,
      1,
      404,
      1,
      404,
      1,
      405,
      1,
      405,
      1,
      405,
      1,
      405,
      1,
      405,
      1,
      406,
      1,
      406,
      1,
      406,
      1,
      406,
      1,
      406,
      1,
      406,
      1,
      407,
      1,
      407,
      1,
      407,
      1,
      407,
      1,
      407,
      1,
      408,
      1,
      408,
      1,
      408,
      5,
      408,
      4206,
      8,
      408,
      10,
      408,
      12,
      408,
      4209,
      9,
      408,
      1,
      408,
      3,
      408,
      4212,
      8,
      408,
      1,
      408,
      3,
      408,
      4215,
      8,
      408,
      1,
      409,
      1,
      409,
      1,
      409,
      1,
      409,
      1,
      409,
      3,
      409,
      4222,
      8,
      409,
      1,
      410,
      1,
      410,
      1,
      410,
      1,
      410,
      1,
      411,
      5,
      411,
      4229,
      8,
      411,
      10,
      411,
      12,
      411,
      4232,
      9,
      411,
      1,
      411,
      1,
      411,
      1,
      411,
      1,
      412,
      1,
      412,
      1,
      412,
      1,
      412,
      1,
      412,
      1,
      412,
      1,
      413,
      1,
      413,
      1,
      413,
      1,
      413,
      1,
      413,
      1,
      414,
      1,
      414,
      1,
      414,
      1,
      414,
      1,
      414,
      1,
      414,
      1,
      415,
      1,
      415,
      1,
      415,
      1,
      415,
      1,
      415,
      1,
      416,
      1,
      416,
      1,
      416,
      1,
      416,
      1,
      417,
      1,
      417,
      5,
      417,
      4265,
      8,
      417,
      10,
      417,
      12,
      417,
      4268,
      9,
      417,
      1,
      417,
      1,
      417,
      1,
      417,
      5,
      417,
      4273,
      8,
      417,
      10,
      417,
      12,
      417,
      4276,
      9,
      417,
      1,
      417,
      1,
      417,
      4,
      417,
      4280,
      8,
      417,
      11,
      417,
      12,
      417,
      4281,
      3,
      417,
      4284,
      8,
      417,
      1,
      417,
      1,
      417,
      1,
      417,
      3,
      417,
      4289,
      8,
      417,
      1,
      418,
      1,
      418,
      1,
      418,
      1,
      418,
      1,
      418,
      1,
      418,
      1,
      418,
      1,
      419,
      1,
      419,
      1,
      419,
      1,
      419,
      1,
      419,
      1,
      419,
      1,
      420,
      1,
      420,
      1,
      420,
      1,
      420,
      3,
      420,
      4308,
      8,
      420,
      1,
      420,
      1,
      420,
      1,
      420,
      3,
      420,
      4313,
      8,
      420,
      3,
      420,
      4315,
      8,
      420,
      1,
      420,
      3,
      420,
      4318,
      8,
      420,
      1,
      420,
      1,
      420,
      1,
      421,
      1,
      421,
      1,
      421,
      1,
      421,
      1,
      421,
      1,
      421,
      1,
      422,
      1,
      422,
      1,
      422,
      5,
      422,
      4331,
      8,
      422,
      10,
      422,
      12,
      422,
      4334,
      9,
      422,
      1,
      422,
      3,
      422,
      4337,
      8,
      422,
      1,
      423,
      1,
      423,
      1,
      423,
      3,
      423,
      4342,
      8,
      423,
      1,
      424,
      1,
      424,
      1,
      424,
      1,
      424,
      1,
      425,
      1,
      425,
      3,
      425,
      4350,
      8,
      425,
      1,
      425,
      1,
      425,
      1,
      425,
      5,
      425,
      4355,
      8,
      425,
      10,
      425,
      12,
      425,
      4358,
      9,
      425,
      1,
      425,
      1,
      425,
      4,
      425,
      4362,
      8,
      425,
      11,
      425,
      12,
      425,
      4363,
      3,
      425,
      4366,
      8,
      425,
      1,
      425,
      3,
      425,
      4369,
      8,
      425,
      1,
      426,
      1,
      426,
      1,
      426,
      3,
      426,
      4374,
      8,
      426,
      1,
      426,
      3,
      426,
      4377,
      8,
      426,
      1,
      426,
      1,
      426,
      1,
      427,
      1,
      427,
      1,
      427,
      5,
      427,
      4384,
      8,
      427,
      10,
      427,
      12,
      427,
      4387,
      9,
      427,
      1,
      427,
      3,
      427,
      4390,
      8,
      427,
      1,
      428,
      1,
      428,
      1,
      428,
      1,
      428,
      3,
      428,
      4396,
      8,
      428,
      1,
      429,
      1,
      429,
      1,
      429,
      3,
      429,
      4401,
      8,
      429,
      1,
      429,
      1,
      429,
      1,
      430,
      1,
      430,
      1,
      431,
      1,
      431,
      1,
      432,
      1,
      432,
      1,
      432,
      1,
      432,
      1,
      432,
      1,
      432,
      1,
      433,
      1,
      433,
      1,
      433,
      1,
      433,
      1,
      433,
      1,
      434,
      1,
      434,
      1,
      434,
      1,
      434,
      1,
      434,
      1,
      435,
      1,
      435,
      1,
      435,
      1,
      435,
      1,
      436,
      3,
      436,
      4430,
      8,
      436,
      1,
      436,
      5,
      436,
      4433,
      8,
      436,
      10,
      436,
      12,
      436,
      4436,
      9,
      436,
      1,
      436,
      1,
      436,
      1,
      436,
      1,
      436,
      1,
      437,
      1,
      437,
      1,
      438,
      1,
      438,
      1,
      439,
      3,
      439,
      4447,
      8,
      439,
      1,
      439,
      3,
      439,
      4450,
      8,
      439,
      1,
      439,
      1,
      439,
      3,
      439,
      4454,
      8,
      439,
      1,
      439,
      3,
      439,
      4457,
      8,
      439,
      1,
      439,
      1,
      439,
      1,
      440,
      3,
      440,
      4462,
      8,
      440,
      1,
      440,
      4,
      440,
      4465,
      8,
      440,
      11,
      440,
      12,
      440,
      4466,
      1,
      440,
      1,
      440,
      1,
      440,
      1,
      441,
      1,
      441,
      4,
      441,
      4474,
      8,
      441,
      11,
      441,
      12,
      441,
      4475,
      1,
      441,
      1,
      441,
      1,
      442,
      1,
      442,
      3,
      442,
      4482,
      8,
      442,
      1,
      443,
      1,
      443,
      1,
      443,
      1,
      443,
      1,
      443,
      3,
      443,
      4489,
      8,
      443,
      1,
      444,
      3,
      444,
      4492,
      8,
      444,
      1,
      444,
      3,
      444,
      4495,
      8,
      444,
      1,
      445,
      1,
      445,
      1,
      446,
      1,
      446,
      1,
      447,
      1,
      447,
      1,
      448,
      1,
      448,
      1,
      449,
      1,
      449,
      1,
      450,
      1,
      450,
      1,
      451,
      1,
      451,
      1,
      451,
      0,
      1,
      0,
      452,
      0,
      2,
      4,
      6,
      8,
      10,
      12,
      14,
      16,
      18,
      20,
      22,
      24,
      26,
      28,
      30,
      32,
      34,
      36,
      38,
      40,
      42,
      44,
      46,
      48,
      50,
      52,
      54,
      56,
      58,
      60,
      62,
      64,
      66,
      68,
      70,
      72,
      74,
      76,
      78,
      80,
      82,
      84,
      86,
      88,
      90,
      92,
      94,
      96,
      98,
      100,
      102,
      104,
      106,
      108,
      110,
      112,
      114,
      116,
      118,
      120,
      122,
      124,
      126,
      128,
      130,
      132,
      134,
      136,
      138,
      140,
      142,
      144,
      146,
      148,
      150,
      152,
      154,
      156,
      158,
      160,
      162,
      164,
      166,
      168,
      170,
      172,
      174,
      176,
      178,
      180,
      182,
      184,
      186,
      188,
      190,
      192,
      194,
      196,
      198,
      200,
      202,
      204,
      206,
      208,
      210,
      212,
      214,
      216,
      218,
      220,
      222,
      224,
      226,
      228,
      230,
      232,
      234,
      236,
      238,
      240,
      242,
      244,
      246,
      248,
      250,
      252,
      254,
      256,
      258,
      260,
      262,
      264,
      266,
      268,
      270,
      272,
      274,
      276,
      278,
      280,
      282,
      284,
      286,
      288,
      290,
      292,
      294,
      296,
      298,
      300,
      302,
      304,
      306,
      308,
      310,
      312,
      314,
      316,
      318,
      320,
      322,
      324,
      326,
      328,
      330,
      332,
      334,
      336,
      338,
      340,
      342,
      344,
      346,
      348,
      350,
      352,
      354,
      356,
      358,
      360,
      362,
      364,
      366,
      368,
      370,
      372,
      374,
      376,
      378,
      380,
      382,
      384,
      386,
      388,
      390,
      392,
      394,
      396,
      398,
      400,
      402,
      404,
      406,
      408,
      410,
      412,
      414,
      416,
      418,
      420,
      422,
      424,
      426,
      428,
      430,
      432,
      434,
      436,
      438,
      440,
      442,
      444,
      446,
      448,
      450,
      452,
      454,
      456,
      458,
      460,
      462,
      464,
      466,
      468,
      470,
      472,
      474,
      476,
      478,
      480,
      482,
      484,
      486,
      488,
      490,
      492,
      494,
      496,
      498,
      500,
      502,
      504,
      506,
      508,
      510,
      512,
      514,
      516,
      518,
      520,
      522,
      524,
      526,
      528,
      530,
      532,
      534,
      536,
      538,
      540,
      542,
      544,
      546,
      548,
      550,
      552,
      554,
      556,
      558,
      560,
      562,
      564,
      566,
      568,
      570,
      572,
      574,
      576,
      578,
      580,
      582,
      584,
      586,
      588,
      590,
      592,
      594,
      596,
      598,
      600,
      602,
      604,
      606,
      608,
      610,
      612,
      614,
      616,
      618,
      620,
      622,
      624,
      626,
      628,
      630,
      632,
      634,
      636,
      638,
      640,
      642,
      644,
      646,
      648,
      650,
      652,
      654,
      656,
      658,
      660,
      662,
      664,
      666,
      668,
      670,
      672,
      674,
      676,
      678,
      680,
      682,
      684,
      686,
      688,
      690,
      692,
      694,
      696,
      698,
      700,
      702,
      704,
      706,
      708,
      710,
      712,
      714,
      716,
      718,
      720,
      722,
      724,
      726,
      728,
      730,
      732,
      734,
      736,
      738,
      740,
      742,
      744,
      746,
      748,
      750,
      752,
      754,
      756,
      758,
      760,
      762,
      764,
      766,
      768,
      770,
      772,
      774,
      776,
      778,
      780,
      782,
      784,
      786,
      788,
      790,
      792,
      794,
      796,
      798,
      800,
      802,
      804,
      806,
      808,
      810,
      812,
      814,
      816,
      818,
      820,
      822,
      824,
      826,
      828,
      830,
      832,
      834,
      836,
      838,
      840,
      842,
      844,
      846,
      848,
      850,
      852,
      854,
      856,
      858,
      860,
      862,
      864,
      866,
      868,
      870,
      872,
      874,
      876,
      878,
      880,
      882,
      884,
      886,
      888,
      890,
      892,
      894,
      896,
      898,
      900,
      902,
      0,
      26,
      4,
      0,
      107,
      107,
      199,
      199,
      201,
      201,
      217,
      217,
      2,
      0,
      191,
      191,
      210,
      210,
      3,
      0,
      174,
      174,
      177,
      178,
      187,
      187,
      4,
      0,
      186,
      186,
      189,
      189,
      206,
      206,
      208,
      208,
      2,
      0,
      199,
      199,
      201,
      201,
      3,
      0,
      194,
      194,
      198,
      198,
      203,
      203,
      2,
      0,
      179,
      179,
      213,
      213,
      3,
      0,
      76,
      76,
      90,
      90,
      210,
      210,
      2,
      0,
      64,
      64,
      156,
      156,
      14,
      0,
      20,
      20,
      42,
      42,
      65,
      65,
      75,
      75,
      84,
      84,
      93,
      93,
      95,
      95,
      97,
      97,
      101,
      101,
      103,
      103,
      121,
      121,
      143,
      143,
      157,
      157,
      163,
      163,
      1,
      0,
      122,
      124,
      2,
      0,
      139,
      139,
      185,
      185,
      2,
      0,
      34,
      34,
      217,
      217,
      2,
      0,
      31,
      31,
      120,
      120,
      2,
      0,
      39,
      39,
      163,
      163,
      3,
      0,
      80,
      80,
      83,
      83,
      114,
      114,
      2,
      0,
      148,
      148,
      185,
      185,
      2,
      0,
      128,
      128,
      175,
      175,
      2,
      0,
      42,
      42,
      188,
      188,
      2,
      0,
      125,
      125,
      176,
      176,
      2,
      0,
      184,
      184,
      207,
      207,
      2,
      0,
      102,
      102,
      210,
      210,
      2,
      0,
      2,
      2,
      165,
      165,
      2,
      0,
      137,
      137,
      153,
      153,
      2,
      0,
      6,
      6,
      18,
      18,
      2,
      0,
      17,
      17,
      132,
      132,
      4801,
      0,
      919,
      1,
      0,
      0,
      0,
      2,
      1005,
      1,
      0,
      0,
      0,
      4,
      1007,
      1,
      0,
      0,
      0,
      6,
      1036,
      1,
      0,
      0,
      0,
      8,
      1041,
      1,
      0,
      0,
      0,
      10,
      1043,
      1,
      0,
      0,
      0,
      12,
      1045,
      1,
      0,
      0,
      0,
      14,
      1049,
      1,
      0,
      0,
      0,
      16,
      1053,
      1,
      0,
      0,
      0,
      18,
      1060,
      1,
      0,
      0,
      0,
      20,
      1068,
      1,
      0,
      0,
      0,
      22,
      1076,
      1,
      0,
      0,
      0,
      24,
      1085,
      1,
      0,
      0,
      0,
      26,
      1087,
      1,
      0,
      0,
      0,
      28,
      1089,
      1,
      0,
      0,
      0,
      30,
      1091,
      1,
      0,
      0,
      0,
      32,
      1093,
      1,
      0,
      0,
      0,
      34,
      1095,
      1,
      0,
      0,
      0,
      36,
      1097,
      1,
      0,
      0,
      0,
      38,
      1099,
      1,
      0,
      0,
      0,
      40,
      1104,
      1,
      0,
      0,
      0,
      42,
      1106,
      1,
      0,
      0,
      0,
      44,
      1118,
      1,
      0,
      0,
      0,
      46,
      1137,
      1,
      0,
      0,
      0,
      48,
      1141,
      1,
      0,
      0,
      0,
      50,
      1145,
      1,
      0,
      0,
      0,
      52,
      1189,
      1,
      0,
      0,
      0,
      54,
      1191,
      1,
      0,
      0,
      0,
      56,
      1193,
      1,
      0,
      0,
      0,
      58,
      1199,
      1,
      0,
      0,
      0,
      60,
      1216,
      1,
      0,
      0,
      0,
      62,
      1224,
      1,
      0,
      0,
      0,
      64,
      1238,
      1,
      0,
      0,
      0,
      66,
      1247,
      1,
      0,
      0,
      0,
      68,
      1255,
      1,
      0,
      0,
      0,
      70,
      1261,
      1,
      0,
      0,
      0,
      72,
      1274,
      1,
      0,
      0,
      0,
      74,
      1279,
      1,
      0,
      0,
      0,
      76,
      1282,
      1,
      0,
      0,
      0,
      78,
      1284,
      1,
      0,
      0,
      0,
      80,
      1288,
      1,
      0,
      0,
      0,
      82,
      1290,
      1,
      0,
      0,
      0,
      84,
      1293,
      1,
      0,
      0,
      0,
      86,
      1296,
      1,
      0,
      0,
      0,
      88,
      1313,
      1,
      0,
      0,
      0,
      90,
      1326,
      1,
      0,
      0,
      0,
      92,
      1337,
      1,
      0,
      0,
      0,
      94,
      1339,
      1,
      0,
      0,
      0,
      96,
      1352,
      1,
      0,
      0,
      0,
      98,
      1366,
      1,
      0,
      0,
      0,
      100,
      1368,
      1,
      0,
      0,
      0,
      102,
      1374,
      1,
      0,
      0,
      0,
      104,
      1402,
      1,
      0,
      0,
      0,
      106,
      1414,
      1,
      0,
      0,
      0,
      108,
      1416,
      1,
      0,
      0,
      0,
      110,
      1422,
      1,
      0,
      0,
      0,
      112,
      1431,
      1,
      0,
      0,
      0,
      114,
      1451,
      1,
      0,
      0,
      0,
      116,
      1460,
      1,
      0,
      0,
      0,
      118,
      1467,
      1,
      0,
      0,
      0,
      120,
      1469,
      1,
      0,
      0,
      0,
      122,
      1479,
      1,
      0,
      0,
      0,
      124,
      1488,
      1,
      0,
      0,
      0,
      126,
      1497,
      1,
      0,
      0,
      0,
      128,
      1515,
      1,
      0,
      0,
      0,
      130,
      1521,
      1,
      0,
      0,
      0,
      132,
      1527,
      1,
      0,
      0,
      0,
      134,
      1535,
      1,
      0,
      0,
      0,
      136,
      1537,
      1,
      0,
      0,
      0,
      138,
      1545,
      1,
      0,
      0,
      0,
      140,
      1557,
      1,
      0,
      0,
      0,
      142,
      1579,
      1,
      0,
      0,
      0,
      144,
      1591,
      1,
      0,
      0,
      0,
      146,
      1613,
      1,
      0,
      0,
      0,
      148,
      1621,
      1,
      0,
      0,
      0,
      150,
      1629,
      1,
      0,
      0,
      0,
      152,
      1637,
      1,
      0,
      0,
      0,
      154,
      1647,
      1,
      0,
      0,
      0,
      156,
      1649,
      1,
      0,
      0,
      0,
      158,
      1653,
      1,
      0,
      0,
      0,
      160,
      1656,
      1,
      0,
      0,
      0,
      162,
      1662,
      1,
      0,
      0,
      0,
      164,
      1680,
      1,
      0,
      0,
      0,
      166,
      1693,
      1,
      0,
      0,
      0,
      168,
      1701,
      1,
      0,
      0,
      0,
      170,
      1720,
      1,
      0,
      0,
      0,
      172,
      1728,
      1,
      0,
      0,
      0,
      174,
      1733,
      1,
      0,
      0,
      0,
      176,
      1751,
      1,
      0,
      0,
      0,
      178,
      1759,
      1,
      0,
      0,
      0,
      180,
      1768,
      1,
      0,
      0,
      0,
      182,
      1770,
      1,
      0,
      0,
      0,
      184,
      1773,
      1,
      0,
      0,
      0,
      186,
      1797,
      1,
      0,
      0,
      0,
      188,
      1803,
      1,
      0,
      0,
      0,
      190,
      1805,
      1,
      0,
      0,
      0,
      192,
      1814,
      1,
      0,
      0,
      0,
      194,
      1818,
      1,
      0,
      0,
      0,
      196,
      1849,
      1,
      0,
      0,
      0,
      198,
      1872,
      1,
      0,
      0,
      0,
      200,
      1879,
      1,
      0,
      0,
      0,
      202,
      1881,
      1,
      0,
      0,
      0,
      204,
      1894,
      1,
      0,
      0,
      0,
      206,
      1898,
      1,
      0,
      0,
      0,
      208,
      1906,
      1,
      0,
      0,
      0,
      210,
      1909,
      1,
      0,
      0,
      0,
      212,
      1912,
      1,
      0,
      0,
      0,
      214,
      1915,
      1,
      0,
      0,
      0,
      216,
      1923,
      1,
      0,
      0,
      0,
      218,
      1944,
      1,
      0,
      0,
      0,
      220,
      1946,
      1,
      0,
      0,
      0,
      222,
      1958,
      1,
      0,
      0,
      0,
      224,
      1966,
      1,
      0,
      0,
      0,
      226,
      1974,
      1,
      0,
      0,
      0,
      228,
      1982,
      1,
      0,
      0,
      0,
      230,
      1994,
      1,
      0,
      0,
      0,
      232,
      2002,
      1,
      0,
      0,
      0,
      234,
      2014,
      1,
      0,
      0,
      0,
      236,
      2036,
      1,
      0,
      0,
      0,
      238,
      2044,
      1,
      0,
      0,
      0,
      240,
      2056,
      1,
      0,
      0,
      0,
      242,
      2058,
      1,
      0,
      0,
      0,
      244,
      2063,
      1,
      0,
      0,
      0,
      246,
      2068,
      1,
      0,
      0,
      0,
      248,
      2073,
      1,
      0,
      0,
      0,
      250,
      2078,
      1,
      0,
      0,
      0,
      252,
      2084,
      1,
      0,
      0,
      0,
      254,
      2099,
      1,
      0,
      0,
      0,
      256,
      2109,
      1,
      0,
      0,
      0,
      258,
      2116,
      1,
      0,
      0,
      0,
      260,
      2131,
      1,
      0,
      0,
      0,
      262,
      2134,
      1,
      0,
      0,
      0,
      264,
      2143,
      1,
      0,
      0,
      0,
      266,
      2145,
      1,
      0,
      0,
      0,
      268,
      2147,
      1,
      0,
      0,
      0,
      270,
      2172,
      1,
      0,
      0,
      0,
      272,
      2174,
      1,
      0,
      0,
      0,
      274,
      2199,
      1,
      0,
      0,
      0,
      276,
      2201,
      1,
      0,
      0,
      0,
      278,
      2206,
      1,
      0,
      0,
      0,
      280,
      2214,
      1,
      0,
      0,
      0,
      282,
      2224,
      1,
      0,
      0,
      0,
      284,
      2231,
      1,
      0,
      0,
      0,
      286,
      2237,
      1,
      0,
      0,
      0,
      288,
      2241,
      1,
      0,
      0,
      0,
      290,
      2244,
      1,
      0,
      0,
      0,
      292,
      2252,
      1,
      0,
      0,
      0,
      294,
      2257,
      1,
      0,
      0,
      0,
      296,
      2265,
      1,
      0,
      0,
      0,
      298,
      2276,
      1,
      0,
      0,
      0,
      300,
      2284,
      1,
      0,
      0,
      0,
      302,
      2289,
      1,
      0,
      0,
      0,
      304,
      2294,
      1,
      0,
      0,
      0,
      306,
      2339,
      1,
      0,
      0,
      0,
      308,
      2341,
      1,
      0,
      0,
      0,
      310,
      2362,
      1,
      0,
      0,
      0,
      312,
      2384,
      1,
      0,
      0,
      0,
      314,
      2386,
      1,
      0,
      0,
      0,
      316,
      2388,
      1,
      0,
      0,
      0,
      318,
      2396,
      1,
      0,
      0,
      0,
      320,
      2404,
      1,
      0,
      0,
      0,
      322,
      2410,
      1,
      0,
      0,
      0,
      324,
      2412,
      1,
      0,
      0,
      0,
      326,
      2419,
      1,
      0,
      0,
      0,
      328,
      2426,
      1,
      0,
      0,
      0,
      330,
      2428,
      1,
      0,
      0,
      0,
      332,
      2430,
      1,
      0,
      0,
      0,
      334,
      2441,
      1,
      0,
      0,
      0,
      336,
      2443,
      1,
      0,
      0,
      0,
      338,
      2452,
      1,
      0,
      0,
      0,
      340,
      2458,
      1,
      0,
      0,
      0,
      342,
      2460,
      1,
      0,
      0,
      0,
      344,
      2465,
      1,
      0,
      0,
      0,
      346,
      2491,
      1,
      0,
      0,
      0,
      348,
      2515,
      1,
      0,
      0,
      0,
      350,
      2521,
      1,
      0,
      0,
      0,
      352,
      2523,
      1,
      0,
      0,
      0,
      354,
      2526,
      1,
      0,
      0,
      0,
      356,
      2543,
      1,
      0,
      0,
      0,
      358,
      2550,
      1,
      0,
      0,
      0,
      360,
      2562,
      1,
      0,
      0,
      0,
      362,
      2575,
      1,
      0,
      0,
      0,
      364,
      2577,
      1,
      0,
      0,
      0,
      366,
      2586,
      1,
      0,
      0,
      0,
      368,
      2605,
      1,
      0,
      0,
      0,
      370,
      2611,
      1,
      0,
      0,
      0,
      372,
      2613,
      1,
      0,
      0,
      0,
      374,
      2648,
      1,
      0,
      0,
      0,
      376,
      2652,
      1,
      0,
      0,
      0,
      378,
      2654,
      1,
      0,
      0,
      0,
      380,
      2656,
      1,
      0,
      0,
      0,
      382,
      2659,
      1,
      0,
      0,
      0,
      384,
      2667,
      1,
      0,
      0,
      0,
      386,
      2671,
      1,
      0,
      0,
      0,
      388,
      2685,
      1,
      0,
      0,
      0,
      390,
      2703,
      1,
      0,
      0,
      0,
      392,
      2723,
      1,
      0,
      0,
      0,
      394,
      2725,
      1,
      0,
      0,
      0,
      396,
      2728,
      1,
      0,
      0,
      0,
      398,
      2732,
      1,
      0,
      0,
      0,
      400,
      2735,
      1,
      0,
      0,
      0,
      402,
      2738,
      1,
      0,
      0,
      0,
      404,
      2742,
      1,
      0,
      0,
      0,
      406,
      2753,
      1,
      0,
      0,
      0,
      408,
      2757,
      1,
      0,
      0,
      0,
      410,
      2760,
      1,
      0,
      0,
      0,
      412,
      2764,
      1,
      0,
      0,
      0,
      414,
      2766,
      1,
      0,
      0,
      0,
      416,
      2774,
      1,
      0,
      0,
      0,
      418,
      2783,
      1,
      0,
      0,
      0,
      420,
      2786,
      1,
      0,
      0,
      0,
      422,
      2790,
      1,
      0,
      0,
      0,
      424,
      2792,
      1,
      0,
      0,
      0,
      426,
      2797,
      1,
      0,
      0,
      0,
      428,
      2802,
      1,
      0,
      0,
      0,
      430,
      2806,
      1,
      0,
      0,
      0,
      432,
      2823,
      1,
      0,
      0,
      0,
      434,
      2825,
      1,
      0,
      0,
      0,
      436,
      2839,
      1,
      0,
      0,
      0,
      438,
      2856,
      1,
      0,
      0,
      0,
      440,
      2874,
      1,
      0,
      0,
      0,
      442,
      2897,
      1,
      0,
      0,
      0,
      444,
      2899,
      1,
      0,
      0,
      0,
      446,
      2908,
      1,
      0,
      0,
      0,
      448,
      2913,
      1,
      0,
      0,
      0,
      450,
      2920,
      1,
      0,
      0,
      0,
      452,
      2938,
      1,
      0,
      0,
      0,
      454,
      2943,
      1,
      0,
      0,
      0,
      456,
      2950,
      1,
      0,
      0,
      0,
      458,
      2954,
      1,
      0,
      0,
      0,
      460,
      2959,
      1,
      0,
      0,
      0,
      462,
      2971,
      1,
      0,
      0,
      0,
      464,
      2977,
      1,
      0,
      0,
      0,
      466,
      2990,
      1,
      0,
      0,
      0,
      468,
      2992,
      1,
      0,
      0,
      0,
      470,
      3005,
      1,
      0,
      0,
      0,
      472,
      3009,
      1,
      0,
      0,
      0,
      474,
      3019,
      1,
      0,
      0,
      0,
      476,
      3032,
      1,
      0,
      0,
      0,
      478,
      3034,
      1,
      0,
      0,
      0,
      480,
      3048,
      1,
      0,
      0,
      0,
      482,
      3051,
      1,
      0,
      0,
      0,
      484,
      3053,
      1,
      0,
      0,
      0,
      486,
      3056,
      1,
      0,
      0,
      0,
      488,
      3058,
      1,
      0,
      0,
      0,
      490,
      3063,
      1,
      0,
      0,
      0,
      492,
      3067,
      1,
      0,
      0,
      0,
      494,
      3072,
      1,
      0,
      0,
      0,
      496,
      3076,
      1,
      0,
      0,
      0,
      498,
      3082,
      1,
      0,
      0,
      0,
      500,
      3084,
      1,
      0,
      0,
      0,
      502,
      3086,
      1,
      0,
      0,
      0,
      504,
      3090,
      1,
      0,
      0,
      0,
      506,
      3093,
      1,
      0,
      0,
      0,
      508,
      3098,
      1,
      0,
      0,
      0,
      510,
      3118,
      1,
      0,
      0,
      0,
      512,
      3120,
      1,
      0,
      0,
      0,
      514,
      3124,
      1,
      0,
      0,
      0,
      516,
      3137,
      1,
      0,
      0,
      0,
      518,
      3150,
      1,
      0,
      0,
      0,
      520,
      3163,
      1,
      0,
      0,
      0,
      522,
      3178,
      1,
      0,
      0,
      0,
      524,
      3189,
      1,
      0,
      0,
      0,
      526,
      3191,
      1,
      0,
      0,
      0,
      528,
      3199,
      1,
      0,
      0,
      0,
      530,
      3201,
      1,
      0,
      0,
      0,
      532,
      3208,
      1,
      0,
      0,
      0,
      534,
      3210,
      1,
      0,
      0,
      0,
      536,
      3213,
      1,
      0,
      0,
      0,
      538,
      3229,
      1,
      0,
      0,
      0,
      540,
      3233,
      1,
      0,
      0,
      0,
      542,
      3235,
      1,
      0,
      0,
      0,
      544,
      3239,
      1,
      0,
      0,
      0,
      546,
      3252,
      1,
      0,
      0,
      0,
      548,
      3255,
      1,
      0,
      0,
      0,
      550,
      3264,
      1,
      0,
      0,
      0,
      552,
      3269,
      1,
      0,
      0,
      0,
      554,
      3283,
      1,
      0,
      0,
      0,
      556,
      3285,
      1,
      0,
      0,
      0,
      558,
      3290,
      1,
      0,
      0,
      0,
      560,
      3316,
      1,
      0,
      0,
      0,
      562,
      3318,
      1,
      0,
      0,
      0,
      564,
      3320,
      1,
      0,
      0,
      0,
      566,
      3322,
      1,
      0,
      0,
      0,
      568,
      3327,
      1,
      0,
      0,
      0,
      570,
      3333,
      1,
      0,
      0,
      0,
      572,
      3335,
      1,
      0,
      0,
      0,
      574,
      3337,
      1,
      0,
      0,
      0,
      576,
      3352,
      1,
      0,
      0,
      0,
      578,
      3373,
      1,
      0,
      0,
      0,
      580,
      3384,
      1,
      0,
      0,
      0,
      582,
      3388,
      1,
      0,
      0,
      0,
      584,
      3390,
      1,
      0,
      0,
      0,
      586,
      3395,
      1,
      0,
      0,
      0,
      588,
      3398,
      1,
      0,
      0,
      0,
      590,
      3401,
      1,
      0,
      0,
      0,
      592,
      3404,
      1,
      0,
      0,
      0,
      594,
      3410,
      1,
      0,
      0,
      0,
      596,
      3415,
      1,
      0,
      0,
      0,
      598,
      3428,
      1,
      0,
      0,
      0,
      600,
      3441,
      1,
      0,
      0,
      0,
      602,
      3443,
      1,
      0,
      0,
      0,
      604,
      3447,
      1,
      0,
      0,
      0,
      606,
      3455,
      1,
      0,
      0,
      0,
      608,
      3457,
      1,
      0,
      0,
      0,
      610,
      3470,
      1,
      0,
      0,
      0,
      612,
      3477,
      1,
      0,
      0,
      0,
      614,
      3484,
      1,
      0,
      0,
      0,
      616,
      3491,
      1,
      0,
      0,
      0,
      618,
      3498,
      1,
      0,
      0,
      0,
      620,
      3503,
      1,
      0,
      0,
      0,
      622,
      3508,
      1,
      0,
      0,
      0,
      624,
      3513,
      1,
      0,
      0,
      0,
      626,
      3523,
      1,
      0,
      0,
      0,
      628,
      3525,
      1,
      0,
      0,
      0,
      630,
      3527,
      1,
      0,
      0,
      0,
      632,
      3533,
      1,
      0,
      0,
      0,
      634,
      3535,
      1,
      0,
      0,
      0,
      636,
      3554,
      1,
      0,
      0,
      0,
      638,
      3571,
      1,
      0,
      0,
      0,
      640,
      3573,
      1,
      0,
      0,
      0,
      642,
      3575,
      1,
      0,
      0,
      0,
      644,
      3577,
      1,
      0,
      0,
      0,
      646,
      3579,
      1,
      0,
      0,
      0,
      648,
      3581,
      1,
      0,
      0,
      0,
      650,
      3586,
      1,
      0,
      0,
      0,
      652,
      3594,
      1,
      0,
      0,
      0,
      654,
      3599,
      1,
      0,
      0,
      0,
      656,
      3601,
      1,
      0,
      0,
      0,
      658,
      3603,
      1,
      0,
      0,
      0,
      660,
      3613,
      1,
      0,
      0,
      0,
      662,
      3624,
      1,
      0,
      0,
      0,
      664,
      3626,
      1,
      0,
      0,
      0,
      666,
      3632,
      1,
      0,
      0,
      0,
      668,
      3643,
      1,
      0,
      0,
      0,
      670,
      3645,
      1,
      0,
      0,
      0,
      672,
      3659,
      1,
      0,
      0,
      0,
      674,
      3667,
      1,
      0,
      0,
      0,
      676,
      3672,
      1,
      0,
      0,
      0,
      678,
      3676,
      1,
      0,
      0,
      0,
      680,
      3680,
      1,
      0,
      0,
      0,
      682,
      3684,
      1,
      0,
      0,
      0,
      684,
      3691,
      1,
      0,
      0,
      0,
      686,
      3700,
      1,
      0,
      0,
      0,
      688,
      3718,
      1,
      0,
      0,
      0,
      690,
      3741,
      1,
      0,
      0,
      0,
      692,
      3743,
      1,
      0,
      0,
      0,
      694,
      3747,
      1,
      0,
      0,
      0,
      696,
      3751,
      1,
      0,
      0,
      0,
      698,
      3755,
      1,
      0,
      0,
      0,
      700,
      3770,
      1,
      0,
      0,
      0,
      702,
      3772,
      1,
      0,
      0,
      0,
      704,
      3775,
      1,
      0,
      0,
      0,
      706,
      3778,
      1,
      0,
      0,
      0,
      708,
      3781,
      1,
      0,
      0,
      0,
      710,
      3784,
      1,
      0,
      0,
      0,
      712,
      3787,
      1,
      0,
      0,
      0,
      714,
      3790,
      1,
      0,
      0,
      0,
      716,
      3807,
      1,
      0,
      0,
      0,
      718,
      3809,
      1,
      0,
      0,
      0,
      720,
      3826,
      1,
      0,
      0,
      0,
      722,
      3850,
      1,
      0,
      0,
      0,
      724,
      3881,
      1,
      0,
      0,
      0,
      726,
      3884,
      1,
      0,
      0,
      0,
      728,
      3886,
      1,
      0,
      0,
      0,
      730,
      3889,
      1,
      0,
      0,
      0,
      732,
      3897,
      1,
      0,
      0,
      0,
      734,
      3899,
      1,
      0,
      0,
      0,
      736,
      3910,
      1,
      0,
      0,
      0,
      738,
      3921,
      1,
      0,
      0,
      0,
      740,
      3932,
      1,
      0,
      0,
      0,
      742,
      3943,
      1,
      0,
      0,
      0,
      744,
      3945,
      1,
      0,
      0,
      0,
      746,
      3948,
      1,
      0,
      0,
      0,
      748,
      3950,
      1,
      0,
      0,
      0,
      750,
      3956,
      1,
      0,
      0,
      0,
      752,
      3966,
      1,
      0,
      0,
      0,
      754,
      3971,
      1,
      0,
      0,
      0,
      756,
      3979,
      1,
      0,
      0,
      0,
      758,
      3981,
      1,
      0,
      0,
      0,
      760,
      3985,
      1,
      0,
      0,
      0,
      762,
      3991,
      1,
      0,
      0,
      0,
      764,
      3996,
      1,
      0,
      0,
      0,
      766,
      4012,
      1,
      0,
      0,
      0,
      768,
      4017,
      1,
      0,
      0,
      0,
      770,
      4032,
      1,
      0,
      0,
      0,
      772,
      4041,
      1,
      0,
      0,
      0,
      774,
      4043,
      1,
      0,
      0,
      0,
      776,
      4046,
      1,
      0,
      0,
      0,
      778,
      4055,
      1,
      0,
      0,
      0,
      780,
      4059,
      1,
      0,
      0,
      0,
      782,
      4084,
      1,
      0,
      0,
      0,
      784,
      4086,
      1,
      0,
      0,
      0,
      786,
      4113,
      1,
      0,
      0,
      0,
      788,
      4115,
      1,
      0,
      0,
      0,
      790,
      4118,
      1,
      0,
      0,
      0,
      792,
      4127,
      1,
      0,
      0,
      0,
      794,
      4130,
      1,
      0,
      0,
      0,
      796,
      4139,
      1,
      0,
      0,
      0,
      798,
      4144,
      1,
      0,
      0,
      0,
      800,
      4172,
      1,
      0,
      0,
      0,
      802,
      4174,
      1,
      0,
      0,
      0,
      804,
      4176,
      1,
      0,
      0,
      0,
      806,
      4178,
      1,
      0,
      0,
      0,
      808,
      4180,
      1,
      0,
      0,
      0,
      810,
      4186,
      1,
      0,
      0,
      0,
      812,
      4191,
      1,
      0,
      0,
      0,
      814,
      4197,
      1,
      0,
      0,
      0,
      816,
      4214,
      1,
      0,
      0,
      0,
      818,
      4221,
      1,
      0,
      0,
      0,
      820,
      4223,
      1,
      0,
      0,
      0,
      822,
      4230,
      1,
      0,
      0,
      0,
      824,
      4236,
      1,
      0,
      0,
      0,
      826,
      4242,
      1,
      0,
      0,
      0,
      828,
      4247,
      1,
      0,
      0,
      0,
      830,
      4253,
      1,
      0,
      0,
      0,
      832,
      4258,
      1,
      0,
      0,
      0,
      834,
      4288,
      1,
      0,
      0,
      0,
      836,
      4290,
      1,
      0,
      0,
      0,
      838,
      4297,
      1,
      0,
      0,
      0,
      840,
      4303,
      1,
      0,
      0,
      0,
      842,
      4321,
      1,
      0,
      0,
      0,
      844,
      4336,
      1,
      0,
      0,
      0,
      846,
      4341,
      1,
      0,
      0,
      0,
      848,
      4343,
      1,
      0,
      0,
      0,
      850,
      4368,
      1,
      0,
      0,
      0,
      852,
      4370,
      1,
      0,
      0,
      0,
      854,
      4389,
      1,
      0,
      0,
      0,
      856,
      4395,
      1,
      0,
      0,
      0,
      858,
      4397,
      1,
      0,
      0,
      0,
      860,
      4404,
      1,
      0,
      0,
      0,
      862,
      4406,
      1,
      0,
      0,
      0,
      864,
      4408,
      1,
      0,
      0,
      0,
      866,
      4414,
      1,
      0,
      0,
      0,
      868,
      4419,
      1,
      0,
      0,
      0,
      870,
      4424,
      1,
      0,
      0,
      0,
      872,
      4429,
      1,
      0,
      0,
      0,
      874,
      4441,
      1,
      0,
      0,
      0,
      876,
      4443,
      1,
      0,
      0,
      0,
      878,
      4446,
      1,
      0,
      0,
      0,
      880,
      4461,
      1,
      0,
      0,
      0,
      882,
      4471,
      1,
      0,
      0,
      0,
      884,
      4481,
      1,
      0,
      0,
      0,
      886,
      4483,
      1,
      0,
      0,
      0,
      888,
      4491,
      1,
      0,
      0,
      0,
      890,
      4496,
      1,
      0,
      0,
      0,
      892,
      4498,
      1,
      0,
      0,
      0,
      894,
      4500,
      1,
      0,
      0,
      0,
      896,
      4502,
      1,
      0,
      0,
      0,
      898,
      4504,
      1,
      0,
      0,
      0,
      900,
      4506,
      1,
      0,
      0,
      0,
      902,
      4508,
      1,
      0,
      0,
      0,
      904,
      905,
      6,
      0,
      -1,
      0,
      905,
      906,
      5,
      77,
      0,
      0,
      906,
      907,
      3,
      0,
      0,
      0,
      907,
      908,
      5,
      209,
      0,
      0,
      908,
      909,
      3,
      0,
      0,
      0,
      909,
      910,
      5,
      55,
      0,
      0,
      910,
      911,
      3,
      0,
      0,
      28,
      911,
      920,
      1,
      0,
      0,
      0,
      912,
      913,
      7,
      0,
      0,
      0,
      913,
      920,
      3,
      0,
      0,
      14,
      914,
      915,
      7,
      1,
      0,
      0,
      915,
      920,
      3,
      2,
      1,
      0,
      916,
      917,
      5,
      8,
      0,
      0,
      917,
      920,
      3,
      2,
      1,
      0,
      918,
      920,
      3,
      6,
      3,
      0,
      919,
      904,
      1,
      0,
      0,
      0,
      919,
      912,
      1,
      0,
      0,
      0,
      919,
      914,
      1,
      0,
      0,
      0,
      919,
      916,
      1,
      0,
      0,
      0,
      919,
      918,
      1,
      0,
      0,
      0,
      920,
      1002,
      1,
      0,
      0,
      0,
      921,
      922,
      10,
      27,
      0,
      0,
      922,
      923,
      5,
      190,
      0,
      0,
      923,
      1001,
      3,
      0,
      0,
      28,
      924,
      925,
      10,
      26,
      0,
      0,
      925,
      926,
      5,
      78,
      0,
      0,
      926,
      1001,
      3,
      0,
      0,
      27,
      927,
      928,
      10,
      25,
      0,
      0,
      928,
      929,
      5,
      112,
      0,
      0,
      929,
      1001,
      3,
      0,
      0,
      26,
      930,
      931,
      10,
      24,
      0,
      0,
      931,
      932,
      5,
      12,
      0,
      0,
      932,
      1001,
      3,
      0,
      0,
      25,
      933,
      934,
      10,
      23,
      0,
      0,
      934,
      935,
      5,
      173,
      0,
      0,
      935,
      1001,
      3,
      0,
      0,
      24,
      936,
      937,
      10,
      22,
      0,
      0,
      937,
      938,
      5,
      215,
      0,
      0,
      938,
      1001,
      3,
      0,
      0,
      23,
      939,
      940,
      10,
      21,
      0,
      0,
      940,
      941,
      5,
      195,
      0,
      0,
      941,
      1001,
      3,
      0,
      0,
      22,
      942,
      943,
      10,
      20,
      0,
      0,
      943,
      944,
      7,
      2,
      0,
      0,
      944,
      1001,
      3,
      0,
      0,
      21,
      945,
      946,
      10,
      19,
      0,
      0,
      946,
      947,
      7,
      3,
      0,
      0,
      947,
      1001,
      3,
      0,
      0,
      20,
      948,
      949,
      10,
      18,
      0,
      0,
      949,
      950,
      5,
      181,
      0,
      0,
      950,
      1001,
      3,
      0,
      0,
      19,
      951,
      952,
      10,
      17,
      0,
      0,
      952,
      953,
      7,
      4,
      0,
      0,
      953,
      1001,
      3,
      0,
      0,
      18,
      954,
      955,
      10,
      16,
      0,
      0,
      955,
      956,
      7,
      5,
      0,
      0,
      956,
      1001,
      3,
      0,
      0,
      17,
      957,
      958,
      10,
      15,
      0,
      0,
      958,
      959,
      7,
      6,
      0,
      0,
      959,
      1001,
      3,
      0,
      0,
      15,
      960,
      961,
      10,
      12,
      0,
      0,
      961,
      962,
      7,
      7,
      0,
      0,
      962,
      1001,
      3,
      2,
      1,
      0,
      963,
      964,
      10,
      11,
      0,
      0,
      964,
      965,
      5,
      13,
      0,
      0,
      965,
      1001,
      3,
      2,
      1,
      0,
      966,
      967,
      10,
      10,
      0,
      0,
      967,
      968,
      5,
      191,
      0,
      0,
      968,
      1001,
      3,
      2,
      1,
      0,
      969,
      970,
      10,
      9,
      0,
      0,
      970,
      971,
      5,
      100,
      0,
      0,
      971,
      1001,
      3,
      2,
      1,
      0,
      972,
      973,
      10,
      8,
      0,
      0,
      973,
      975,
      5,
      211,
      0,
      0,
      974,
      976,
      3,
      4,
      2,
      0,
      975,
      974,
      1,
      0,
      0,
      0,
      975,
      976,
      1,
      0,
      0,
      0,
      976,
      977,
      1,
      0,
      0,
      0,
      977,
      1001,
      5,
      212,
      0,
      0,
      978,
      979,
      10,
      7,
      0,
      0,
      979,
      980,
      5,
      192,
      0,
      0,
      980,
      982,
      5,
      196,
      0,
      0,
      981,
      983,
      3,
      4,
      2,
      0,
      982,
      981,
      1,
      0,
      0,
      0,
      982,
      983,
      1,
      0,
      0,
      0,
      983,
      984,
      1,
      0,
      0,
      0,
      984,
      1001,
      5,
      197,
      0,
      0,
      985,
      986,
      10,
      6,
      0,
      0,
      986,
      1001,
      3,
      16,
      8,
      0,
      987,
      988,
      10,
      5,
      0,
      0,
      988,
      989,
      5,
      202,
      0,
      0,
      989,
      1001,
      3,
      88,
      44,
      0,
      990,
      991,
      10,
      4,
      0,
      0,
      991,
      992,
      5,
      182,
      0,
      0,
      992,
      1001,
      3,
      14,
      7,
      0,
      993,
      994,
      10,
      3,
      0,
      0,
      994,
      995,
      5,
      180,
      0,
      0,
      995,
      998,
      3,
      88,
      44,
      0,
      996,
      999,
      3,
      14,
      7,
      0,
      997,
      999,
      3,
      16,
      8,
      0,
      998,
      996,
      1,
      0,
      0,
      0,
      998,
      997,
      1,
      0,
      0,
      0,
      999,
      1001,
      1,
      0,
      0,
      0,
      1e3,
      921,
      1,
      0,
      0,
      0,
      1e3,
      924,
      1,
      0,
      0,
      0,
      1e3,
      927,
      1,
      0,
      0,
      0,
      1e3,
      930,
      1,
      0,
      0,
      0,
      1e3,
      933,
      1,
      0,
      0,
      0,
      1e3,
      936,
      1,
      0,
      0,
      0,
      1e3,
      939,
      1,
      0,
      0,
      0,
      1e3,
      942,
      1,
      0,
      0,
      0,
      1e3,
      945,
      1,
      0,
      0,
      0,
      1e3,
      948,
      1,
      0,
      0,
      0,
      1e3,
      951,
      1,
      0,
      0,
      0,
      1e3,
      954,
      1,
      0,
      0,
      0,
      1e3,
      957,
      1,
      0,
      0,
      0,
      1e3,
      960,
      1,
      0,
      0,
      0,
      1e3,
      963,
      1,
      0,
      0,
      0,
      1e3,
      966,
      1,
      0,
      0,
      0,
      1e3,
      969,
      1,
      0,
      0,
      0,
      1e3,
      972,
      1,
      0,
      0,
      0,
      1e3,
      978,
      1,
      0,
      0,
      0,
      1e3,
      985,
      1,
      0,
      0,
      0,
      1e3,
      987,
      1,
      0,
      0,
      0,
      1e3,
      990,
      1,
      0,
      0,
      0,
      1e3,
      993,
      1,
      0,
      0,
      0,
      1001,
      1004,
      1,
      0,
      0,
      0,
      1002,
      1e3,
      1,
      0,
      0,
      0,
      1002,
      1003,
      1,
      0,
      0,
      0,
      1003,
      1,
      1,
      0,
      0,
      0,
      1004,
      1002,
      1,
      0,
      0,
      0,
      1005,
      1006,
      3,
      88,
      44,
      0,
      1006,
      3,
      1,
      0,
      0,
      0,
      1007,
      1012,
      3,
      0,
      0,
      0,
      1008,
      1009,
      5,
      200,
      0,
      0,
      1009,
      1011,
      3,
      0,
      0,
      0,
      1010,
      1008,
      1,
      0,
      0,
      0,
      1011,
      1014,
      1,
      0,
      0,
      0,
      1012,
      1010,
      1,
      0,
      0,
      0,
      1012,
      1013,
      1,
      0,
      0,
      0,
      1013,
      5,
      1,
      0,
      0,
      0,
      1014,
      1012,
      1,
      0,
      0,
      0,
      1015,
      1037,
      3,
      8,
      4,
      0,
      1016,
      1037,
      5,
      223,
      0,
      0,
      1017,
      1037,
      3,
      24,
      12,
      0,
      1018,
      1022,
      3,
      88,
      44,
      0,
      1019,
      1023,
      3,
      16,
      8,
      0,
      1020,
      1021,
      5,
      202,
      0,
      0,
      1021,
      1023,
      5,
      102,
      0,
      0,
      1022,
      1019,
      1,
      0,
      0,
      0,
      1022,
      1020,
      1,
      0,
      0,
      0,
      1022,
      1023,
      1,
      0,
      0,
      0,
      1023,
      1037,
      1,
      0,
      0,
      0,
      1024,
      1037,
      3,
      12,
      6,
      0,
      1025,
      1037,
      3,
      14,
      7,
      0,
      1026,
      1027,
      5,
      196,
      0,
      0,
      1027,
      1028,
      5,
      13,
      0,
      0,
      1028,
      1029,
      3,
      2,
      1,
      0,
      1029,
      1030,
      5,
      197,
      0,
      0,
      1030,
      1037,
      1,
      0,
      0,
      0,
      1031,
      1033,
      5,
      196,
      0,
      0,
      1032,
      1034,
      3,
      4,
      2,
      0,
      1033,
      1032,
      1,
      0,
      0,
      0,
      1033,
      1034,
      1,
      0,
      0,
      0,
      1034,
      1035,
      1,
      0,
      0,
      0,
      1035,
      1037,
      5,
      197,
      0,
      0,
      1036,
      1015,
      1,
      0,
      0,
      0,
      1036,
      1016,
      1,
      0,
      0,
      0,
      1036,
      1017,
      1,
      0,
      0,
      0,
      1036,
      1018,
      1,
      0,
      0,
      0,
      1036,
      1024,
      1,
      0,
      0,
      0,
      1036,
      1025,
      1,
      0,
      0,
      0,
      1036,
      1026,
      1,
      0,
      0,
      0,
      1036,
      1031,
      1,
      0,
      0,
      0,
      1037,
      7,
      1,
      0,
      0,
      0,
      1038,
      1042,
      5,
      108,
      0,
      0,
      1039,
      1040,
      5,
      196,
      0,
      0,
      1040,
      1042,
      5,
      197,
      0,
      0,
      1041,
      1038,
      1,
      0,
      0,
      0,
      1041,
      1039,
      1,
      0,
      0,
      0,
      1042,
      9,
      1,
      0,
      0,
      0,
      1043,
      1044,
      3,
      88,
      44,
      0,
      1044,
      11,
      1,
      0,
      0,
      0,
      1045,
      1046,
      5,
      105,
      0,
      0,
      1046,
      1047,
      3,
      88,
      44,
      0,
      1047,
      1048,
      3,
      16,
      8,
      0,
      1048,
      13,
      1,
      0,
      0,
      0,
      1049,
      1050,
      5,
      214,
      0,
      0,
      1050,
      1051,
      3,
      284,
      142,
      0,
      1051,
      1052,
      5,
      216,
      0,
      0,
      1052,
      15,
      1,
      0,
      0,
      0,
      1053,
      1056,
      5,
      196,
      0,
      0,
      1054,
      1057,
      3,
      18,
      9,
      0,
      1055,
      1057,
      3,
      20,
      10,
      0,
      1056,
      1054,
      1,
      0,
      0,
      0,
      1056,
      1055,
      1,
      0,
      0,
      0,
      1056,
      1057,
      1,
      0,
      0,
      0,
      1057,
      1058,
      1,
      0,
      0,
      0,
      1058,
      1059,
      5,
      197,
      0,
      0,
      1059,
      17,
      1,
      0,
      0,
      0,
      1060,
      1065,
      3,
      0,
      0,
      0,
      1061,
      1062,
      5,
      200,
      0,
      0,
      1062,
      1064,
      3,
      0,
      0,
      0,
      1063,
      1061,
      1,
      0,
      0,
      0,
      1064,
      1067,
      1,
      0,
      0,
      0,
      1065,
      1063,
      1,
      0,
      0,
      0,
      1065,
      1066,
      1,
      0,
      0,
      0,
      1066,
      19,
      1,
      0,
      0,
      0,
      1067,
      1065,
      1,
      0,
      0,
      0,
      1068,
      1073,
      3,
      22,
      11,
      0,
      1069,
      1070,
      5,
      200,
      0,
      0,
      1070,
      1072,
      3,
      22,
      11,
      0,
      1071,
      1069,
      1,
      0,
      0,
      0,
      1072,
      1075,
      1,
      0,
      0,
      0,
      1073,
      1071,
      1,
      0,
      0,
      0,
      1073,
      1074,
      1,
      0,
      0,
      0,
      1074,
      21,
      1,
      0,
      0,
      0,
      1075,
      1073,
      1,
      0,
      0,
      0,
      1076,
      1077,
      3,
      88,
      44,
      0,
      1077,
      1078,
      5,
      207,
      0,
      0,
      1078,
      1079,
      3,
      0,
      0,
      0,
      1079,
      23,
      1,
      0,
      0,
      0,
      1080,
      1086,
      3,
      26,
      13,
      0,
      1081,
      1086,
      3,
      28,
      14,
      0,
      1082,
      1086,
      3,
      30,
      15,
      0,
      1083,
      1086,
      3,
      32,
      16,
      0,
      1084,
      1086,
      3,
      34,
      17,
      0,
      1085,
      1080,
      1,
      0,
      0,
      0,
      1085,
      1081,
      1,
      0,
      0,
      0,
      1085,
      1082,
      1,
      0,
      0,
      0,
      1085,
      1083,
      1,
      0,
      0,
      0,
      1085,
      1084,
      1,
      0,
      0,
      0,
      1086,
      25,
      1,
      0,
      0,
      0,
      1087,
      1088,
      7,
      8,
      0,
      0,
      1088,
      27,
      1,
      0,
      0,
      0,
      1089,
      1090,
      5,
      220,
      0,
      0,
      1090,
      29,
      1,
      0,
      0,
      0,
      1091,
      1092,
      5,
      221,
      0,
      0,
      1092,
      31,
      1,
      0,
      0,
      0,
      1093,
      1094,
      5,
      222,
      0,
      0,
      1094,
      33,
      1,
      0,
      0,
      0,
      1095,
      1096,
      5,
      198,
      0,
      0,
      1096,
      35,
      1,
      0,
      0,
      0,
      1097,
      1098,
      3,
      0,
      0,
      0,
      1098,
      37,
      1,
      0,
      0,
      0,
      1099,
      1100,
      3,
      0,
      0,
      0,
      1100,
      39,
      1,
      0,
      0,
      0,
      1101,
      1105,
      5,
      218,
      0,
      0,
      1102,
      1105,
      5,
      219,
      0,
      0,
      1103,
      1105,
      3,
      42,
      21,
      0,
      1104,
      1101,
      1,
      0,
      0,
      0,
      1104,
      1102,
      1,
      0,
      0,
      0,
      1104,
      1103,
      1,
      0,
      0,
      0,
      1105,
      41,
      1,
      0,
      0,
      0,
      1106,
      1107,
      7,
      9,
      0,
      0,
      1107,
      43,
      1,
      0,
      0,
      0,
      1108,
      1109,
      5,
      206,
      0,
      0,
      1109,
      1110,
      3,
      40,
      20,
      0,
      1110,
      1111,
      5,
      208,
      0,
      0,
      1111,
      1112,
      3,
      40,
      20,
      0,
      1112,
      1119,
      1,
      0,
      0,
      0,
      1113,
      1114,
      5,
      206,
      0,
      0,
      1114,
      1115,
      3,
      40,
      20,
      0,
      1115,
      1116,
      5,
      208,
      0,
      0,
      1116,
      1119,
      1,
      0,
      0,
      0,
      1117,
      1119,
      3,
      40,
      20,
      0,
      1118,
      1108,
      1,
      0,
      0,
      0,
      1118,
      1113,
      1,
      0,
      0,
      0,
      1118,
      1117,
      1,
      0,
      0,
      0,
      1119,
      45,
      1,
      0,
      0,
      0,
      1120,
      1138,
      5,
      205,
      0,
      0,
      1121,
      1125,
      5,
      214,
      0,
      0,
      1122,
      1124,
      3,
      48,
      24,
      0,
      1123,
      1122,
      1,
      0,
      0,
      0,
      1124,
      1127,
      1,
      0,
      0,
      0,
      1125,
      1123,
      1,
      0,
      0,
      0,
      1125,
      1126,
      1,
      0,
      0,
      0,
      1126,
      1128,
      1,
      0,
      0,
      0,
      1127,
      1125,
      1,
      0,
      0,
      0,
      1128,
      1138,
      5,
      216,
      0,
      0,
      1129,
      1133,
      5,
      214,
      0,
      0,
      1130,
      1132,
      3,
      56,
      28,
      0,
      1131,
      1130,
      1,
      0,
      0,
      0,
      1132,
      1135,
      1,
      0,
      0,
      0,
      1133,
      1131,
      1,
      0,
      0,
      0,
      1133,
      1134,
      1,
      0,
      0,
      0,
      1134,
      1136,
      1,
      0,
      0,
      0,
      1135,
      1133,
      1,
      0,
      0,
      0,
      1136,
      1138,
      5,
      216,
      0,
      0,
      1137,
      1120,
      1,
      0,
      0,
      0,
      1137,
      1121,
      1,
      0,
      0,
      0,
      1137,
      1129,
      1,
      0,
      0,
      0,
      1138,
      47,
      1,
      0,
      0,
      0,
      1139,
      1142,
      3,
      50,
      25,
      0,
      1140,
      1142,
      3,
      56,
      28,
      0,
      1141,
      1139,
      1,
      0,
      0,
      0,
      1141,
      1140,
      1,
      0,
      0,
      0,
      1142,
      49,
      1,
      0,
      0,
      0,
      1143,
      1146,
      3,
      104,
      52,
      0,
      1144,
      1146,
      3,
      106,
      53,
      0,
      1145,
      1143,
      1,
      0,
      0,
      0,
      1145,
      1144,
      1,
      0,
      0,
      0,
      1146,
      51,
      1,
      0,
      0,
      0,
      1147,
      1149,
      3,
      338,
      169,
      0,
      1148,
      1147,
      1,
      0,
      0,
      0,
      1149,
      1152,
      1,
      0,
      0,
      0,
      1150,
      1148,
      1,
      0,
      0,
      0,
      1150,
      1151,
      1,
      0,
      0,
      0,
      1151,
      1153,
      1,
      0,
      0,
      0,
      1152,
      1150,
      1,
      0,
      0,
      0,
      1153,
      1158,
      5,
      48,
      0,
      0,
      1154,
      1156,
      3,
      44,
      22,
      0,
      1155,
      1154,
      1,
      0,
      0,
      0,
      1155,
      1156,
      1,
      0,
      0,
      0,
      1156,
      1157,
      1,
      0,
      0,
      0,
      1157,
      1159,
      5,
      74,
      0,
      0,
      1158,
      1155,
      1,
      0,
      0,
      0,
      1158,
      1159,
      1,
      0,
      0,
      0,
      1159,
      1160,
      1,
      0,
      0,
      0,
      1160,
      1165,
      3,
      88,
      44,
      0,
      1161,
      1162,
      5,
      200,
      0,
      0,
      1162,
      1164,
      3,
      88,
      44,
      0,
      1163,
      1161,
      1,
      0,
      0,
      0,
      1164,
      1167,
      1,
      0,
      0,
      0,
      1165,
      1163,
      1,
      0,
      0,
      0,
      1165,
      1166,
      1,
      0,
      0,
      0,
      1166,
      1168,
      1,
      0,
      0,
      0,
      1167,
      1165,
      1,
      0,
      0,
      0,
      1168,
      1169,
      5,
      154,
      0,
      0,
      1169,
      1174,
      3,
      88,
      44,
      0,
      1170,
      1171,
      5,
      200,
      0,
      0,
      1171,
      1173,
      3,
      88,
      44,
      0,
      1172,
      1170,
      1,
      0,
      0,
      0,
      1173,
      1176,
      1,
      0,
      0,
      0,
      1174,
      1172,
      1,
      0,
      0,
      0,
      1174,
      1175,
      1,
      0,
      0,
      0,
      1175,
      1177,
      1,
      0,
      0,
      0,
      1176,
      1174,
      1,
      0,
      0,
      0,
      1177,
      1178,
      3,
      46,
      23,
      0,
      1178,
      1190,
      1,
      0,
      0,
      0,
      1179,
      1181,
      3,
      338,
      169,
      0,
      1180,
      1179,
      1,
      0,
      0,
      0,
      1181,
      1184,
      1,
      0,
      0,
      0,
      1182,
      1180,
      1,
      0,
      0,
      0,
      1182,
      1183,
      1,
      0,
      0,
      0,
      1183,
      1185,
      1,
      0,
      0,
      0,
      1184,
      1182,
      1,
      0,
      0,
      0,
      1185,
      1186,
      5,
      48,
      0,
      0,
      1186,
      1187,
      3,
      366,
      183,
      0,
      1187,
      1188,
      3,
      46,
      23,
      0,
      1188,
      1190,
      1,
      0,
      0,
      0,
      1189,
      1150,
      1,
      0,
      0,
      0,
      1189,
      1182,
      1,
      0,
      0,
      0,
      1190,
      53,
      1,
      0,
      0,
      0,
      1191,
      1192,
      3,
      88,
      44,
      0,
      1192,
      55,
      1,
      0,
      0,
      0,
      1193,
      1194,
      3,
      58,
      29,
      0,
      1194,
      57,
      1,
      0,
      0,
      0,
      1195,
      1200,
      3,
      60,
      30,
      0,
      1196,
      1200,
      3,
      62,
      31,
      0,
      1197,
      1200,
      3,
      64,
      32,
      0,
      1198,
      1200,
      3,
      344,
      172,
      0,
      1199,
      1195,
      1,
      0,
      0,
      0,
      1199,
      1196,
      1,
      0,
      0,
      0,
      1199,
      1197,
      1,
      0,
      0,
      0,
      1199,
      1198,
      1,
      0,
      0,
      0,
      1200,
      59,
      1,
      0,
      0,
      0,
      1201,
      1203,
      5,
      30,
      0,
      0,
      1202,
      1204,
      3,
      44,
      22,
      0,
      1203,
      1202,
      1,
      0,
      0,
      0,
      1203,
      1204,
      1,
      0,
      0,
      0,
      1204,
      1214,
      1,
      0,
      0,
      0,
      1205,
      1206,
      5,
      1,
      0,
      0,
      1206,
      1211,
      3,
      54,
      27,
      0,
      1207,
      1208,
      5,
      200,
      0,
      0,
      1208,
      1210,
      3,
      54,
      27,
      0,
      1209,
      1207,
      1,
      0,
      0,
      0,
      1210,
      1213,
      1,
      0,
      0,
      0,
      1211,
      1209,
      1,
      0,
      0,
      0,
      1211,
      1212,
      1,
      0,
      0,
      0,
      1212,
      1215,
      1,
      0,
      0,
      0,
      1213,
      1211,
      1,
      0,
      0,
      0,
      1214,
      1205,
      1,
      0,
      0,
      0,
      1214,
      1215,
      1,
      0,
      0,
      0,
      1215,
      1217,
      1,
      0,
      0,
      0,
      1216,
      1201,
      1,
      0,
      0,
      0,
      1216,
      1217,
      1,
      0,
      0,
      0,
      1217,
      1220,
      1,
      0,
      0,
      0,
      1218,
      1219,
      5,
      95,
      0,
      0,
      1219,
      1221,
      5,
      220,
      0,
      0,
      1220,
      1218,
      1,
      0,
      0,
      0,
      1220,
      1221,
      1,
      0,
      0,
      0,
      1221,
      1222,
      1,
      0,
      0,
      0,
      1222,
      1223,
      5,
      223,
      0,
      0,
      1223,
      61,
      1,
      0,
      0,
      0,
      1224,
      1226,
      5,
      54,
      0,
      0,
      1225,
      1227,
      3,
      44,
      22,
      0,
      1226,
      1225,
      1,
      0,
      0,
      0,
      1226,
      1227,
      1,
      0,
      0,
      0,
      1227,
      1230,
      1,
      0,
      0,
      0,
      1228,
      1229,
      5,
      95,
      0,
      0,
      1229,
      1231,
      5,
      220,
      0,
      0,
      1230,
      1228,
      1,
      0,
      0,
      0,
      1230,
      1231,
      1,
      0,
      0,
      0,
      1231,
      1232,
      1,
      0,
      0,
      0,
      1232,
      1233,
      5,
      223,
      0,
      0,
      1233,
      63,
      1,
      0,
      0,
      0,
      1234,
      1236,
      5,
      131,
      0,
      0,
      1235,
      1237,
      3,
      44,
      22,
      0,
      1236,
      1235,
      1,
      0,
      0,
      0,
      1236,
      1237,
      1,
      0,
      0,
      0,
      1237,
      1239,
      1,
      0,
      0,
      0,
      1238,
      1234,
      1,
      0,
      0,
      0,
      1238,
      1239,
      1,
      0,
      0,
      0,
      1239,
      1240,
      1,
      0,
      0,
      0,
      1240,
      1241,
      5,
      93,
      0,
      0,
      1241,
      1242,
      5,
      220,
      0,
      0,
      1242,
      1243,
      5,
      223,
      0,
      0,
      1243,
      65,
      1,
      0,
      0,
      0,
      1244,
      1246,
      3,
      370,
      185,
      0,
      1245,
      1244,
      1,
      0,
      0,
      0,
      1246,
      1249,
      1,
      0,
      0,
      0,
      1247,
      1245,
      1,
      0,
      0,
      0,
      1247,
      1248,
      1,
      0,
      0,
      0,
      1248,
      1250,
      1,
      0,
      0,
      0,
      1249,
      1247,
      1,
      0,
      0,
      0,
      1250,
      1251,
      5,
      0,
      0,
      1,
      1251,
      67,
      1,
      0,
      0,
      0,
      1252,
      1254,
      3,
      340,
      170,
      0,
      1253,
      1252,
      1,
      0,
      0,
      0,
      1254,
      1257,
      1,
      0,
      0,
      0,
      1255,
      1253,
      1,
      0,
      0,
      0,
      1255,
      1256,
      1,
      0,
      0,
      0,
      1256,
      1258,
      1,
      0,
      0,
      0,
      1257,
      1255,
      1,
      0,
      0,
      0,
      1258,
      1259,
      3,
      70,
      35,
      0,
      1259,
      1260,
      3,
      72,
      36,
      0,
      1260,
      69,
      1,
      0,
      0,
      0,
      1261,
      1263,
      5,
      104,
      0,
      0,
      1262,
      1264,
      3,
      44,
      22,
      0,
      1263,
      1262,
      1,
      0,
      0,
      0,
      1263,
      1264,
      1,
      0,
      0,
      0,
      1264,
      71,
      1,
      0,
      0,
      0,
      1265,
      1275,
      5,
      205,
      0,
      0,
      1266,
      1270,
      5,
      214,
      0,
      0,
      1267,
      1269,
      3,
      74,
      37,
      0,
      1268,
      1267,
      1,
      0,
      0,
      0,
      1269,
      1272,
      1,
      0,
      0,
      0,
      1270,
      1268,
      1,
      0,
      0,
      0,
      1270,
      1271,
      1,
      0,
      0,
      0,
      1271,
      1273,
      1,
      0,
      0,
      0,
      1272,
      1270,
      1,
      0,
      0,
      0,
      1273,
      1275,
      5,
      216,
      0,
      0,
      1274,
      1265,
      1,
      0,
      0,
      0,
      1274,
      1266,
      1,
      0,
      0,
      0,
      1275,
      73,
      1,
      0,
      0,
      0,
      1276,
      1280,
      3,
      80,
      40,
      0,
      1277,
      1280,
      3,
      86,
      43,
      0,
      1278,
      1280,
      3,
      90,
      45,
      0,
      1279,
      1276,
      1,
      0,
      0,
      0,
      1279,
      1277,
      1,
      0,
      0,
      0,
      1279,
      1278,
      1,
      0,
      0,
      0,
      1280,
      75,
      1,
      0,
      0,
      0,
      1281,
      1283,
      3,
      78,
      39,
      0,
      1282,
      1281,
      1,
      0,
      0,
      0,
      1282,
      1283,
      1,
      0,
      0,
      0,
      1283,
      77,
      1,
      0,
      0,
      0,
      1284,
      1285,
      7,
      10,
      0,
      0,
      1285,
      79,
      1,
      0,
      0,
      0,
      1286,
      1289,
      3,
      82,
      41,
      0,
      1287,
      1289,
      3,
      84,
      42,
      0,
      1288,
      1286,
      1,
      0,
      0,
      0,
      1288,
      1287,
      1,
      0,
      0,
      0,
      1289,
      81,
      1,
      0,
      0,
      0,
      1290,
      1291,
      3,
      76,
      38,
      0,
      1291,
      1292,
      3,
      102,
      51,
      0,
      1292,
      83,
      1,
      0,
      0,
      0,
      1293,
      1294,
      3,
      76,
      38,
      0,
      1294,
      1295,
      3,
      106,
      53,
      0,
      1295,
      85,
      1,
      0,
      0,
      0,
      1296,
      1297,
      3,
      76,
      38,
      0,
      1297,
      1302,
      5,
      7,
      0,
      0,
      1298,
      1299,
      5,
      206,
      0,
      0,
      1299,
      1300,
      3,
      40,
      20,
      0,
      1300,
      1301,
      5,
      208,
      0,
      0,
      1301,
      1303,
      1,
      0,
      0,
      0,
      1302,
      1298,
      1,
      0,
      0,
      0,
      1302,
      1303,
      1,
      0,
      0,
      0,
      1303,
      1305,
      1,
      0,
      0,
      0,
      1304,
      1306,
      3,
      40,
      20,
      0,
      1305,
      1304,
      1,
      0,
      0,
      0,
      1305,
      1306,
      1,
      0,
      0,
      0,
      1306,
      1307,
      1,
      0,
      0,
      0,
      1307,
      1308,
      5,
      71,
      0,
      0,
      1308,
      1309,
      3,
      88,
      44,
      0,
      1309,
      1310,
      3,
      46,
      23,
      0,
      1310,
      87,
      1,
      0,
      0,
      0,
      1311,
      1312,
      5,
      193,
      0,
      0,
      1312,
      1314,
      5,
      183,
      0,
      0,
      1313,
      1311,
      1,
      0,
      0,
      0,
      1313,
      1314,
      1,
      0,
      0,
      0,
      1314,
      1320,
      1,
      0,
      0,
      0,
      1315,
      1316,
      3,
      40,
      20,
      0,
      1316,
      1317,
      5,
      183,
      0,
      0,
      1317,
      1319,
      1,
      0,
      0,
      0,
      1318,
      1315,
      1,
      0,
      0,
      0,
      1319,
      1322,
      1,
      0,
      0,
      0,
      1320,
      1318,
      1,
      0,
      0,
      0,
      1320,
      1321,
      1,
      0,
      0,
      0,
      1321,
      1323,
      1,
      0,
      0,
      0,
      1322,
      1320,
      1,
      0,
      0,
      0,
      1323,
      1324,
      3,
      40,
      20,
      0,
      1324,
      89,
      1,
      0,
      0,
      0,
      1325,
      1327,
      3,
      78,
      39,
      0,
      1326,
      1325,
      1,
      0,
      0,
      0,
      1326,
      1327,
      1,
      0,
      0,
      0,
      1327,
      1328,
      1,
      0,
      0,
      0,
      1328,
      1330,
      5,
      79,
      0,
      0,
      1329,
      1331,
      5,
      8,
      0,
      0,
      1330,
      1329,
      1,
      0,
      0,
      0,
      1330,
      1331,
      1,
      0,
      0,
      0,
      1331,
      1332,
      1,
      0,
      0,
      0,
      1332,
      1333,
      3,
      92,
      46,
      0,
      1333,
      1334,
      3,
      46,
      23,
      0,
      1334,
      91,
      1,
      0,
      0,
      0,
      1335,
      1338,
      3,
      94,
      47,
      0,
      1336,
      1338,
      3,
      96,
      48,
      0,
      1337,
      1335,
      1,
      0,
      0,
      0,
      1337,
      1336,
      1,
      0,
      0,
      0,
      1338,
      93,
      1,
      0,
      0,
      0,
      1339,
      1342,
      3,
      88,
      44,
      0,
      1340,
      1341,
      5,
      183,
      0,
      0,
      1341,
      1343,
      5,
      179,
      0,
      0,
      1342,
      1340,
      1,
      0,
      0,
      0,
      1342,
      1343,
      1,
      0,
      0,
      0,
      1343,
      95,
      1,
      0,
      0,
      0,
      1344,
      1345,
      3,
      88,
      44,
      0,
      1345,
      1346,
      5,
      183,
      0,
      0,
      1346,
      1349,
      5,
      198,
      0,
      0,
      1347,
      1348,
      5,
      183,
      0,
      0,
      1348,
      1350,
      5,
      179,
      0,
      0,
      1349,
      1347,
      1,
      0,
      0,
      0,
      1349,
      1350,
      1,
      0,
      0,
      0,
      1350,
      1353,
      1,
      0,
      0,
      0,
      1351,
      1353,
      3,
      98,
      49,
      0,
      1352,
      1344,
      1,
      0,
      0,
      0,
      1352,
      1351,
      1,
      0,
      0,
      0,
      1353,
      97,
      1,
      0,
      0,
      0,
      1354,
      1356,
      3,
      884,
      442,
      0,
      1355,
      1357,
      3,
      100,
      50,
      0,
      1356,
      1355,
      1,
      0,
      0,
      0,
      1357,
      1358,
      1,
      0,
      0,
      0,
      1358,
      1356,
      1,
      0,
      0,
      0,
      1358,
      1359,
      1,
      0,
      0,
      0,
      1359,
      1367,
      1,
      0,
      0,
      0,
      1360,
      1362,
      3,
      898,
      449,
      0,
      1361,
      1363,
      3,
      100,
      50,
      0,
      1362,
      1361,
      1,
      0,
      0,
      0,
      1363,
      1364,
      1,
      0,
      0,
      0,
      1364,
      1362,
      1,
      0,
      0,
      0,
      1364,
      1365,
      1,
      0,
      0,
      0,
      1365,
      1367,
      1,
      0,
      0,
      0,
      1366,
      1354,
      1,
      0,
      0,
      0,
      1366,
      1360,
      1,
      0,
      0,
      0,
      1367,
      99,
      1,
      0,
      0,
      0,
      1368,
      1369,
      5,
      211,
      0,
      0,
      1369,
      1370,
      3,
      0,
      0,
      0,
      1370,
      1371,
      5,
      212,
      0,
      0,
      1371,
      101,
      1,
      0,
      0,
      0,
      1372,
      1375,
      3,
      58,
      29,
      0,
      1373,
      1375,
      3,
      104,
      52,
      0,
      1374,
      1372,
      1,
      0,
      0,
      0,
      1374,
      1373,
      1,
      0,
      0,
      0,
      1375,
      103,
      1,
      0,
      0,
      0,
      1376,
      1403,
      3,
      52,
      26,
      0,
      1377,
      1403,
      3,
      68,
      34,
      0,
      1378,
      1403,
      3,
      108,
      54,
      0,
      1379,
      1403,
      3,
      160,
      80,
      0,
      1380,
      1403,
      3,
      242,
      121,
      0,
      1381,
      1403,
      3,
      244,
      122,
      0,
      1382,
      1403,
      3,
      246,
      123,
      0,
      1383,
      1403,
      3,
      336,
      168,
      0,
      1384,
      1403,
      3,
      248,
      124,
      0,
      1385,
      1403,
      3,
      250,
      125,
      0,
      1386,
      1403,
      3,
      300,
      150,
      0,
      1387,
      1403,
      3,
      276,
      138,
      0,
      1388,
      1403,
      3,
      280,
      140,
      0,
      1389,
      1403,
      3,
      292,
      146,
      0,
      1390,
      1403,
      3,
      322,
      161,
      0,
      1391,
      1403,
      3,
      356,
      178,
      0,
      1392,
      1403,
      3,
      358,
      179,
      0,
      1393,
      1403,
      3,
      132,
      66,
      0,
      1394,
      1403,
      3,
      140,
      70,
      0,
      1395,
      1403,
      3,
      166,
      83,
      0,
      1396,
      1403,
      3,
      144,
      72,
      0,
      1397,
      1403,
      3,
      234,
      117,
      0,
      1398,
      1403,
      3,
      218,
      109,
      0,
      1399,
      1403,
      3,
      222,
      111,
      0,
      1400,
      1403,
      3,
      230,
      115,
      0,
      1401,
      1403,
      3,
      238,
      119,
      0,
      1402,
      1376,
      1,
      0,
      0,
      0,
      1402,
      1377,
      1,
      0,
      0,
      0,
      1402,
      1378,
      1,
      0,
      0,
      0,
      1402,
      1379,
      1,
      0,
      0,
      0,
      1402,
      1380,
      1,
      0,
      0,
      0,
      1402,
      1381,
      1,
      0,
      0,
      0,
      1402,
      1382,
      1,
      0,
      0,
      0,
      1402,
      1383,
      1,
      0,
      0,
      0,
      1402,
      1384,
      1,
      0,
      0,
      0,
      1402,
      1385,
      1,
      0,
      0,
      0,
      1402,
      1386,
      1,
      0,
      0,
      0,
      1402,
      1387,
      1,
      0,
      0,
      0,
      1402,
      1388,
      1,
      0,
      0,
      0,
      1402,
      1389,
      1,
      0,
      0,
      0,
      1402,
      1390,
      1,
      0,
      0,
      0,
      1402,
      1391,
      1,
      0,
      0,
      0,
      1402,
      1392,
      1,
      0,
      0,
      0,
      1402,
      1393,
      1,
      0,
      0,
      0,
      1402,
      1394,
      1,
      0,
      0,
      0,
      1402,
      1395,
      1,
      0,
      0,
      0,
      1402,
      1396,
      1,
      0,
      0,
      0,
      1402,
      1397,
      1,
      0,
      0,
      0,
      1402,
      1398,
      1,
      0,
      0,
      0,
      1402,
      1399,
      1,
      0,
      0,
      0,
      1402,
      1400,
      1,
      0,
      0,
      0,
      1402,
      1401,
      1,
      0,
      0,
      0,
      1403,
      105,
      1,
      0,
      0,
      0,
      1404,
      1415,
      3,
      170,
      85,
      0,
      1405,
      1415,
      3,
      278,
      139,
      0,
      1406,
      1415,
      3,
      290,
      145,
      0,
      1407,
      1415,
      3,
      294,
      147,
      0,
      1408,
      1415,
      3,
      296,
      148,
      0,
      1409,
      1415,
      3,
      252,
      126,
      0,
      1410,
      1415,
      3,
      268,
      134,
      0,
      1411,
      1415,
      3,
      272,
      136,
      0,
      1412,
      1415,
      3,
      302,
      151,
      0,
      1413,
      1415,
      3,
      304,
      152,
      0,
      1414,
      1404,
      1,
      0,
      0,
      0,
      1414,
      1405,
      1,
      0,
      0,
      0,
      1414,
      1406,
      1,
      0,
      0,
      0,
      1414,
      1407,
      1,
      0,
      0,
      0,
      1414,
      1408,
      1,
      0,
      0,
      0,
      1414,
      1409,
      1,
      0,
      0,
      0,
      1414,
      1410,
      1,
      0,
      0,
      0,
      1414,
      1411,
      1,
      0,
      0,
      0,
      1414,
      1412,
      1,
      0,
      0,
      0,
      1414,
      1413,
      1,
      0,
      0,
      0,
      1415,
      107,
      1,
      0,
      0,
      0,
      1416,
      1417,
      3,
      110,
      55,
      0,
      1417,
      1418,
      5,
      157,
      0,
      0,
      1418,
      1419,
      3,
      112,
      56,
      0,
      1419,
      1420,
      3,
      128,
      64,
      0,
      1420,
      109,
      1,
      0,
      0,
      0,
      1421,
      1423,
      5,
      2,
      0,
      0,
      1422,
      1421,
      1,
      0,
      0,
      0,
      1422,
      1423,
      1,
      0,
      0,
      0,
      1423,
      1427,
      1,
      0,
      0,
      0,
      1424,
      1426,
      3,
      340,
      170,
      0,
      1425,
      1424,
      1,
      0,
      0,
      0,
      1426,
      1429,
      1,
      0,
      0,
      0,
      1427,
      1425,
      1,
      0,
      0,
      0,
      1427,
      1428,
      1,
      0,
      0,
      0,
      1428,
      111,
      1,
      0,
      0,
      0,
      1429,
      1427,
      1,
      0,
      0,
      0,
      1430,
      1432,
      5,
      8,
      0,
      0,
      1431,
      1430,
      1,
      0,
      0,
      0,
      1431,
      1432,
      1,
      0,
      0,
      0,
      1432,
      1434,
      1,
      0,
      0,
      0,
      1433,
      1435,
      3,
      44,
      22,
      0,
      1434,
      1433,
      1,
      0,
      0,
      0,
      1434,
      1435,
      1,
      0,
      0,
      0,
      1435,
      1437,
      1,
      0,
      0,
      0,
      1436,
      1438,
      3,
      328,
      164,
      0,
      1437,
      1436,
      1,
      0,
      0,
      0,
      1437,
      1438,
      1,
      0,
      0,
      0,
      1438,
      1441,
      1,
      0,
      0,
      0,
      1439,
      1442,
      3,
      114,
      57,
      0,
      1440,
      1442,
      3,
      116,
      58,
      0,
      1441,
      1439,
      1,
      0,
      0,
      0,
      1441,
      1440,
      1,
      0,
      0,
      0,
      1442,
      1443,
      1,
      0,
      0,
      0,
      1443,
      1441,
      1,
      0,
      0,
      0,
      1443,
      1444,
      1,
      0,
      0,
      0,
      1444,
      1448,
      1,
      0,
      0,
      0,
      1445,
      1447,
      3,
      118,
      59,
      0,
      1446,
      1445,
      1,
      0,
      0,
      0,
      1447,
      1450,
      1,
      0,
      0,
      0,
      1448,
      1446,
      1,
      0,
      0,
      0,
      1448,
      1449,
      1,
      0,
      0,
      0,
      1449,
      113,
      1,
      0,
      0,
      0,
      1450,
      1448,
      1,
      0,
      0,
      0,
      1451,
      1452,
      7,
      11,
      0,
      0,
      1452,
      1457,
      3,
      134,
      67,
      0,
      1453,
      1454,
      5,
      200,
      0,
      0,
      1454,
      1456,
      3,
      134,
      67,
      0,
      1455,
      1453,
      1,
      0,
      0,
      0,
      1456,
      1459,
      1,
      0,
      0,
      0,
      1457,
      1455,
      1,
      0,
      0,
      0,
      1457,
      1458,
      1,
      0,
      0,
      0,
      1458,
      115,
      1,
      0,
      0,
      0,
      1459,
      1457,
      1,
      0,
      0,
      0,
      1460,
      1461,
      7,
      12,
      0,
      0,
      1461,
      1462,
      3,
      142,
      71,
      0,
      1462,
      117,
      1,
      0,
      0,
      0,
      1463,
      1468,
      3,
      120,
      60,
      0,
      1464,
      1468,
      3,
      122,
      61,
      0,
      1465,
      1468,
      3,
      124,
      62,
      0,
      1466,
      1468,
      3,
      126,
      63,
      0,
      1467,
      1463,
      1,
      0,
      0,
      0,
      1467,
      1464,
      1,
      0,
      0,
      0,
      1467,
      1465,
      1,
      0,
      0,
      0,
      1467,
      1466,
      1,
      0,
      0,
      0,
      1468,
      119,
      1,
      0,
      0,
      0,
      1469,
      1470,
      5,
      52,
      0,
      0,
      1470,
      1471,
      5,
      74,
      0,
      0,
      1471,
      1476,
      3,
      146,
      73,
      0,
      1472,
      1473,
      5,
      200,
      0,
      0,
      1473,
      1475,
      3,
      146,
      73,
      0,
      1474,
      1472,
      1,
      0,
      0,
      0,
      1475,
      1478,
      1,
      0,
      0,
      0,
      1476,
      1474,
      1,
      0,
      0,
      0,
      1476,
      1477,
      1,
      0,
      0,
      0,
      1477,
      121,
      1,
      0,
      0,
      0,
      1478,
      1476,
      1,
      0,
      0,
      0,
      1479,
      1480,
      5,
      160,
      0,
      0,
      1480,
      1485,
      3,
      148,
      74,
      0,
      1481,
      1482,
      5,
      200,
      0,
      0,
      1482,
      1484,
      3,
      148,
      74,
      0,
      1483,
      1481,
      1,
      0,
      0,
      0,
      1484,
      1487,
      1,
      0,
      0,
      0,
      1485,
      1483,
      1,
      0,
      0,
      0,
      1485,
      1486,
      1,
      0,
      0,
      0,
      1486,
      123,
      1,
      0,
      0,
      0,
      1487,
      1485,
      1,
      0,
      0,
      0,
      1488,
      1489,
      5,
      86,
      0,
      0,
      1489,
      1494,
      3,
      150,
      75,
      0,
      1490,
      1491,
      5,
      200,
      0,
      0,
      1491,
      1493,
      3,
      150,
      75,
      0,
      1492,
      1490,
      1,
      0,
      0,
      0,
      1493,
      1496,
      1,
      0,
      0,
      0,
      1494,
      1492,
      1,
      0,
      0,
      0,
      1494,
      1495,
      1,
      0,
      0,
      0,
      1495,
      125,
      1,
      0,
      0,
      0,
      1496,
      1494,
      1,
      0,
      0,
      0,
      1497,
      1498,
      5,
      50,
      0,
      0,
      1498,
      1503,
      3,
      152,
      76,
      0,
      1499,
      1500,
      5,
      200,
      0,
      0,
      1500,
      1502,
      3,
      152,
      76,
      0,
      1501,
      1499,
      1,
      0,
      0,
      0,
      1502,
      1505,
      1,
      0,
      0,
      0,
      1503,
      1501,
      1,
      0,
      0,
      0,
      1503,
      1504,
      1,
      0,
      0,
      0,
      1504,
      127,
      1,
      0,
      0,
      0,
      1505,
      1503,
      1,
      0,
      0,
      0,
      1506,
      1516,
      5,
      205,
      0,
      0,
      1507,
      1511,
      5,
      214,
      0,
      0,
      1508,
      1510,
      3,
      130,
      65,
      0,
      1509,
      1508,
      1,
      0,
      0,
      0,
      1510,
      1513,
      1,
      0,
      0,
      0,
      1511,
      1509,
      1,
      0,
      0,
      0,
      1511,
      1512,
      1,
      0,
      0,
      0,
      1512,
      1514,
      1,
      0,
      0,
      0,
      1513,
      1511,
      1,
      0,
      0,
      0,
      1514,
      1516,
      5,
      216,
      0,
      0,
      1515,
      1506,
      1,
      0,
      0,
      0,
      1515,
      1507,
      1,
      0,
      0,
      0,
      1516,
      129,
      1,
      0,
      0,
      0,
      1517,
      1522,
      3,
      82,
      41,
      0,
      1518,
      1522,
      3,
      154,
      77,
      0,
      1519,
      1522,
      3,
      86,
      43,
      0,
      1520,
      1522,
      3,
      90,
      45,
      0,
      1521,
      1517,
      1,
      0,
      0,
      0,
      1521,
      1518,
      1,
      0,
      0,
      0,
      1521,
      1519,
      1,
      0,
      0,
      0,
      1521,
      1520,
      1,
      0,
      0,
      0,
      1522,
      131,
      1,
      0,
      0,
      0,
      1523,
      1525,
      5,
      138,
      0,
      0,
      1524,
      1526,
      3,
      44,
      22,
      0,
      1525,
      1524,
      1,
      0,
      0,
      0,
      1525,
      1526,
      1,
      0,
      0,
      0,
      1526,
      1528,
      1,
      0,
      0,
      0,
      1527,
      1523,
      1,
      0,
      0,
      0,
      1527,
      1528,
      1,
      0,
      0,
      0,
      1528,
      1529,
      1,
      0,
      0,
      0,
      1529,
      1530,
      5,
      149,
      0,
      0,
      1530,
      1531,
      3,
      136,
      68,
      0,
      1531,
      1532,
      7,
      11,
      0,
      0,
      1532,
      1533,
      3,
      138,
      69,
      0,
      1533,
      1534,
      3,
      46,
      23,
      0,
      1534,
      133,
      1,
      0,
      0,
      0,
      1535,
      1536,
      3,
      138,
      69,
      0,
      1536,
      135,
      1,
      0,
      0,
      0,
      1537,
      1542,
      3,
      88,
      44,
      0,
      1538,
      1539,
      5,
      202,
      0,
      0,
      1539,
      1541,
      3,
      88,
      44,
      0,
      1540,
      1538,
      1,
      0,
      0,
      0,
      1541,
      1544,
      1,
      0,
      0,
      0,
      1542,
      1540,
      1,
      0,
      0,
      0,
      1542,
      1543,
      1,
      0,
      0,
      0,
      1543,
      137,
      1,
      0,
      0,
      0,
      1544,
      1542,
      1,
      0,
      0,
      0,
      1545,
      1550,
      3,
      88,
      44,
      0,
      1546,
      1547,
      5,
      202,
      0,
      0,
      1547,
      1549,
      3,
      88,
      44,
      0,
      1548,
      1546,
      1,
      0,
      0,
      0,
      1549,
      1552,
      1,
      0,
      0,
      0,
      1550,
      1548,
      1,
      0,
      0,
      0,
      1550,
      1551,
      1,
      0,
      0,
      0,
      1551,
      139,
      1,
      0,
      0,
      0,
      1552,
      1550,
      1,
      0,
      0,
      0,
      1553,
      1555,
      5,
      35,
      0,
      0,
      1554,
      1556,
      3,
      44,
      22,
      0,
      1555,
      1554,
      1,
      0,
      0,
      0,
      1555,
      1556,
      1,
      0,
      0,
      0,
      1556,
      1558,
      1,
      0,
      0,
      0,
      1557,
      1553,
      1,
      0,
      0,
      0,
      1557,
      1558,
      1,
      0,
      0,
      0,
      1558,
      1559,
      1,
      0,
      0,
      0,
      1559,
      1560,
      5,
      33,
      0,
      0,
      1560,
      1565,
      3,
      88,
      44,
      0,
      1561,
      1562,
      5,
      202,
      0,
      0,
      1562,
      1564,
      3,
      88,
      44,
      0,
      1563,
      1561,
      1,
      0,
      0,
      0,
      1564,
      1567,
      1,
      0,
      0,
      0,
      1565,
      1563,
      1,
      0,
      0,
      0,
      1565,
      1566,
      1,
      0,
      0,
      0,
      1566,
      1568,
      1,
      0,
      0,
      0,
      1567,
      1565,
      1,
      0,
      0,
      0,
      1568,
      1569,
      7,
      12,
      0,
      0,
      1569,
      1574,
      3,
      88,
      44,
      0,
      1570,
      1571,
      5,
      202,
      0,
      0,
      1571,
      1573,
      3,
      88,
      44,
      0,
      1572,
      1570,
      1,
      0,
      0,
      0,
      1573,
      1576,
      1,
      0,
      0,
      0,
      1574,
      1572,
      1,
      0,
      0,
      0,
      1574,
      1575,
      1,
      0,
      0,
      0,
      1575,
      1577,
      1,
      0,
      0,
      0,
      1576,
      1574,
      1,
      0,
      0,
      0,
      1577,
      1578,
      3,
      46,
      23,
      0,
      1578,
      141,
      1,
      0,
      0,
      0,
      1579,
      1584,
      3,
      88,
      44,
      0,
      1580,
      1581,
      5,
      202,
      0,
      0,
      1581,
      1583,
      3,
      88,
      44,
      0,
      1582,
      1580,
      1,
      0,
      0,
      0,
      1583,
      1586,
      1,
      0,
      0,
      0,
      1584,
      1582,
      1,
      0,
      0,
      0,
      1584,
      1585,
      1,
      0,
      0,
      0,
      1585,
      143,
      1,
      0,
      0,
      0,
      1586,
      1584,
      1,
      0,
      0,
      0,
      1587,
      1589,
      5,
      51,
      0,
      0,
      1588,
      1590,
      3,
      44,
      22,
      0,
      1589,
      1588,
      1,
      0,
      0,
      0,
      1589,
      1590,
      1,
      0,
      0,
      0,
      1590,
      1592,
      1,
      0,
      0,
      0,
      1591,
      1587,
      1,
      0,
      0,
      0,
      1591,
      1592,
      1,
      0,
      0,
      0,
      1592,
      1593,
      1,
      0,
      0,
      0,
      1593,
      1594,
      5,
      52,
      0,
      0,
      1594,
      1599,
      3,
      88,
      44,
      0,
      1595,
      1596,
      5,
      202,
      0,
      0,
      1596,
      1598,
      3,
      88,
      44,
      0,
      1597,
      1595,
      1,
      0,
      0,
      0,
      1598,
      1601,
      1,
      0,
      0,
      0,
      1599,
      1597,
      1,
      0,
      0,
      0,
      1599,
      1600,
      1,
      0,
      0,
      0,
      1600,
      1602,
      1,
      0,
      0,
      0,
      1601,
      1599,
      1,
      0,
      0,
      0,
      1602,
      1603,
      5,
      74,
      0,
      0,
      1603,
      1608,
      3,
      88,
      44,
      0,
      1604,
      1605,
      5,
      202,
      0,
      0,
      1605,
      1607,
      3,
      88,
      44,
      0,
      1606,
      1604,
      1,
      0,
      0,
      0,
      1607,
      1610,
      1,
      0,
      0,
      0,
      1608,
      1606,
      1,
      0,
      0,
      0,
      1608,
      1609,
      1,
      0,
      0,
      0,
      1609,
      1611,
      1,
      0,
      0,
      0,
      1610,
      1608,
      1,
      0,
      0,
      0,
      1611,
      1612,
      3,
      46,
      23,
      0,
      1612,
      145,
      1,
      0,
      0,
      0,
      1613,
      1618,
      3,
      88,
      44,
      0,
      1614,
      1615,
      5,
      202,
      0,
      0,
      1615,
      1617,
      3,
      88,
      44,
      0,
      1616,
      1614,
      1,
      0,
      0,
      0,
      1617,
      1620,
      1,
      0,
      0,
      0,
      1618,
      1616,
      1,
      0,
      0,
      0,
      1618,
      1619,
      1,
      0,
      0,
      0,
      1619,
      147,
      1,
      0,
      0,
      0,
      1620,
      1618,
      1,
      0,
      0,
      0,
      1621,
      1626,
      3,
      88,
      44,
      0,
      1622,
      1623,
      5,
      202,
      0,
      0,
      1623,
      1625,
      3,
      88,
      44,
      0,
      1624,
      1622,
      1,
      0,
      0,
      0,
      1625,
      1628,
      1,
      0,
      0,
      0,
      1626,
      1624,
      1,
      0,
      0,
      0,
      1626,
      1627,
      1,
      0,
      0,
      0,
      1627,
      149,
      1,
      0,
      0,
      0,
      1628,
      1626,
      1,
      0,
      0,
      0,
      1629,
      1634,
      3,
      88,
      44,
      0,
      1630,
      1631,
      5,
      202,
      0,
      0,
      1631,
      1633,
      3,
      88,
      44,
      0,
      1632,
      1630,
      1,
      0,
      0,
      0,
      1633,
      1636,
      1,
      0,
      0,
      0,
      1634,
      1632,
      1,
      0,
      0,
      0,
      1634,
      1635,
      1,
      0,
      0,
      0,
      1635,
      151,
      1,
      0,
      0,
      0,
      1636,
      1634,
      1,
      0,
      0,
      0,
      1637,
      1642,
      3,
      88,
      44,
      0,
      1638,
      1639,
      5,
      202,
      0,
      0,
      1639,
      1641,
      3,
      88,
      44,
      0,
      1640,
      1638,
      1,
      0,
      0,
      0,
      1641,
      1644,
      1,
      0,
      0,
      0,
      1642,
      1640,
      1,
      0,
      0,
      0,
      1642,
      1643,
      1,
      0,
      0,
      0,
      1643,
      153,
      1,
      0,
      0,
      0,
      1644,
      1642,
      1,
      0,
      0,
      0,
      1645,
      1648,
      3,
      156,
      78,
      0,
      1646,
      1648,
      3,
      158,
      79,
      0,
      1647,
      1645,
      1,
      0,
      0,
      0,
      1647,
      1646,
      1,
      0,
      0,
      0,
      1648,
      155,
      1,
      0,
      0,
      0,
      1649,
      1650,
      3,
      76,
      38,
      0,
      1650,
      1651,
      5,
      97,
      0,
      0,
      1651,
      1652,
      3,
      106,
      53,
      0,
      1652,
      157,
      1,
      0,
      0,
      0,
      1653,
      1654,
      3,
      76,
      38,
      0,
      1654,
      1655,
      3,
      106,
      53,
      0,
      1655,
      159,
      1,
      0,
      0,
      0,
      1656,
      1657,
      3,
      110,
      55,
      0,
      1657,
      1658,
      5,
      29,
      0,
      0,
      1658,
      1659,
      3,
      162,
      81,
      0,
      1659,
      1660,
      3,
      128,
      64,
      0,
      1660,
      161,
      1,
      0,
      0,
      0,
      1661,
      1663,
      5,
      8,
      0,
      0,
      1662,
      1661,
      1,
      0,
      0,
      0,
      1662,
      1663,
      1,
      0,
      0,
      0,
      1663,
      1665,
      1,
      0,
      0,
      0,
      1664,
      1666,
      3,
      44,
      22,
      0,
      1665,
      1664,
      1,
      0,
      0,
      0,
      1665,
      1666,
      1,
      0,
      0,
      0,
      1666,
      1668,
      1,
      0,
      0,
      0,
      1667,
      1669,
      3,
      328,
      164,
      0,
      1668,
      1667,
      1,
      0,
      0,
      0,
      1668,
      1669,
      1,
      0,
      0,
      0,
      1669,
      1672,
      1,
      0,
      0,
      0,
      1670,
      1673,
      3,
      164,
      82,
      0,
      1671,
      1673,
      3,
      116,
      58,
      0,
      1672,
      1670,
      1,
      0,
      0,
      0,
      1672,
      1671,
      1,
      0,
      0,
      0,
      1672,
      1673,
      1,
      0,
      0,
      0,
      1673,
      1677,
      1,
      0,
      0,
      0,
      1674,
      1676,
      3,
      118,
      59,
      0,
      1675,
      1674,
      1,
      0,
      0,
      0,
      1676,
      1679,
      1,
      0,
      0,
      0,
      1677,
      1675,
      1,
      0,
      0,
      0,
      1677,
      1678,
      1,
      0,
      0,
      0,
      1678,
      163,
      1,
      0,
      0,
      0,
      1679,
      1677,
      1,
      0,
      0,
      0,
      1680,
      1681,
      7,
      11,
      0,
      0,
      1681,
      1686,
      3,
      168,
      84,
      0,
      1682,
      1683,
      5,
      200,
      0,
      0,
      1683,
      1685,
      3,
      168,
      84,
      0,
      1684,
      1682,
      1,
      0,
      0,
      0,
      1685,
      1688,
      1,
      0,
      0,
      0,
      1686,
      1684,
      1,
      0,
      0,
      0,
      1686,
      1687,
      1,
      0,
      0,
      0,
      1687,
      165,
      1,
      0,
      0,
      0,
      1688,
      1686,
      1,
      0,
      0,
      0,
      1689,
      1691,
      5,
      138,
      0,
      0,
      1690,
      1692,
      3,
      44,
      22,
      0,
      1691,
      1690,
      1,
      0,
      0,
      0,
      1691,
      1692,
      1,
      0,
      0,
      0,
      1692,
      1694,
      1,
      0,
      0,
      0,
      1693,
      1689,
      1,
      0,
      0,
      0,
      1693,
      1694,
      1,
      0,
      0,
      0,
      1694,
      1695,
      1,
      0,
      0,
      0,
      1695,
      1696,
      5,
      145,
      0,
      0,
      1696,
      1697,
      3,
      88,
      44,
      0,
      1697,
      1698,
      7,
      11,
      0,
      0,
      1698,
      1699,
      3,
      88,
      44,
      0,
      1699,
      1700,
      3,
      46,
      23,
      0,
      1700,
      167,
      1,
      0,
      0,
      0,
      1701,
      1702,
      3,
      88,
      44,
      0,
      1702,
      169,
      1,
      0,
      0,
      0,
      1703,
      1706,
      3,
      176,
      88,
      0,
      1704,
      1707,
      5,
      65,
      0,
      0,
      1705,
      1707,
      3,
      340,
      170,
      0,
      1706,
      1704,
      1,
      0,
      0,
      0,
      1706,
      1705,
      1,
      0,
      0,
      0,
      1707,
      1709,
      1,
      0,
      0,
      0,
      1708,
      1710,
      3,
      184,
      92,
      0,
      1709,
      1708,
      1,
      0,
      0,
      0,
      1709,
      1710,
      1,
      0,
      0,
      0,
      1710,
      1721,
      1,
      0,
      0,
      0,
      1711,
      1714,
      3,
      172,
      86,
      0,
      1712,
      1714,
      3,
      174,
      87,
      0,
      1713,
      1711,
      1,
      0,
      0,
      0,
      1713,
      1712,
      1,
      0,
      0,
      0,
      1714,
      1716,
      1,
      0,
      0,
      0,
      1715,
      1717,
      5,
      127,
      0,
      0,
      1716,
      1715,
      1,
      0,
      0,
      0,
      1716,
      1717,
      1,
      0,
      0,
      0,
      1717,
      1718,
      1,
      0,
      0,
      0,
      1718,
      1719,
      3,
      184,
      92,
      0,
      1719,
      1721,
      1,
      0,
      0,
      0,
      1720,
      1703,
      1,
      0,
      0,
      0,
      1720,
      1713,
      1,
      0,
      0,
      0,
      1721,
      1723,
      1,
      0,
      0,
      0,
      1722,
      1724,
      3,
      318,
      159,
      0,
      1723,
      1722,
      1,
      0,
      0,
      0,
      1723,
      1724,
      1,
      0,
      0,
      0,
      1724,
      1725,
      1,
      0,
      0,
      0,
      1725,
      1726,
      3,
      128,
      64,
      0,
      1726,
      171,
      1,
      0,
      0,
      0,
      1727,
      1729,
      5,
      39,
      0,
      0,
      1728,
      1727,
      1,
      0,
      0,
      0,
      1728,
      1729,
      1,
      0,
      0,
      0,
      1729,
      1730,
      1,
      0,
      0,
      0,
      1730,
      1731,
      5,
      56,
      0,
      0,
      1731,
      173,
      1,
      0,
      0,
      0,
      1732,
      1734,
      3,
      182,
      91,
      0,
      1733,
      1732,
      1,
      0,
      0,
      0,
      1733,
      1734,
      1,
      0,
      0,
      0,
      1734,
      1736,
      1,
      0,
      0,
      0,
      1735,
      1737,
      5,
      49,
      0,
      0,
      1736,
      1735,
      1,
      0,
      0,
      0,
      1736,
      1737,
      1,
      0,
      0,
      0,
      1737,
      1739,
      1,
      0,
      0,
      0,
      1738,
      1740,
      5,
      2,
      0,
      0,
      1739,
      1738,
      1,
      0,
      0,
      0,
      1739,
      1740,
      1,
      0,
      0,
      0,
      1740,
      1742,
      1,
      0,
      0,
      0,
      1741,
      1743,
      7,
      13,
      0,
      0,
      1742,
      1741,
      1,
      0,
      0,
      0,
      1742,
      1743,
      1,
      0,
      0,
      0,
      1743,
      1745,
      1,
      0,
      0,
      0,
      1744,
      1746,
      7,
      14,
      0,
      0,
      1745,
      1744,
      1,
      0,
      0,
      0,
      1745,
      1746,
      1,
      0,
      0,
      0,
      1746,
      175,
      1,
      0,
      0,
      0,
      1747,
      1748,
      3,
      172,
      86,
      0,
      1748,
      1749,
      3,
      178,
      89,
      0,
      1749,
      1752,
      1,
      0,
      0,
      0,
      1750,
      1752,
      3,
      174,
      87,
      0,
      1751,
      1747,
      1,
      0,
      0,
      0,
      1751,
      1750,
      1,
      0,
      0,
      0,
      1752,
      1756,
      1,
      0,
      0,
      0,
      1753,
      1755,
      3,
      340,
      170,
      0,
      1754,
      1753,
      1,
      0,
      0,
      0,
      1755,
      1758,
      1,
      0,
      0,
      0,
      1756,
      1754,
      1,
      0,
      0,
      0,
      1756,
      1757,
      1,
      0,
      0,
      0,
      1757,
      177,
      1,
      0,
      0,
      0,
      1758,
      1756,
      1,
      0,
      0,
      0,
      1759,
      1760,
      3,
      180,
      90,
      0,
      1760,
      179,
      1,
      0,
      0,
      0,
      1761,
      1762,
      3,
      174,
      87,
      0,
      1762,
      1763,
      3,
      184,
      92,
      0,
      1763,
      1769,
      1,
      0,
      0,
      0,
      1764,
      1766,
      3,
      406,
      203,
      0,
      1765,
      1767,
      3,
      418,
      209,
      0,
      1766,
      1765,
      1,
      0,
      0,
      0,
      1766,
      1767,
      1,
      0,
      0,
      0,
      1767,
      1769,
      1,
      0,
      0,
      0,
      1768,
      1761,
      1,
      0,
      0,
      0,
      1768,
      1764,
      1,
      0,
      0,
      0,
      1769,
      181,
      1,
      0,
      0,
      0,
      1770,
      1771,
      7,
      15,
      0,
      0,
      1771,
      183,
      1,
      0,
      0,
      0,
      1772,
      1774,
      5,
      8,
      0,
      0,
      1773,
      1772,
      1,
      0,
      0,
      0,
      1773,
      1774,
      1,
      0,
      0,
      0,
      1774,
      1782,
      1,
      0,
      0,
      0,
      1775,
      1778,
      3,
      186,
      93,
      0,
      1776,
      1779,
      3,
      196,
      98,
      0,
      1777,
      1779,
      3,
      116,
      58,
      0,
      1778,
      1776,
      1,
      0,
      0,
      0,
      1778,
      1777,
      1,
      0,
      0,
      0,
      1778,
      1779,
      1,
      0,
      0,
      0,
      1779,
      1783,
      1,
      0,
      0,
      0,
      1780,
      1783,
      3,
      196,
      98,
      0,
      1781,
      1783,
      3,
      116,
      58,
      0,
      1782,
      1775,
      1,
      0,
      0,
      0,
      1782,
      1780,
      1,
      0,
      0,
      0,
      1782,
      1781,
      1,
      0,
      0,
      0,
      1783,
      1787,
      1,
      0,
      0,
      0,
      1784,
      1786,
      3,
      188,
      94,
      0,
      1785,
      1784,
      1,
      0,
      0,
      0,
      1786,
      1789,
      1,
      0,
      0,
      0,
      1787,
      1785,
      1,
      0,
      0,
      0,
      1787,
      1788,
      1,
      0,
      0,
      0,
      1788,
      185,
      1,
      0,
      0,
      0,
      1789,
      1787,
      1,
      0,
      0,
      0,
      1790,
      1791,
      5,
      206,
      0,
      0,
      1791,
      1792,
      3,
      40,
      20,
      0,
      1792,
      1794,
      5,
      208,
      0,
      0,
      1793,
      1795,
      3,
      40,
      20,
      0,
      1794,
      1793,
      1,
      0,
      0,
      0,
      1794,
      1795,
      1,
      0,
      0,
      0,
      1795,
      1798,
      1,
      0,
      0,
      0,
      1796,
      1798,
      3,
      40,
      20,
      0,
      1797,
      1790,
      1,
      0,
      0,
      0,
      1797,
      1796,
      1,
      0,
      0,
      0,
      1798,
      187,
      1,
      0,
      0,
      0,
      1799,
      1804,
      3,
      118,
      59,
      0,
      1800,
      1804,
      3,
      190,
      95,
      0,
      1801,
      1804,
      3,
      192,
      96,
      0,
      1802,
      1804,
      3,
      194,
      97,
      0,
      1803,
      1799,
      1,
      0,
      0,
      0,
      1803,
      1800,
      1,
      0,
      0,
      0,
      1803,
      1801,
      1,
      0,
      0,
      0,
      1803,
      1802,
      1,
      0,
      0,
      0,
      1804,
      189,
      1,
      0,
      0,
      0,
      1805,
      1806,
      5,
      27,
      0,
      0,
      1806,
      1811,
      3,
      88,
      44,
      0,
      1807,
      1808,
      5,
      202,
      0,
      0,
      1808,
      1810,
      3,
      88,
      44,
      0,
      1809,
      1807,
      1,
      0,
      0,
      0,
      1810,
      1813,
      1,
      0,
      0,
      0,
      1811,
      1809,
      1,
      0,
      0,
      0,
      1811,
      1812,
      1,
      0,
      0,
      0,
      1812,
      191,
      1,
      0,
      0,
      0,
      1813,
      1811,
      1,
      0,
      0,
      0,
      1814,
      1815,
      5,
      88,
      0,
      0,
      1815,
      1816,
      5,
      111,
      0,
      0,
      1816,
      1817,
      3,
      236,
      118,
      0,
      1817,
      193,
      1,
      0,
      0,
      0,
      1818,
      1819,
      5,
      66,
      0,
      0,
      1819,
      1820,
      5,
      24,
      0,
      0,
      1820,
      1825,
      3,
      240,
      120,
      0,
      1821,
      1822,
      5,
      200,
      0,
      0,
      1822,
      1824,
      3,
      240,
      120,
      0,
      1823,
      1821,
      1,
      0,
      0,
      0,
      1824,
      1827,
      1,
      0,
      0,
      0,
      1825,
      1823,
      1,
      0,
      0,
      0,
      1825,
      1826,
      1,
      0,
      0,
      0,
      1826,
      195,
      1,
      0,
      0,
      0,
      1827,
      1825,
      1,
      0,
      0,
      0,
      1828,
      1830,
      3,
      200,
      100,
      0,
      1829,
      1828,
      1,
      0,
      0,
      0,
      1830,
      1831,
      1,
      0,
      0,
      0,
      1831,
      1829,
      1,
      0,
      0,
      0,
      1831,
      1832,
      1,
      0,
      0,
      0,
      1832,
      1834,
      1,
      0,
      0,
      0,
      1833,
      1835,
      3,
      198,
      99,
      0,
      1834,
      1833,
      1,
      0,
      0,
      0,
      1834,
      1835,
      1,
      0,
      0,
      0,
      1835,
      1839,
      1,
      0,
      0,
      0,
      1836,
      1838,
      3,
      200,
      100,
      0,
      1837,
      1836,
      1,
      0,
      0,
      0,
      1838,
      1841,
      1,
      0,
      0,
      0,
      1839,
      1837,
      1,
      0,
      0,
      0,
      1839,
      1840,
      1,
      0,
      0,
      0,
      1840,
      1850,
      1,
      0,
      0,
      0,
      1841,
      1839,
      1,
      0,
      0,
      0,
      1842,
      1846,
      3,
      198,
      99,
      0,
      1843,
      1845,
      3,
      200,
      100,
      0,
      1844,
      1843,
      1,
      0,
      0,
      0,
      1845,
      1848,
      1,
      0,
      0,
      0,
      1846,
      1844,
      1,
      0,
      0,
      0,
      1846,
      1847,
      1,
      0,
      0,
      0,
      1847,
      1850,
      1,
      0,
      0,
      0,
      1848,
      1846,
      1,
      0,
      0,
      0,
      1849,
      1829,
      1,
      0,
      0,
      0,
      1849,
      1842,
      1,
      0,
      0,
      0,
      1850,
      197,
      1,
      0,
      0,
      0,
      1851,
      1860,
      3,
      328,
      164,
      0,
      1852,
      1854,
      5,
      113,
      0,
      0,
      1853,
      1855,
      5,
      106,
      0,
      0,
      1854,
      1853,
      1,
      0,
      0,
      0,
      1854,
      1855,
      1,
      0,
      0,
      0,
      1855,
      1861,
      1,
      0,
      0,
      0,
      1856,
      1858,
      5,
      106,
      0,
      0,
      1857,
      1859,
      5,
      113,
      0,
      0,
      1858,
      1857,
      1,
      0,
      0,
      0,
      1858,
      1859,
      1,
      0,
      0,
      0,
      1859,
      1861,
      1,
      0,
      0,
      0,
      1860,
      1852,
      1,
      0,
      0,
      0,
      1860,
      1856,
      1,
      0,
      0,
      0,
      1860,
      1861,
      1,
      0,
      0,
      0,
      1861,
      1873,
      1,
      0,
      0,
      0,
      1862,
      1864,
      5,
      113,
      0,
      0,
      1863,
      1865,
      5,
      106,
      0,
      0,
      1864,
      1863,
      1,
      0,
      0,
      0,
      1864,
      1865,
      1,
      0,
      0,
      0,
      1865,
      1871,
      1,
      0,
      0,
      0,
      1866,
      1868,
      5,
      106,
      0,
      0,
      1867,
      1869,
      5,
      113,
      0,
      0,
      1868,
      1867,
      1,
      0,
      0,
      0,
      1868,
      1869,
      1,
      0,
      0,
      0,
      1869,
      1871,
      1,
      0,
      0,
      0,
      1870,
      1862,
      1,
      0,
      0,
      0,
      1870,
      1866,
      1,
      0,
      0,
      0,
      1871,
      1873,
      1,
      0,
      0,
      0,
      1872,
      1851,
      1,
      0,
      0,
      0,
      1872,
      1870,
      1,
      0,
      0,
      0,
      1873,
      199,
      1,
      0,
      0,
      0,
      1874,
      1880,
      3,
      202,
      101,
      0,
      1875,
      1880,
      3,
      206,
      103,
      0,
      1876,
      1880,
      3,
      210,
      105,
      0,
      1877,
      1880,
      3,
      212,
      106,
      0,
      1878,
      1880,
      3,
      214,
      107,
      0,
      1879,
      1874,
      1,
      0,
      0,
      0,
      1879,
      1875,
      1,
      0,
      0,
      0,
      1879,
      1876,
      1,
      0,
      0,
      0,
      1879,
      1877,
      1,
      0,
      0,
      0,
      1879,
      1878,
      1,
      0,
      0,
      0,
      1880,
      201,
      1,
      0,
      0,
      0,
      1881,
      1886,
      3,
      204,
      102,
      0,
      1882,
      1883,
      5,
      200,
      0,
      0,
      1883,
      1885,
      3,
      218,
      109,
      0,
      1884,
      1882,
      1,
      0,
      0,
      0,
      1885,
      1888,
      1,
      0,
      0,
      0,
      1886,
      1884,
      1,
      0,
      0,
      0,
      1886,
      1887,
      1,
      0,
      0,
      0,
      1887,
      203,
      1,
      0,
      0,
      0,
      1888,
      1886,
      1,
      0,
      0,
      0,
      1889,
      1895,
      5,
      204,
      0,
      0,
      1890,
      1891,
      5,
      158,
      0,
      0,
      1891,
      1895,
      5,
      24,
      0,
      0,
      1892,
      1893,
      5,
      47,
      0,
      0,
      1893,
      1895,
      5,
      24,
      0,
      0,
      1894,
      1889,
      1,
      0,
      0,
      0,
      1894,
      1890,
      1,
      0,
      0,
      0,
      1894,
      1892,
      1,
      0,
      0,
      0,
      1895,
      1896,
      1,
      0,
      0,
      0,
      1896,
      1897,
      3,
      218,
      109,
      0,
      1897,
      205,
      1,
      0,
      0,
      0,
      1898,
      1903,
      3,
      208,
      104,
      0,
      1899,
      1900,
      5,
      200,
      0,
      0,
      1900,
      1902,
      3,
      224,
      112,
      0,
      1901,
      1899,
      1,
      0,
      0,
      0,
      1902,
      1905,
      1,
      0,
      0,
      0,
      1903,
      1901,
      1,
      0,
      0,
      0,
      1903,
      1904,
      1,
      0,
      0,
      0,
      1904,
      207,
      1,
      0,
      0,
      0,
      1905,
      1903,
      1,
      0,
      0,
      0,
      1906,
      1907,
      7,
      16,
      0,
      0,
      1907,
      1908,
      3,
      224,
      112,
      0,
      1908,
      209,
      1,
      0,
      0,
      0,
      1909,
      1910,
      7,
      17,
      0,
      0,
      1910,
      1911,
      3,
      226,
      113,
      0,
      1911,
      211,
      1,
      0,
      0,
      0,
      1912,
      1913,
      7,
      18,
      0,
      0,
      1913,
      1914,
      3,
      228,
      114,
      0,
      1914,
      213,
      1,
      0,
      0,
      0,
      1915,
      1920,
      3,
      216,
      108,
      0,
      1916,
      1917,
      5,
      200,
      0,
      0,
      1917,
      1919,
      3,
      232,
      116,
      0,
      1918,
      1916,
      1,
      0,
      0,
      0,
      1919,
      1922,
      1,
      0,
      0,
      0,
      1920,
      1918,
      1,
      0,
      0,
      0,
      1920,
      1921,
      1,
      0,
      0,
      0,
      1921,
      215,
      1,
      0,
      0,
      0,
      1922,
      1920,
      1,
      0,
      0,
      0,
      1923,
      1924,
      7,
      19,
      0,
      0,
      1924,
      1925,
      3,
      232,
      116,
      0,
      1925,
      217,
      1,
      0,
      0,
      0,
      1926,
      1928,
      5,
      138,
      0,
      0,
      1927,
      1929,
      3,
      44,
      22,
      0,
      1928,
      1927,
      1,
      0,
      0,
      0,
      1928,
      1929,
      1,
      0,
      0,
      0,
      1929,
      1931,
      1,
      0,
      0,
      0,
      1930,
      1926,
      1,
      0,
      0,
      0,
      1930,
      1931,
      1,
      0,
      0,
      0,
      1931,
      1932,
      1,
      0,
      0,
      0,
      1932,
      1933,
      5,
      159,
      0,
      0,
      1933,
      1937,
      3,
      88,
      44,
      0,
      1934,
      1938,
      5,
      204,
      0,
      0,
      1935,
      1936,
      5,
      158,
      0,
      0,
      1936,
      1938,
      5,
      24,
      0,
      0,
      1937,
      1934,
      1,
      0,
      0,
      0,
      1937,
      1935,
      1,
      0,
      0,
      0,
      1938,
      1939,
      1,
      0,
      0,
      0,
      1939,
      1940,
      3,
      138,
      69,
      0,
      1940,
      1941,
      3,
      46,
      23,
      0,
      1941,
      1945,
      1,
      0,
      0,
      0,
      1942,
      1945,
      3,
      220,
      110,
      0,
      1943,
      1945,
      3,
      504,
      252,
      0,
      1944,
      1930,
      1,
      0,
      0,
      0,
      1944,
      1942,
      1,
      0,
      0,
      0,
      1944,
      1943,
      1,
      0,
      0,
      0,
      1945,
      219,
      1,
      0,
      0,
      0,
      1946,
      1951,
      3,
      88,
      44,
      0,
      1947,
      1948,
      5,
      202,
      0,
      0,
      1948,
      1950,
      3,
      88,
      44,
      0,
      1949,
      1947,
      1,
      0,
      0,
      0,
      1950,
      1953,
      1,
      0,
      0,
      0,
      1951,
      1949,
      1,
      0,
      0,
      0,
      1951,
      1952,
      1,
      0,
      0,
      0,
      1952,
      221,
      1,
      0,
      0,
      0,
      1953,
      1951,
      1,
      0,
      0,
      0,
      1954,
      1956,
      5,
      138,
      0,
      0,
      1955,
      1957,
      3,
      44,
      22,
      0,
      1956,
      1955,
      1,
      0,
      0,
      0,
      1956,
      1957,
      1,
      0,
      0,
      0,
      1957,
      1959,
      1,
      0,
      0,
      0,
      1958,
      1954,
      1,
      0,
      0,
      0,
      1958,
      1959,
      1,
      0,
      0,
      0,
      1959,
      1960,
      1,
      0,
      0,
      0,
      1960,
      1961,
      5,
      147,
      0,
      0,
      1961,
      1962,
      3,
      136,
      68,
      0,
      1962,
      1963,
      7,
      16,
      0,
      0,
      1963,
      1964,
      3,
      138,
      69,
      0,
      1964,
      1965,
      3,
      46,
      23,
      0,
      1965,
      223,
      1,
      0,
      0,
      0,
      1966,
      1971,
      3,
      88,
      44,
      0,
      1967,
      1968,
      5,
      202,
      0,
      0,
      1968,
      1970,
      3,
      88,
      44,
      0,
      1969,
      1967,
      1,
      0,
      0,
      0,
      1970,
      1973,
      1,
      0,
      0,
      0,
      1971,
      1969,
      1,
      0,
      0,
      0,
      1971,
      1972,
      1,
      0,
      0,
      0,
      1972,
      225,
      1,
      0,
      0,
      0,
      1973,
      1971,
      1,
      0,
      0,
      0,
      1974,
      1979,
      3,
      88,
      44,
      0,
      1975,
      1976,
      5,
      202,
      0,
      0,
      1976,
      1978,
      3,
      88,
      44,
      0,
      1977,
      1975,
      1,
      0,
      0,
      0,
      1978,
      1981,
      1,
      0,
      0,
      0,
      1979,
      1977,
      1,
      0,
      0,
      0,
      1979,
      1980,
      1,
      0,
      0,
      0,
      1980,
      227,
      1,
      0,
      0,
      0,
      1981,
      1979,
      1,
      0,
      0,
      0,
      1982,
      1987,
      3,
      88,
      44,
      0,
      1983,
      1984,
      5,
      202,
      0,
      0,
      1984,
      1986,
      3,
      88,
      44,
      0,
      1985,
      1983,
      1,
      0,
      0,
      0,
      1986,
      1989,
      1,
      0,
      0,
      0,
      1987,
      1985,
      1,
      0,
      0,
      0,
      1987,
      1988,
      1,
      0,
      0,
      0,
      1988,
      229,
      1,
      0,
      0,
      0,
      1989,
      1987,
      1,
      0,
      0,
      0,
      1990,
      1992,
      5,
      138,
      0,
      0,
      1991,
      1993,
      3,
      44,
      22,
      0,
      1992,
      1991,
      1,
      0,
      0,
      0,
      1992,
      1993,
      1,
      0,
      0,
      0,
      1993,
      1995,
      1,
      0,
      0,
      0,
      1994,
      1990,
      1,
      0,
      0,
      0,
      1994,
      1995,
      1,
      0,
      0,
      0,
      1995,
      1996,
      1,
      0,
      0,
      0,
      1996,
      1997,
      5,
      126,
      0,
      0,
      1997,
      1998,
      3,
      136,
      68,
      0,
      1998,
      1999,
      7,
      19,
      0,
      0,
      1999,
      2e3,
      3,
      138,
      69,
      0,
      2e3,
      2001,
      3,
      46,
      23,
      0,
      2001,
      231,
      1,
      0,
      0,
      0,
      2002,
      2007,
      3,
      88,
      44,
      0,
      2003,
      2004,
      5,
      202,
      0,
      0,
      2004,
      2006,
      3,
      88,
      44,
      0,
      2005,
      2003,
      1,
      0,
      0,
      0,
      2006,
      2009,
      1,
      0,
      0,
      0,
      2007,
      2005,
      1,
      0,
      0,
      0,
      2007,
      2008,
      1,
      0,
      0,
      0,
      2008,
      233,
      1,
      0,
      0,
      0,
      2009,
      2007,
      1,
      0,
      0,
      0,
      2010,
      2012,
      5,
      89,
      0,
      0,
      2011,
      2013,
      3,
      44,
      22,
      0,
      2012,
      2011,
      1,
      0,
      0,
      0,
      2012,
      2013,
      1,
      0,
      0,
      0,
      2013,
      2015,
      1,
      0,
      0,
      0,
      2014,
      2010,
      1,
      0,
      0,
      0,
      2014,
      2015,
      1,
      0,
      0,
      0,
      2015,
      2016,
      1,
      0,
      0,
      0,
      2016,
      2017,
      5,
      88,
      0,
      0,
      2017,
      2022,
      3,
      88,
      44,
      0,
      2018,
      2019,
      5,
      202,
      0,
      0,
      2019,
      2021,
      3,
      88,
      44,
      0,
      2020,
      2018,
      1,
      0,
      0,
      0,
      2021,
      2024,
      1,
      0,
      0,
      0,
      2022,
      2020,
      1,
      0,
      0,
      0,
      2022,
      2023,
      1,
      0,
      0,
      0,
      2023,
      2025,
      1,
      0,
      0,
      0,
      2024,
      2022,
      1,
      0,
      0,
      0,
      2025,
      2026,
      5,
      111,
      0,
      0,
      2026,
      2031,
      3,
      88,
      44,
      0,
      2027,
      2028,
      5,
      202,
      0,
      0,
      2028,
      2030,
      3,
      88,
      44,
      0,
      2029,
      2027,
      1,
      0,
      0,
      0,
      2030,
      2033,
      1,
      0,
      0,
      0,
      2031,
      2029,
      1,
      0,
      0,
      0,
      2031,
      2032,
      1,
      0,
      0,
      0,
      2032,
      2034,
      1,
      0,
      0,
      0,
      2033,
      2031,
      1,
      0,
      0,
      0,
      2034,
      2035,
      3,
      46,
      23,
      0,
      2035,
      235,
      1,
      0,
      0,
      0,
      2036,
      2041,
      3,
      88,
      44,
      0,
      2037,
      2038,
      5,
      202,
      0,
      0,
      2038,
      2040,
      3,
      88,
      44,
      0,
      2039,
      2037,
      1,
      0,
      0,
      0,
      2040,
      2043,
      1,
      0,
      0,
      0,
      2041,
      2039,
      1,
      0,
      0,
      0,
      2041,
      2042,
      1,
      0,
      0,
      0,
      2042,
      237,
      1,
      0,
      0,
      0,
      2043,
      2041,
      1,
      0,
      0,
      0,
      2044,
      2049,
      5,
      67,
      0,
      0,
      2045,
      2047,
      3,
      44,
      22,
      0,
      2046,
      2045,
      1,
      0,
      0,
      0,
      2046,
      2047,
      1,
      0,
      0,
      0,
      2047,
      2048,
      1,
      0,
      0,
      0,
      2048,
      2050,
      5,
      111,
      0,
      0,
      2049,
      2046,
      1,
      0,
      0,
      0,
      2049,
      2050,
      1,
      0,
      0,
      0,
      2050,
      2051,
      1,
      0,
      0,
      0,
      2051,
      2052,
      3,
      88,
      44,
      0,
      2052,
      2053,
      5,
      24,
      0,
      0,
      2053,
      2054,
      3,
      88,
      44,
      0,
      2054,
      2055,
      3,
      46,
      23,
      0,
      2055,
      239,
      1,
      0,
      0,
      0,
      2056,
      2057,
      3,
      88,
      44,
      0,
      2057,
      241,
      1,
      0,
      0,
      0,
      2058,
      2059,
      3,
      110,
      55,
      0,
      2059,
      2060,
      5,
      43,
      0,
      0,
      2060,
      2061,
      3,
      162,
      81,
      0,
      2061,
      2062,
      3,
      128,
      64,
      0,
      2062,
      243,
      1,
      0,
      0,
      0,
      2063,
      2064,
      3,
      110,
      55,
      0,
      2064,
      2065,
      5,
      28,
      0,
      0,
      2065,
      2066,
      3,
      162,
      81,
      0,
      2066,
      2067,
      3,
      128,
      64,
      0,
      2067,
      245,
      1,
      0,
      0,
      0,
      2068,
      2069,
      3,
      110,
      55,
      0,
      2069,
      2070,
      5,
      144,
      0,
      0,
      2070,
      2071,
      3,
      162,
      81,
      0,
      2071,
      2072,
      3,
      128,
      64,
      0,
      2072,
      247,
      1,
      0,
      0,
      0,
      2073,
      2074,
      3,
      110,
      55,
      0,
      2074,
      2075,
      5,
      16,
      0,
      0,
      2075,
      2076,
      3,
      162,
      81,
      0,
      2076,
      2077,
      3,
      128,
      64,
      0,
      2077,
      249,
      1,
      0,
      0,
      0,
      2078,
      2079,
      3,
      110,
      55,
      0,
      2079,
      2080,
      5,
      16,
      0,
      0,
      2080,
      2081,
      5,
      144,
      0,
      0,
      2081,
      2082,
      3,
      162,
      81,
      0,
      2082,
      2083,
      3,
      128,
      64,
      0,
      2083,
      251,
      1,
      0,
      0,
      0,
      2084,
      2085,
      3,
      176,
      88,
      0,
      2085,
      2093,
      5,
      38,
      0,
      0,
      2086,
      2088,
      3,
      184,
      92,
      0,
      2087,
      2086,
      1,
      0,
      0,
      0,
      2087,
      2088,
      1,
      0,
      0,
      0,
      2088,
      2090,
      1,
      0,
      0,
      0,
      2089,
      2091,
      3,
      318,
      159,
      0,
      2090,
      2089,
      1,
      0,
      0,
      0,
      2090,
      2091,
      1,
      0,
      0,
      0,
      2091,
      2094,
      1,
      0,
      0,
      0,
      2092,
      2094,
      3,
      254,
      127,
      0,
      2093,
      2087,
      1,
      0,
      0,
      0,
      2093,
      2092,
      1,
      0,
      0,
      0,
      2094,
      2095,
      1,
      0,
      0,
      0,
      2095,
      2096,
      3,
      128,
      64,
      0,
      2096,
      253,
      1,
      0,
      0,
      0,
      2097,
      2100,
      3,
      256,
      128,
      0,
      2098,
      2100,
      3,
      258,
      129,
      0,
      2099,
      2097,
      1,
      0,
      0,
      0,
      2099,
      2098,
      1,
      0,
      0,
      0,
      2100,
      255,
      1,
      0,
      0,
      0,
      2101,
      2103,
      3,
      184,
      92,
      0,
      2102,
      2101,
      1,
      0,
      0,
      0,
      2102,
      2103,
      1,
      0,
      0,
      0,
      2103,
      2104,
      1,
      0,
      0,
      0,
      2104,
      2110,
      5,
      74,
      0,
      0,
      2105,
      2107,
      5,
      8,
      0,
      0,
      2106,
      2108,
      5,
      74,
      0,
      0,
      2107,
      2106,
      1,
      0,
      0,
      0,
      2107,
      2108,
      1,
      0,
      0,
      0,
      2108,
      2110,
      1,
      0,
      0,
      0,
      2109,
      2102,
      1,
      0,
      0,
      0,
      2109,
      2105,
      1,
      0,
      0,
      0,
      2109,
      2110,
      1,
      0,
      0,
      0,
      2110,
      2111,
      1,
      0,
      0,
      0,
      2111,
      2112,
      3,
      260,
      130,
      0,
      2112,
      2113,
      5,
      154,
      0,
      0,
      2113,
      2114,
      3,
      260,
      130,
      0,
      2114,
      257,
      1,
      0,
      0,
      0,
      2115,
      2117,
      3,
      184,
      92,
      0,
      2116,
      2115,
      1,
      0,
      0,
      0,
      2116,
      2117,
      1,
      0,
      0,
      0,
      2117,
      2118,
      1,
      0,
      0,
      0,
      2118,
      2119,
      5,
      196,
      0,
      0,
      2119,
      2120,
      3,
      260,
      130,
      0,
      2120,
      2121,
      5,
      200,
      0,
      0,
      2121,
      2126,
      3,
      260,
      130,
      0,
      2122,
      2123,
      5,
      200,
      0,
      0,
      2123,
      2125,
      3,
      260,
      130,
      0,
      2124,
      2122,
      1,
      0,
      0,
      0,
      2125,
      2128,
      1,
      0,
      0,
      0,
      2126,
      2124,
      1,
      0,
      0,
      0,
      2126,
      2127,
      1,
      0,
      0,
      0,
      2127,
      2129,
      1,
      0,
      0,
      0,
      2128,
      2126,
      1,
      0,
      0,
      0,
      2129,
      2130,
      5,
      197,
      0,
      0,
      2130,
      259,
      1,
      0,
      0,
      0,
      2131,
      2132,
      3,
      262,
      131,
      0,
      2132,
      261,
      1,
      0,
      0,
      0,
      2133,
      2135,
      3,
      264,
      132,
      0,
      2134,
      2133,
      1,
      0,
      0,
      0,
      2134,
      2135,
      1,
      0,
      0,
      0,
      2135,
      2139,
      1,
      0,
      0,
      0,
      2136,
      2137,
      3,
      40,
      20,
      0,
      2137,
      2138,
      7,
      17,
      0,
      0,
      2138,
      2140,
      1,
      0,
      0,
      0,
      2139,
      2136,
      1,
      0,
      0,
      0,
      2139,
      2140,
      1,
      0,
      0,
      0,
      2140,
      2141,
      1,
      0,
      0,
      0,
      2141,
      2142,
      3,
      226,
      113,
      0,
      2142,
      263,
      1,
      0,
      0,
      0,
      2143,
      2144,
      3,
      266,
      133,
      0,
      2144,
      265,
      1,
      0,
      0,
      0,
      2145,
      2146,
      3,
      328,
      164,
      0,
      2146,
      267,
      1,
      0,
      0,
      0,
      2147,
      2148,
      3,
      176,
      88,
      0,
      2148,
      2149,
      5,
      22,
      0,
      0,
      2149,
      2150,
      3,
      270,
      135,
      0,
      2150,
      2151,
      3,
      128,
      64,
      0,
      2151,
      269,
      1,
      0,
      0,
      0,
      2152,
      2158,
      3,
      184,
      92,
      0,
      2153,
      2154,
      5,
      111,
      0,
      0,
      2154,
      2155,
      3,
      260,
      130,
      0,
      2155,
      2156,
      5,
      207,
      0,
      0,
      2156,
      2157,
      3,
      260,
      130,
      0,
      2157,
      2159,
      1,
      0,
      0,
      0,
      2158,
      2153,
      1,
      0,
      0,
      0,
      2158,
      2159,
      1,
      0,
      0,
      0,
      2159,
      2173,
      1,
      0,
      0,
      0,
      2160,
      2162,
      5,
      8,
      0,
      0,
      2161,
      2160,
      1,
      0,
      0,
      0,
      2161,
      2162,
      1,
      0,
      0,
      0,
      2162,
      2170,
      1,
      0,
      0,
      0,
      2163,
      2165,
      5,
      111,
      0,
      0,
      2164,
      2163,
      1,
      0,
      0,
      0,
      2164,
      2165,
      1,
      0,
      0,
      0,
      2165,
      2166,
      1,
      0,
      0,
      0,
      2166,
      2167,
      3,
      260,
      130,
      0,
      2167,
      2168,
      5,
      207,
      0,
      0,
      2168,
      2169,
      3,
      260,
      130,
      0,
      2169,
      2171,
      1,
      0,
      0,
      0,
      2170,
      2164,
      1,
      0,
      0,
      0,
      2170,
      2171,
      1,
      0,
      0,
      0,
      2171,
      2173,
      1,
      0,
      0,
      0,
      2172,
      2152,
      1,
      0,
      0,
      0,
      2172,
      2161,
      1,
      0,
      0,
      0,
      2173,
      271,
      1,
      0,
      0,
      0,
      2174,
      2175,
      3,
      176,
      88,
      0,
      2175,
      2176,
      5,
      150,
      0,
      0,
      2176,
      2177,
      3,
      274,
      137,
      0,
      2177,
      2178,
      3,
      128,
      64,
      0,
      2178,
      273,
      1,
      0,
      0,
      0,
      2179,
      2185,
      3,
      184,
      92,
      0,
      2180,
      2181,
      5,
      69,
      0,
      0,
      2181,
      2182,
      3,
      260,
      130,
      0,
      2182,
      2183,
      5,
      152,
      0,
      0,
      2183,
      2184,
      3,
      260,
      130,
      0,
      2184,
      2186,
      1,
      0,
      0,
      0,
      2185,
      2180,
      1,
      0,
      0,
      0,
      2185,
      2186,
      1,
      0,
      0,
      0,
      2186,
      2200,
      1,
      0,
      0,
      0,
      2187,
      2189,
      5,
      8,
      0,
      0,
      2188,
      2187,
      1,
      0,
      0,
      0,
      2188,
      2189,
      1,
      0,
      0,
      0,
      2189,
      2197,
      1,
      0,
      0,
      0,
      2190,
      2192,
      5,
      69,
      0,
      0,
      2191,
      2190,
      1,
      0,
      0,
      0,
      2191,
      2192,
      1,
      0,
      0,
      0,
      2192,
      2193,
      1,
      0,
      0,
      0,
      2193,
      2194,
      3,
      260,
      130,
      0,
      2194,
      2195,
      5,
      152,
      0,
      0,
      2195,
      2196,
      3,
      260,
      130,
      0,
      2196,
      2198,
      1,
      0,
      0,
      0,
      2197,
      2191,
      1,
      0,
      0,
      0,
      2197,
      2198,
      1,
      0,
      0,
      0,
      2198,
      2200,
      1,
      0,
      0,
      0,
      2199,
      2179,
      1,
      0,
      0,
      0,
      2199,
      2188,
      1,
      0,
      0,
      0,
      2200,
      275,
      1,
      0,
      0,
      0,
      2201,
      2202,
      3,
      110,
      55,
      0,
      2202,
      2203,
      5,
      20,
      0,
      0,
      2203,
      2204,
      3,
      162,
      81,
      0,
      2204,
      2205,
      3,
      128,
      64,
      0,
      2205,
      277,
      1,
      0,
      0,
      0,
      2206,
      2207,
      3,
      176,
      88,
      0,
      2207,
      2208,
      5,
      143,
      0,
      0,
      2208,
      2210,
      3,
      184,
      92,
      0,
      2209,
      2211,
      3,
      318,
      159,
      0,
      2210,
      2209,
      1,
      0,
      0,
      0,
      2210,
      2211,
      1,
      0,
      0,
      0,
      2211,
      2212,
      1,
      0,
      0,
      0,
      2212,
      2213,
      3,
      128,
      64,
      0,
      2213,
      279,
      1,
      0,
      0,
      0,
      2214,
      2215,
      3,
      110,
      55,
      0,
      2215,
      2216,
      5,
      75,
      0,
      0,
      2216,
      2217,
      3,
      162,
      81,
      0,
      2217,
      2218,
      3,
      282,
      141,
      0,
      2218,
      281,
      1,
      0,
      0,
      0,
      2219,
      2225,
      5,
      205,
      0,
      0,
      2220,
      2221,
      5,
      214,
      0,
      0,
      2221,
      2222,
      3,
      284,
      142,
      0,
      2222,
      2223,
      5,
      216,
      0,
      0,
      2223,
      2225,
      1,
      0,
      0,
      0,
      2224,
      2219,
      1,
      0,
      0,
      0,
      2224,
      2220,
      1,
      0,
      0,
      0,
      2225,
      283,
      1,
      0,
      0,
      0,
      2226,
      2230,
      3,
      390,
      195,
      0,
      2227,
      2230,
      3,
      130,
      65,
      0,
      2228,
      2230,
      3,
      286,
      143,
      0,
      2229,
      2226,
      1,
      0,
      0,
      0,
      2229,
      2227,
      1,
      0,
      0,
      0,
      2229,
      2228,
      1,
      0,
      0,
      0,
      2230,
      2233,
      1,
      0,
      0,
      0,
      2231,
      2229,
      1,
      0,
      0,
      0,
      2231,
      2232,
      1,
      0,
      0,
      0,
      2232,
      2235,
      1,
      0,
      0,
      0,
      2233,
      2231,
      1,
      0,
      0,
      0,
      2234,
      2236,
      3,
      288,
      144,
      0,
      2235,
      2234,
      1,
      0,
      0,
      0,
      2235,
      2236,
      1,
      0,
      0,
      0,
      2236,
      285,
      1,
      0,
      0,
      0,
      2237,
      2238,
      3,
      76,
      38,
      0,
      2238,
      2239,
      5,
      134,
      0,
      0,
      2239,
      2240,
      3,
      106,
      53,
      0,
      2240,
      287,
      1,
      0,
      0,
      0,
      2241,
      2242,
      3,
      76,
      38,
      0,
      2242,
      2243,
      3,
      0,
      0,
      0,
      2243,
      289,
      1,
      0,
      0,
      0,
      2244,
      2245,
      3,
      176,
      88,
      0,
      2245,
      2246,
      5,
      63,
      0,
      0,
      2246,
      2248,
      3,
      184,
      92,
      0,
      2247,
      2249,
      3,
      318,
      159,
      0,
      2248,
      2247,
      1,
      0,
      0,
      0,
      2248,
      2249,
      1,
      0,
      0,
      0,
      2249,
      2250,
      1,
      0,
      0,
      0,
      2250,
      2251,
      3,
      282,
      141,
      0,
      2251,
      291,
      1,
      0,
      0,
      0,
      2252,
      2253,
      3,
      110,
      55,
      0,
      2253,
      2254,
      5,
      121,
      0,
      0,
      2254,
      2255,
      3,
      162,
      81,
      0,
      2255,
      2256,
      3,
      282,
      141,
      0,
      2256,
      293,
      1,
      0,
      0,
      0,
      2257,
      2258,
      3,
      176,
      88,
      0,
      2258,
      2259,
      5,
      23,
      0,
      0,
      2259,
      2261,
      3,
      184,
      92,
      0,
      2260,
      2262,
      3,
      318,
      159,
      0,
      2261,
      2260,
      1,
      0,
      0,
      0,
      2261,
      2262,
      1,
      0,
      0,
      0,
      2262,
      2263,
      1,
      0,
      0,
      0,
      2263,
      2264,
      3,
      282,
      141,
      0,
      2264,
      295,
      1,
      0,
      0,
      0,
      2265,
      2266,
      3,
      176,
      88,
      0,
      2266,
      2268,
      5,
      87,
      0,
      0,
      2267,
      2269,
      7,
      8,
      0,
      0,
      2268,
      2267,
      1,
      0,
      0,
      0,
      2268,
      2269,
      1,
      0,
      0,
      0,
      2269,
      2270,
      1,
      0,
      0,
      0,
      2270,
      2272,
      3,
      184,
      92,
      0,
      2271,
      2273,
      3,
      318,
      159,
      0,
      2272,
      2271,
      1,
      0,
      0,
      0,
      2272,
      2273,
      1,
      0,
      0,
      0,
      2273,
      2274,
      1,
      0,
      0,
      0,
      2274,
      2275,
      3,
      282,
      141,
      0,
      2275,
      297,
      1,
      0,
      0,
      0,
      2276,
      2281,
      3,
      88,
      44,
      0,
      2277,
      2278,
      5,
      202,
      0,
      0,
      2278,
      2280,
      3,
      88,
      44,
      0,
      2279,
      2277,
      1,
      0,
      0,
      0,
      2280,
      2283,
      1,
      0,
      0,
      0,
      2281,
      2279,
      1,
      0,
      0,
      0,
      2281,
      2282,
      1,
      0,
      0,
      0,
      2282,
      299,
      1,
      0,
      0,
      0,
      2283,
      2281,
      1,
      0,
      0,
      0,
      2284,
      2285,
      3,
      110,
      55,
      0,
      2285,
      2286,
      5,
      84,
      0,
      0,
      2286,
      2287,
      3,
      162,
      81,
      0,
      2287,
      2288,
      3,
      128,
      64,
      0,
      2288,
      301,
      1,
      0,
      0,
      0,
      2289,
      2290,
      3,
      176,
      88,
      0,
      2290,
      2291,
      5,
      70,
      0,
      0,
      2291,
      2292,
      3,
      306,
      153,
      0,
      2292,
      2293,
      3,
      128,
      64,
      0,
      2293,
      303,
      1,
      0,
      0,
      0,
      2294,
      2295,
      3,
      176,
      88,
      0,
      2295,
      2296,
      5,
      150,
      0,
      0,
      2296,
      2297,
      5,
      70,
      0,
      0,
      2297,
      2298,
      3,
      306,
      153,
      0,
      2298,
      2299,
      3,
      128,
      64,
      0,
      2299,
      305,
      1,
      0,
      0,
      0,
      2300,
      2302,
      3,
      184,
      92,
      0,
      2301,
      2303,
      3,
      318,
      159,
      0,
      2302,
      2301,
      1,
      0,
      0,
      0,
      2302,
      2303,
      1,
      0,
      0,
      0,
      2303,
      2306,
      1,
      0,
      0,
      0,
      2304,
      2305,
      5,
      111,
      0,
      0,
      2305,
      2307,
      3,
      308,
      154,
      0,
      2306,
      2304,
      1,
      0,
      0,
      0,
      2306,
      2307,
      1,
      0,
      0,
      0,
      2307,
      2313,
      1,
      0,
      0,
      0,
      2308,
      2309,
      5,
      74,
      0,
      0,
      2309,
      2310,
      3,
      314,
      157,
      0,
      2310,
      2311,
      5,
      154,
      0,
      0,
      2311,
      2312,
      3,
      314,
      157,
      0,
      2312,
      2314,
      1,
      0,
      0,
      0,
      2313,
      2308,
      1,
      0,
      0,
      0,
      2313,
      2314,
      1,
      0,
      0,
      0,
      2314,
      2340,
      1,
      0,
      0,
      0,
      2315,
      2317,
      5,
      8,
      0,
      0,
      2316,
      2315,
      1,
      0,
      0,
      0,
      2316,
      2317,
      1,
      0,
      0,
      0,
      2317,
      2318,
      1,
      0,
      0,
      0,
      2318,
      2319,
      3,
      314,
      157,
      0,
      2319,
      2320,
      5,
      154,
      0,
      0,
      2320,
      2321,
      3,
      314,
      157,
      0,
      2321,
      2340,
      1,
      0,
      0,
      0,
      2322,
      2324,
      3,
      418,
      209,
      0,
      2323,
      2322,
      1,
      0,
      0,
      0,
      2323,
      2324,
      1,
      0,
      0,
      0,
      2324,
      2326,
      1,
      0,
      0,
      0,
      2325,
      2327,
      3,
      318,
      159,
      0,
      2326,
      2325,
      1,
      0,
      0,
      0,
      2326,
      2327,
      1,
      0,
      0,
      0,
      2327,
      2330,
      1,
      0,
      0,
      0,
      2328,
      2329,
      5,
      111,
      0,
      0,
      2329,
      2331,
      3,
      570,
      285,
      0,
      2330,
      2328,
      1,
      0,
      0,
      0,
      2330,
      2331,
      1,
      0,
      0,
      0,
      2331,
      2337,
      1,
      0,
      0,
      0,
      2332,
      2333,
      5,
      74,
      0,
      0,
      2333,
      2334,
      3,
      314,
      157,
      0,
      2334,
      2335,
      5,
      154,
      0,
      0,
      2335,
      2336,
      3,
      314,
      157,
      0,
      2336,
      2338,
      1,
      0,
      0,
      0,
      2337,
      2332,
      1,
      0,
      0,
      0,
      2337,
      2338,
      1,
      0,
      0,
      0,
      2338,
      2340,
      1,
      0,
      0,
      0,
      2339,
      2300,
      1,
      0,
      0,
      0,
      2339,
      2316,
      1,
      0,
      0,
      0,
      2339,
      2323,
      1,
      0,
      0,
      0,
      2340,
      307,
      1,
      0,
      0,
      0,
      2341,
      2342,
      3,
      310,
      155,
      0,
      2342,
      309,
      1,
      0,
      0,
      0,
      2343,
      2345,
      3,
      44,
      22,
      0,
      2344,
      2343,
      1,
      0,
      0,
      0,
      2344,
      2345,
      1,
      0,
      0,
      0,
      2345,
      2346,
      1,
      0,
      0,
      0,
      2346,
      2363,
      3,
      318,
      159,
      0,
      2347,
      2349,
      3,
      44,
      22,
      0,
      2348,
      2347,
      1,
      0,
      0,
      0,
      2348,
      2349,
      1,
      0,
      0,
      0,
      2349,
      2350,
      1,
      0,
      0,
      0,
      2350,
      2352,
      3,
      312,
      156,
      0,
      2351,
      2353,
      3,
      318,
      159,
      0,
      2352,
      2351,
      1,
      0,
      0,
      0,
      2352,
      2353,
      1,
      0,
      0,
      0,
      2353,
      2363,
      1,
      0,
      0,
      0,
      2354,
      2356,
      3,
      220,
      110,
      0,
      2355,
      2357,
      3,
      328,
      164,
      0,
      2356,
      2355,
      1,
      0,
      0,
      0,
      2356,
      2357,
      1,
      0,
      0,
      0,
      2357,
      2363,
      1,
      0,
      0,
      0,
      2358,
      2360,
      3,
      328,
      164,
      0,
      2359,
      2361,
      3,
      220,
      110,
      0,
      2360,
      2359,
      1,
      0,
      0,
      0,
      2360,
      2361,
      1,
      0,
      0,
      0,
      2361,
      2363,
      1,
      0,
      0,
      0,
      2362,
      2344,
      1,
      0,
      0,
      0,
      2362,
      2348,
      1,
      0,
      0,
      0,
      2362,
      2354,
      1,
      0,
      0,
      0,
      2362,
      2358,
      1,
      0,
      0,
      0,
      2363,
      311,
      1,
      0,
      0,
      0,
      2364,
      2366,
      3,
      200,
      100,
      0,
      2365,
      2364,
      1,
      0,
      0,
      0,
      2366,
      2367,
      1,
      0,
      0,
      0,
      2367,
      2365,
      1,
      0,
      0,
      0,
      2367,
      2368,
      1,
      0,
      0,
      0,
      2368,
      2370,
      1,
      0,
      0,
      0,
      2369,
      2371,
      3,
      198,
      99,
      0,
      2370,
      2369,
      1,
      0,
      0,
      0,
      2370,
      2371,
      1,
      0,
      0,
      0,
      2371,
      2375,
      1,
      0,
      0,
      0,
      2372,
      2374,
      3,
      200,
      100,
      0,
      2373,
      2372,
      1,
      0,
      0,
      0,
      2374,
      2377,
      1,
      0,
      0,
      0,
      2375,
      2373,
      1,
      0,
      0,
      0,
      2375,
      2376,
      1,
      0,
      0,
      0,
      2376,
      2385,
      1,
      0,
      0,
      0,
      2377,
      2375,
      1,
      0,
      0,
      0,
      2378,
      2380,
      3,
      198,
      99,
      0,
      2379,
      2381,
      3,
      200,
      100,
      0,
      2380,
      2379,
      1,
      0,
      0,
      0,
      2381,
      2382,
      1,
      0,
      0,
      0,
      2382,
      2380,
      1,
      0,
      0,
      0,
      2382,
      2383,
      1,
      0,
      0,
      0,
      2383,
      2385,
      1,
      0,
      0,
      0,
      2384,
      2365,
      1,
      0,
      0,
      0,
      2384,
      2378,
      1,
      0,
      0,
      0,
      2385,
      313,
      1,
      0,
      0,
      0,
      2386,
      2387,
      3,
      316,
      158,
      0,
      2387,
      315,
      1,
      0,
      0,
      0,
      2388,
      2393,
      3,
      88,
      44,
      0,
      2389,
      2390,
      5,
      202,
      0,
      0,
      2390,
      2392,
      3,
      88,
      44,
      0,
      2391,
      2389,
      1,
      0,
      0,
      0,
      2392,
      2395,
      1,
      0,
      0,
      0,
      2393,
      2391,
      1,
      0,
      0,
      0,
      2393,
      2394,
      1,
      0,
      0,
      0,
      2394,
      317,
      1,
      0,
      0,
      0,
      2395,
      2393,
      1,
      0,
      0,
      0,
      2396,
      2397,
      3,
      320,
      160,
      0,
      2397,
      319,
      1,
      0,
      0,
      0,
      2398,
      2405,
      5,
      207,
      0,
      0,
      2399,
      2405,
      5,
      184,
      0,
      0,
      2400,
      2402,
      5,
      46,
      0,
      0,
      2401,
      2403,
      7,
      20,
      0,
      0,
      2402,
      2401,
      1,
      0,
      0,
      0,
      2402,
      2403,
      1,
      0,
      0,
      0,
      2403,
      2405,
      1,
      0,
      0,
      0,
      2404,
      2398,
      1,
      0,
      0,
      0,
      2404,
      2399,
      1,
      0,
      0,
      0,
      2404,
      2400,
      1,
      0,
      0,
      0,
      2405,
      2406,
      1,
      0,
      0,
      0,
      2406,
      2407,
      3,
      0,
      0,
      0,
      2407,
      321,
      1,
      0,
      0,
      0,
      2408,
      2411,
      3,
      324,
      162,
      0,
      2409,
      2411,
      3,
      326,
      163,
      0,
      2410,
      2408,
      1,
      0,
      0,
      0,
      2410,
      2409,
      1,
      0,
      0,
      0,
      2411,
      323,
      1,
      0,
      0,
      0,
      2412,
      2414,
      5,
      103,
      0,
      0,
      2413,
      2415,
      3,
      44,
      22,
      0,
      2414,
      2413,
      1,
      0,
      0,
      0,
      2414,
      2415,
      1,
      0,
      0,
      0,
      2415,
      2416,
      1,
      0,
      0,
      0,
      2416,
      2417,
      3,
      208,
      104,
      0,
      2417,
      2418,
      3,
      128,
      64,
      0,
      2418,
      325,
      1,
      0,
      0,
      0,
      2419,
      2421,
      5,
      103,
      0,
      0,
      2420,
      2422,
      3,
      44,
      22,
      0,
      2421,
      2420,
      1,
      0,
      0,
      0,
      2421,
      2422,
      1,
      0,
      0,
      0,
      2422,
      2423,
      1,
      0,
      0,
      0,
      2423,
      2424,
      3,
      332,
      166,
      0,
      2424,
      2425,
      3,
      128,
      64,
      0,
      2425,
      327,
      1,
      0,
      0,
      0,
      2426,
      2427,
      3,
      330,
      165,
      0,
      2427,
      329,
      1,
      0,
      0,
      0,
      2428,
      2429,
      3,
      332,
      166,
      0,
      2429,
      331,
      1,
      0,
      0,
      0,
      2430,
      2434,
      5,
      211,
      0,
      0,
      2431,
      2432,
      3,
      334,
      167,
      0,
      2432,
      2433,
      5,
      181,
      0,
      0,
      2433,
      2435,
      1,
      0,
      0,
      0,
      2434,
      2431,
      1,
      0,
      0,
      0,
      2434,
      2435,
      1,
      0,
      0,
      0,
      2435,
      2436,
      1,
      0,
      0,
      0,
      2436,
      2437,
      3,
      334,
      167,
      0,
      2437,
      2438,
      5,
      212,
      0,
      0,
      2438,
      333,
      1,
      0,
      0,
      0,
      2439,
      2442,
      3,
      24,
      12,
      0,
      2440,
      2442,
      3,
      10,
      5,
      0,
      2441,
      2439,
      1,
      0,
      0,
      0,
      2441,
      2440,
      1,
      0,
      0,
      0,
      2442,
      335,
      1,
      0,
      0,
      0,
      2443,
      2444,
      3,
      110,
      55,
      0,
      2444,
      2445,
      5,
      101,
      0,
      0,
      2445,
      2446,
      3,
      162,
      81,
      0,
      2446,
      2447,
      3,
      128,
      64,
      0,
      2447,
      337,
      1,
      0,
      0,
      0,
      2448,
      2449,
      5,
      192,
      0,
      0,
      2449,
      2453,
      3,
      342,
      171,
      0,
      2450,
      2451,
      5,
      192,
      0,
      0,
      2451,
      2453,
      3,
      874,
      437,
      0,
      2452,
      2448,
      1,
      0,
      0,
      0,
      2452,
      2450,
      1,
      0,
      0,
      0,
      2453,
      339,
      1,
      0,
      0,
      0,
      2454,
      2455,
      5,
      192,
      0,
      0,
      2455,
      2459,
      3,
      342,
      171,
      0,
      2456,
      2457,
      5,
      192,
      0,
      0,
      2457,
      2459,
      3,
      874,
      437,
      0,
      2458,
      2454,
      1,
      0,
      0,
      0,
      2458,
      2456,
      1,
      0,
      0,
      0,
      2459,
      341,
      1,
      0,
      0,
      0,
      2460,
      2461,
      3,
      220,
      110,
      0,
      2461,
      343,
      1,
      0,
      0,
      0,
      2462,
      2464,
      3,
      340,
      170,
      0,
      2463,
      2462,
      1,
      0,
      0,
      0,
      2464,
      2467,
      1,
      0,
      0,
      0,
      2465,
      2463,
      1,
      0,
      0,
      0,
      2465,
      2466,
      1,
      0,
      0,
      0,
      2466,
      2468,
      1,
      0,
      0,
      0,
      2467,
      2465,
      1,
      0,
      0,
      0,
      2468,
      2469,
      7,
      21,
      0,
      0,
      2469,
      2479,
      3,
      346,
      173,
      0,
      2470,
      2471,
      5,
      1,
      0,
      0,
      2471,
      2476,
      3,
      54,
      27,
      0,
      2472,
      2473,
      5,
      200,
      0,
      0,
      2473,
      2475,
      3,
      54,
      27,
      0,
      2474,
      2472,
      1,
      0,
      0,
      0,
      2475,
      2478,
      1,
      0,
      0,
      0,
      2476,
      2474,
      1,
      0,
      0,
      0,
      2476,
      2477,
      1,
      0,
      0,
      0,
      2477,
      2480,
      1,
      0,
      0,
      0,
      2478,
      2476,
      1,
      0,
      0,
      0,
      2479,
      2470,
      1,
      0,
      0,
      0,
      2479,
      2480,
      1,
      0,
      0,
      0,
      2480,
      2481,
      1,
      0,
      0,
      0,
      2481,
      2482,
      3,
      348,
      174,
      0,
      2482,
      345,
      1,
      0,
      0,
      0,
      2483,
      2485,
      3,
      44,
      22,
      0,
      2484,
      2483,
      1,
      0,
      0,
      0,
      2484,
      2485,
      1,
      0,
      0,
      0,
      2485,
      2489,
      1,
      0,
      0,
      0,
      2486,
      2490,
      5,
      204,
      0,
      0,
      2487,
      2488,
      5,
      158,
      0,
      0,
      2488,
      2490,
      5,
      24,
      0,
      0,
      2489,
      2486,
      1,
      0,
      0,
      0,
      2489,
      2487,
      1,
      0,
      0,
      0,
      2490,
      2492,
      1,
      0,
      0,
      0,
      2491,
      2484,
      1,
      0,
      0,
      0,
      2491,
      2492,
      1,
      0,
      0,
      0,
      2492,
      2493,
      1,
      0,
      0,
      0,
      2493,
      2494,
      3,
      220,
      110,
      0,
      2494,
      347,
      1,
      0,
      0,
      0,
      2495,
      2516,
      5,
      205,
      0,
      0,
      2496,
      2500,
      5,
      214,
      0,
      0,
      2497,
      2499,
      3,
      350,
      175,
      0,
      2498,
      2497,
      1,
      0,
      0,
      0,
      2499,
      2502,
      1,
      0,
      0,
      0,
      2500,
      2498,
      1,
      0,
      0,
      0,
      2500,
      2501,
      1,
      0,
      0,
      0,
      2501,
      2503,
      1,
      0,
      0,
      0,
      2502,
      2500,
      1,
      0,
      0,
      0,
      2503,
      2516,
      5,
      216,
      0,
      0,
      2504,
      2511,
      5,
      214,
      0,
      0,
      2505,
      2510,
      3,
      394,
      197,
      0,
      2506,
      2510,
      3,
      876,
      438,
      0,
      2507,
      2510,
      3,
      86,
      43,
      0,
      2508,
      2510,
      3,
      90,
      45,
      0,
      2509,
      2505,
      1,
      0,
      0,
      0,
      2509,
      2506,
      1,
      0,
      0,
      0,
      2509,
      2507,
      1,
      0,
      0,
      0,
      2509,
      2508,
      1,
      0,
      0,
      0,
      2510,
      2513,
      1,
      0,
      0,
      0,
      2511,
      2509,
      1,
      0,
      0,
      0,
      2511,
      2512,
      1,
      0,
      0,
      0,
      2512,
      2514,
      1,
      0,
      0,
      0,
      2513,
      2511,
      1,
      0,
      0,
      0,
      2514,
      2516,
      5,
      216,
      0,
      0,
      2515,
      2495,
      1,
      0,
      0,
      0,
      2515,
      2496,
      1,
      0,
      0,
      0,
      2515,
      2504,
      1,
      0,
      0,
      0,
      2516,
      349,
      1,
      0,
      0,
      0,
      2517,
      2522,
      3,
      82,
      41,
      0,
      2518,
      2522,
      3,
      352,
      176,
      0,
      2519,
      2522,
      3,
      86,
      43,
      0,
      2520,
      2522,
      3,
      90,
      45,
      0,
      2521,
      2517,
      1,
      0,
      0,
      0,
      2521,
      2518,
      1,
      0,
      0,
      0,
      2521,
      2519,
      1,
      0,
      0,
      0,
      2521,
      2520,
      1,
      0,
      0,
      0,
      2522,
      351,
      1,
      0,
      0,
      0,
      2523,
      2524,
      3,
      354,
      177,
      0,
      2524,
      353,
      1,
      0,
      0,
      0,
      2525,
      2527,
      5,
      65,
      0,
      0,
      2526,
      2525,
      1,
      0,
      0,
      0,
      2526,
      2527,
      1,
      0,
      0,
      0,
      2527,
      2529,
      1,
      0,
      0,
      0,
      2528,
      2530,
      7,
      19,
      0,
      0,
      2529,
      2528,
      1,
      0,
      0,
      0,
      2529,
      2530,
      1,
      0,
      0,
      0,
      2530,
      2531,
      1,
      0,
      0,
      0,
      2531,
      2533,
      3,
      232,
      116,
      0,
      2532,
      2534,
      3,
      196,
      98,
      0,
      2533,
      2532,
      1,
      0,
      0,
      0,
      2533,
      2534,
      1,
      0,
      0,
      0,
      2534,
      2536,
      1,
      0,
      0,
      0,
      2535,
      2537,
      3,
      318,
      159,
      0,
      2536,
      2535,
      1,
      0,
      0,
      0,
      2536,
      2537,
      1,
      0,
      0,
      0,
      2537,
      2538,
      1,
      0,
      0,
      0,
      2538,
      2539,
      3,
      348,
      174,
      0,
      2539,
      355,
      1,
      0,
      0,
      0,
      2540,
      2542,
      3,
      340,
      170,
      0,
      2541,
      2540,
      1,
      0,
      0,
      0,
      2542,
      2545,
      1,
      0,
      0,
      0,
      2543,
      2541,
      1,
      0,
      0,
      0,
      2543,
      2544,
      1,
      0,
      0,
      0,
      2544,
      2546,
      1,
      0,
      0,
      0,
      2545,
      2543,
      1,
      0,
      0,
      0,
      2546,
      2547,
      3,
      360,
      180,
      0,
      2547,
      2548,
      3,
      362,
      181,
      0,
      2548,
      357,
      1,
      0,
      0,
      0,
      2549,
      2551,
      5,
      141,
      0,
      0,
      2550,
      2549,
      1,
      0,
      0,
      0,
      2550,
      2551,
      1,
      0,
      0,
      0,
      2551,
      2552,
      1,
      0,
      0,
      0,
      2552,
      2556,
      5,
      94,
      0,
      0,
      2553,
      2555,
      3,
      340,
      170,
      0,
      2554,
      2553,
      1,
      0,
      0,
      0,
      2555,
      2558,
      1,
      0,
      0,
      0,
      2556,
      2554,
      1,
      0,
      0,
      0,
      2556,
      2557,
      1,
      0,
      0,
      0,
      2557,
      2559,
      1,
      0,
      0,
      0,
      2558,
      2556,
      1,
      0,
      0,
      0,
      2559,
      2560,
      3,
      360,
      180,
      0,
      2560,
      2561,
      3,
      362,
      181,
      0,
      2561,
      359,
      1,
      0,
      0,
      0,
      2562,
      2564,
      5,
      115,
      0,
      0,
      2563,
      2565,
      3,
      44,
      22,
      0,
      2564,
      2563,
      1,
      0,
      0,
      0,
      2564,
      2565,
      1,
      0,
      0,
      0,
      2565,
      361,
      1,
      0,
      0,
      0,
      2566,
      2576,
      5,
      205,
      0,
      0,
      2567,
      2571,
      5,
      214,
      0,
      0,
      2568,
      2570,
      3,
      370,
      185,
      0,
      2569,
      2568,
      1,
      0,
      0,
      0,
      2570,
      2573,
      1,
      0,
      0,
      0,
      2571,
      2569,
      1,
      0,
      0,
      0,
      2571,
      2572,
      1,
      0,
      0,
      0,
      2572,
      2574,
      1,
      0,
      0,
      0,
      2573,
      2571,
      1,
      0,
      0,
      0,
      2574,
      2576,
      5,
      216,
      0,
      0,
      2575,
      2566,
      1,
      0,
      0,
      0,
      2575,
      2567,
      1,
      0,
      0,
      0,
      2576,
      363,
      1,
      0,
      0,
      0,
      2577,
      2578,
      3,
      76,
      38,
      0,
      2578,
      2579,
      5,
      68,
      0,
      0,
      2579,
      2580,
      3,
      0,
      0,
      0,
      2580,
      2581,
      5,
      205,
      0,
      0,
      2581,
      365,
      1,
      0,
      0,
      0,
      2582,
      2584,
      3,
      44,
      22,
      0,
      2583,
      2582,
      1,
      0,
      0,
      0,
      2583,
      2584,
      1,
      0,
      0,
      0,
      2584,
      2585,
      1,
      0,
      0,
      0,
      2585,
      2587,
      5,
      74,
      0,
      0,
      2586,
      2583,
      1,
      0,
      0,
      0,
      2586,
      2587,
      1,
      0,
      0,
      0,
      2587,
      2588,
      1,
      0,
      0,
      0,
      2588,
      2593,
      3,
      88,
      44,
      0,
      2589,
      2590,
      5,
      200,
      0,
      0,
      2590,
      2592,
      3,
      88,
      44,
      0,
      2591,
      2589,
      1,
      0,
      0,
      0,
      2592,
      2595,
      1,
      0,
      0,
      0,
      2593,
      2591,
      1,
      0,
      0,
      0,
      2593,
      2594,
      1,
      0,
      0,
      0,
      2594,
      2596,
      1,
      0,
      0,
      0,
      2595,
      2593,
      1,
      0,
      0,
      0,
      2596,
      2597,
      5,
      154,
      0,
      0,
      2597,
      2602,
      3,
      88,
      44,
      0,
      2598,
      2599,
      5,
      200,
      0,
      0,
      2599,
      2601,
      3,
      88,
      44,
      0,
      2600,
      2598,
      1,
      0,
      0,
      0,
      2601,
      2604,
      1,
      0,
      0,
      0,
      2602,
      2600,
      1,
      0,
      0,
      0,
      2602,
      2603,
      1,
      0,
      0,
      0,
      2603,
      367,
      1,
      0,
      0,
      0,
      2604,
      2602,
      1,
      0,
      0,
      0,
      2605,
      2606,
      3,
      58,
      29,
      0,
      2606,
      369,
      1,
      0,
      0,
      0,
      2607,
      2612,
      3,
      372,
      186,
      0,
      2608,
      2612,
      3,
      364,
      182,
      0,
      2609,
      2612,
      3,
      86,
      43,
      0,
      2610,
      2612,
      3,
      90,
      45,
      0,
      2611,
      2607,
      1,
      0,
      0,
      0,
      2611,
      2608,
      1,
      0,
      0,
      0,
      2611,
      2609,
      1,
      0,
      0,
      0,
      2611,
      2610,
      1,
      0,
      0,
      0,
      2612,
      371,
      1,
      0,
      0,
      0,
      2613,
      2616,
      3,
      76,
      38,
      0,
      2614,
      2617,
      3,
      374,
      187,
      0,
      2615,
      2617,
      3,
      376,
      188,
      0,
      2616,
      2614,
      1,
      0,
      0,
      0,
      2616,
      2615,
      1,
      0,
      0,
      0,
      2617,
      373,
      1,
      0,
      0,
      0,
      2618,
      2649,
      3,
      356,
      178,
      0,
      2619,
      2649,
      3,
      358,
      179,
      0,
      2620,
      2649,
      3,
      58,
      29,
      0,
      2621,
      2649,
      3,
      52,
      26,
      0,
      2622,
      2649,
      3,
      446,
      223,
      0,
      2623,
      2649,
      3,
      450,
      225,
      0,
      2624,
      2649,
      3,
      462,
      231,
      0,
      2625,
      2649,
      3,
      464,
      232,
      0,
      2626,
      2649,
      3,
      488,
      244,
      0,
      2627,
      2649,
      3,
      492,
      246,
      0,
      2628,
      2649,
      3,
      506,
      253,
      0,
      2629,
      2649,
      3,
      556,
      278,
      0,
      2630,
      2649,
      3,
      520,
      260,
      0,
      2631,
      2649,
      3,
      496,
      248,
      0,
      2632,
      2649,
      3,
      574,
      287,
      0,
      2633,
      2649,
      3,
      748,
      374,
      0,
      2634,
      2649,
      3,
      686,
      343,
      0,
      2635,
      2649,
      3,
      760,
      380,
      0,
      2636,
      2649,
      3,
      768,
      384,
      0,
      2637,
      2649,
      3,
      808,
      404,
      0,
      2638,
      2649,
      3,
      812,
      406,
      0,
      2639,
      2649,
      3,
      824,
      412,
      0,
      2640,
      2649,
      3,
      828,
      414,
      0,
      2641,
      2649,
      3,
      836,
      418,
      0,
      2642,
      2649,
      3,
      842,
      421,
      0,
      2643,
      2649,
      3,
      864,
      432,
      0,
      2644,
      2649,
      3,
      868,
      434,
      0,
      2645,
      2649,
      3,
      872,
      436,
      0,
      2646,
      2649,
      3,
      550,
      275,
      0,
      2647,
      2649,
      3,
      880,
      440,
      0,
      2648,
      2618,
      1,
      0,
      0,
      0,
      2648,
      2619,
      1,
      0,
      0,
      0,
      2648,
      2620,
      1,
      0,
      0,
      0,
      2648,
      2621,
      1,
      0,
      0,
      0,
      2648,
      2622,
      1,
      0,
      0,
      0,
      2648,
      2623,
      1,
      0,
      0,
      0,
      2648,
      2624,
      1,
      0,
      0,
      0,
      2648,
      2625,
      1,
      0,
      0,
      0,
      2648,
      2626,
      1,
      0,
      0,
      0,
      2648,
      2627,
      1,
      0,
      0,
      0,
      2648,
      2628,
      1,
      0,
      0,
      0,
      2648,
      2629,
      1,
      0,
      0,
      0,
      2648,
      2630,
      1,
      0,
      0,
      0,
      2648,
      2631,
      1,
      0,
      0,
      0,
      2648,
      2632,
      1,
      0,
      0,
      0,
      2648,
      2633,
      1,
      0,
      0,
      0,
      2648,
      2634,
      1,
      0,
      0,
      0,
      2648,
      2635,
      1,
      0,
      0,
      0,
      2648,
      2636,
      1,
      0,
      0,
      0,
      2648,
      2637,
      1,
      0,
      0,
      0,
      2648,
      2638,
      1,
      0,
      0,
      0,
      2648,
      2639,
      1,
      0,
      0,
      0,
      2648,
      2640,
      1,
      0,
      0,
      0,
      2648,
      2641,
      1,
      0,
      0,
      0,
      2648,
      2642,
      1,
      0,
      0,
      0,
      2648,
      2643,
      1,
      0,
      0,
      0,
      2648,
      2644,
      1,
      0,
      0,
      0,
      2648,
      2645,
      1,
      0,
      0,
      0,
      2648,
      2646,
      1,
      0,
      0,
      0,
      2648,
      2647,
      1,
      0,
      0,
      0,
      2649,
      375,
      1,
      0,
      0,
      0,
      2650,
      2653,
      3,
      432,
      216,
      0,
      2651,
      2653,
      3,
      436,
      218,
      0,
      2652,
      2650,
      1,
      0,
      0,
      0,
      2652,
      2651,
      1,
      0,
      0,
      0,
      2653,
      377,
      1,
      0,
      0,
      0,
      2654,
      2655,
      7,
      22,
      0,
      0,
      2655,
      379,
      1,
      0,
      0,
      0,
      2656,
      2657,
      3,
      340,
      170,
      0,
      2657,
      381,
      1,
      0,
      0,
      0,
      2658,
      2660,
      3,
      378,
      189,
      0,
      2659,
      2658,
      1,
      0,
      0,
      0,
      2659,
      2660,
      1,
      0,
      0,
      0,
      2660,
      2664,
      1,
      0,
      0,
      0,
      2661,
      2663,
      3,
      380,
      190,
      0,
      2662,
      2661,
      1,
      0,
      0,
      0,
      2663,
      2666,
      1,
      0,
      0,
      0,
      2664,
      2662,
      1,
      0,
      0,
      0,
      2664,
      2665,
      1,
      0,
      0,
      0,
      2665,
      383,
      1,
      0,
      0,
      0,
      2666,
      2664,
      1,
      0,
      0,
      0,
      2667,
      2668,
      3,
      386,
      193,
      0,
      2668,
      2669,
      3,
      388,
      194,
      0,
      2669,
      385,
      1,
      0,
      0,
      0,
      2670,
      2672,
      3,
      44,
      22,
      0,
      2671,
      2670,
      1,
      0,
      0,
      0,
      2671,
      2672,
      1,
      0,
      0,
      0,
      2672,
      2674,
      1,
      0,
      0,
      0,
      2673,
      2675,
      3,
      444,
      222,
      0,
      2674,
      2673,
      1,
      0,
      0,
      0,
      2674,
      2675,
      1,
      0,
      0,
      0,
      2675,
      387,
      1,
      0,
      0,
      0,
      2676,
      2686,
      5,
      205,
      0,
      0,
      2677,
      2681,
      5,
      214,
      0,
      0,
      2678,
      2680,
      3,
      390,
      195,
      0,
      2679,
      2678,
      1,
      0,
      0,
      0,
      2680,
      2683,
      1,
      0,
      0,
      0,
      2681,
      2679,
      1,
      0,
      0,
      0,
      2681,
      2682,
      1,
      0,
      0,
      0,
      2682,
      2684,
      1,
      0,
      0,
      0,
      2683,
      2681,
      1,
      0,
      0,
      0,
      2684,
      2686,
      5,
      216,
      0,
      0,
      2685,
      2676,
      1,
      0,
      0,
      0,
      2685,
      2677,
      1,
      0,
      0,
      0,
      2686,
      389,
      1,
      0,
      0,
      0,
      2687,
      2704,
      3,
      90,
      45,
      0,
      2688,
      2689,
      3,
      76,
      38,
      0,
      2689,
      2690,
      3,
      392,
      196,
      0,
      2690,
      2704,
      1,
      0,
      0,
      0,
      2691,
      2693,
      3,
      480,
      240,
      0,
      2692,
      2691,
      1,
      0,
      0,
      0,
      2692,
      2693,
      1,
      0,
      0,
      0,
      2693,
      2694,
      1,
      0,
      0,
      0,
      2694,
      2695,
      3,
      76,
      38,
      0,
      2695,
      2696,
      3,
      434,
      217,
      0,
      2696,
      2704,
      1,
      0,
      0,
      0,
      2697,
      2699,
      3,
      480,
      240,
      0,
      2698,
      2697,
      1,
      0,
      0,
      0,
      2698,
      2699,
      1,
      0,
      0,
      0,
      2699,
      2700,
      1,
      0,
      0,
      0,
      2700,
      2701,
      3,
      76,
      38,
      0,
      2701,
      2702,
      3,
      436,
      218,
      0,
      2702,
      2704,
      1,
      0,
      0,
      0,
      2703,
      2687,
      1,
      0,
      0,
      0,
      2703,
      2688,
      1,
      0,
      0,
      0,
      2703,
      2692,
      1,
      0,
      0,
      0,
      2703,
      2698,
      1,
      0,
      0,
      0,
      2704,
      391,
      1,
      0,
      0,
      0,
      2705,
      2710,
      5,
      7,
      0,
      0,
      2706,
      2707,
      5,
      206,
      0,
      0,
      2707,
      2708,
      3,
      40,
      20,
      0,
      2708,
      2709,
      5,
      208,
      0,
      0,
      2709,
      2711,
      1,
      0,
      0,
      0,
      2710,
      2706,
      1,
      0,
      0,
      0,
      2710,
      2711,
      1,
      0,
      0,
      0,
      2711,
      2713,
      1,
      0,
      0,
      0,
      2712,
      2714,
      3,
      40,
      20,
      0,
      2713,
      2712,
      1,
      0,
      0,
      0,
      2713,
      2714,
      1,
      0,
      0,
      0,
      2714,
      2715,
      1,
      0,
      0,
      0,
      2715,
      2716,
      5,
      71,
      0,
      0,
      2716,
      2717,
      3,
      88,
      44,
      0,
      2717,
      2718,
      3,
      46,
      23,
      0,
      2718,
      2724,
      1,
      0,
      0,
      0,
      2719,
      2720,
      5,
      164,
      0,
      0,
      2720,
      2724,
      3,
      442,
      221,
      0,
      2721,
      2724,
      3,
      374,
      187,
      0,
      2722,
      2724,
      3,
      432,
      216,
      0,
      2723,
      2705,
      1,
      0,
      0,
      0,
      2723,
      2719,
      1,
      0,
      0,
      0,
      2723,
      2721,
      1,
      0,
      0,
      0,
      2723,
      2722,
      1,
      0,
      0,
      0,
      2724,
      393,
      1,
      0,
      0,
      0,
      2725,
      2726,
      3,
      76,
      38,
      0,
      2726,
      2727,
      3,
      374,
      187,
      0,
      2727,
      395,
      1,
      0,
      0,
      0,
      2728,
      2729,
      3,
      76,
      38,
      0,
      2729,
      2730,
      5,
      164,
      0,
      0,
      2730,
      2731,
      3,
      442,
      221,
      0,
      2731,
      397,
      1,
      0,
      0,
      0,
      2732,
      2733,
      3,
      76,
      38,
      0,
      2733,
      2734,
      3,
      432,
      216,
      0,
      2734,
      399,
      1,
      0,
      0,
      0,
      2735,
      2736,
      3,
      76,
      38,
      0,
      2736,
      2737,
      3,
      438,
      219,
      0,
      2737,
      401,
      1,
      0,
      0,
      0,
      2738,
      2739,
      3,
      76,
      38,
      0,
      2739,
      2740,
      3,
      440,
      220,
      0,
      2740,
      403,
      1,
      0,
      0,
      0,
      2741,
      2743,
      3,
      182,
      91,
      0,
      2742,
      2741,
      1,
      0,
      0,
      0,
      2742,
      2743,
      1,
      0,
      0,
      0,
      2743,
      2745,
      1,
      0,
      0,
      0,
      2744,
      2746,
      5,
      49,
      0,
      0,
      2745,
      2744,
      1,
      0,
      0,
      0,
      2745,
      2746,
      1,
      0,
      0,
      0,
      2746,
      2748,
      1,
      0,
      0,
      0,
      2747,
      2749,
      7,
      22,
      0,
      0,
      2748,
      2747,
      1,
      0,
      0,
      0,
      2748,
      2749,
      1,
      0,
      0,
      0,
      2749,
      2751,
      1,
      0,
      0,
      0,
      2750,
      2752,
      5,
      40,
      0,
      0,
      2751,
      2750,
      1,
      0,
      0,
      0,
      2751,
      2752,
      1,
      0,
      0,
      0,
      2752,
      405,
      1,
      0,
      0,
      0,
      2753,
      2755,
      3,
      404,
      202,
      0,
      2754,
      2756,
      5,
      127,
      0,
      0,
      2755,
      2754,
      1,
      0,
      0,
      0,
      2755,
      2756,
      1,
      0,
      0,
      0,
      2756,
      407,
      1,
      0,
      0,
      0,
      2757,
      2758,
      5,
      56,
      0,
      0,
      2758,
      2759,
      3,
      178,
      89,
      0,
      2759,
      409,
      1,
      0,
      0,
      0,
      2760,
      2761,
      3,
      340,
      170,
      0,
      2761,
      411,
      1,
      0,
      0,
      0,
      2762,
      2765,
      3,
      408,
      204,
      0,
      2763,
      2765,
      3,
      406,
      203,
      0,
      2764,
      2762,
      1,
      0,
      0,
      0,
      2764,
      2763,
      1,
      0,
      0,
      0,
      2765,
      413,
      1,
      0,
      0,
      0,
      2766,
      2770,
      3,
      412,
      206,
      0,
      2767,
      2769,
      3,
      410,
      205,
      0,
      2768,
      2767,
      1,
      0,
      0,
      0,
      2769,
      2772,
      1,
      0,
      0,
      0,
      2770,
      2768,
      1,
      0,
      0,
      0,
      2770,
      2771,
      1,
      0,
      0,
      0,
      2771,
      415,
      1,
      0,
      0,
      0,
      2772,
      2770,
      1,
      0,
      0,
      0,
      2773,
      2775,
      3,
      418,
      209,
      0,
      2774,
      2773,
      1,
      0,
      0,
      0,
      2774,
      2775,
      1,
      0,
      0,
      0,
      2775,
      2776,
      1,
      0,
      0,
      0,
      2776,
      2777,
      3,
      420,
      210,
      0,
      2777,
      417,
      1,
      0,
      0,
      0,
      2778,
      2780,
      3,
      44,
      22,
      0,
      2779,
      2781,
      3,
      196,
      98,
      0,
      2780,
      2779,
      1,
      0,
      0,
      0,
      2780,
      2781,
      1,
      0,
      0,
      0,
      2781,
      2784,
      1,
      0,
      0,
      0,
      2782,
      2784,
      3,
      196,
      98,
      0,
      2783,
      2778,
      1,
      0,
      0,
      0,
      2783,
      2782,
      1,
      0,
      0,
      0,
      2784,
      419,
      1,
      0,
      0,
      0,
      2785,
      2787,
      3,
      318,
      159,
      0,
      2786,
      2785,
      1,
      0,
      0,
      0,
      2786,
      2787,
      1,
      0,
      0,
      0,
      2787,
      2788,
      1,
      0,
      0,
      0,
      2788,
      2789,
      3,
      422,
      211,
      0,
      2789,
      421,
      1,
      0,
      0,
      0,
      2790,
      2791,
      3,
      388,
      194,
      0,
      2791,
      423,
      1,
      0,
      0,
      0,
      2792,
      2793,
      3,
      404,
      202,
      0,
      2793,
      2794,
      3,
      416,
      208,
      0,
      2794,
      425,
      1,
      0,
      0,
      0,
      2795,
      2798,
      3,
      408,
      204,
      0,
      2796,
      2798,
      3,
      404,
      202,
      0,
      2797,
      2795,
      1,
      0,
      0,
      0,
      2797,
      2796,
      1,
      0,
      0,
      0,
      2798,
      2799,
      1,
      0,
      0,
      0,
      2799,
      2800,
      5,
      127,
      0,
      0,
      2800,
      2801,
      3,
      416,
      208,
      0,
      2801,
      427,
      1,
      0,
      0,
      0,
      2802,
      2803,
      3,
      408,
      204,
      0,
      2803,
      2804,
      3,
      184,
      92,
      0,
      2804,
      2805,
      3,
      420,
      210,
      0,
      2805,
      429,
      1,
      0,
      0,
      0,
      2806,
      2810,
      3,
      226,
      113,
      0,
      2807,
      2809,
      3,
      200,
      100,
      0,
      2808,
      2807,
      1,
      0,
      0,
      0,
      2809,
      2812,
      1,
      0,
      0,
      0,
      2810,
      2808,
      1,
      0,
      0,
      0,
      2810,
      2811,
      1,
      0,
      0,
      0,
      2811,
      2813,
      1,
      0,
      0,
      0,
      2812,
      2810,
      1,
      0,
      0,
      0,
      2813,
      2814,
      3,
      422,
      211,
      0,
      2814,
      431,
      1,
      0,
      0,
      0,
      2815,
      2824,
      3,
      426,
      213,
      0,
      2816,
      2824,
      3,
      428,
      214,
      0,
      2817,
      2824,
      3,
      448,
      224,
      0,
      2818,
      2824,
      3,
      458,
      229,
      0,
      2819,
      2824,
      3,
      516,
      258,
      0,
      2820,
      2824,
      3,
      518,
      259,
      0,
      2821,
      2824,
      3,
      882,
      441,
      0,
      2822,
      2824,
      3,
      424,
      212,
      0,
      2823,
      2815,
      1,
      0,
      0,
      0,
      2823,
      2816,
      1,
      0,
      0,
      0,
      2823,
      2817,
      1,
      0,
      0,
      0,
      2823,
      2818,
      1,
      0,
      0,
      0,
      2823,
      2819,
      1,
      0,
      0,
      0,
      2823,
      2820,
      1,
      0,
      0,
      0,
      2823,
      2821,
      1,
      0,
      0,
      0,
      2823,
      2822,
      1,
      0,
      0,
      0,
      2824,
      433,
      1,
      0,
      0,
      0,
      2825,
      2827,
      5,
      56,
      0,
      0,
      2826,
      2828,
      3,
      40,
      20,
      0,
      2827,
      2826,
      1,
      0,
      0,
      0,
      2827,
      2828,
      1,
      0,
      0,
      0,
      2828,
      2830,
      1,
      0,
      0,
      0,
      2829,
      2831,
      3,
      264,
      132,
      0,
      2830,
      2829,
      1,
      0,
      0,
      0,
      2830,
      2831,
      1,
      0,
      0,
      0,
      2831,
      2833,
      1,
      0,
      0,
      0,
      2832,
      2834,
      5,
      106,
      0,
      0,
      2833,
      2832,
      1,
      0,
      0,
      0,
      2833,
      2834,
      1,
      0,
      0,
      0,
      2834,
      2835,
      1,
      0,
      0,
      0,
      2835,
      2836,
      3,
      436,
      218,
      0,
      2836,
      435,
      1,
      0,
      0,
      0,
      2837,
      2840,
      3,
      438,
      219,
      0,
      2838,
      2840,
      3,
      440,
      220,
      0,
      2839,
      2837,
      1,
      0,
      0,
      0,
      2839,
      2838,
      1,
      0,
      0,
      0,
      2840,
      437,
      1,
      0,
      0,
      0,
      2841,
      2857,
      3,
      470,
      235,
      0,
      2842,
      2857,
      3,
      472,
      236,
      0,
      2843,
      2857,
      3,
      474,
      237,
      0,
      2844,
      2857,
      3,
      478,
      239,
      0,
      2845,
      2857,
      3,
      490,
      245,
      0,
      2846,
      2857,
      3,
      494,
      247,
      0,
      2847,
      2857,
      3,
      852,
      426,
      0,
      2848,
      2857,
      3,
      870,
      435,
      0,
      2849,
      2857,
      3,
      502,
      251,
      0,
      2850,
      2857,
      3,
      508,
      254,
      0,
      2851,
      2857,
      3,
      536,
      268,
      0,
      2852,
      2857,
      3,
      552,
      276,
      0,
      2853,
      2857,
      3,
      558,
      279,
      0,
      2854,
      2857,
      3,
      566,
      283,
      0,
      2855,
      2857,
      3,
      568,
      284,
      0,
      2856,
      2841,
      1,
      0,
      0,
      0,
      2856,
      2842,
      1,
      0,
      0,
      0,
      2856,
      2843,
      1,
      0,
      0,
      0,
      2856,
      2844,
      1,
      0,
      0,
      0,
      2856,
      2845,
      1,
      0,
      0,
      0,
      2856,
      2846,
      1,
      0,
      0,
      0,
      2856,
      2847,
      1,
      0,
      0,
      0,
      2856,
      2848,
      1,
      0,
      0,
      0,
      2856,
      2849,
      1,
      0,
      0,
      0,
      2856,
      2850,
      1,
      0,
      0,
      0,
      2856,
      2851,
      1,
      0,
      0,
      0,
      2856,
      2852,
      1,
      0,
      0,
      0,
      2856,
      2853,
      1,
      0,
      0,
      0,
      2856,
      2854,
      1,
      0,
      0,
      0,
      2856,
      2855,
      1,
      0,
      0,
      0,
      2857,
      439,
      1,
      0,
      0,
      0,
      2858,
      2875,
      3,
      592,
      296,
      0,
      2859,
      2875,
      3,
      750,
      375,
      0,
      2860,
      2875,
      3,
      714,
      357,
      0,
      2861,
      2875,
      3,
      762,
      381,
      0,
      2862,
      2875,
      3,
      796,
      398,
      0,
      2863,
      2875,
      3,
      810,
      405,
      0,
      2864,
      2875,
      3,
      814,
      407,
      0,
      2865,
      2875,
      3,
      826,
      413,
      0,
      2866,
      2875,
      3,
      830,
      415,
      0,
      2867,
      2875,
      3,
      838,
      419,
      0,
      2868,
      2875,
      3,
      866,
      433,
      0,
      2869,
      2875,
      3,
      596,
      298,
      0,
      2870,
      2875,
      3,
      718,
      359,
      0,
      2871,
      2875,
      3,
      840,
      420,
      0,
      2872,
      2875,
      3,
      764,
      382,
      0,
      2873,
      2875,
      3,
      798,
      399,
      0,
      2874,
      2858,
      1,
      0,
      0,
      0,
      2874,
      2859,
      1,
      0,
      0,
      0,
      2874,
      2860,
      1,
      0,
      0,
      0,
      2874,
      2861,
      1,
      0,
      0,
      0,
      2874,
      2862,
      1,
      0,
      0,
      0,
      2874,
      2863,
      1,
      0,
      0,
      0,
      2874,
      2864,
      1,
      0,
      0,
      0,
      2874,
      2865,
      1,
      0,
      0,
      0,
      2874,
      2866,
      1,
      0,
      0,
      0,
      2874,
      2867,
      1,
      0,
      0,
      0,
      2874,
      2868,
      1,
      0,
      0,
      0,
      2874,
      2869,
      1,
      0,
      0,
      0,
      2874,
      2870,
      1,
      0,
      0,
      0,
      2874,
      2871,
      1,
      0,
      0,
      0,
      2874,
      2872,
      1,
      0,
      0,
      0,
      2874,
      2873,
      1,
      0,
      0,
      0,
      2875,
      441,
      1,
      0,
      0,
      0,
      2876,
      2898,
      3,
      430,
      215,
      0,
      2877,
      2898,
      3,
      426,
      213,
      0,
      2878,
      2898,
      3,
      448,
      224,
      0,
      2879,
      2898,
      3,
      516,
      258,
      0,
      2880,
      2898,
      3,
      518,
      259,
      0,
      2881,
      2898,
      3,
      470,
      235,
      0,
      2882,
      2898,
      3,
      472,
      236,
      0,
      2883,
      2898,
      3,
      474,
      237,
      0,
      2884,
      2898,
      3,
      478,
      239,
      0,
      2885,
      2898,
      3,
      490,
      245,
      0,
      2886,
      2898,
      3,
      494,
      247,
      0,
      2887,
      2898,
      3,
      852,
      426,
      0,
      2888,
      2898,
      3,
      870,
      435,
      0,
      2889,
      2898,
      3,
      502,
      251,
      0,
      2890,
      2898,
      3,
      508,
      254,
      0,
      2891,
      2898,
      3,
      536,
      268,
      0,
      2892,
      2898,
      3,
      552,
      276,
      0,
      2893,
      2898,
      3,
      558,
      279,
      0,
      2894,
      2898,
      3,
      566,
      283,
      0,
      2895,
      2898,
      3,
      568,
      284,
      0,
      2896,
      2898,
      3,
      440,
      220,
      0,
      2897,
      2876,
      1,
      0,
      0,
      0,
      2897,
      2877,
      1,
      0,
      0,
      0,
      2897,
      2878,
      1,
      0,
      0,
      0,
      2897,
      2879,
      1,
      0,
      0,
      0,
      2897,
      2880,
      1,
      0,
      0,
      0,
      2897,
      2881,
      1,
      0,
      0,
      0,
      2897,
      2882,
      1,
      0,
      0,
      0,
      2897,
      2883,
      1,
      0,
      0,
      0,
      2897,
      2884,
      1,
      0,
      0,
      0,
      2897,
      2885,
      1,
      0,
      0,
      0,
      2897,
      2886,
      1,
      0,
      0,
      0,
      2897,
      2887,
      1,
      0,
      0,
      0,
      2897,
      2888,
      1,
      0,
      0,
      0,
      2897,
      2889,
      1,
      0,
      0,
      0,
      2897,
      2890,
      1,
      0,
      0,
      0,
      2897,
      2891,
      1,
      0,
      0,
      0,
      2897,
      2892,
      1,
      0,
      0,
      0,
      2897,
      2893,
      1,
      0,
      0,
      0,
      2897,
      2894,
      1,
      0,
      0,
      0,
      2897,
      2895,
      1,
      0,
      0,
      0,
      2897,
      2896,
      1,
      0,
      0,
      0,
      2898,
      443,
      1,
      0,
      0,
      0,
      2899,
      2900,
      7,
      11,
      0,
      0,
      2900,
      2905,
      3,
      168,
      84,
      0,
      2901,
      2902,
      5,
      200,
      0,
      0,
      2902,
      2904,
      3,
      168,
      84,
      0,
      2903,
      2901,
      1,
      0,
      0,
      0,
      2904,
      2907,
      1,
      0,
      0,
      0,
      2905,
      2903,
      1,
      0,
      0,
      0,
      2905,
      2906,
      1,
      0,
      0,
      0,
      2906,
      445,
      1,
      0,
      0,
      0,
      2907,
      2905,
      1,
      0,
      0,
      0,
      2908,
      2909,
      3,
      382,
      191,
      0,
      2909,
      2910,
      5,
      19,
      0,
      0,
      2910,
      2911,
      5,
      45,
      0,
      0,
      2911,
      2912,
      3,
      384,
      192,
      0,
      2912,
      447,
      1,
      0,
      0,
      0,
      2913,
      2914,
      3,
      414,
      207,
      0,
      2914,
      2915,
      5,
      19,
      0,
      0,
      2915,
      2916,
      3,
      416,
      208,
      0,
      2916,
      449,
      1,
      0,
      0,
      0,
      2917,
      2919,
      3,
      380,
      190,
      0,
      2918,
      2917,
      1,
      0,
      0,
      0,
      2919,
      2922,
      1,
      0,
      0,
      0,
      2920,
      2918,
      1,
      0,
      0,
      0,
      2920,
      2921,
      1,
      0,
      0,
      0,
      2921,
      2923,
      1,
      0,
      0,
      0,
      2922,
      2920,
      1,
      0,
      0,
      0,
      2923,
      2924,
      5,
      58,
      0,
      0,
      2924,
      2925,
      5,
      45,
      0,
      0,
      2925,
      2926,
      3,
      386,
      193,
      0,
      2926,
      2927,
      3,
      452,
      226,
      0,
      2927,
      451,
      1,
      0,
      0,
      0,
      2928,
      2939,
      5,
      205,
      0,
      0,
      2929,
      2934,
      5,
      214,
      0,
      0,
      2930,
      2933,
      3,
      368,
      184,
      0,
      2931,
      2933,
      3,
      454,
      227,
      0,
      2932,
      2930,
      1,
      0,
      0,
      0,
      2932,
      2931,
      1,
      0,
      0,
      0,
      2933,
      2936,
      1,
      0,
      0,
      0,
      2934,
      2932,
      1,
      0,
      0,
      0,
      2934,
      2935,
      1,
      0,
      0,
      0,
      2935,
      2937,
      1,
      0,
      0,
      0,
      2936,
      2934,
      1,
      0,
      0,
      0,
      2937,
      2939,
      5,
      216,
      0,
      0,
      2938,
      2928,
      1,
      0,
      0,
      0,
      2938,
      2929,
      1,
      0,
      0,
      0,
      2939,
      453,
      1,
      0,
      0,
      0,
      2940,
      2942,
      3,
      340,
      170,
      0,
      2941,
      2940,
      1,
      0,
      0,
      0,
      2942,
      2945,
      1,
      0,
      0,
      0,
      2943,
      2941,
      1,
      0,
      0,
      0,
      2943,
      2944,
      1,
      0,
      0,
      0,
      2944,
      2946,
      1,
      0,
      0,
      0,
      2945,
      2943,
      1,
      0,
      0,
      0,
      2946,
      2947,
      3,
      76,
      38,
      0,
      2947,
      2948,
      3,
      456,
      228,
      0,
      2948,
      455,
      1,
      0,
      0,
      0,
      2949,
      2951,
      5,
      58,
      0,
      0,
      2950,
      2949,
      1,
      0,
      0,
      0,
      2950,
      2951,
      1,
      0,
      0,
      0,
      2951,
      2952,
      1,
      0,
      0,
      0,
      2952,
      2953,
      3,
      416,
      208,
      0,
      2953,
      457,
      1,
      0,
      0,
      0,
      2954,
      2955,
      3,
      414,
      207,
      0,
      2955,
      2956,
      5,
      58,
      0,
      0,
      2956,
      2957,
      3,
      416,
      208,
      0,
      2957,
      459,
      1,
      0,
      0,
      0,
      2958,
      2960,
      3,
      378,
      189,
      0,
      2959,
      2958,
      1,
      0,
      0,
      0,
      2959,
      2960,
      1,
      0,
      0,
      0,
      2960,
      2963,
      1,
      0,
      0,
      0,
      2961,
      2962,
      5,
      82,
      0,
      0,
      2962,
      2964,
      3,
      466,
      233,
      0,
      2963,
      2961,
      1,
      0,
      0,
      0,
      2963,
      2964,
      1,
      0,
      0,
      0,
      2964,
      2968,
      1,
      0,
      0,
      0,
      2965,
      2967,
      3,
      380,
      190,
      0,
      2966,
      2965,
      1,
      0,
      0,
      0,
      2967,
      2970,
      1,
      0,
      0,
      0,
      2968,
      2966,
      1,
      0,
      0,
      0,
      2968,
      2969,
      1,
      0,
      0,
      0,
      2969,
      461,
      1,
      0,
      0,
      0,
      2970,
      2968,
      1,
      0,
      0,
      0,
      2971,
      2972,
      3,
      460,
      230,
      0,
      2972,
      2973,
      5,
      110,
      0,
      0,
      2973,
      2974,
      5,
      45,
      0,
      0,
      2974,
      2975,
      3,
      384,
      192,
      0,
      2975,
      463,
      1,
      0,
      0,
      0,
      2976,
      2978,
      3,
      378,
      189,
      0,
      2977,
      2976,
      1,
      0,
      0,
      0,
      2977,
      2978,
      1,
      0,
      0,
      0,
      2978,
      2979,
      1,
      0,
      0,
      0,
      2979,
      2983,
      5,
      82,
      0,
      0,
      2980,
      2982,
      3,
      380,
      190,
      0,
      2981,
      2980,
      1,
      0,
      0,
      0,
      2982,
      2985,
      1,
      0,
      0,
      0,
      2983,
      2981,
      1,
      0,
      0,
      0,
      2983,
      2984,
      1,
      0,
      0,
      0,
      2984,
      2986,
      1,
      0,
      0,
      0,
      2985,
      2983,
      1,
      0,
      0,
      0,
      2986,
      2987,
      5,
      45,
      0,
      0,
      2987,
      2988,
      3,
      384,
      192,
      0,
      2988,
      2989,
      3,
      466,
      233,
      0,
      2989,
      465,
      1,
      0,
      0,
      0,
      2990,
      2991,
      3,
      894,
      447,
      0,
      2991,
      467,
      1,
      0,
      0,
      0,
      2992,
      2994,
      3,
      406,
      203,
      0,
      2993,
      2995,
      5,
      82,
      0,
      0,
      2994,
      2993,
      1,
      0,
      0,
      0,
      2994,
      2995,
      1,
      0,
      0,
      0,
      2995,
      2997,
      1,
      0,
      0,
      0,
      2996,
      2998,
      3,
      476,
      238,
      0,
      2997,
      2996,
      1,
      0,
      0,
      0,
      2997,
      2998,
      1,
      0,
      0,
      0,
      2998,
      3002,
      1,
      0,
      0,
      0,
      2999,
      3001,
      3,
      410,
      205,
      0,
      3e3,
      2999,
      1,
      0,
      0,
      0,
      3001,
      3004,
      1,
      0,
      0,
      0,
      3002,
      3e3,
      1,
      0,
      0,
      0,
      3002,
      3003,
      1,
      0,
      0,
      0,
      3003,
      469,
      1,
      0,
      0,
      0,
      3004,
      3002,
      1,
      0,
      0,
      0,
      3005,
      3006,
      3,
      468,
      234,
      0,
      3006,
      3007,
      5,
      110,
      0,
      0,
      3007,
      3008,
      3,
      416,
      208,
      0,
      3008,
      471,
      1,
      0,
      0,
      0,
      3009,
      3010,
      3,
      406,
      203,
      0,
      3010,
      3014,
      5,
      82,
      0,
      0,
      3011,
      3013,
      3,
      410,
      205,
      0,
      3012,
      3011,
      1,
      0,
      0,
      0,
      3013,
      3016,
      1,
      0,
      0,
      0,
      3014,
      3012,
      1,
      0,
      0,
      0,
      3014,
      3015,
      1,
      0,
      0,
      0,
      3015,
      3017,
      1,
      0,
      0,
      0,
      3016,
      3014,
      1,
      0,
      0,
      0,
      3017,
      3018,
      3,
      416,
      208,
      0,
      3018,
      473,
      1,
      0,
      0,
      0,
      3019,
      3021,
      3,
      406,
      203,
      0,
      3020,
      3022,
      5,
      82,
      0,
      0,
      3021,
      3020,
      1,
      0,
      0,
      0,
      3021,
      3022,
      1,
      0,
      0,
      0,
      3022,
      3023,
      1,
      0,
      0,
      0,
      3023,
      3027,
      3,
      476,
      238,
      0,
      3024,
      3026,
      3,
      410,
      205,
      0,
      3025,
      3024,
      1,
      0,
      0,
      0,
      3026,
      3029,
      1,
      0,
      0,
      0,
      3027,
      3025,
      1,
      0,
      0,
      0,
      3027,
      3028,
      1,
      0,
      0,
      0,
      3028,
      3030,
      1,
      0,
      0,
      0,
      3029,
      3027,
      1,
      0,
      0,
      0,
      3030,
      3031,
      3,
      416,
      208,
      0,
      3031,
      475,
      1,
      0,
      0,
      0,
      3032,
      3033,
      7,
      23,
      0,
      0,
      3033,
      477,
      1,
      0,
      0,
      0,
      3034,
      3035,
      3,
      468,
      234,
      0,
      3035,
      3044,
      5,
      59,
      0,
      0,
      3036,
      3038,
      3,
      226,
      113,
      0,
      3037,
      3039,
      3,
      196,
      98,
      0,
      3038,
      3037,
      1,
      0,
      0,
      0,
      3038,
      3039,
      1,
      0,
      0,
      0,
      3039,
      3045,
      1,
      0,
      0,
      0,
      3040,
      3042,
      5,
      110,
      0,
      0,
      3041,
      3043,
      3,
      418,
      209,
      0,
      3042,
      3041,
      1,
      0,
      0,
      0,
      3042,
      3043,
      1,
      0,
      0,
      0,
      3043,
      3045,
      1,
      0,
      0,
      0,
      3044,
      3036,
      1,
      0,
      0,
      0,
      3044,
      3040,
      1,
      0,
      0,
      0,
      3045,
      3046,
      1,
      0,
      0,
      0,
      3046,
      3047,
      3,
      420,
      210,
      0,
      3047,
      479,
      1,
      0,
      0,
      0,
      3048,
      3049,
      5,
      152,
      0,
      0,
      3049,
      3050,
      3,
      482,
      241,
      0,
      3050,
      481,
      1,
      0,
      0,
      0,
      3051,
      3052,
      3,
      484,
      242,
      0,
      3052,
      483,
      1,
      0,
      0,
      0,
      3053,
      3054,
      3,
      486,
      243,
      0,
      3054,
      485,
      1,
      0,
      0,
      0,
      3055,
      3057,
      3,
      328,
      164,
      0,
      3056,
      3055,
      1,
      0,
      0,
      0,
      3056,
      3057,
      1,
      0,
      0,
      0,
      3057,
      487,
      1,
      0,
      0,
      0,
      3058,
      3059,
      3,
      460,
      230,
      0,
      3059,
      3060,
      5,
      91,
      0,
      0,
      3060,
      3061,
      5,
      45,
      0,
      0,
      3061,
      3062,
      3,
      384,
      192,
      0,
      3062,
      489,
      1,
      0,
      0,
      0,
      3063,
      3064,
      3,
      468,
      234,
      0,
      3064,
      3065,
      5,
      91,
      0,
      0,
      3065,
      3066,
      3,
      416,
      208,
      0,
      3066,
      491,
      1,
      0,
      0,
      0,
      3067,
      3068,
      3,
      460,
      230,
      0,
      3068,
      3069,
      5,
      117,
      0,
      0,
      3069,
      3070,
      5,
      45,
      0,
      0,
      3070,
      3071,
      3,
      384,
      192,
      0,
      3071,
      493,
      1,
      0,
      0,
      0,
      3072,
      3073,
      3,
      468,
      234,
      0,
      3073,
      3074,
      5,
      117,
      0,
      0,
      3074,
      3075,
      3,
      416,
      208,
      0,
      3075,
      495,
      1,
      0,
      0,
      0,
      3076,
      3077,
      3,
      382,
      191,
      0,
      3077,
      3078,
      5,
      119,
      0,
      0,
      3078,
      3079,
      5,
      45,
      0,
      0,
      3079,
      3080,
      3,
      384,
      192,
      0,
      3080,
      3081,
      3,
      498,
      249,
      0,
      3081,
      497,
      1,
      0,
      0,
      0,
      3082,
      3083,
      3,
      500,
      250,
      0,
      3083,
      499,
      1,
      0,
      0,
      0,
      3084,
      3085,
      3,
      902,
      451,
      0,
      3085,
      501,
      1,
      0,
      0,
      0,
      3086,
      3087,
      3,
      468,
      234,
      0,
      3087,
      3088,
      5,
      119,
      0,
      0,
      3088,
      3089,
      3,
      416,
      208,
      0,
      3089,
      503,
      1,
      0,
      0,
      0,
      3090,
      3091,
      5,
      217,
      0,
      0,
      3091,
      3092,
      3,
      88,
      44,
      0,
      3092,
      505,
      1,
      0,
      0,
      0,
      3093,
      3094,
      3,
      460,
      230,
      0,
      3094,
      3095,
      5,
      37,
      0,
      0,
      3095,
      3096,
      5,
      45,
      0,
      0,
      3096,
      3097,
      3,
      384,
      192,
      0,
      3097,
      507,
      1,
      0,
      0,
      0,
      3098,
      3112,
      3,
      468,
      234,
      0,
      3099,
      3101,
      5,
      37,
      0,
      0,
      3100,
      3102,
      3,
      418,
      209,
      0,
      3101,
      3100,
      1,
      0,
      0,
      0,
      3101,
      3102,
      1,
      0,
      0,
      0,
      3102,
      3104,
      1,
      0,
      0,
      0,
      3103,
      3105,
      3,
      318,
      159,
      0,
      3104,
      3103,
      1,
      0,
      0,
      0,
      3104,
      3105,
      1,
      0,
      0,
      0,
      3105,
      3108,
      1,
      0,
      0,
      0,
      3106,
      3107,
      5,
      36,
      0,
      0,
      3107,
      3109,
      3,
      510,
      255,
      0,
      3108,
      3106,
      1,
      0,
      0,
      0,
      3108,
      3109,
      1,
      0,
      0,
      0,
      3109,
      3113,
      1,
      0,
      0,
      0,
      3110,
      3111,
      5,
      36,
      0,
      0,
      3111,
      3113,
      3,
      510,
      255,
      0,
      3112,
      3099,
      1,
      0,
      0,
      0,
      3112,
      3110,
      1,
      0,
      0,
      0,
      3113,
      3114,
      1,
      0,
      0,
      0,
      3114,
      3115,
      3,
      422,
      211,
      0,
      3115,
      509,
      1,
      0,
      0,
      0,
      3116,
      3119,
      3,
      512,
      256,
      0,
      3117,
      3119,
      3,
      514,
      257,
      0,
      3118,
      3116,
      1,
      0,
      0,
      0,
      3118,
      3117,
      1,
      0,
      0,
      0,
      3119,
      511,
      1,
      0,
      0,
      0,
      3120,
      3121,
      3,
      260,
      130,
      0,
      3121,
      3122,
      5,
      154,
      0,
      0,
      3122,
      3123,
      3,
      260,
      130,
      0,
      3123,
      513,
      1,
      0,
      0,
      0,
      3124,
      3125,
      5,
      196,
      0,
      0,
      3125,
      3126,
      3,
      260,
      130,
      0,
      3126,
      3127,
      5,
      200,
      0,
      0,
      3127,
      3132,
      3,
      260,
      130,
      0,
      3128,
      3129,
      5,
      200,
      0,
      0,
      3129,
      3131,
      3,
      260,
      130,
      0,
      3130,
      3128,
      1,
      0,
      0,
      0,
      3131,
      3134,
      1,
      0,
      0,
      0,
      3132,
      3130,
      1,
      0,
      0,
      0,
      3132,
      3133,
      1,
      0,
      0,
      0,
      3133,
      3135,
      1,
      0,
      0,
      0,
      3134,
      3132,
      1,
      0,
      0,
      0,
      3135,
      3136,
      5,
      197,
      0,
      0,
      3136,
      515,
      1,
      0,
      0,
      0,
      3137,
      3142,
      3,
      414,
      207,
      0,
      3138,
      3140,
      5,
      22,
      0,
      0,
      3139,
      3141,
      3,
      418,
      209,
      0,
      3140,
      3139,
      1,
      0,
      0,
      0,
      3140,
      3141,
      1,
      0,
      0,
      0,
      3141,
      3143,
      1,
      0,
      0,
      0,
      3142,
      3138,
      1,
      0,
      0,
      0,
      3142,
      3143,
      1,
      0,
      0,
      0,
      3143,
      3144,
      1,
      0,
      0,
      0,
      3144,
      3145,
      5,
      21,
      0,
      0,
      3145,
      3146,
      3,
      260,
      130,
      0,
      3146,
      3147,
      5,
      207,
      0,
      0,
      3147,
      3148,
      3,
      260,
      130,
      0,
      3148,
      3149,
      3,
      422,
      211,
      0,
      3149,
      517,
      1,
      0,
      0,
      0,
      3150,
      3155,
      3,
      414,
      207,
      0,
      3151,
      3153,
      5,
      150,
      0,
      0,
      3152,
      3154,
      3,
      418,
      209,
      0,
      3153,
      3152,
      1,
      0,
      0,
      0,
      3153,
      3154,
      1,
      0,
      0,
      0,
      3154,
      3156,
      1,
      0,
      0,
      0,
      3155,
      3151,
      1,
      0,
      0,
      0,
      3155,
      3156,
      1,
      0,
      0,
      0,
      3156,
      3157,
      1,
      0,
      0,
      0,
      3157,
      3158,
      5,
      69,
      0,
      0,
      3158,
      3159,
      3,
      260,
      130,
      0,
      3159,
      3160,
      5,
      152,
      0,
      0,
      3160,
      3161,
      3,
      260,
      130,
      0,
      3161,
      3162,
      3,
      422,
      211,
      0,
      3162,
      519,
      1,
      0,
      0,
      0,
      3163,
      3164,
      3,
      460,
      230,
      0,
      3164,
      3165,
      5,
      85,
      0,
      0,
      3165,
      3166,
      5,
      45,
      0,
      0,
      3166,
      3167,
      3,
      386,
      193,
      0,
      3167,
      3168,
      3,
      522,
      261,
      0,
      3168,
      521,
      1,
      0,
      0,
      0,
      3169,
      3179,
      5,
      205,
      0,
      0,
      3170,
      3174,
      5,
      214,
      0,
      0,
      3171,
      3173,
      3,
      524,
      262,
      0,
      3172,
      3171,
      1,
      0,
      0,
      0,
      3173,
      3176,
      1,
      0,
      0,
      0,
      3174,
      3172,
      1,
      0,
      0,
      0,
      3174,
      3175,
      1,
      0,
      0,
      0,
      3175,
      3177,
      1,
      0,
      0,
      0,
      3176,
      3174,
      1,
      0,
      0,
      0,
      3177,
      3179,
      5,
      216,
      0,
      0,
      3178,
      3169,
      1,
      0,
      0,
      0,
      3178,
      3170,
      1,
      0,
      0,
      0,
      3179,
      523,
      1,
      0,
      0,
      0,
      3180,
      3190,
      3,
      394,
      197,
      0,
      3181,
      3190,
      3,
      396,
      198,
      0,
      3182,
      3190,
      3,
      526,
      263,
      0,
      3183,
      3185,
      3,
      480,
      240,
      0,
      3184,
      3183,
      1,
      0,
      0,
      0,
      3184,
      3185,
      1,
      0,
      0,
      0,
      3185,
      3186,
      1,
      0,
      0,
      0,
      3186,
      3190,
      3,
      530,
      265,
      0,
      3187,
      3190,
      3,
      86,
      43,
      0,
      3188,
      3190,
      3,
      90,
      45,
      0,
      3189,
      3180,
      1,
      0,
      0,
      0,
      3189,
      3181,
      1,
      0,
      0,
      0,
      3189,
      3182,
      1,
      0,
      0,
      0,
      3189,
      3184,
      1,
      0,
      0,
      0,
      3189,
      3187,
      1,
      0,
      0,
      0,
      3189,
      3188,
      1,
      0,
      0,
      0,
      3190,
      525,
      1,
      0,
      0,
      0,
      3191,
      3192,
      3,
      76,
      38,
      0,
      3192,
      3193,
      3,
      528,
      264,
      0,
      3193,
      527,
      1,
      0,
      0,
      0,
      3194,
      3200,
      3,
      426,
      213,
      0,
      3195,
      3200,
      3,
      448,
      224,
      0,
      3196,
      3200,
      3,
      458,
      229,
      0,
      3197,
      3200,
      3,
      516,
      258,
      0,
      3198,
      3200,
      3,
      518,
      259,
      0,
      3199,
      3194,
      1,
      0,
      0,
      0,
      3199,
      3195,
      1,
      0,
      0,
      0,
      3199,
      3196,
      1,
      0,
      0,
      0,
      3199,
      3197,
      1,
      0,
      0,
      0,
      3199,
      3198,
      1,
      0,
      0,
      0,
      3200,
      529,
      1,
      0,
      0,
      0,
      3201,
      3202,
      3,
      76,
      38,
      0,
      3202,
      3203,
      3,
      532,
      266,
      0,
      3203,
      531,
      1,
      0,
      0,
      0,
      3204,
      3209,
      3,
      534,
      267,
      0,
      3205,
      3209,
      3,
      434,
      217,
      0,
      3206,
      3209,
      3,
      438,
      219,
      0,
      3207,
      3209,
      3,
      440,
      220,
      0,
      3208,
      3204,
      1,
      0,
      0,
      0,
      3208,
      3205,
      1,
      0,
      0,
      0,
      3208,
      3206,
      1,
      0,
      0,
      0,
      3208,
      3207,
      1,
      0,
      0,
      0,
      3209,
      533,
      1,
      0,
      0,
      0,
      3210,
      3211,
      5,
      56,
      0,
      0,
      3211,
      3212,
      3,
      416,
      208,
      0,
      3212,
      535,
      1,
      0,
      0,
      0,
      3213,
      3214,
      3,
      468,
      234,
      0,
      3214,
      3215,
      5,
      85,
      0,
      0,
      3215,
      3216,
      3,
      538,
      269,
      0,
      3216,
      3217,
      3,
      522,
      261,
      0,
      3217,
      537,
      1,
      0,
      0,
      0,
      3218,
      3220,
      3,
      418,
      209,
      0,
      3219,
      3218,
      1,
      0,
      0,
      0,
      3219,
      3220,
      1,
      0,
      0,
      0,
      3220,
      3222,
      1,
      0,
      0,
      0,
      3221,
      3223,
      3,
      318,
      159,
      0,
      3222,
      3221,
      1,
      0,
      0,
      0,
      3222,
      3223,
      1,
      0,
      0,
      0,
      3223,
      3226,
      1,
      0,
      0,
      0,
      3224,
      3225,
      5,
      36,
      0,
      0,
      3225,
      3227,
      3,
      540,
      270,
      0,
      3226,
      3224,
      1,
      0,
      0,
      0,
      3226,
      3227,
      1,
      0,
      0,
      0,
      3227,
      3230,
      1,
      0,
      0,
      0,
      3228,
      3230,
      3,
      540,
      270,
      0,
      3229,
      3219,
      1,
      0,
      0,
      0,
      3229,
      3228,
      1,
      0,
      0,
      0,
      3230,
      539,
      1,
      0,
      0,
      0,
      3231,
      3234,
      3,
      542,
      271,
      0,
      3232,
      3234,
      3,
      544,
      272,
      0,
      3233,
      3231,
      1,
      0,
      0,
      0,
      3233,
      3232,
      1,
      0,
      0,
      0,
      3234,
      541,
      1,
      0,
      0,
      0,
      3235,
      3236,
      3,
      546,
      273,
      0,
      3236,
      3237,
      5,
      154,
      0,
      0,
      3237,
      3238,
      3,
      546,
      273,
      0,
      3238,
      543,
      1,
      0,
      0,
      0,
      3239,
      3240,
      5,
      196,
      0,
      0,
      3240,
      3241,
      3,
      546,
      273,
      0,
      3241,
      3242,
      5,
      200,
      0,
      0,
      3242,
      3247,
      3,
      546,
      273,
      0,
      3243,
      3244,
      5,
      200,
      0,
      0,
      3244,
      3246,
      3,
      546,
      273,
      0,
      3245,
      3243,
      1,
      0,
      0,
      0,
      3246,
      3249,
      1,
      0,
      0,
      0,
      3247,
      3245,
      1,
      0,
      0,
      0,
      3247,
      3248,
      1,
      0,
      0,
      0,
      3248,
      3250,
      1,
      0,
      0,
      0,
      3249,
      3247,
      1,
      0,
      0,
      0,
      3250,
      3251,
      5,
      197,
      0,
      0,
      3251,
      545,
      1,
      0,
      0,
      0,
      3252,
      3253,
      3,
      548,
      274,
      0,
      3253,
      547,
      1,
      0,
      0,
      0,
      3254,
      3256,
      3,
      264,
      132,
      0,
      3255,
      3254,
      1,
      0,
      0,
      0,
      3255,
      3256,
      1,
      0,
      0,
      0,
      3256,
      3260,
      1,
      0,
      0,
      0,
      3257,
      3258,
      3,
      40,
      20,
      0,
      3258,
      3259,
      7,
      17,
      0,
      0,
      3259,
      3261,
      1,
      0,
      0,
      0,
      3260,
      3257,
      1,
      0,
      0,
      0,
      3260,
      3261,
      1,
      0,
      0,
      0,
      3261,
      3262,
      1,
      0,
      0,
      0,
      3262,
      3263,
      3,
      226,
      113,
      0,
      3263,
      549,
      1,
      0,
      0,
      0,
      3264,
      3265,
      3,
      460,
      230,
      0,
      3265,
      3266,
      5,
      10,
      0,
      0,
      3266,
      3267,
      5,
      45,
      0,
      0,
      3267,
      3268,
      3,
      384,
      192,
      0,
      3268,
      551,
      1,
      0,
      0,
      0,
      3269,
      3270,
      3,
      468,
      234,
      0,
      3270,
      3271,
      3,
      554,
      277,
      0,
      3271,
      3272,
      3,
      422,
      211,
      0,
      3272,
      553,
      1,
      0,
      0,
      0,
      3273,
      3275,
      5,
      10,
      0,
      0,
      3274,
      3276,
      3,
      418,
      209,
      0,
      3275,
      3274,
      1,
      0,
      0,
      0,
      3275,
      3276,
      1,
      0,
      0,
      0,
      3276,
      3279,
      1,
      0,
      0,
      0,
      3277,
      3278,
      5,
      9,
      0,
      0,
      3278,
      3280,
      3,
      510,
      255,
      0,
      3279,
      3277,
      1,
      0,
      0,
      0,
      3279,
      3280,
      1,
      0,
      0,
      0,
      3280,
      3284,
      1,
      0,
      0,
      0,
      3281,
      3282,
      5,
      9,
      0,
      0,
      3282,
      3284,
      3,
      510,
      255,
      0,
      3283,
      3273,
      1,
      0,
      0,
      0,
      3283,
      3281,
      1,
      0,
      0,
      0,
      3284,
      555,
      1,
      0,
      0,
      0,
      3285,
      3286,
      3,
      460,
      230,
      0,
      3286,
      3287,
      5,
      70,
      0,
      0,
      3287,
      3288,
      5,
      45,
      0,
      0,
      3288,
      3289,
      3,
      384,
      192,
      0,
      3289,
      557,
      1,
      0,
      0,
      0,
      3290,
      3291,
      3,
      468,
      234,
      0,
      3291,
      3292,
      5,
      99,
      0,
      0,
      3292,
      3293,
      3,
      560,
      280,
      0,
      3293,
      3294,
      3,
      388,
      194,
      0,
      3294,
      559,
      1,
      0,
      0,
      0,
      3295,
      3297,
      3,
      418,
      209,
      0,
      3296,
      3295,
      1,
      0,
      0,
      0,
      3296,
      3297,
      1,
      0,
      0,
      0,
      3297,
      3299,
      1,
      0,
      0,
      0,
      3298,
      3300,
      3,
      318,
      159,
      0,
      3299,
      3298,
      1,
      0,
      0,
      0,
      3299,
      3300,
      1,
      0,
      0,
      0,
      3300,
      3303,
      1,
      0,
      0,
      0,
      3301,
      3302,
      5,
      111,
      0,
      0,
      3302,
      3304,
      3,
      570,
      285,
      0,
      3303,
      3301,
      1,
      0,
      0,
      0,
      3303,
      3304,
      1,
      0,
      0,
      0,
      3304,
      3310,
      1,
      0,
      0,
      0,
      3305,
      3306,
      5,
      74,
      0,
      0,
      3306,
      3307,
      3,
      562,
      281,
      0,
      3307,
      3308,
      5,
      154,
      0,
      0,
      3308,
      3309,
      3,
      562,
      281,
      0,
      3309,
      3311,
      1,
      0,
      0,
      0,
      3310,
      3305,
      1,
      0,
      0,
      0,
      3310,
      3311,
      1,
      0,
      0,
      0,
      3311,
      3317,
      1,
      0,
      0,
      0,
      3312,
      3313,
      3,
      562,
      281,
      0,
      3313,
      3314,
      5,
      154,
      0,
      0,
      3314,
      3315,
      3,
      562,
      281,
      0,
      3315,
      3317,
      1,
      0,
      0,
      0,
      3316,
      3296,
      1,
      0,
      0,
      0,
      3316,
      3312,
      1,
      0,
      0,
      0,
      3317,
      561,
      1,
      0,
      0,
      0,
      3318,
      3319,
      3,
      564,
      282,
      0,
      3319,
      563,
      1,
      0,
      0,
      0,
      3320,
      3321,
      3,
      226,
      113,
      0,
      3321,
      565,
      1,
      0,
      0,
      0,
      3322,
      3323,
      3,
      468,
      234,
      0,
      3323,
      3324,
      5,
      70,
      0,
      0,
      3324,
      3325,
      3,
      306,
      153,
      0,
      3325,
      3326,
      3,
      388,
      194,
      0,
      3326,
      567,
      1,
      0,
      0,
      0,
      3327,
      3328,
      3,
      468,
      234,
      0,
      3328,
      3329,
      5,
      150,
      0,
      0,
      3329,
      3330,
      5,
      70,
      0,
      0,
      3330,
      3331,
      3,
      306,
      153,
      0,
      3331,
      3332,
      3,
      388,
      194,
      0,
      3332,
      569,
      1,
      0,
      0,
      0,
      3333,
      3334,
      3,
      572,
      286,
      0,
      3334,
      571,
      1,
      0,
      0,
      0,
      3335,
      3336,
      3,
      310,
      155,
      0,
      3336,
      573,
      1,
      0,
      0,
      0,
      3337,
      3338,
      3,
      460,
      230,
      0,
      3338,
      3339,
      5,
      4,
      0,
      0,
      3339,
      3340,
      5,
      45,
      0,
      0,
      3340,
      3341,
      3,
      386,
      193,
      0,
      3341,
      3342,
      3,
      576,
      288,
      0,
      3342,
      575,
      1,
      0,
      0,
      0,
      3343,
      3353,
      5,
      205,
      0,
      0,
      3344,
      3348,
      5,
      214,
      0,
      0,
      3345,
      3347,
      3,
      578,
      289,
      0,
      3346,
      3345,
      1,
      0,
      0,
      0,
      3347,
      3350,
      1,
      0,
      0,
      0,
      3348,
      3346,
      1,
      0,
      0,
      0,
      3348,
      3349,
      1,
      0,
      0,
      0,
      3349,
      3351,
      1,
      0,
      0,
      0,
      3350,
      3348,
      1,
      0,
      0,
      0,
      3351,
      3353,
      5,
      216,
      0,
      0,
      3352,
      3343,
      1,
      0,
      0,
      0,
      3352,
      3344,
      1,
      0,
      0,
      0,
      3353,
      577,
      1,
      0,
      0,
      0,
      3354,
      3374,
      3,
      580,
      290,
      0,
      3355,
      3359,
      3,
      584,
      292,
      0,
      3356,
      3358,
      3,
      588,
      294,
      0,
      3357,
      3356,
      1,
      0,
      0,
      0,
      3358,
      3361,
      1,
      0,
      0,
      0,
      3359,
      3357,
      1,
      0,
      0,
      0,
      3359,
      3360,
      1,
      0,
      0,
      0,
      3360,
      3374,
      1,
      0,
      0,
      0,
      3361,
      3359,
      1,
      0,
      0,
      0,
      3362,
      3364,
      3,
      480,
      240,
      0,
      3363,
      3362,
      1,
      0,
      0,
      0,
      3363,
      3364,
      1,
      0,
      0,
      0,
      3364,
      3365,
      1,
      0,
      0,
      0,
      3365,
      3369,
      3,
      582,
      291,
      0,
      3366,
      3368,
      3,
      588,
      294,
      0,
      3367,
      3366,
      1,
      0,
      0,
      0,
      3368,
      3371,
      1,
      0,
      0,
      0,
      3369,
      3367,
      1,
      0,
      0,
      0,
      3369,
      3370,
      1,
      0,
      0,
      0,
      3370,
      3374,
      1,
      0,
      0,
      0,
      3371,
      3369,
      1,
      0,
      0,
      0,
      3372,
      3374,
      3,
      590,
      295,
      0,
      3373,
      3354,
      1,
      0,
      0,
      0,
      3373,
      3355,
      1,
      0,
      0,
      0,
      3373,
      3363,
      1,
      0,
      0,
      0,
      3373,
      3372,
      1,
      0,
      0,
      0,
      3374,
      579,
      1,
      0,
      0,
      0,
      3375,
      3385,
      3,
      90,
      45,
      0,
      3376,
      3385,
      3,
      86,
      43,
      0,
      3377,
      3385,
      3,
      394,
      197,
      0,
      3378,
      3385,
      3,
      396,
      198,
      0,
      3379,
      3385,
      3,
      398,
      199,
      0,
      3380,
      3382,
      3,
      480,
      240,
      0,
      3381,
      3380,
      1,
      0,
      0,
      0,
      3381,
      3382,
      1,
      0,
      0,
      0,
      3382,
      3383,
      1,
      0,
      0,
      0,
      3383,
      3385,
      3,
      400,
      200,
      0,
      3384,
      3375,
      1,
      0,
      0,
      0,
      3384,
      3376,
      1,
      0,
      0,
      0,
      3384,
      3377,
      1,
      0,
      0,
      0,
      3384,
      3378,
      1,
      0,
      0,
      0,
      3384,
      3379,
      1,
      0,
      0,
      0,
      3384,
      3381,
      1,
      0,
      0,
      0,
      3385,
      581,
      1,
      0,
      0,
      0,
      3386,
      3389,
      3,
      586,
      293,
      0,
      3387,
      3389,
      3,
      402,
      201,
      0,
      3388,
      3386,
      1,
      0,
      0,
      0,
      3388,
      3387,
      1,
      0,
      0,
      0,
      3389,
      583,
      1,
      0,
      0,
      0,
      3390,
      3391,
      3,
      76,
      38,
      0,
      3391,
      3392,
      5,
      69,
      0,
      0,
      3392,
      3393,
      3,
      88,
      44,
      0,
      3393,
      3394,
      3,
      46,
      23,
      0,
      3394,
      585,
      1,
      0,
      0,
      0,
      3395,
      3396,
      3,
      76,
      38,
      0,
      3396,
      3397,
      3,
      600,
      300,
      0,
      3397,
      587,
      1,
      0,
      0,
      0,
      3398,
      3399,
      3,
      76,
      38,
      0,
      3399,
      3400,
      3,
      676,
      338,
      0,
      3400,
      589,
      1,
      0,
      0,
      0,
      3401,
      3402,
      3,
      76,
      38,
      0,
      3402,
      3403,
      3,
      684,
      342,
      0,
      3403,
      591,
      1,
      0,
      0,
      0,
      3404,
      3405,
      3,
      468,
      234,
      0,
      3405,
      3406,
      5,
      4,
      0,
      0,
      3406,
      3407,
      3,
      594,
      297,
      0,
      3407,
      3408,
      3,
      576,
      288,
      0,
      3408,
      593,
      1,
      0,
      0,
      0,
      3409,
      3411,
      3,
      418,
      209,
      0,
      3410,
      3409,
      1,
      0,
      0,
      0,
      3410,
      3411,
      1,
      0,
      0,
      0,
      3411,
      3413,
      1,
      0,
      0,
      0,
      3412,
      3414,
      3,
      318,
      159,
      0,
      3413,
      3412,
      1,
      0,
      0,
      0,
      3413,
      3414,
      1,
      0,
      0,
      0,
      3414,
      595,
      1,
      0,
      0,
      0,
      3415,
      3416,
      3,
      468,
      234,
      0,
      3416,
      3417,
      5,
      118,
      0,
      0,
      3417,
      3418,
      3,
      598,
      299,
      0,
      3418,
      3419,
      3,
      576,
      288,
      0,
      3419,
      597,
      1,
      0,
      0,
      0,
      3420,
      3422,
      3,
      226,
      113,
      0,
      3421,
      3423,
      3,
      196,
      98,
      0,
      3422,
      3421,
      1,
      0,
      0,
      0,
      3422,
      3423,
      1,
      0,
      0,
      0,
      3423,
      3429,
      1,
      0,
      0,
      0,
      3424,
      3426,
      5,
      4,
      0,
      0,
      3425,
      3427,
      3,
      418,
      209,
      0,
      3426,
      3425,
      1,
      0,
      0,
      0,
      3426,
      3427,
      1,
      0,
      0,
      0,
      3427,
      3429,
      1,
      0,
      0,
      0,
      3428,
      3420,
      1,
      0,
      0,
      0,
      3428,
      3424,
      1,
      0,
      0,
      0,
      3429,
      3431,
      1,
      0,
      0,
      0,
      3430,
      3432,
      3,
      318,
      159,
      0,
      3431,
      3430,
      1,
      0,
      0,
      0,
      3431,
      3432,
      1,
      0,
      0,
      0,
      3432,
      599,
      1,
      0,
      0,
      0,
      3433,
      3442,
      3,
      606,
      303,
      0,
      3434,
      3442,
      3,
      634,
      317,
      0,
      3435,
      3442,
      3,
      618,
      309,
      0,
      3436,
      3442,
      3,
      648,
      324,
      0,
      3437,
      3442,
      3,
      658,
      329,
      0,
      3438,
      3442,
      3,
      660,
      330,
      0,
      3439,
      3442,
      3,
      670,
      335,
      0,
      3440,
      3442,
      3,
      672,
      336,
      0,
      3441,
      3433,
      1,
      0,
      0,
      0,
      3441,
      3434,
      1,
      0,
      0,
      0,
      3441,
      3435,
      1,
      0,
      0,
      0,
      3441,
      3436,
      1,
      0,
      0,
      0,
      3441,
      3437,
      1,
      0,
      0,
      0,
      3441,
      3438,
      1,
      0,
      0,
      0,
      3441,
      3439,
      1,
      0,
      0,
      0,
      3441,
      3440,
      1,
      0,
      0,
      0,
      3442,
      601,
      1,
      0,
      0,
      0,
      3443,
      3445,
      5,
      4,
      0,
      0,
      3444,
      3446,
      3,
      418,
      209,
      0,
      3445,
      3444,
      1,
      0,
      0,
      0,
      3445,
      3446,
      1,
      0,
      0,
      0,
      3446,
      603,
      1,
      0,
      0,
      0,
      3447,
      3449,
      3,
      468,
      234,
      0,
      3448,
      3450,
      3,
      602,
      301,
      0,
      3449,
      3448,
      1,
      0,
      0,
      0,
      3449,
      3450,
      1,
      0,
      0,
      0,
      3450,
      605,
      1,
      0,
      0,
      0,
      3451,
      3456,
      3,
      610,
      305,
      0,
      3452,
      3456,
      3,
      612,
      306,
      0,
      3453,
      3456,
      3,
      614,
      307,
      0,
      3454,
      3456,
      3,
      616,
      308,
      0,
      3455,
      3451,
      1,
      0,
      0,
      0,
      3455,
      3452,
      1,
      0,
      0,
      0,
      3455,
      3453,
      1,
      0,
      0,
      0,
      3455,
      3454,
      1,
      0,
      0,
      0,
      3456,
      607,
      1,
      0,
      0,
      0,
      3457,
      3459,
      3,
      404,
      202,
      0,
      3458,
      3460,
      5,
      82,
      0,
      0,
      3459,
      3458,
      1,
      0,
      0,
      0,
      3459,
      3460,
      1,
      0,
      0,
      0,
      3460,
      3462,
      1,
      0,
      0,
      0,
      3461,
      3463,
      3,
      476,
      238,
      0,
      3462,
      3461,
      1,
      0,
      0,
      0,
      3462,
      3463,
      1,
      0,
      0,
      0,
      3463,
      3467,
      1,
      0,
      0,
      0,
      3464,
      3466,
      3,
      410,
      205,
      0,
      3465,
      3464,
      1,
      0,
      0,
      0,
      3466,
      3469,
      1,
      0,
      0,
      0,
      3467,
      3465,
      1,
      0,
      0,
      0,
      3467,
      3468,
      1,
      0,
      0,
      0,
      3468,
      609,
      1,
      0,
      0,
      0,
      3469,
      3467,
      1,
      0,
      0,
      0,
      3470,
      3471,
      3,
      608,
      304,
      0,
      3471,
      3473,
      5,
      98,
      0,
      0,
      3472,
      3474,
      3,
      418,
      209,
      0,
      3473,
      3472,
      1,
      0,
      0,
      0,
      3473,
      3474,
      1,
      0,
      0,
      0,
      3474,
      3475,
      1,
      0,
      0,
      0,
      3475,
      3476,
      3,
      576,
      288,
      0,
      3476,
      611,
      1,
      0,
      0,
      0,
      3477,
      3478,
      3,
      608,
      304,
      0,
      3478,
      3480,
      5,
      44,
      0,
      0,
      3479,
      3481,
      3,
      418,
      209,
      0,
      3480,
      3479,
      1,
      0,
      0,
      0,
      3480,
      3481,
      1,
      0,
      0,
      0,
      3481,
      3482,
      1,
      0,
      0,
      0,
      3482,
      3483,
      3,
      576,
      288,
      0,
      3483,
      613,
      1,
      0,
      0,
      0,
      3484,
      3485,
      3,
      608,
      304,
      0,
      3485,
      3487,
      5,
      92,
      0,
      0,
      3486,
      3488,
      3,
      418,
      209,
      0,
      3487,
      3486,
      1,
      0,
      0,
      0,
      3487,
      3488,
      1,
      0,
      0,
      0,
      3488,
      3489,
      1,
      0,
      0,
      0,
      3489,
      3490,
      3,
      576,
      288,
      0,
      3490,
      615,
      1,
      0,
      0,
      0,
      3491,
      3492,
      3,
      608,
      304,
      0,
      3492,
      3494,
      5,
      72,
      0,
      0,
      3493,
      3495,
      3,
      418,
      209,
      0,
      3494,
      3493,
      1,
      0,
      0,
      0,
      3494,
      3495,
      1,
      0,
      0,
      0,
      3495,
      3496,
      1,
      0,
      0,
      0,
      3496,
      3497,
      3,
      576,
      288,
      0,
      3497,
      617,
      1,
      0,
      0,
      0,
      3498,
      3499,
      3,
      468,
      234,
      0,
      3499,
      3500,
      3,
      620,
      310,
      0,
      3500,
      3501,
      3,
      576,
      288,
      0,
      3501,
      619,
      1,
      0,
      0,
      0,
      3502,
      3504,
      3,
      602,
      301,
      0,
      3503,
      3502,
      1,
      0,
      0,
      0,
      3503,
      3504,
      1,
      0,
      0,
      0,
      3504,
      3505,
      1,
      0,
      0,
      0,
      3505,
      3506,
      5,
      3,
      0,
      0,
      3506,
      3507,
      3,
      622,
      311,
      0,
      3507,
      621,
      1,
      0,
      0,
      0,
      3508,
      3511,
      3,
      624,
      312,
      0,
      3509,
      3510,
      5,
      168,
      0,
      0,
      3510,
      3512,
      3,
      640,
      320,
      0,
      3511,
      3509,
      1,
      0,
      0,
      0,
      3511,
      3512,
      1,
      0,
      0,
      0,
      3512,
      623,
      1,
      0,
      0,
      0,
      3513,
      3514,
      3,
      626,
      313,
      0,
      3514,
      625,
      1,
      0,
      0,
      0,
      3515,
      3524,
      3,
      310,
      155,
      0,
      3516,
      3518,
      3,
      44,
      22,
      0,
      3517,
      3516,
      1,
      0,
      0,
      0,
      3517,
      3518,
      1,
      0,
      0,
      0,
      3518,
      3520,
      1,
      0,
      0,
      0,
      3519,
      3521,
      3,
      312,
      156,
      0,
      3520,
      3519,
      1,
      0,
      0,
      0,
      3520,
      3521,
      1,
      0,
      0,
      0,
      3521,
      3522,
      1,
      0,
      0,
      0,
      3522,
      3524,
      3,
      628,
      314,
      0,
      3523,
      3515,
      1,
      0,
      0,
      0,
      3523,
      3517,
      1,
      0,
      0,
      0,
      3524,
      627,
      1,
      0,
      0,
      0,
      3525,
      3526,
      3,
      630,
      315,
      0,
      3526,
      629,
      1,
      0,
      0,
      0,
      3527,
      3528,
      3,
      632,
      316,
      0,
      3528,
      631,
      1,
      0,
      0,
      0,
      3529,
      3530,
      7,
      24,
      0,
      0,
      3530,
      3534,
      3,
      36,
      18,
      0,
      3531,
      3532,
      5,
      171,
      0,
      0,
      3532,
      3534,
      3,
      38,
      19,
      0,
      3533,
      3529,
      1,
      0,
      0,
      0,
      3533,
      3531,
      1,
      0,
      0,
      0,
      3534,
      633,
      1,
      0,
      0,
      0,
      3535,
      3538,
      3,
      468,
      234,
      0,
      3536,
      3539,
      3,
      602,
      301,
      0,
      3537,
      3539,
      3,
      594,
      297,
      0,
      3538,
      3536,
      1,
      0,
      0,
      0,
      3538,
      3537,
      1,
      0,
      0,
      0,
      3539,
      3540,
      1,
      0,
      0,
      0,
      3540,
      3549,
      5,
      136,
      0,
      0,
      3541,
      3543,
      3,
      640,
      320,
      0,
      3542,
      3544,
      3,
      638,
      319,
      0,
      3543,
      3542,
      1,
      0,
      0,
      0,
      3543,
      3544,
      1,
      0,
      0,
      0,
      3544,
      3550,
      1,
      0,
      0,
      0,
      3545,
      3547,
      3,
      646,
      323,
      0,
      3546,
      3548,
      3,
      638,
      319,
      0,
      3547,
      3546,
      1,
      0,
      0,
      0,
      3547,
      3548,
      1,
      0,
      0,
      0,
      3548,
      3550,
      1,
      0,
      0,
      0,
      3549,
      3541,
      1,
      0,
      0,
      0,
      3549,
      3545,
      1,
      0,
      0,
      0,
      3550,
      3551,
      1,
      0,
      0,
      0,
      3551,
      3552,
      3,
      576,
      288,
      0,
      3552,
      635,
      1,
      0,
      0,
      0,
      3553,
      3555,
      3,
      602,
      301,
      0,
      3554,
      3553,
      1,
      0,
      0,
      0,
      3554,
      3555,
      1,
      0,
      0,
      0,
      3555,
      3556,
      1,
      0,
      0,
      0,
      3556,
      3557,
      5,
      136,
      0,
      0,
      3557,
      3559,
      3,
      640,
      320,
      0,
      3558,
      3560,
      3,
      638,
      319,
      0,
      3559,
      3558,
      1,
      0,
      0,
      0,
      3559,
      3560,
      1,
      0,
      0,
      0,
      3560,
      637,
      1,
      0,
      0,
      0,
      3561,
      3562,
      5,
      168,
      0,
      0,
      3562,
      3565,
      3,
      640,
      320,
      0,
      3563,
      3564,
      5,
      154,
      0,
      0,
      3564,
      3566,
      3,
      640,
      320,
      0,
      3565,
      3563,
      1,
      0,
      0,
      0,
      3565,
      3566,
      1,
      0,
      0,
      0,
      3566,
      3572,
      1,
      0,
      0,
      0,
      3567,
      3568,
      3,
      646,
      323,
      0,
      3568,
      3569,
      5,
      154,
      0,
      0,
      3569,
      3570,
      3,
      640,
      320,
      0,
      3570,
      3572,
      1,
      0,
      0,
      0,
      3571,
      3561,
      1,
      0,
      0,
      0,
      3571,
      3567,
      1,
      0,
      0,
      0,
      3572,
      639,
      1,
      0,
      0,
      0,
      3573,
      3574,
      3,
      642,
      321,
      0,
      3574,
      641,
      1,
      0,
      0,
      0,
      3575,
      3576,
      3,
      644,
      322,
      0,
      3576,
      643,
      1,
      0,
      0,
      0,
      3577,
      3578,
      3,
      0,
      0,
      0,
      3578,
      645,
      1,
      0,
      0,
      0,
      3579,
      3580,
      3,
      896,
      448,
      0,
      3580,
      647,
      1,
      0,
      0,
      0,
      3581,
      3582,
      3,
      468,
      234,
      0,
      3582,
      3583,
      3,
      650,
      325,
      0,
      3583,
      3584,
      3,
      576,
      288,
      0,
      3584,
      649,
      1,
      0,
      0,
      0,
      3585,
      3587,
      3,
      602,
      301,
      0,
      3586,
      3585,
      1,
      0,
      0,
      0,
      3586,
      3587,
      1,
      0,
      0,
      0,
      3587,
      3588,
      1,
      0,
      0,
      0,
      3588,
      3589,
      5,
      15,
      0,
      0,
      3589,
      3590,
      3,
      652,
      326,
      0,
      3590,
      3591,
      3,
      298,
      149,
      0,
      3591,
      3592,
      5,
      184,
      0,
      0,
      3592,
      3593,
      3,
      640,
      320,
      0,
      3593,
      651,
      1,
      0,
      0,
      0,
      3594,
      3595,
      3,
      654,
      327,
      0,
      3595,
      653,
      1,
      0,
      0,
      0,
      3596,
      3597,
      3,
      656,
      328,
      0,
      3597,
      3598,
      5,
      202,
      0,
      0,
      3598,
      3600,
      1,
      0,
      0,
      0,
      3599,
      3596,
      1,
      0,
      0,
      0,
      3599,
      3600,
      1,
      0,
      0,
      0,
      3600,
      655,
      1,
      0,
      0,
      0,
      3601,
      3602,
      3,
      900,
      450,
      0,
      3602,
      657,
      1,
      0,
      0,
      0,
      3603,
      3605,
      3,
      468,
      234,
      0,
      3604,
      3606,
      3,
      602,
      301,
      0,
      3605,
      3604,
      1,
      0,
      0,
      0,
      3605,
      3606,
      1,
      0,
      0,
      0,
      3606,
      3607,
      1,
      0,
      0,
      0,
      3607,
      3609,
      5,
      151,
      0,
      0,
      3608,
      3610,
      3,
      640,
      320,
      0,
      3609,
      3608,
      1,
      0,
      0,
      0,
      3609,
      3610,
      1,
      0,
      0,
      0,
      3610,
      3611,
      1,
      0,
      0,
      0,
      3611,
      3612,
      3,
      576,
      288,
      0,
      3612,
      659,
      1,
      0,
      0,
      0,
      3613,
      3614,
      3,
      604,
      302,
      0,
      3614,
      3615,
      5,
      77,
      0,
      0,
      3615,
      3616,
      3,
      662,
      331,
      0,
      3616,
      3622,
      3,
      664,
      332,
      0,
      3617,
      3620,
      5,
      55,
      0,
      0,
      3618,
      3621,
      3,
      664,
      332,
      0,
      3619,
      3621,
      3,
      668,
      334,
      0,
      3620,
      3618,
      1,
      0,
      0,
      0,
      3620,
      3619,
      1,
      0,
      0,
      0,
      3621,
      3623,
      1,
      0,
      0,
      0,
      3622,
      3617,
      1,
      0,
      0,
      0,
      3622,
      3623,
      1,
      0,
      0,
      0,
      3623,
      661,
      1,
      0,
      0,
      0,
      3624,
      3625,
      3,
      0,
      0,
      0,
      3625,
      663,
      1,
      0,
      0,
      0,
      3626,
      3627,
      3,
      666,
      333,
      0,
      3627,
      665,
      1,
      0,
      0,
      0,
      3628,
      3630,
      5,
      4,
      0,
      0,
      3629,
      3631,
      3,
      418,
      209,
      0,
      3630,
      3629,
      1,
      0,
      0,
      0,
      3630,
      3631,
      1,
      0,
      0,
      0,
      3631,
      3633,
      1,
      0,
      0,
      0,
      3632,
      3628,
      1,
      0,
      0,
      0,
      3632,
      3633,
      1,
      0,
      0,
      0,
      3633,
      3634,
      1,
      0,
      0,
      0,
      3634,
      3638,
      5,
      214,
      0,
      0,
      3635,
      3637,
      3,
      578,
      289,
      0,
      3636,
      3635,
      1,
      0,
      0,
      0,
      3637,
      3640,
      1,
      0,
      0,
      0,
      3638,
      3636,
      1,
      0,
      0,
      0,
      3638,
      3639,
      1,
      0,
      0,
      0,
      3639,
      3641,
      1,
      0,
      0,
      0,
      3640,
      3638,
      1,
      0,
      0,
      0,
      3641,
      3642,
      5,
      216,
      0,
      0,
      3642,
      667,
      1,
      0,
      0,
      0,
      3643,
      3644,
      3,
      660,
      330,
      0,
      3644,
      669,
      1,
      0,
      0,
      0,
      3645,
      3650,
      3,
      604,
      302,
      0,
      3646,
      3647,
      5,
      172,
      0,
      0,
      3647,
      3651,
      3,
      662,
      331,
      0,
      3648,
      3649,
      5,
      96,
      0,
      0,
      3649,
      3651,
      3,
      646,
      323,
      0,
      3650,
      3646,
      1,
      0,
      0,
      0,
      3650,
      3648,
      1,
      0,
      0,
      0,
      3651,
      3652,
      1,
      0,
      0,
      0,
      3652,
      3657,
      3,
      664,
      332,
      0,
      3653,
      3654,
      5,
      161,
      0,
      0,
      3654,
      3655,
      3,
      662,
      331,
      0,
      3655,
      3656,
      5,
      205,
      0,
      0,
      3656,
      3658,
      1,
      0,
      0,
      0,
      3657,
      3653,
      1,
      0,
      0,
      0,
      3657,
      3658,
      1,
      0,
      0,
      0,
      3658,
      671,
      1,
      0,
      0,
      0,
      3659,
      3660,
      3,
      604,
      302,
      0,
      3660,
      3661,
      5,
      71,
      0,
      0,
      3661,
      3662,
      3,
      674,
      337,
      0,
      3662,
      3663,
      5,
      80,
      0,
      0,
      3663,
      3664,
      3,
      640,
      320,
      0,
      3664,
      3665,
      3,
      664,
      332,
      0,
      3665,
      673,
      1,
      0,
      0,
      0,
      3666,
      3668,
      3,
      418,
      209,
      0,
      3667,
      3666,
      1,
      0,
      0,
      0,
      3667,
      3668,
      1,
      0,
      0,
      0,
      3668,
      675,
      1,
      0,
      0,
      0,
      3669,
      3673,
      3,
      678,
      339,
      0,
      3670,
      3673,
      3,
      680,
      340,
      0,
      3671,
      3673,
      3,
      682,
      341,
      0,
      3672,
      3669,
      1,
      0,
      0,
      0,
      3672,
      3670,
      1,
      0,
      0,
      0,
      3672,
      3671,
      1,
      0,
      0,
      0,
      3673,
      3674,
      1,
      0,
      0,
      0,
      3674,
      3675,
      3,
      422,
      211,
      0,
      3675,
      677,
      1,
      0,
      0,
      0,
      3676,
      3677,
      3,
      484,
      242,
      0,
      3677,
      3678,
      5,
      152,
      0,
      0,
      3678,
      3679,
      3,
      260,
      130,
      0,
      3679,
      679,
      1,
      0,
      0,
      0,
      3680,
      3681,
      3,
      728,
      364,
      0,
      3681,
      3682,
      5,
      152,
      0,
      0,
      3682,
      3683,
      3,
      742,
      371,
      0,
      3683,
      681,
      1,
      0,
      0,
      0,
      3684,
      3685,
      5,
      55,
      0,
      0,
      3685,
      3686,
      3,
      742,
      371,
      0,
      3686,
      683,
      1,
      0,
      0,
      0,
      3687,
      3689,
      5,
      150,
      0,
      0,
      3688,
      3690,
      3,
      418,
      209,
      0,
      3689,
      3688,
      1,
      0,
      0,
      0,
      3689,
      3690,
      1,
      0,
      0,
      0,
      3690,
      3692,
      1,
      0,
      0,
      0,
      3691,
      3687,
      1,
      0,
      0,
      0,
      3691,
      3692,
      1,
      0,
      0,
      0,
      3692,
      3693,
      1,
      0,
      0,
      0,
      3693,
      3694,
      5,
      69,
      0,
      0,
      3694,
      3695,
      3,
      298,
      149,
      0,
      3695,
      3696,
      3,
      728,
      364,
      0,
      3696,
      3697,
      5,
      152,
      0,
      0,
      3697,
      3698,
      3,
      742,
      371,
      0,
      3698,
      3699,
      3,
      422,
      211,
      0,
      3699,
      685,
      1,
      0,
      0,
      0,
      3700,
      3701,
      3,
      460,
      230,
      0,
      3701,
      3702,
      5,
      142,
      0,
      0,
      3702,
      3703,
      5,
      45,
      0,
      0,
      3703,
      3704,
      3,
      386,
      193,
      0,
      3704,
      3705,
      3,
      688,
      344,
      0,
      3705,
      687,
      1,
      0,
      0,
      0,
      3706,
      3719,
      5,
      205,
      0,
      0,
      3707,
      3709,
      5,
      116,
      0,
      0,
      3708,
      3707,
      1,
      0,
      0,
      0,
      3708,
      3709,
      1,
      0,
      0,
      0,
      3709,
      3710,
      1,
      0,
      0,
      0,
      3710,
      3714,
      5,
      214,
      0,
      0,
      3711,
      3713,
      3,
      690,
      345,
      0,
      3712,
      3711,
      1,
      0,
      0,
      0,
      3713,
      3716,
      1,
      0,
      0,
      0,
      3714,
      3712,
      1,
      0,
      0,
      0,
      3714,
      3715,
      1,
      0,
      0,
      0,
      3715,
      3717,
      1,
      0,
      0,
      0,
      3716,
      3714,
      1,
      0,
      0,
      0,
      3717,
      3719,
      5,
      216,
      0,
      0,
      3718,
      3706,
      1,
      0,
      0,
      0,
      3718,
      3708,
      1,
      0,
      0,
      0,
      3719,
      689,
      1,
      0,
      0,
      0,
      3720,
      3742,
      3,
      580,
      290,
      0,
      3721,
      3723,
      3,
      480,
      240,
      0,
      3722,
      3721,
      1,
      0,
      0,
      0,
      3722,
      3723,
      1,
      0,
      0,
      0,
      3723,
      3724,
      1,
      0,
      0,
      0,
      3724,
      3728,
      3,
      402,
      201,
      0,
      3725,
      3727,
      3,
      712,
      356,
      0,
      3726,
      3725,
      1,
      0,
      0,
      0,
      3727,
      3730,
      1,
      0,
      0,
      0,
      3728,
      3726,
      1,
      0,
      0,
      0,
      3728,
      3729,
      1,
      0,
      0,
      0,
      3729,
      3742,
      1,
      0,
      0,
      0,
      3730,
      3728,
      1,
      0,
      0,
      0,
      3731,
      3742,
      3,
      710,
      355,
      0,
      3732,
      3736,
      3,
      692,
      346,
      0,
      3733,
      3735,
      3,
      698,
      349,
      0,
      3734,
      3733,
      1,
      0,
      0,
      0,
      3735,
      3738,
      1,
      0,
      0,
      0,
      3736,
      3734,
      1,
      0,
      0,
      0,
      3736,
      3737,
      1,
      0,
      0,
      0,
      3737,
      3742,
      1,
      0,
      0,
      0,
      3738,
      3736,
      1,
      0,
      0,
      0,
      3739,
      3742,
      3,
      694,
      347,
      0,
      3740,
      3742,
      3,
      696,
      348,
      0,
      3741,
      3720,
      1,
      0,
      0,
      0,
      3741,
      3722,
      1,
      0,
      0,
      0,
      3741,
      3731,
      1,
      0,
      0,
      0,
      3741,
      3732,
      1,
      0,
      0,
      0,
      3741,
      3739,
      1,
      0,
      0,
      0,
      3741,
      3740,
      1,
      0,
      0,
      0,
      3742,
      691,
      1,
      0,
      0,
      0,
      3743,
      3744,
      3,
      76,
      38,
      0,
      3744,
      3745,
      5,
      57,
      0,
      0,
      3745,
      3746,
      3,
      700,
      350,
      0,
      3746,
      693,
      1,
      0,
      0,
      0,
      3747,
      3748,
      3,
      76,
      38,
      0,
      3748,
      3749,
      5,
      53,
      0,
      0,
      3749,
      3750,
      3,
      700,
      350,
      0,
      3750,
      695,
      1,
      0,
      0,
      0,
      3751,
      3752,
      3,
      76,
      38,
      0,
      3752,
      3753,
      5,
      61,
      0,
      0,
      3753,
      3754,
      3,
      700,
      350,
      0,
      3754,
      697,
      1,
      0,
      0,
      0,
      3755,
      3759,
      3,
      76,
      38,
      0,
      3756,
      3760,
      3,
      680,
      340,
      0,
      3757,
      3758,
      5,
      152,
      0,
      0,
      3758,
      3760,
      3,
      742,
      371,
      0,
      3759,
      3756,
      1,
      0,
      0,
      0,
      3759,
      3757,
      1,
      0,
      0,
      0,
      3760,
      3761,
      1,
      0,
      0,
      0,
      3761,
      3762,
      5,
      205,
      0,
      0,
      3762,
      699,
      1,
      0,
      0,
      0,
      3763,
      3764,
      3,
      890,
      445,
      0,
      3764,
      3765,
      5,
      205,
      0,
      0,
      3765,
      3771,
      1,
      0,
      0,
      0,
      3766,
      3771,
      3,
      702,
      351,
      0,
      3767,
      3771,
      3,
      704,
      352,
      0,
      3768,
      3771,
      3,
      706,
      353,
      0,
      3769,
      3771,
      3,
      708,
      354,
      0,
      3770,
      3763,
      1,
      0,
      0,
      0,
      3770,
      3766,
      1,
      0,
      0,
      0,
      3770,
      3767,
      1,
      0,
      0,
      0,
      3770,
      3768,
      1,
      0,
      0,
      0,
      3770,
      3769,
      1,
      0,
      0,
      0,
      3771,
      701,
      1,
      0,
      0,
      0,
      3772,
      3773,
      3,
      598,
      299,
      0,
      3773,
      3774,
      3,
      576,
      288,
      0,
      3774,
      703,
      1,
      0,
      0,
      0,
      3775,
      3776,
      3,
      620,
      310,
      0,
      3776,
      3777,
      3,
      576,
      288,
      0,
      3777,
      705,
      1,
      0,
      0,
      0,
      3778,
      3779,
      3,
      636,
      318,
      0,
      3779,
      3780,
      3,
      576,
      288,
      0,
      3780,
      707,
      1,
      0,
      0,
      0,
      3781,
      3782,
      3,
      650,
      325,
      0,
      3782,
      3783,
      3,
      576,
      288,
      0,
      3783,
      709,
      1,
      0,
      0,
      0,
      3784,
      3785,
      3,
      76,
      38,
      0,
      3785,
      3786,
      3,
      720,
      360,
      0,
      3786,
      711,
      1,
      0,
      0,
      0,
      3787,
      3788,
      3,
      76,
      38,
      0,
      3788,
      3789,
      3,
      722,
      361,
      0,
      3789,
      713,
      1,
      0,
      0,
      0,
      3790,
      3791,
      3,
      468,
      234,
      0,
      3791,
      3792,
      5,
      142,
      0,
      0,
      3792,
      3793,
      3,
      594,
      297,
      0,
      3793,
      3794,
      3,
      716,
      358,
      0,
      3794,
      715,
      1,
      0,
      0,
      0,
      3795,
      3808,
      5,
      205,
      0,
      0,
      3796,
      3798,
      5,
      116,
      0,
      0,
      3797,
      3796,
      1,
      0,
      0,
      0,
      3797,
      3798,
      1,
      0,
      0,
      0,
      3798,
      3799,
      1,
      0,
      0,
      0,
      3799,
      3803,
      5,
      214,
      0,
      0,
      3800,
      3802,
      3,
      690,
      345,
      0,
      3801,
      3800,
      1,
      0,
      0,
      0,
      3802,
      3805,
      1,
      0,
      0,
      0,
      3803,
      3801,
      1,
      0,
      0,
      0,
      3803,
      3804,
      1,
      0,
      0,
      0,
      3804,
      3806,
      1,
      0,
      0,
      0,
      3805,
      3803,
      1,
      0,
      0,
      0,
      3806,
      3808,
      5,
      216,
      0,
      0,
      3807,
      3795,
      1,
      0,
      0,
      0,
      3807,
      3797,
      1,
      0,
      0,
      0,
      3808,
      717,
      1,
      0,
      0,
      0,
      3809,
      3810,
      3,
      468,
      234,
      0,
      3810,
      3819,
      5,
      60,
      0,
      0,
      3811,
      3813,
      3,
      226,
      113,
      0,
      3812,
      3814,
      3,
      196,
      98,
      0,
      3813,
      3812,
      1,
      0,
      0,
      0,
      3813,
      3814,
      1,
      0,
      0,
      0,
      3814,
      3820,
      1,
      0,
      0,
      0,
      3815,
      3817,
      5,
      142,
      0,
      0,
      3816,
      3818,
      3,
      418,
      209,
      0,
      3817,
      3816,
      1,
      0,
      0,
      0,
      3817,
      3818,
      1,
      0,
      0,
      0,
      3818,
      3820,
      1,
      0,
      0,
      0,
      3819,
      3811,
      1,
      0,
      0,
      0,
      3819,
      3815,
      1,
      0,
      0,
      0,
      3820,
      3822,
      1,
      0,
      0,
      0,
      3821,
      3823,
      3,
      318,
      159,
      0,
      3822,
      3821,
      1,
      0,
      0,
      0,
      3822,
      3823,
      1,
      0,
      0,
      0,
      3823,
      3824,
      1,
      0,
      0,
      0,
      3824,
      3825,
      3,
      716,
      358,
      0,
      3825,
      719,
      1,
      0,
      0,
      0,
      3826,
      3831,
      5,
      155,
      0,
      0,
      3827,
      3829,
      3,
      418,
      209,
      0,
      3828,
      3827,
      1,
      0,
      0,
      0,
      3828,
      3829,
      1,
      0,
      0,
      0,
      3829,
      3830,
      1,
      0,
      0,
      0,
      3830,
      3832,
      5,
      69,
      0,
      0,
      3831,
      3828,
      1,
      0,
      0,
      0,
      3831,
      3832,
      1,
      0,
      0,
      0,
      3832,
      3833,
      1,
      0,
      0,
      0,
      3833,
      3834,
      3,
      298,
      149,
      0,
      3834,
      3838,
      3,
      646,
      323,
      0,
      3835,
      3836,
      3,
      646,
      323,
      0,
      3836,
      3837,
      3,
      724,
      362,
      0,
      3837,
      3839,
      1,
      0,
      0,
      0,
      3838,
      3835,
      1,
      0,
      0,
      0,
      3838,
      3839,
      1,
      0,
      0,
      0,
      3839,
      3841,
      1,
      0,
      0,
      0,
      3840,
      3842,
      3,
      728,
      364,
      0,
      3841,
      3840,
      1,
      0,
      0,
      0,
      3841,
      3842,
      1,
      0,
      0,
      0,
      3842,
      3844,
      1,
      0,
      0,
      0,
      3843,
      3845,
      3,
      730,
      365,
      0,
      3844,
      3843,
      1,
      0,
      0,
      0,
      3844,
      3845,
      1,
      0,
      0,
      0,
      3845,
      3846,
      1,
      0,
      0,
      0,
      3846,
      3847,
      5,
      152,
      0,
      0,
      3847,
      3848,
      3,
      742,
      371,
      0,
      3848,
      3849,
      3,
      576,
      288,
      0,
      3849,
      721,
      1,
      0,
      0,
      0,
      3850,
      3875,
      3,
      646,
      323,
      0,
      3851,
      3855,
      5,
      155,
      0,
      0,
      3852,
      3853,
      3,
      646,
      323,
      0,
      3853,
      3854,
      3,
      724,
      362,
      0,
      3854,
      3856,
      1,
      0,
      0,
      0,
      3855,
      3852,
      1,
      0,
      0,
      0,
      3855,
      3856,
      1,
      0,
      0,
      0,
      3856,
      3858,
      1,
      0,
      0,
      0,
      3857,
      3859,
      3,
      728,
      364,
      0,
      3858,
      3857,
      1,
      0,
      0,
      0,
      3858,
      3859,
      1,
      0,
      0,
      0,
      3859,
      3861,
      1,
      0,
      0,
      0,
      3860,
      3862,
      3,
      730,
      365,
      0,
      3861,
      3860,
      1,
      0,
      0,
      0,
      3861,
      3862,
      1,
      0,
      0,
      0,
      3862,
      3876,
      1,
      0,
      0,
      0,
      3863,
      3864,
      3,
      646,
      323,
      0,
      3864,
      3866,
      3,
      724,
      362,
      0,
      3865,
      3867,
      3,
      728,
      364,
      0,
      3866,
      3865,
      1,
      0,
      0,
      0,
      3866,
      3867,
      1,
      0,
      0,
      0,
      3867,
      3869,
      1,
      0,
      0,
      0,
      3868,
      3870,
      3,
      730,
      365,
      0,
      3869,
      3868,
      1,
      0,
      0,
      0,
      3869,
      3870,
      1,
      0,
      0,
      0,
      3870,
      3876,
      1,
      0,
      0,
      0,
      3871,
      3873,
      3,
      728,
      364,
      0,
      3872,
      3874,
      3,
      730,
      365,
      0,
      3873,
      3872,
      1,
      0,
      0,
      0,
      3873,
      3874,
      1,
      0,
      0,
      0,
      3874,
      3876,
      1,
      0,
      0,
      0,
      3875,
      3851,
      1,
      0,
      0,
      0,
      3875,
      3863,
      1,
      0,
      0,
      0,
      3875,
      3871,
      1,
      0,
      0,
      0,
      3875,
      3876,
      1,
      0,
      0,
      0,
      3876,
      3877,
      1,
      0,
      0,
      0,
      3877,
      3878,
      5,
      152,
      0,
      0,
      3878,
      3879,
      3,
      742,
      371,
      0,
      3879,
      3880,
      3,
      576,
      288,
      0,
      3880,
      723,
      1,
      0,
      0,
      0,
      3881,
      3882,
      5,
      3,
      0,
      0,
      3882,
      3883,
      3,
      726,
      363,
      0,
      3883,
      725,
      1,
      0,
      0,
      0,
      3884,
      3885,
      3,
      622,
      311,
      0,
      3885,
      727,
      1,
      0,
      0,
      0,
      3886,
      3887,
      5,
      77,
      0,
      0,
      3887,
      3888,
      3,
      0,
      0,
      0,
      3888,
      729,
      1,
      0,
      0,
      0,
      3889,
      3890,
      5,
      53,
      0,
      0,
      3890,
      3891,
      3,
      732,
      366,
      0,
      3891,
      731,
      1,
      0,
      0,
      0,
      3892,
      3898,
      3,
      890,
      445,
      0,
      3893,
      3898,
      3,
      734,
      367,
      0,
      3894,
      3898,
      3,
      736,
      368,
      0,
      3895,
      3898,
      3,
      738,
      369,
      0,
      3896,
      3898,
      3,
      740,
      370,
      0,
      3897,
      3892,
      1,
      0,
      0,
      0,
      3897,
      3893,
      1,
      0,
      0,
      0,
      3897,
      3894,
      1,
      0,
      0,
      0,
      3897,
      3895,
      1,
      0,
      0,
      0,
      3897,
      3896,
      1,
      0,
      0,
      0,
      3898,
      733,
      1,
      0,
      0,
      0,
      3899,
      3908,
      3,
      598,
      299,
      0,
      3900,
      3904,
      5,
      214,
      0,
      0,
      3901,
      3903,
      3,
      578,
      289,
      0,
      3902,
      3901,
      1,
      0,
      0,
      0,
      3903,
      3906,
      1,
      0,
      0,
      0,
      3904,
      3902,
      1,
      0,
      0,
      0,
      3904,
      3905,
      1,
      0,
      0,
      0,
      3905,
      3907,
      1,
      0,
      0,
      0,
      3906,
      3904,
      1,
      0,
      0,
      0,
      3907,
      3909,
      5,
      216,
      0,
      0,
      3908,
      3900,
      1,
      0,
      0,
      0,
      3908,
      3909,
      1,
      0,
      0,
      0,
      3909,
      735,
      1,
      0,
      0,
      0,
      3910,
      3919,
      3,
      620,
      310,
      0,
      3911,
      3915,
      5,
      214,
      0,
      0,
      3912,
      3914,
      3,
      578,
      289,
      0,
      3913,
      3912,
      1,
      0,
      0,
      0,
      3914,
      3917,
      1,
      0,
      0,
      0,
      3915,
      3913,
      1,
      0,
      0,
      0,
      3915,
      3916,
      1,
      0,
      0,
      0,
      3916,
      3918,
      1,
      0,
      0,
      0,
      3917,
      3915,
      1,
      0,
      0,
      0,
      3918,
      3920,
      5,
      216,
      0,
      0,
      3919,
      3911,
      1,
      0,
      0,
      0,
      3919,
      3920,
      1,
      0,
      0,
      0,
      3920,
      737,
      1,
      0,
      0,
      0,
      3921,
      3930,
      3,
      636,
      318,
      0,
      3922,
      3926,
      5,
      214,
      0,
      0,
      3923,
      3925,
      3,
      578,
      289,
      0,
      3924,
      3923,
      1,
      0,
      0,
      0,
      3925,
      3928,
      1,
      0,
      0,
      0,
      3926,
      3924,
      1,
      0,
      0,
      0,
      3926,
      3927,
      1,
      0,
      0,
      0,
      3927,
      3929,
      1,
      0,
      0,
      0,
      3928,
      3926,
      1,
      0,
      0,
      0,
      3929,
      3931,
      5,
      216,
      0,
      0,
      3930,
      3922,
      1,
      0,
      0,
      0,
      3930,
      3931,
      1,
      0,
      0,
      0,
      3931,
      739,
      1,
      0,
      0,
      0,
      3932,
      3941,
      3,
      650,
      325,
      0,
      3933,
      3937,
      5,
      214,
      0,
      0,
      3934,
      3936,
      3,
      578,
      289,
      0,
      3935,
      3934,
      1,
      0,
      0,
      0,
      3936,
      3939,
      1,
      0,
      0,
      0,
      3937,
      3935,
      1,
      0,
      0,
      0,
      3937,
      3938,
      1,
      0,
      0,
      0,
      3938,
      3940,
      1,
      0,
      0,
      0,
      3939,
      3937,
      1,
      0,
      0,
      0,
      3940,
      3942,
      5,
      216,
      0,
      0,
      3941,
      3933,
      1,
      0,
      0,
      0,
      3941,
      3942,
      1,
      0,
      0,
      0,
      3942,
      741,
      1,
      0,
      0,
      0,
      3943,
      3944,
      3,
      744,
      372,
      0,
      3944,
      743,
      1,
      0,
      0,
      0,
      3945,
      3946,
      3,
      746,
      373,
      0,
      3946,
      3947,
      3,
      260,
      130,
      0,
      3947,
      745,
      1,
      0,
      0,
      0,
      3948,
      3949,
      3,
      892,
      446,
      0,
      3949,
      747,
      1,
      0,
      0,
      0,
      3950,
      3951,
      3,
      460,
      230,
      0,
      3951,
      3952,
      5,
      25,
      0,
      0,
      3952,
      3953,
      5,
      45,
      0,
      0,
      3953,
      3954,
      3,
      386,
      193,
      0,
      3954,
      3955,
      3,
      752,
      376,
      0,
      3955,
      749,
      1,
      0,
      0,
      0,
      3956,
      3957,
      3,
      468,
      234,
      0,
      3957,
      3958,
      5,
      25,
      0,
      0,
      3958,
      3959,
      3,
      594,
      297,
      0,
      3959,
      3960,
      3,
      752,
      376,
      0,
      3960,
      751,
      1,
      0,
      0,
      0,
      3961,
      3967,
      5,
      205,
      0,
      0,
      3962,
      3963,
      5,
      214,
      0,
      0,
      3963,
      3964,
      3,
      754,
      377,
      0,
      3964,
      3965,
      5,
      216,
      0,
      0,
      3965,
      3967,
      1,
      0,
      0,
      0,
      3966,
      3961,
      1,
      0,
      0,
      0,
      3966,
      3962,
      1,
      0,
      0,
      0,
      3967,
      753,
      1,
      0,
      0,
      0,
      3968,
      3970,
      3,
      756,
      378,
      0,
      3969,
      3968,
      1,
      0,
      0,
      0,
      3970,
      3973,
      1,
      0,
      0,
      0,
      3971,
      3969,
      1,
      0,
      0,
      0,
      3971,
      3972,
      1,
      0,
      0,
      0,
      3972,
      3975,
      1,
      0,
      0,
      0,
      3973,
      3971,
      1,
      0,
      0,
      0,
      3974,
      3976,
      3,
      288,
      144,
      0,
      3975,
      3974,
      1,
      0,
      0,
      0,
      3975,
      3976,
      1,
      0,
      0,
      0,
      3976,
      755,
      1,
      0,
      0,
      0,
      3977,
      3980,
      3,
      578,
      289,
      0,
      3978,
      3980,
      3,
      758,
      379,
      0,
      3979,
      3977,
      1,
      0,
      0,
      0,
      3979,
      3978,
      1,
      0,
      0,
      0,
      3980,
      757,
      1,
      0,
      0,
      0,
      3981,
      3982,
      3,
      76,
      38,
      0,
      3982,
      3983,
      5,
      134,
      0,
      0,
      3983,
      3984,
      3,
      376,
      188,
      0,
      3984,
      759,
      1,
      0,
      0,
      0,
      3985,
      3986,
      3,
      460,
      230,
      0,
      3986,
      3987,
      5,
      41,
      0,
      0,
      3987,
      3988,
      5,
      45,
      0,
      0,
      3988,
      3989,
      3,
      386,
      193,
      0,
      3989,
      3990,
      3,
      752,
      376,
      0,
      3990,
      761,
      1,
      0,
      0,
      0,
      3991,
      3992,
      3,
      468,
      234,
      0,
      3992,
      3993,
      5,
      41,
      0,
      0,
      3993,
      3994,
      3,
      766,
      383,
      0,
      3994,
      3995,
      3,
      752,
      376,
      0,
      3995,
      763,
      1,
      0,
      0,
      0,
      3996,
      3997,
      3,
      468,
      234,
      0,
      3997,
      3999,
      5,
      14,
      0,
      0,
      3998,
      4e3,
      5,
      107,
      0,
      0,
      3999,
      3998,
      1,
      0,
      0,
      0,
      3999,
      4e3,
      1,
      0,
      0,
      0,
      4e3,
      4007,
      1,
      0,
      0,
      0,
      4001,
      4003,
      3,
      226,
      113,
      0,
      4002,
      4004,
      3,
      196,
      98,
      0,
      4003,
      4002,
      1,
      0,
      0,
      0,
      4003,
      4004,
      1,
      0,
      0,
      0,
      4004,
      4008,
      1,
      0,
      0,
      0,
      4005,
      4006,
      5,
      41,
      0,
      0,
      4006,
      4008,
      3,
      766,
      383,
      0,
      4007,
      4001,
      1,
      0,
      0,
      0,
      4007,
      4005,
      1,
      0,
      0,
      0,
      4008,
      4009,
      1,
      0,
      0,
      0,
      4009,
      4010,
      3,
      752,
      376,
      0,
      4010,
      765,
      1,
      0,
      0,
      0,
      4011,
      4013,
      3,
      418,
      209,
      0,
      4012,
      4011,
      1,
      0,
      0,
      0,
      4012,
      4013,
      1,
      0,
      0,
      0,
      4013,
      4015,
      1,
      0,
      0,
      0,
      4014,
      4016,
      3,
      318,
      159,
      0,
      4015,
      4014,
      1,
      0,
      0,
      0,
      4015,
      4016,
      1,
      0,
      0,
      0,
      4016,
      767,
      1,
      0,
      0,
      0,
      4017,
      4018,
      3,
      460,
      230,
      0,
      4018,
      4019,
      5,
      133,
      0,
      0,
      4019,
      4020,
      5,
      45,
      0,
      0,
      4020,
      4021,
      3,
      386,
      193,
      0,
      4021,
      4022,
      3,
      770,
      385,
      0,
      4022,
      769,
      1,
      0,
      0,
      0,
      4023,
      4033,
      5,
      205,
      0,
      0,
      4024,
      4028,
      5,
      214,
      0,
      0,
      4025,
      4027,
      3,
      772,
      386,
      0,
      4026,
      4025,
      1,
      0,
      0,
      0,
      4027,
      4030,
      1,
      0,
      0,
      0,
      4028,
      4026,
      1,
      0,
      0,
      0,
      4028,
      4029,
      1,
      0,
      0,
      0,
      4029,
      4031,
      1,
      0,
      0,
      0,
      4030,
      4028,
      1,
      0,
      0,
      0,
      4031,
      4033,
      5,
      216,
      0,
      0,
      4032,
      4023,
      1,
      0,
      0,
      0,
      4032,
      4024,
      1,
      0,
      0,
      0,
      4033,
      771,
      1,
      0,
      0,
      0,
      4034,
      4042,
      3,
      390,
      195,
      0,
      4035,
      4042,
      3,
      774,
      387,
      0,
      4036,
      4042,
      3,
      778,
      389,
      0,
      4037,
      4042,
      3,
      784,
      392,
      0,
      4038,
      4042,
      3,
      832,
      416,
      0,
      4039,
      4042,
      3,
      788,
      394,
      0,
      4040,
      4042,
      3,
      792,
      396,
      0,
      4041,
      4034,
      1,
      0,
      0,
      0,
      4041,
      4035,
      1,
      0,
      0,
      0,
      4041,
      4036,
      1,
      0,
      0,
      0,
      4041,
      4037,
      1,
      0,
      0,
      0,
      4041,
      4038,
      1,
      0,
      0,
      0,
      4041,
      4039,
      1,
      0,
      0,
      0,
      4041,
      4040,
      1,
      0,
      0,
      0,
      4042,
      773,
      1,
      0,
      0,
      0,
      4043,
      4044,
      3,
      76,
      38,
      0,
      4044,
      4045,
      3,
      776,
      388,
      0,
      4045,
      775,
      1,
      0,
      0,
      0,
      4046,
      4050,
      5,
      146,
      0,
      0,
      4047,
      4049,
      3,
      410,
      205,
      0,
      4048,
      4047,
      1,
      0,
      0,
      0,
      4049,
      4052,
      1,
      0,
      0,
      0,
      4050,
      4048,
      1,
      0,
      0,
      0,
      4050,
      4051,
      1,
      0,
      0,
      0,
      4051,
      4053,
      1,
      0,
      0,
      0,
      4052,
      4050,
      1,
      0,
      0,
      0,
      4053,
      4054,
      3,
      416,
      208,
      0,
      4054,
      777,
      1,
      0,
      0,
      0,
      4055,
      4056,
      3,
      76,
      38,
      0,
      4056,
      4057,
      3,
      780,
      390,
      0,
      4057,
      4058,
      3,
      782,
      391,
      0,
      4058,
      779,
      1,
      0,
      0,
      0,
      4059,
      4060,
      7,
      25,
      0,
      0,
      4060,
      781,
      1,
      0,
      0,
      0,
      4061,
      4063,
      3,
      226,
      113,
      0,
      4062,
      4064,
      3,
      196,
      98,
      0,
      4063,
      4062,
      1,
      0,
      0,
      0,
      4063,
      4064,
      1,
      0,
      0,
      0,
      4064,
      4065,
      1,
      0,
      0,
      0,
      4065,
      4066,
      3,
      770,
      385,
      0,
      4066,
      4085,
      1,
      0,
      0,
      0,
      4067,
      4069,
      3,
      410,
      205,
      0,
      4068,
      4067,
      1,
      0,
      0,
      0,
      4069,
      4072,
      1,
      0,
      0,
      0,
      4070,
      4068,
      1,
      0,
      0,
      0,
      4070,
      4071,
      1,
      0,
      0,
      0,
      4071,
      4073,
      1,
      0,
      0,
      0,
      4072,
      4070,
      1,
      0,
      0,
      0,
      4073,
      4080,
      5,
      41,
      0,
      0,
      4074,
      4076,
      3,
      410,
      205,
      0,
      4075,
      4074,
      1,
      0,
      0,
      0,
      4076,
      4077,
      1,
      0,
      0,
      0,
      4077,
      4075,
      1,
      0,
      0,
      0,
      4077,
      4078,
      1,
      0,
      0,
      0,
      4078,
      4080,
      1,
      0,
      0,
      0,
      4079,
      4070,
      1,
      0,
      0,
      0,
      4079,
      4075,
      1,
      0,
      0,
      0,
      4080,
      4081,
      1,
      0,
      0,
      0,
      4081,
      4082,
      3,
      766,
      383,
      0,
      4082,
      4083,
      3,
      752,
      376,
      0,
      4083,
      4085,
      1,
      0,
      0,
      0,
      4084,
      4061,
      1,
      0,
      0,
      0,
      4084,
      4079,
      1,
      0,
      0,
      0,
      4085,
      783,
      1,
      0,
      0,
      0,
      4086,
      4087,
      3,
      76,
      38,
      0,
      4087,
      4088,
      5,
      73,
      0,
      0,
      4088,
      4089,
      3,
      786,
      393,
      0,
      4089,
      785,
      1,
      0,
      0,
      0,
      4090,
      4092,
      3,
      226,
      113,
      0,
      4091,
      4093,
      3,
      196,
      98,
      0,
      4092,
      4091,
      1,
      0,
      0,
      0,
      4092,
      4093,
      1,
      0,
      0,
      0,
      4093,
      4094,
      1,
      0,
      0,
      0,
      4094,
      4095,
      3,
      752,
      376,
      0,
      4095,
      4114,
      1,
      0,
      0,
      0,
      4096,
      4098,
      3,
      410,
      205,
      0,
      4097,
      4096,
      1,
      0,
      0,
      0,
      4098,
      4101,
      1,
      0,
      0,
      0,
      4099,
      4097,
      1,
      0,
      0,
      0,
      4099,
      4100,
      1,
      0,
      0,
      0,
      4100,
      4102,
      1,
      0,
      0,
      0,
      4101,
      4099,
      1,
      0,
      0,
      0,
      4102,
      4109,
      5,
      32,
      0,
      0,
      4103,
      4105,
      3,
      410,
      205,
      0,
      4104,
      4103,
      1,
      0,
      0,
      0,
      4105,
      4106,
      1,
      0,
      0,
      0,
      4106,
      4104,
      1,
      0,
      0,
      0,
      4106,
      4107,
      1,
      0,
      0,
      0,
      4107,
      4109,
      1,
      0,
      0,
      0,
      4108,
      4099,
      1,
      0,
      0,
      0,
      4108,
      4104,
      1,
      0,
      0,
      0,
      4109,
      4110,
      1,
      0,
      0,
      0,
      4110,
      4111,
      3,
      888,
      444,
      0,
      4111,
      4112,
      3,
      752,
      376,
      0,
      4112,
      4114,
      1,
      0,
      0,
      0,
      4113,
      4090,
      1,
      0,
      0,
      0,
      4113,
      4108,
      1,
      0,
      0,
      0,
      4114,
      787,
      1,
      0,
      0,
      0,
      4115,
      4116,
      3,
      76,
      38,
      0,
      4116,
      4117,
      3,
      790,
      395,
      0,
      4117,
      789,
      1,
      0,
      0,
      0,
      4118,
      4122,
      5,
      5,
      0,
      0,
      4119,
      4121,
      3,
      410,
      205,
      0,
      4120,
      4119,
      1,
      0,
      0,
      0,
      4121,
      4124,
      1,
      0,
      0,
      0,
      4122,
      4120,
      1,
      0,
      0,
      0,
      4122,
      4123,
      1,
      0,
      0,
      0,
      4123,
      4125,
      1,
      0,
      0,
      0,
      4124,
      4122,
      1,
      0,
      0,
      0,
      4125,
      4126,
      3,
      416,
      208,
      0,
      4126,
      791,
      1,
      0,
      0,
      0,
      4127,
      4128,
      3,
      76,
      38,
      0,
      4128,
      4129,
      3,
      794,
      397,
      0,
      4129,
      793,
      1,
      0,
      0,
      0,
      4130,
      4134,
      5,
      140,
      0,
      0,
      4131,
      4133,
      3,
      410,
      205,
      0,
      4132,
      4131,
      1,
      0,
      0,
      0,
      4133,
      4136,
      1,
      0,
      0,
      0,
      4134,
      4132,
      1,
      0,
      0,
      0,
      4134,
      4135,
      1,
      0,
      0,
      0,
      4135,
      4137,
      1,
      0,
      0,
      0,
      4136,
      4134,
      1,
      0,
      0,
      0,
      4137,
      4138,
      3,
      416,
      208,
      0,
      4138,
      795,
      1,
      0,
      0,
      0,
      4139,
      4140,
      3,
      468,
      234,
      0,
      4140,
      4141,
      5,
      133,
      0,
      0,
      4141,
      4142,
      3,
      766,
      383,
      0,
      4142,
      4143,
      3,
      770,
      385,
      0,
      4143,
      797,
      1,
      0,
      0,
      0,
      4144,
      4150,
      3,
      468,
      234,
      0,
      4145,
      4147,
      5,
      14,
      0,
      0,
      4146,
      4148,
      5,
      107,
      0,
      0,
      4147,
      4146,
      1,
      0,
      0,
      0,
      4147,
      4148,
      1,
      0,
      0,
      0,
      4148,
      4151,
      1,
      0,
      0,
      0,
      4149,
      4151,
      5,
      107,
      0,
      0,
      4150,
      4145,
      1,
      0,
      0,
      0,
      4150,
      4149,
      1,
      0,
      0,
      0,
      4150,
      4151,
      1,
      0,
      0,
      0,
      4151,
      4152,
      1,
      0,
      0,
      0,
      4152,
      4161,
      5,
      135,
      0,
      0,
      4153,
      4155,
      3,
      226,
      113,
      0,
      4154,
      4156,
      3,
      196,
      98,
      0,
      4155,
      4154,
      1,
      0,
      0,
      0,
      4155,
      4156,
      1,
      0,
      0,
      0,
      4156,
      4162,
      1,
      0,
      0,
      0,
      4157,
      4159,
      5,
      133,
      0,
      0,
      4158,
      4160,
      3,
      418,
      209,
      0,
      4159,
      4158,
      1,
      0,
      0,
      0,
      4159,
      4160,
      1,
      0,
      0,
      0,
      4160,
      4162,
      1,
      0,
      0,
      0,
      4161,
      4153,
      1,
      0,
      0,
      0,
      4161,
      4157,
      1,
      0,
      0,
      0,
      4162,
      4164,
      1,
      0,
      0,
      0,
      4163,
      4165,
      3,
      318,
      159,
      0,
      4164,
      4163,
      1,
      0,
      0,
      0,
      4164,
      4165,
      1,
      0,
      0,
      0,
      4165,
      4168,
      1,
      0,
      0,
      0,
      4166,
      4167,
      5,
      24,
      0,
      0,
      4167,
      4169,
      3,
      800,
      400,
      0,
      4168,
      4166,
      1,
      0,
      0,
      0,
      4168,
      4169,
      1,
      0,
      0,
      0,
      4169,
      4170,
      1,
      0,
      0,
      0,
      4170,
      4171,
      3,
      770,
      385,
      0,
      4171,
      799,
      1,
      0,
      0,
      0,
      4172,
      4173,
      3,
      802,
      401,
      0,
      4173,
      801,
      1,
      0,
      0,
      0,
      4174,
      4175,
      3,
      804,
      402,
      0,
      4175,
      803,
      1,
      0,
      0,
      0,
      4176,
      4177,
      3,
      806,
      403,
      0,
      4177,
      805,
      1,
      0,
      0,
      0,
      4178,
      4179,
      3,
      298,
      149,
      0,
      4179,
      807,
      1,
      0,
      0,
      0,
      4180,
      4181,
      3,
      460,
      230,
      0,
      4181,
      4182,
      5,
      32,
      0,
      0,
      4182,
      4183,
      5,
      45,
      0,
      0,
      4183,
      4184,
      3,
      386,
      193,
      0,
      4184,
      4185,
      3,
      770,
      385,
      0,
      4185,
      809,
      1,
      0,
      0,
      0,
      4186,
      4187,
      3,
      468,
      234,
      0,
      4187,
      4188,
      5,
      32,
      0,
      0,
      4188,
      4189,
      3,
      766,
      383,
      0,
      4189,
      4190,
      3,
      770,
      385,
      0,
      4190,
      811,
      1,
      0,
      0,
      0,
      4191,
      4192,
      3,
      460,
      230,
      0,
      4192,
      4193,
      5,
      26,
      0,
      0,
      4193,
      4194,
      5,
      45,
      0,
      0,
      4194,
      4195,
      3,
      386,
      193,
      0,
      4195,
      4196,
      3,
      816,
      408,
      0,
      4196,
      813,
      1,
      0,
      0,
      0,
      4197,
      4198,
      3,
      468,
      234,
      0,
      4198,
      4199,
      5,
      26,
      0,
      0,
      4199,
      4200,
      3,
      766,
      383,
      0,
      4200,
      4201,
      3,
      816,
      408,
      0,
      4201,
      815,
      1,
      0,
      0,
      0,
      4202,
      4215,
      5,
      205,
      0,
      0,
      4203,
      4207,
      5,
      214,
      0,
      0,
      4204,
      4206,
      3,
      818,
      409,
      0,
      4205,
      4204,
      1,
      0,
      0,
      0,
      4206,
      4209,
      1,
      0,
      0,
      0,
      4207,
      4205,
      1,
      0,
      0,
      0,
      4207,
      4208,
      1,
      0,
      0,
      0,
      4208,
      4211,
      1,
      0,
      0,
      0,
      4209,
      4207,
      1,
      0,
      0,
      0,
      4210,
      4212,
      3,
      288,
      144,
      0,
      4211,
      4210,
      1,
      0,
      0,
      0,
      4211,
      4212,
      1,
      0,
      0,
      0,
      4212,
      4213,
      1,
      0,
      0,
      0,
      4213,
      4215,
      5,
      216,
      0,
      0,
      4214,
      4202,
      1,
      0,
      0,
      0,
      4214,
      4203,
      1,
      0,
      0,
      0,
      4215,
      817,
      1,
      0,
      0,
      0,
      4216,
      4222,
      3,
      578,
      289,
      0,
      4217,
      4222,
      3,
      758,
      379,
      0,
      4218,
      4222,
      3,
      774,
      387,
      0,
      4219,
      4222,
      3,
      788,
      394,
      0,
      4220,
      4222,
      3,
      820,
      410,
      0,
      4221,
      4216,
      1,
      0,
      0,
      0,
      4221,
      4217,
      1,
      0,
      0,
      0,
      4221,
      4218,
      1,
      0,
      0,
      0,
      4221,
      4219,
      1,
      0,
      0,
      0,
      4221,
      4220,
      1,
      0,
      0,
      0,
      4222,
      819,
      1,
      0,
      0,
      0,
      4223,
      4224,
      3,
      76,
      38,
      0,
      4224,
      4225,
      5,
      109,
      0,
      0,
      4225,
      4226,
      3,
      822,
      411,
      0,
      4226,
      821,
      1,
      0,
      0,
      0,
      4227,
      4229,
      3,
      410,
      205,
      0,
      4228,
      4227,
      1,
      0,
      0,
      0,
      4229,
      4232,
      1,
      0,
      0,
      0,
      4230,
      4228,
      1,
      0,
      0,
      0,
      4230,
      4231,
      1,
      0,
      0,
      0,
      4231,
      4233,
      1,
      0,
      0,
      0,
      4232,
      4230,
      1,
      0,
      0,
      0,
      4233,
      4234,
      3,
      766,
      383,
      0,
      4234,
      4235,
      3,
      770,
      385,
      0,
      4235,
      823,
      1,
      0,
      0,
      0,
      4236,
      4237,
      3,
      460,
      230,
      0,
      4237,
      4238,
      5,
      11,
      0,
      0,
      4238,
      4239,
      5,
      45,
      0,
      0,
      4239,
      4240,
      3,
      386,
      193,
      0,
      4240,
      4241,
      3,
      816,
      408,
      0,
      4241,
      825,
      1,
      0,
      0,
      0,
      4242,
      4243,
      3,
      468,
      234,
      0,
      4243,
      4244,
      5,
      11,
      0,
      0,
      4244,
      4245,
      3,
      766,
      383,
      0,
      4245,
      4246,
      3,
      816,
      408,
      0,
      4246,
      827,
      1,
      0,
      0,
      0,
      4247,
      4248,
      3,
      460,
      230,
      0,
      4248,
      4249,
      5,
      166,
      0,
      0,
      4249,
      4250,
      5,
      45,
      0,
      0,
      4250,
      4251,
      3,
      386,
      193,
      0,
      4251,
      4252,
      3,
      816,
      408,
      0,
      4252,
      829,
      1,
      0,
      0,
      0,
      4253,
      4254,
      3,
      468,
      234,
      0,
      4254,
      4255,
      5,
      166,
      0,
      0,
      4255,
      4256,
      3,
      766,
      383,
      0,
      4256,
      4257,
      3,
      816,
      408,
      0,
      4257,
      831,
      1,
      0,
      0,
      0,
      4258,
      4259,
      3,
      76,
      38,
      0,
      4259,
      4260,
      5,
      167,
      0,
      0,
      4260,
      4261,
      3,
      834,
      417,
      0,
      4261,
      833,
      1,
      0,
      0,
      0,
      4262,
      4266,
      3,
      226,
      113,
      0,
      4263,
      4265,
      3,
      200,
      100,
      0,
      4264,
      4263,
      1,
      0,
      0,
      0,
      4265,
      4268,
      1,
      0,
      0,
      0,
      4266,
      4264,
      1,
      0,
      0,
      0,
      4266,
      4267,
      1,
      0,
      0,
      0,
      4267,
      4269,
      1,
      0,
      0,
      0,
      4268,
      4266,
      1,
      0,
      0,
      0,
      4269,
      4270,
      3,
      770,
      385,
      0,
      4270,
      4289,
      1,
      0,
      0,
      0,
      4271,
      4273,
      3,
      410,
      205,
      0,
      4272,
      4271,
      1,
      0,
      0,
      0,
      4273,
      4276,
      1,
      0,
      0,
      0,
      4274,
      4272,
      1,
      0,
      0,
      0,
      4274,
      4275,
      1,
      0,
      0,
      0,
      4275,
      4277,
      1,
      0,
      0,
      0,
      4276,
      4274,
      1,
      0,
      0,
      0,
      4277,
      4284,
      5,
      133,
      0,
      0,
      4278,
      4280,
      3,
      410,
      205,
      0,
      4279,
      4278,
      1,
      0,
      0,
      0,
      4280,
      4281,
      1,
      0,
      0,
      0,
      4281,
      4279,
      1,
      0,
      0,
      0,
      4281,
      4282,
      1,
      0,
      0,
      0,
      4282,
      4284,
      1,
      0,
      0,
      0,
      4283,
      4274,
      1,
      0,
      0,
      0,
      4283,
      4279,
      1,
      0,
      0,
      0,
      4284,
      4285,
      1,
      0,
      0,
      0,
      4285,
      4286,
      3,
      766,
      383,
      0,
      4286,
      4287,
      3,
      770,
      385,
      0,
      4287,
      4289,
      1,
      0,
      0,
      0,
      4288,
      4262,
      1,
      0,
      0,
      0,
      4288,
      4283,
      1,
      0,
      0,
      0,
      4289,
      835,
      1,
      0,
      0,
      0,
      4290,
      4291,
      3,
      460,
      230,
      0,
      4291,
      4292,
      5,
      162,
      0,
      0,
      4292,
      4293,
      5,
      26,
      0,
      0,
      4293,
      4294,
      5,
      45,
      0,
      0,
      4294,
      4295,
      3,
      386,
      193,
      0,
      4295,
      4296,
      3,
      816,
      408,
      0,
      4296,
      837,
      1,
      0,
      0,
      0,
      4297,
      4298,
      3,
      468,
      234,
      0,
      4298,
      4299,
      5,
      162,
      0,
      0,
      4299,
      4300,
      5,
      26,
      0,
      0,
      4300,
      4301,
      3,
      766,
      383,
      0,
      4301,
      4302,
      3,
      816,
      408,
      0,
      4302,
      839,
      1,
      0,
      0,
      0,
      4303,
      4304,
      3,
      468,
      234,
      0,
      4304,
      4314,
      5,
      81,
      0,
      0,
      4305,
      4307,
      3,
      226,
      113,
      0,
      4306,
      4308,
      3,
      196,
      98,
      0,
      4307,
      4306,
      1,
      0,
      0,
      0,
      4307,
      4308,
      1,
      0,
      0,
      0,
      4308,
      4315,
      1,
      0,
      0,
      0,
      4309,
      4310,
      5,
      162,
      0,
      0,
      4310,
      4312,
      5,
      26,
      0,
      0,
      4311,
      4313,
      3,
      418,
      209,
      0,
      4312,
      4311,
      1,
      0,
      0,
      0,
      4312,
      4313,
      1,
      0,
      0,
      0,
      4313,
      4315,
      1,
      0,
      0,
      0,
      4314,
      4305,
      1,
      0,
      0,
      0,
      4314,
      4309,
      1,
      0,
      0,
      0,
      4315,
      4317,
      1,
      0,
      0,
      0,
      4316,
      4318,
      3,
      318,
      159,
      0,
      4317,
      4316,
      1,
      0,
      0,
      0,
      4317,
      4318,
      1,
      0,
      0,
      0,
      4318,
      4319,
      1,
      0,
      0,
      0,
      4319,
      4320,
      3,
      816,
      408,
      0,
      4320,
      841,
      1,
      0,
      0,
      0,
      4321,
      4322,
      3,
      460,
      230,
      0,
      4322,
      4323,
      5,
      169,
      0,
      0,
      4323,
      4324,
      5,
      45,
      0,
      0,
      4324,
      4325,
      3,
      386,
      193,
      0,
      4325,
      4326,
      3,
      844,
      422,
      0,
      4326,
      843,
      1,
      0,
      0,
      0,
      4327,
      4337,
      5,
      205,
      0,
      0,
      4328,
      4332,
      5,
      214,
      0,
      0,
      4329,
      4331,
      3,
      846,
      423,
      0,
      4330,
      4329,
      1,
      0,
      0,
      0,
      4331,
      4334,
      1,
      0,
      0,
      0,
      4332,
      4330,
      1,
      0,
      0,
      0,
      4332,
      4333,
      1,
      0,
      0,
      0,
      4333,
      4335,
      1,
      0,
      0,
      0,
      4334,
      4332,
      1,
      0,
      0,
      0,
      4335,
      4337,
      5,
      216,
      0,
      0,
      4336,
      4327,
      1,
      0,
      0,
      0,
      4336,
      4328,
      1,
      0,
      0,
      0,
      4337,
      845,
      1,
      0,
      0,
      0,
      4338,
      4342,
      3,
      390,
      195,
      0,
      4339,
      4342,
      3,
      364,
      182,
      0,
      4340,
      4342,
      3,
      848,
      424,
      0,
      4341,
      4338,
      1,
      0,
      0,
      0,
      4341,
      4339,
      1,
      0,
      0,
      0,
      4341,
      4340,
      1,
      0,
      0,
      0,
      4342,
      847,
      1,
      0,
      0,
      0,
      4343,
      4344,
      3,
      76,
      38,
      0,
      4344,
      4345,
      5,
      129,
      0,
      0,
      4345,
      4346,
      3,
      850,
      425,
      0,
      4346,
      849,
      1,
      0,
      0,
      0,
      4347,
      4349,
      3,
      226,
      113,
      0,
      4348,
      4350,
      3,
      196,
      98,
      0,
      4349,
      4348,
      1,
      0,
      0,
      0,
      4349,
      4350,
      1,
      0,
      0,
      0,
      4350,
      4351,
      1,
      0,
      0,
      0,
      4351,
      4352,
      3,
      422,
      211,
      0,
      4352,
      4369,
      1,
      0,
      0,
      0,
      4353,
      4355,
      3,
      410,
      205,
      0,
      4354,
      4353,
      1,
      0,
      0,
      0,
      4355,
      4358,
      1,
      0,
      0,
      0,
      4356,
      4354,
      1,
      0,
      0,
      0,
      4356,
      4357,
      1,
      0,
      0,
      0,
      4357,
      4359,
      1,
      0,
      0,
      0,
      4358,
      4356,
      1,
      0,
      0,
      0,
      4359,
      4366,
      5,
      130,
      0,
      0,
      4360,
      4362,
      3,
      410,
      205,
      0,
      4361,
      4360,
      1,
      0,
      0,
      0,
      4362,
      4363,
      1,
      0,
      0,
      0,
      4363,
      4361,
      1,
      0,
      0,
      0,
      4363,
      4364,
      1,
      0,
      0,
      0,
      4364,
      4366,
      1,
      0,
      0,
      0,
      4365,
      4356,
      1,
      0,
      0,
      0,
      4365,
      4361,
      1,
      0,
      0,
      0,
      4366,
      4367,
      1,
      0,
      0,
      0,
      4367,
      4369,
      3,
      416,
      208,
      0,
      4368,
      4347,
      1,
      0,
      0,
      0,
      4368,
      4365,
      1,
      0,
      0,
      0,
      4369,
      851,
      1,
      0,
      0,
      0,
      4370,
      4371,
      3,
      468,
      234,
      0,
      4371,
      4373,
      5,
      169,
      0,
      0,
      4372,
      4374,
      3,
      418,
      209,
      0,
      4373,
      4372,
      1,
      0,
      0,
      0,
      4373,
      4374,
      1,
      0,
      0,
      0,
      4374,
      4376,
      1,
      0,
      0,
      0,
      4375,
      4377,
      3,
      318,
      159,
      0,
      4376,
      4375,
      1,
      0,
      0,
      0,
      4376,
      4377,
      1,
      0,
      0,
      0,
      4377,
      4378,
      1,
      0,
      0,
      0,
      4378,
      4379,
      3,
      854,
      427,
      0,
      4379,
      853,
      1,
      0,
      0,
      0,
      4380,
      4390,
      5,
      205,
      0,
      0,
      4381,
      4385,
      5,
      214,
      0,
      0,
      4382,
      4384,
      3,
      856,
      428,
      0,
      4383,
      4382,
      1,
      0,
      0,
      0,
      4384,
      4387,
      1,
      0,
      0,
      0,
      4385,
      4383,
      1,
      0,
      0,
      0,
      4385,
      4386,
      1,
      0,
      0,
      0,
      4386,
      4388,
      1,
      0,
      0,
      0,
      4387,
      4385,
      1,
      0,
      0,
      0,
      4388,
      4390,
      5,
      216,
      0,
      0,
      4389,
      4380,
      1,
      0,
      0,
      0,
      4389,
      4381,
      1,
      0,
      0,
      0,
      4390,
      855,
      1,
      0,
      0,
      0,
      4391,
      4396,
      3,
      390,
      195,
      0,
      4392,
      4396,
      3,
      364,
      182,
      0,
      4393,
      4396,
      3,
      848,
      424,
      0,
      4394,
      4396,
      3,
      858,
      429,
      0,
      4395,
      4391,
      1,
      0,
      0,
      0,
      4395,
      4392,
      1,
      0,
      0,
      0,
      4395,
      4393,
      1,
      0,
      0,
      0,
      4395,
      4394,
      1,
      0,
      0,
      0,
      4396,
      857,
      1,
      0,
      0,
      0,
      4397,
      4400,
      5,
      62,
      0,
      0,
      4398,
      4401,
      3,
      860,
      430,
      0,
      4399,
      4401,
      3,
      862,
      431,
      0,
      4400,
      4398,
      1,
      0,
      0,
      0,
      4400,
      4399,
      1,
      0,
      0,
      0,
      4401,
      4402,
      1,
      0,
      0,
      0,
      4402,
      4403,
      3,
      46,
      23,
      0,
      4403,
      859,
      1,
      0,
      0,
      0,
      4404,
      4405,
      3,
      94,
      47,
      0,
      4405,
      861,
      1,
      0,
      0,
      0,
      4406,
      4407,
      3,
      96,
      48,
      0,
      4407,
      863,
      1,
      0,
      0,
      0,
      4408,
      4409,
      3,
      460,
      230,
      0,
      4409,
      4410,
      5,
      170,
      0,
      0,
      4410,
      4411,
      5,
      45,
      0,
      0,
      4411,
      4412,
      3,
      386,
      193,
      0,
      4412,
      4413,
      3,
      770,
      385,
      0,
      4413,
      865,
      1,
      0,
      0,
      0,
      4414,
      4415,
      3,
      468,
      234,
      0,
      4415,
      4416,
      5,
      170,
      0,
      0,
      4416,
      4417,
      3,
      766,
      383,
      0,
      4417,
      4418,
      3,
      770,
      385,
      0,
      4418,
      867,
      1,
      0,
      0,
      0,
      4419,
      4420,
      3,
      460,
      230,
      0,
      4420,
      4421,
      5,
      130,
      0,
      0,
      4421,
      4422,
      5,
      45,
      0,
      0,
      4422,
      4423,
      3,
      384,
      192,
      0,
      4423,
      869,
      1,
      0,
      0,
      0,
      4424,
      4425,
      3,
      468,
      234,
      0,
      4425,
      4426,
      5,
      130,
      0,
      0,
      4426,
      4427,
      3,
      416,
      208,
      0,
      4427,
      871,
      1,
      0,
      0,
      0,
      4428,
      4430,
      5,
      2,
      0,
      0,
      4429,
      4428,
      1,
      0,
      0,
      0,
      4429,
      4430,
      1,
      0,
      0,
      0,
      4430,
      4434,
      1,
      0,
      0,
      0,
      4431,
      4433,
      3,
      380,
      190,
      0,
      4432,
      4431,
      1,
      0,
      0,
      0,
      4433,
      4436,
      1,
      0,
      0,
      0,
      4434,
      4432,
      1,
      0,
      0,
      0,
      4434,
      4435,
      1,
      0,
      0,
      0,
      4435,
      4437,
      1,
      0,
      0,
      0,
      4436,
      4434,
      1,
      0,
      0,
      0,
      4437,
      4438,
      5,
      102,
      0,
      0,
      4438,
      4439,
      5,
      45,
      0,
      0,
      4439,
      4440,
      3,
      384,
      192,
      0,
      4440,
      873,
      1,
      0,
      0,
      0,
      4441,
      4442,
      3,
      220,
      110,
      0,
      4442,
      875,
      1,
      0,
      0,
      0,
      4443,
      4444,
      3,
      878,
      439,
      0,
      4444,
      877,
      1,
      0,
      0,
      0,
      4445,
      4447,
      5,
      127,
      0,
      0,
      4446,
      4445,
      1,
      0,
      0,
      0,
      4446,
      4447,
      1,
      0,
      0,
      0,
      4447,
      4449,
      1,
      0,
      0,
      0,
      4448,
      4450,
      7,
      19,
      0,
      0,
      4449,
      4448,
      1,
      0,
      0,
      0,
      4449,
      4450,
      1,
      0,
      0,
      0,
      4450,
      4451,
      1,
      0,
      0,
      0,
      4451,
      4453,
      3,
      232,
      116,
      0,
      4452,
      4454,
      3,
      196,
      98,
      0,
      4453,
      4452,
      1,
      0,
      0,
      0,
      4453,
      4454,
      1,
      0,
      0,
      0,
      4454,
      4456,
      1,
      0,
      0,
      0,
      4455,
      4457,
      3,
      318,
      159,
      0,
      4456,
      4455,
      1,
      0,
      0,
      0,
      4456,
      4457,
      1,
      0,
      0,
      0,
      4457,
      4458,
      1,
      0,
      0,
      0,
      4458,
      4459,
      3,
      348,
      174,
      0,
      4459,
      879,
      1,
      0,
      0,
      0,
      4460,
      4462,
      3,
      378,
      189,
      0,
      4461,
      4460,
      1,
      0,
      0,
      0,
      4461,
      4462,
      1,
      0,
      0,
      0,
      4462,
      4464,
      1,
      0,
      0,
      0,
      4463,
      4465,
      3,
      380,
      190,
      0,
      4464,
      4463,
      1,
      0,
      0,
      0,
      4465,
      4466,
      1,
      0,
      0,
      0,
      4466,
      4464,
      1,
      0,
      0,
      0,
      4466,
      4467,
      1,
      0,
      0,
      0,
      4467,
      4468,
      1,
      0,
      0,
      0,
      4468,
      4469,
      5,
      45,
      0,
      0,
      4469,
      4470,
      3,
      384,
      192,
      0,
      4470,
      881,
      1,
      0,
      0,
      0,
      4471,
      4473,
      3,
      412,
      206,
      0,
      4472,
      4474,
      3,
      410,
      205,
      0,
      4473,
      4472,
      1,
      0,
      0,
      0,
      4474,
      4475,
      1,
      0,
      0,
      0,
      4475,
      4473,
      1,
      0,
      0,
      0,
      4475,
      4476,
      1,
      0,
      0,
      0,
      4476,
      4477,
      1,
      0,
      0,
      0,
      4477,
      4478,
      3,
      416,
      208,
      0,
      4478,
      883,
      1,
      0,
      0,
      0,
      4479,
      4482,
      3,
      94,
      47,
      0,
      4480,
      4482,
      3,
      886,
      443,
      0,
      4481,
      4479,
      1,
      0,
      0,
      0,
      4481,
      4480,
      1,
      0,
      0,
      0,
      4482,
      885,
      1,
      0,
      0,
      0,
      4483,
      4484,
      3,
      88,
      44,
      0,
      4484,
      4485,
      5,
      183,
      0,
      0,
      4485,
      4488,
      5,
      198,
      0,
      0,
      4486,
      4487,
      5,
      183,
      0,
      0,
      4487,
      4489,
      5,
      179,
      0,
      0,
      4488,
      4486,
      1,
      0,
      0,
      0,
      4488,
      4489,
      1,
      0,
      0,
      0,
      4489,
      887,
      1,
      0,
      0,
      0,
      4490,
      4492,
      3,
      418,
      209,
      0,
      4491,
      4490,
      1,
      0,
      0,
      0,
      4491,
      4492,
      1,
      0,
      0,
      0,
      4492,
      4494,
      1,
      0,
      0,
      0,
      4493,
      4495,
      3,
      318,
      159,
      0,
      4494,
      4493,
      1,
      0,
      0,
      0,
      4494,
      4495,
      1,
      0,
      0,
      0,
      4495,
      889,
      1,
      0,
      0,
      0,
      4496,
      4497,
      1,
      0,
      0,
      0,
      4497,
      891,
      1,
      0,
      0,
      0,
      4498,
      4499,
      1,
      0,
      0,
      0,
      4499,
      893,
      1,
      0,
      0,
      0,
      4500,
      4501,
      1,
      0,
      0,
      0,
      4501,
      895,
      1,
      0,
      0,
      0,
      4502,
      4503,
      1,
      0,
      0,
      0,
      4503,
      897,
      1,
      0,
      0,
      0,
      4504,
      4505,
      5,
      218,
      0,
      0,
      4505,
      899,
      1,
      0,
      0,
      0,
      4506,
      4507,
      5,
      218,
      0,
      0,
      4507,
      901,
      1,
      0,
      0,
      0,
      4508,
      4509,
      1,
      0,
      0,
      0,
      4509,
      903,
      1,
      0,
      0,
      0,
      510,
      919,
      975,
      982,
      998,
      1e3,
      1002,
      1012,
      1022,
      1033,
      1036,
      1041,
      1056,
      1065,
      1073,
      1085,
      1104,
      1118,
      1125,
      1133,
      1137,
      1141,
      1145,
      1150,
      1155,
      1158,
      1165,
      1174,
      1182,
      1189,
      1199,
      1203,
      1211,
      1214,
      1216,
      1220,
      1226,
      1230,
      1236,
      1238,
      1247,
      1255,
      1263,
      1270,
      1274,
      1279,
      1282,
      1288,
      1302,
      1305,
      1313,
      1320,
      1326,
      1330,
      1337,
      1342,
      1349,
      1352,
      1358,
      1364,
      1366,
      1374,
      1402,
      1414,
      1422,
      1427,
      1431,
      1434,
      1437,
      1441,
      1443,
      1448,
      1457,
      1467,
      1476,
      1485,
      1494,
      1503,
      1511,
      1515,
      1521,
      1525,
      1527,
      1542,
      1550,
      1555,
      1557,
      1565,
      1574,
      1584,
      1589,
      1591,
      1599,
      1608,
      1618,
      1626,
      1634,
      1642,
      1647,
      1662,
      1665,
      1668,
      1672,
      1677,
      1686,
      1691,
      1693,
      1706,
      1709,
      1713,
      1716,
      1720,
      1723,
      1728,
      1733,
      1736,
      1739,
      1742,
      1745,
      1751,
      1756,
      1766,
      1768,
      1773,
      1778,
      1782,
      1787,
      1794,
      1797,
      1803,
      1811,
      1825,
      1831,
      1834,
      1839,
      1846,
      1849,
      1854,
      1858,
      1860,
      1864,
      1868,
      1870,
      1872,
      1879,
      1886,
      1894,
      1903,
      1920,
      1928,
      1930,
      1937,
      1944,
      1951,
      1956,
      1958,
      1971,
      1979,
      1987,
      1992,
      1994,
      2007,
      2012,
      2014,
      2022,
      2031,
      2041,
      2046,
      2049,
      2087,
      2090,
      2093,
      2099,
      2102,
      2107,
      2109,
      2116,
      2126,
      2134,
      2139,
      2158,
      2161,
      2164,
      2170,
      2172,
      2185,
      2188,
      2191,
      2197,
      2199,
      2210,
      2224,
      2229,
      2231,
      2235,
      2248,
      2261,
      2268,
      2272,
      2281,
      2302,
      2306,
      2313,
      2316,
      2323,
      2326,
      2330,
      2337,
      2339,
      2344,
      2348,
      2352,
      2356,
      2360,
      2362,
      2367,
      2370,
      2375,
      2382,
      2384,
      2393,
      2402,
      2404,
      2410,
      2414,
      2421,
      2434,
      2441,
      2452,
      2458,
      2465,
      2476,
      2479,
      2484,
      2489,
      2491,
      2500,
      2509,
      2511,
      2515,
      2521,
      2526,
      2529,
      2533,
      2536,
      2543,
      2550,
      2556,
      2564,
      2571,
      2575,
      2583,
      2586,
      2593,
      2602,
      2611,
      2616,
      2648,
      2652,
      2659,
      2664,
      2671,
      2674,
      2681,
      2685,
      2692,
      2698,
      2703,
      2710,
      2713,
      2723,
      2742,
      2745,
      2748,
      2751,
      2755,
      2764,
      2770,
      2774,
      2780,
      2783,
      2786,
      2797,
      2810,
      2823,
      2827,
      2830,
      2833,
      2839,
      2856,
      2874,
      2897,
      2905,
      2920,
      2932,
      2934,
      2938,
      2943,
      2950,
      2959,
      2963,
      2968,
      2977,
      2983,
      2994,
      2997,
      3002,
      3014,
      3021,
      3027,
      3038,
      3042,
      3044,
      3056,
      3101,
      3104,
      3108,
      3112,
      3118,
      3132,
      3140,
      3142,
      3153,
      3155,
      3174,
      3178,
      3184,
      3189,
      3199,
      3208,
      3219,
      3222,
      3226,
      3229,
      3233,
      3247,
      3255,
      3260,
      3275,
      3279,
      3283,
      3296,
      3299,
      3303,
      3310,
      3316,
      3348,
      3352,
      3359,
      3363,
      3369,
      3373,
      3381,
      3384,
      3388,
      3410,
      3413,
      3422,
      3426,
      3428,
      3431,
      3441,
      3445,
      3449,
      3455,
      3459,
      3462,
      3467,
      3473,
      3480,
      3487,
      3494,
      3503,
      3511,
      3517,
      3520,
      3523,
      3533,
      3538,
      3543,
      3547,
      3549,
      3554,
      3559,
      3565,
      3571,
      3586,
      3599,
      3605,
      3609,
      3620,
      3622,
      3630,
      3632,
      3638,
      3650,
      3657,
      3667,
      3672,
      3689,
      3691,
      3708,
      3714,
      3718,
      3722,
      3728,
      3736,
      3741,
      3759,
      3770,
      3797,
      3803,
      3807,
      3813,
      3817,
      3819,
      3822,
      3828,
      3831,
      3838,
      3841,
      3844,
      3855,
      3858,
      3861,
      3866,
      3869,
      3873,
      3875,
      3897,
      3904,
      3908,
      3915,
      3919,
      3926,
      3930,
      3937,
      3941,
      3966,
      3971,
      3975,
      3979,
      3999,
      4003,
      4007,
      4012,
      4015,
      4028,
      4032,
      4041,
      4050,
      4063,
      4070,
      4077,
      4079,
      4084,
      4092,
      4099,
      4106,
      4108,
      4113,
      4122,
      4134,
      4147,
      4150,
      4155,
      4159,
      4161,
      4164,
      4168,
      4207,
      4211,
      4214,
      4221,
      4230,
      4266,
      4274,
      4281,
      4283,
      4288,
      4307,
      4312,
      4314,
      4317,
      4332,
      4336,
      4341,
      4349,
      4356,
      4363,
      4365,
      4368,
      4373,
      4376,
      4385,
      4389,
      4395,
      4400,
      4429,
      4434,
      4446,
      4449,
      4453,
      4456,
      4461,
      4466,
      4475,
      4481,
      4488,
      4491,
      4494
    ];
    static __ATN;
    static get _ATN() {
      if (!_SysMLv2Parser.__ATN) {
        _SysMLv2Parser.__ATN = new ATNDeserializer().deserialize(_SysMLv2Parser._serializedATN);
      }
      return _SysMLv2Parser.__ATN;
    }
    static vocabulary = new Vocabulary(_SysMLv2Parser.literalNames, _SysMLv2Parser.symbolicNames, []);
    get vocabulary() {
      return _SysMLv2Parser.vocabulary;
    }
    static decisionsToDFA = _SysMLv2Parser._ATN.decisionToState.map((ds, index2) => new DFA(ds, index2));
  };
  var OwnedExpressionContext = class _OwnedExpressionContext extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    IF() {
      return this.getToken(SysMLv2Parser.IF, 0);
    }
    ownedExpression(i) {
      if (i === void 0) {
        return this.getRuleContexts(_OwnedExpressionContext);
      }
      return this.getRuleContext(i, _OwnedExpressionContext);
    }
    QUESTION() {
      return this.getToken(SysMLv2Parser.QUESTION, 0);
    }
    ELSE() {
      return this.getToken(SysMLv2Parser.ELSE, 0);
    }
    PLUS() {
      return this.getToken(SysMLv2Parser.PLUS, 0);
    }
    MINUS() {
      return this.getToken(SysMLv2Parser.MINUS, 0);
    }
    TILDE() {
      return this.getToken(SysMLv2Parser.TILDE, 0);
    }
    NOT() {
      return this.getToken(SysMLv2Parser.NOT, 0);
    }
    typeReference() {
      return this.getRuleContext(0, TypeReferenceContext);
    }
    AT_SIGN() {
      return this.getToken(SysMLv2Parser.AT_SIGN, 0);
    }
    AT_AT() {
      return this.getToken(SysMLv2Parser.AT_AT, 0);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    baseExpression() {
      return this.getRuleContext(0, BaseExpressionContext);
    }
    QUESTION_QUESTION() {
      return this.getToken(SysMLv2Parser.QUESTION_QUESTION, 0);
    }
    IMPLIES() {
      return this.getToken(SysMLv2Parser.IMPLIES, 0);
    }
    OR() {
      return this.getToken(SysMLv2Parser.OR, 0);
    }
    AND() {
      return this.getToken(SysMLv2Parser.AND, 0);
    }
    XOR() {
      return this.getToken(SysMLv2Parser.XOR, 0);
    }
    PIPE() {
      return this.getToken(SysMLv2Parser.PIPE, 0);
    }
    AMP() {
      return this.getToken(SysMLv2Parser.AMP, 0);
    }
    EQ_EQ() {
      return this.getToken(SysMLv2Parser.EQ_EQ, 0);
    }
    BANG_EQ() {
      return this.getToken(SysMLv2Parser.BANG_EQ, 0);
    }
    EQ_EQ_EQ() {
      return this.getToken(SysMLv2Parser.EQ_EQ_EQ, 0);
    }
    BANG_EQ_EQ() {
      return this.getToken(SysMLv2Parser.BANG_EQ_EQ, 0);
    }
    LT() {
      return this.getToken(SysMLv2Parser.LT, 0);
    }
    GT() {
      return this.getToken(SysMLv2Parser.GT, 0);
    }
    LE() {
      return this.getToken(SysMLv2Parser.LE, 0);
    }
    GE() {
      return this.getToken(SysMLv2Parser.GE, 0);
    }
    DOT_DOT() {
      return this.getToken(SysMLv2Parser.DOT_DOT, 0);
    }
    STAR() {
      return this.getToken(SysMLv2Parser.STAR, 0);
    }
    SLASH() {
      return this.getToken(SysMLv2Parser.SLASH, 0);
    }
    PERCENT() {
      return this.getToken(SysMLv2Parser.PERCENT, 0);
    }
    STAR_STAR() {
      return this.getToken(SysMLv2Parser.STAR_STAR, 0);
    }
    CARET() {
      return this.getToken(SysMLv2Parser.CARET, 0);
    }
    ISTYPE() {
      return this.getToken(SysMLv2Parser.ISTYPE, 0);
    }
    HASTYPE() {
      return this.getToken(SysMLv2Parser.HASTYPE, 0);
    }
    AS() {
      return this.getToken(SysMLv2Parser.AS, 0);
    }
    META() {
      return this.getToken(SysMLv2Parser.META, 0);
    }
    LBRACK() {
      return this.getToken(SysMLv2Parser.LBRACK, 0);
    }
    RBRACK() {
      return this.getToken(SysMLv2Parser.RBRACK, 0);
    }
    sequenceExpressionList() {
      return this.getRuleContext(0, SequenceExpressionListContext);
    }
    HASH() {
      return this.getToken(SysMLv2Parser.HASH, 0);
    }
    LPAREN() {
      return this.getToken(SysMLv2Parser.LPAREN, 0);
    }
    RPAREN() {
      return this.getToken(SysMLv2Parser.RPAREN, 0);
    }
    argumentList() {
      return this.getRuleContext(0, ArgumentListContext);
    }
    DOT() {
      return this.getToken(SysMLv2Parser.DOT, 0);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    DOT_QUESTION() {
      return this.getToken(SysMLv2Parser.DOT_QUESTION, 0);
    }
    bodyExpression() {
      return this.getRuleContext(0, BodyExpressionContext);
    }
    ARROW() {
      return this.getToken(SysMLv2Parser.ARROW, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedExpression;
    }
    enterRule(listener) {
      if (listener.enterOwnedExpression) {
        listener.enterOwnedExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedExpression) {
        listener.exitOwnedExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedExpression) {
        return visitor.visitOwnedExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeReferenceContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typeReference;
    }
    enterRule(listener) {
      if (listener.enterTypeReference) {
        listener.enterTypeReference(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypeReference) {
        listener.exitTypeReference(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypeReference) {
        return visitor.visitTypeReference(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SequenceExpressionListContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedExpression(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedExpressionContext);
      }
      return this.getRuleContext(i, OwnedExpressionContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_sequenceExpressionList;
    }
    enterRule(listener) {
      if (listener.enterSequenceExpressionList) {
        listener.enterSequenceExpressionList(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSequenceExpressionList) {
        listener.exitSequenceExpressionList(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSequenceExpressionList) {
        return visitor.visitSequenceExpressionList(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BaseExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nullExpression() {
      return this.getRuleContext(0, NullExpressionContext);
    }
    REGULAR_COMMENT() {
      return this.getToken(SysMLv2Parser.REGULAR_COMMENT, 0);
    }
    literalExpression() {
      return this.getRuleContext(0, LiteralExpressionContext);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    argumentList() {
      return this.getRuleContext(0, ArgumentListContext);
    }
    DOT() {
      return this.getToken(SysMLv2Parser.DOT, 0);
    }
    METADATA() {
      return this.getToken(SysMLv2Parser.METADATA, 0);
    }
    constructorExpression() {
      return this.getRuleContext(0, ConstructorExpressionContext);
    }
    bodyExpression() {
      return this.getRuleContext(0, BodyExpressionContext);
    }
    LPAREN() {
      return this.getToken(SysMLv2Parser.LPAREN, 0);
    }
    AS() {
      return this.getToken(SysMLv2Parser.AS, 0);
    }
    typeReference() {
      return this.getRuleContext(0, TypeReferenceContext);
    }
    RPAREN() {
      return this.getToken(SysMLv2Parser.RPAREN, 0);
    }
    sequenceExpressionList() {
      return this.getRuleContext(0, SequenceExpressionListContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_baseExpression;
    }
    enterRule(listener) {
      if (listener.enterBaseExpression) {
        listener.enterBaseExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBaseExpression) {
        listener.exitBaseExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBaseExpression) {
        return visitor.visitBaseExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NullExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    NULL() {
      return this.getToken(SysMLv2Parser.NULL, 0);
    }
    LPAREN() {
      return this.getToken(SysMLv2Parser.LPAREN, 0);
    }
    RPAREN() {
      return this.getToken(SysMLv2Parser.RPAREN, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nullExpression;
    }
    enterRule(listener) {
      if (listener.enterNullExpression) {
        listener.enterNullExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNullExpression) {
        listener.exitNullExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNullExpression) {
        return visitor.visitNullExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureReferenceExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureReferenceExpression;
    }
    enterRule(listener) {
      if (listener.enterFeatureReferenceExpression) {
        listener.enterFeatureReferenceExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureReferenceExpression) {
        listener.exitFeatureReferenceExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureReferenceExpression) {
        return visitor.visitFeatureReferenceExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConstructorExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    NEW() {
      return this.getToken(SysMLv2Parser.NEW, 0);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    argumentList() {
      return this.getRuleContext(0, ArgumentListContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_constructorExpression;
    }
    enterRule(listener) {
      if (listener.enterConstructorExpression) {
        listener.enterConstructorExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConstructorExpression) {
        listener.exitConstructorExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConstructorExpression) {
        return visitor.visitConstructorExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BodyExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    functionBodyPart() {
      return this.getRuleContext(0, FunctionBodyPartContext);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_bodyExpression;
    }
    enterRule(listener) {
      if (listener.enterBodyExpression) {
        listener.enterBodyExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBodyExpression) {
        listener.exitBodyExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBodyExpression) {
        return visitor.visitBodyExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ArgumentListContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LPAREN() {
      return this.getToken(SysMLv2Parser.LPAREN, 0);
    }
    RPAREN() {
      return this.getToken(SysMLv2Parser.RPAREN, 0);
    }
    positionalArgumentList() {
      return this.getRuleContext(0, PositionalArgumentListContext);
    }
    namedArgumentList() {
      return this.getRuleContext(0, NamedArgumentListContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_argumentList;
    }
    enterRule(listener) {
      if (listener.enterArgumentList) {
        listener.enterArgumentList(this);
      }
    }
    exitRule(listener) {
      if (listener.exitArgumentList) {
        listener.exitArgumentList(this);
      }
    }
    accept(visitor) {
      if (visitor.visitArgumentList) {
        return visitor.visitArgumentList(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PositionalArgumentListContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedExpression(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedExpressionContext);
      }
      return this.getRuleContext(i, OwnedExpressionContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_positionalArgumentList;
    }
    enterRule(listener) {
      if (listener.enterPositionalArgumentList) {
        listener.enterPositionalArgumentList(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPositionalArgumentList) {
        listener.exitPositionalArgumentList(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPositionalArgumentList) {
        return visitor.visitPositionalArgumentList(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamedArgumentListContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    namedArgument(i) {
      if (i === void 0) {
        return this.getRuleContexts(NamedArgumentContext);
      }
      return this.getRuleContext(i, NamedArgumentContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namedArgumentList;
    }
    enterRule(listener) {
      if (listener.enterNamedArgumentList) {
        listener.enterNamedArgumentList(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamedArgumentList) {
        listener.exitNamedArgumentList(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamedArgumentList) {
        return visitor.visitNamedArgumentList(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamedArgumentContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    EQ() {
      return this.getToken(SysMLv2Parser.EQ, 0);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namedArgument;
    }
    enterRule(listener) {
      if (listener.enterNamedArgument) {
        listener.enterNamedArgument(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamedArgument) {
        listener.exitNamedArgument(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamedArgument) {
        return visitor.visitNamedArgument(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var LiteralExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    literalBoolean() {
      return this.getRuleContext(0, LiteralBooleanContext);
    }
    literalString() {
      return this.getRuleContext(0, LiteralStringContext);
    }
    literalInteger() {
      return this.getRuleContext(0, LiteralIntegerContext);
    }
    literalReal() {
      return this.getRuleContext(0, LiteralRealContext);
    }
    literalInfinity() {
      return this.getRuleContext(0, LiteralInfinityContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_literalExpression;
    }
    enterRule(listener) {
      if (listener.enterLiteralExpression) {
        listener.enterLiteralExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitLiteralExpression) {
        listener.exitLiteralExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitLiteralExpression) {
        return visitor.visitLiteralExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var LiteralBooleanContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    TRUE() {
      return this.getToken(SysMLv2Parser.TRUE, 0);
    }
    FALSE() {
      return this.getToken(SysMLv2Parser.FALSE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_literalBoolean;
    }
    enterRule(listener) {
      if (listener.enterLiteralBoolean) {
        listener.enterLiteralBoolean(this);
      }
    }
    exitRule(listener) {
      if (listener.exitLiteralBoolean) {
        listener.exitLiteralBoolean(this);
      }
    }
    accept(visitor) {
      if (visitor.visitLiteralBoolean) {
        return visitor.visitLiteralBoolean(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var LiteralStringContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    DOUBLE_STRING() {
      return this.getToken(SysMLv2Parser.DOUBLE_STRING, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_literalString;
    }
    enterRule(listener) {
      if (listener.enterLiteralString) {
        listener.enterLiteralString(this);
      }
    }
    exitRule(listener) {
      if (listener.exitLiteralString) {
        listener.exitLiteralString(this);
      }
    }
    accept(visitor) {
      if (visitor.visitLiteralString) {
        return visitor.visitLiteralString(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var LiteralIntegerContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    INTEGER() {
      return this.getToken(SysMLv2Parser.INTEGER, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_literalInteger;
    }
    enterRule(listener) {
      if (listener.enterLiteralInteger) {
        listener.enterLiteralInteger(this);
      }
    }
    exitRule(listener) {
      if (listener.exitLiteralInteger) {
        listener.exitLiteralInteger(this);
      }
    }
    accept(visitor) {
      if (visitor.visitLiteralInteger) {
        return visitor.visitLiteralInteger(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var LiteralRealContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    REAL() {
      return this.getToken(SysMLv2Parser.REAL, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_literalReal;
    }
    enterRule(listener) {
      if (listener.enterLiteralReal) {
        listener.enterLiteralReal(this);
      }
    }
    exitRule(listener) {
      if (listener.exitLiteralReal) {
        listener.exitLiteralReal(this);
      }
    }
    accept(visitor) {
      if (visitor.visitLiteralReal) {
        return visitor.visitLiteralReal(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var LiteralInfinityContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    STAR() {
      return this.getToken(SysMLv2Parser.STAR, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_literalInfinity;
    }
    enterRule(listener) {
      if (listener.enterLiteralInfinity) {
        listener.enterLiteralInfinity(this);
      }
    }
    exitRule(listener) {
      if (listener.exitLiteralInfinity) {
        listener.exitLiteralInfinity(this);
      }
    }
    accept(visitor) {
      if (visitor.visitLiteralInfinity) {
        return visitor.visitLiteralInfinity(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ArgumentMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_argumentMember;
    }
    enterRule(listener) {
      if (listener.enterArgumentMember) {
        listener.enterArgumentMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitArgumentMember) {
        listener.exitArgumentMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitArgumentMember) {
        return visitor.visitArgumentMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ArgumentExpressionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_argumentExpressionMember;
    }
    enterRule(listener) {
      if (listener.enterArgumentExpressionMember) {
        listener.enterArgumentExpressionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitArgumentExpressionMember) {
        listener.exitArgumentExpressionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitArgumentExpressionMember) {
        return visitor.visitArgumentExpressionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NameContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    IDENTIFIER() {
      return this.getToken(SysMLv2Parser.IDENTIFIER, 0);
    }
    STRING() {
      return this.getToken(SysMLv2Parser.STRING, 0);
    }
    unreservedKeyword() {
      return this.getRuleContext(0, UnreservedKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_name;
    }
    enterRule(listener) {
      if (listener.enterName) {
        listener.enterName(this);
      }
    }
    exitRule(listener) {
      if (listener.exitName) {
        listener.exitName(this);
      }
    }
    accept(visitor) {
      if (visitor.visitName) {
        return visitor.visitName(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UnreservedKeywordContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    TYPE() {
      return this.getToken(SysMLv2Parser.TYPE, 0);
    }
    MULTIPLICITY() {
      return this.getToken(SysMLv2Parser.MULTIPLICITY, 0);
    }
    VAR() {
      return this.getToken(SysMLv2Parser.VAR, 0);
    }
    LANGUAGE() {
      return this.getToken(SysMLv2Parser.LANGUAGE, 0);
    }
    LOCALE() {
      return this.getToken(SysMLv2Parser.LOCALE, 0);
    }
    CROSSES() {
      return this.getToken(SysMLv2Parser.CROSSES, 0);
    }
    STEP() {
      return this.getToken(SysMLv2Parser.STEP, 0);
    }
    FEATURE() {
      return this.getToken(SysMLv2Parser.FEATURE, 0);
    }
    BEHAVIOR() {
      return this.getToken(SysMLv2Parser.BEHAVIOR, 0);
    }
    FUNCTION() {
      return this.getToken(SysMLv2Parser.FUNCTION, 0);
    }
    MEMBER() {
      return this.getToken(SysMLv2Parser.MEMBER, 0);
    }
    PREDICATE() {
      return this.getToken(SysMLv2Parser.PREDICATE, 0);
    }
    INTERACTION() {
      return this.getToken(SysMLv2Parser.INTERACTION, 0);
    }
    METACLASS() {
      return this.getToken(SysMLv2Parser.METACLASS, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_unreservedKeyword;
    }
    enterRule(listener) {
      if (listener.enterUnreservedKeyword) {
        listener.enterUnreservedKeyword(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUnreservedKeyword) {
        listener.exitUnreservedKeyword(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUnreservedKeyword) {
        return visitor.visitUnreservedKeyword(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var IdentificationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LT() {
      return this.getToken(SysMLv2Parser.LT, 0);
    }
    name(i) {
      if (i === void 0) {
        return this.getRuleContexts(NameContext);
      }
      return this.getRuleContext(i, NameContext);
    }
    GT() {
      return this.getToken(SysMLv2Parser.GT, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_identification;
    }
    enterRule(listener) {
      if (listener.enterIdentification) {
        listener.enterIdentification(this);
      }
    }
    exitRule(listener) {
      if (listener.exitIdentification) {
        listener.exitIdentification(this);
      }
    }
    accept(visitor) {
      if (visitor.visitIdentification) {
        return visitor.visitIdentification(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RelationshipBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    relationshipOwnedElement(i) {
      if (i === void 0) {
        return this.getRuleContexts(RelationshipOwnedElementContext);
      }
      return this.getRuleContext(i, RelationshipOwnedElementContext);
    }
    ownedAnnotation(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedAnnotationContext);
      }
      return this.getRuleContext(i, OwnedAnnotationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_relationshipBody;
    }
    enterRule(listener) {
      if (listener.enterRelationshipBody) {
        listener.enterRelationshipBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRelationshipBody) {
        listener.exitRelationshipBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRelationshipBody) {
        return visitor.visitRelationshipBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RelationshipOwnedElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedRelatedElement() {
      return this.getRuleContext(0, OwnedRelatedElementContext);
    }
    ownedAnnotation() {
      return this.getRuleContext(0, OwnedAnnotationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_relationshipOwnedElement;
    }
    enterRule(listener) {
      if (listener.enterRelationshipOwnedElement) {
        listener.enterRelationshipOwnedElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRelationshipOwnedElement) {
        listener.exitRelationshipOwnedElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRelationshipOwnedElement) {
        return visitor.visitRelationshipOwnedElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedRelatedElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nonFeatureElement() {
      return this.getRuleContext(0, NonFeatureElementContext);
    }
    featureElement() {
      return this.getRuleContext(0, FeatureElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedRelatedElement;
    }
    enterRule(listener) {
      if (listener.enterOwnedRelatedElement) {
        listener.enterOwnedRelatedElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedRelatedElement) {
        listener.exitOwnedRelatedElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedRelatedElement) {
        return visitor.visitOwnedRelatedElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DependencyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    DEPENDENCY() {
      return this.getToken(SysMLv2Parser.DEPENDENCY, 0);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    TO() {
      return this.getToken(SysMLv2Parser.TO, 0);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    prefixMetadataAnnotation(i) {
      if (i === void 0) {
        return this.getRuleContexts(PrefixMetadataAnnotationContext);
      }
      return this.getRuleContext(i, PrefixMetadataAnnotationContext);
    }
    FROM() {
      return this.getToken(SysMLv2Parser.FROM, 0);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    dependencyDeclaration() {
      return this.getRuleContext(0, DependencyDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_dependency;
    }
    enterRule(listener) {
      if (listener.enterDependency) {
        listener.enterDependency(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDependency) {
        listener.exitDependency(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDependency) {
        return visitor.visitDependency(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AnnotationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_annotation;
    }
    enterRule(listener) {
      if (listener.enterAnnotation) {
        listener.enterAnnotation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAnnotation) {
        listener.exitAnnotation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAnnotation) {
        return visitor.visitAnnotation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedAnnotationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    annotatingElement() {
      return this.getRuleContext(0, AnnotatingElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedAnnotation;
    }
    enterRule(listener) {
      if (listener.enterOwnedAnnotation) {
        listener.enterOwnedAnnotation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedAnnotation) {
        listener.exitOwnedAnnotation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedAnnotation) {
        return visitor.visitOwnedAnnotation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AnnotatingElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    comment() {
      return this.getRuleContext(0, CommentContext);
    }
    documentation() {
      return this.getRuleContext(0, DocumentationContext);
    }
    textualRepresentation() {
      return this.getRuleContext(0, TextualRepresentationContext);
    }
    metadataFeature() {
      return this.getRuleContext(0, MetadataFeatureContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_annotatingElement;
    }
    enterRule(listener) {
      if (listener.enterAnnotatingElement) {
        listener.enterAnnotatingElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAnnotatingElement) {
        listener.exitAnnotatingElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAnnotatingElement) {
        return visitor.visitAnnotatingElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CommentContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    REGULAR_COMMENT() {
      return this.getToken(SysMLv2Parser.REGULAR_COMMENT, 0);
    }
    COMMENT() {
      return this.getToken(SysMLv2Parser.COMMENT, 0);
    }
    LOCALE() {
      return this.getToken(SysMLv2Parser.LOCALE, 0);
    }
    DOUBLE_STRING() {
      return this.getToken(SysMLv2Parser.DOUBLE_STRING, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    ABOUT() {
      return this.getToken(SysMLv2Parser.ABOUT, 0);
    }
    annotation(i) {
      if (i === void 0) {
        return this.getRuleContexts(AnnotationContext);
      }
      return this.getRuleContext(i, AnnotationContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_comment;
    }
    enterRule(listener) {
      if (listener.enterComment) {
        listener.enterComment(this);
      }
    }
    exitRule(listener) {
      if (listener.exitComment) {
        listener.exitComment(this);
      }
    }
    accept(visitor) {
      if (visitor.visitComment) {
        return visitor.visitComment(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DocumentationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    DOC() {
      return this.getToken(SysMLv2Parser.DOC, 0);
    }
    REGULAR_COMMENT() {
      return this.getToken(SysMLv2Parser.REGULAR_COMMENT, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    LOCALE() {
      return this.getToken(SysMLv2Parser.LOCALE, 0);
    }
    DOUBLE_STRING() {
      return this.getToken(SysMLv2Parser.DOUBLE_STRING, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_documentation;
    }
    enterRule(listener) {
      if (listener.enterDocumentation) {
        listener.enterDocumentation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDocumentation) {
        listener.exitDocumentation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDocumentation) {
        return visitor.visitDocumentation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TextualRepresentationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LANGUAGE() {
      return this.getToken(SysMLv2Parser.LANGUAGE, 0);
    }
    DOUBLE_STRING() {
      return this.getToken(SysMLv2Parser.DOUBLE_STRING, 0);
    }
    REGULAR_COMMENT() {
      return this.getToken(SysMLv2Parser.REGULAR_COMMENT, 0);
    }
    REP() {
      return this.getToken(SysMLv2Parser.REP, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_textualRepresentation;
    }
    enterRule(listener) {
      if (listener.enterTextualRepresentation) {
        listener.enterTextualRepresentation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTextualRepresentation) {
        listener.exitTextualRepresentation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTextualRepresentation) {
        return visitor.visitTextualRepresentation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RootNamespaceContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    EOF() {
      return this.getToken(SysMLv2Parser.EOF, 0);
    }
    packageBodyElement(i) {
      if (i === void 0) {
        return this.getRuleContexts(PackageBodyElementContext);
      }
      return this.getRuleContext(i, PackageBodyElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_rootNamespace;
    }
    enterRule(listener) {
      if (listener.enterRootNamespace) {
        listener.enterRootNamespace(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRootNamespace) {
        listener.exitRootNamespace(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRootNamespace) {
        return visitor.visitRootNamespace(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    namespaceDeclaration() {
      return this.getRuleContext(0, NamespaceDeclarationContext);
    }
    namespaceBody() {
      return this.getRuleContext(0, NamespaceBodyContext);
    }
    prefixMetadataMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(PrefixMetadataMemberContext);
      }
      return this.getRuleContext(i, PrefixMetadataMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespace;
    }
    enterRule(listener) {
      if (listener.enterNamespace) {
        listener.enterNamespace(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespace) {
        listener.exitNamespace(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespace) {
        return visitor.visitNamespace(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    NAMESPACE() {
      return this.getToken(SysMLv2Parser.NAMESPACE, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespaceDeclaration;
    }
    enterRule(listener) {
      if (listener.enterNamespaceDeclaration) {
        listener.enterNamespaceDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespaceDeclaration) {
        listener.exitNamespaceDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespaceDeclaration) {
        return visitor.visitNamespaceDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    namespaceBodyElement(i) {
      if (i === void 0) {
        return this.getRuleContexts(NamespaceBodyElementContext);
      }
      return this.getRuleContext(i, NamespaceBodyElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespaceBody;
    }
    enterRule(listener) {
      if (listener.enterNamespaceBody) {
        listener.enterNamespaceBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespaceBody) {
        listener.exitNamespaceBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespaceBody) {
        return visitor.visitNamespaceBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceBodyElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    namespaceMember() {
      return this.getRuleContext(0, NamespaceMemberContext);
    }
    aliasMember() {
      return this.getRuleContext(0, AliasMemberContext);
    }
    importRule() {
      return this.getRuleContext(0, ImportRuleContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespaceBodyElement;
    }
    enterRule(listener) {
      if (listener.enterNamespaceBodyElement) {
        listener.enterNamespaceBodyElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespaceBodyElement) {
        listener.exitNamespaceBodyElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespaceBodyElement) {
        return visitor.visitNamespaceBodyElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MemberPrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    visibilityIndicator() {
      return this.getRuleContext(0, VisibilityIndicatorContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_memberPrefix;
    }
    enterRule(listener) {
      if (listener.enterMemberPrefix) {
        listener.enterMemberPrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMemberPrefix) {
        listener.exitMemberPrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMemberPrefix) {
        return visitor.visitMemberPrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var VisibilityIndicatorContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    PUBLIC() {
      return this.getToken(SysMLv2Parser.PUBLIC, 0);
    }
    PRIVATE() {
      return this.getToken(SysMLv2Parser.PRIVATE, 0);
    }
    PROTECTED() {
      return this.getToken(SysMLv2Parser.PROTECTED, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_visibilityIndicator;
    }
    enterRule(listener) {
      if (listener.enterVisibilityIndicator) {
        listener.enterVisibilityIndicator(this);
      }
    }
    exitRule(listener) {
      if (listener.exitVisibilityIndicator) {
        listener.exitVisibilityIndicator(this);
      }
    }
    accept(visitor) {
      if (visitor.visitVisibilityIndicator) {
        return visitor.visitVisibilityIndicator(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nonFeatureMember() {
      return this.getRuleContext(0, NonFeatureMemberContext);
    }
    namespaceFeatureMember() {
      return this.getRuleContext(0, NamespaceFeatureMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespaceMember;
    }
    enterRule(listener) {
      if (listener.enterNamespaceMember) {
        listener.enterNamespaceMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespaceMember) {
        listener.exitNamespaceMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespaceMember) {
        return visitor.visitNamespaceMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NonFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    memberElement() {
      return this.getRuleContext(0, MemberElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nonFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterNonFeatureMember) {
        listener.enterNonFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNonFeatureMember) {
        listener.exitNonFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNonFeatureMember) {
        return visitor.visitNonFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    featureElement() {
      return this.getRuleContext(0, FeatureElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespaceFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterNamespaceFeatureMember) {
        listener.enterNamespaceFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespaceFeatureMember) {
        listener.exitNamespaceFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespaceFeatureMember) {
        return visitor.visitNamespaceFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AliasMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    ALIAS() {
      return this.getToken(SysMLv2Parser.ALIAS, 0);
    }
    FOR() {
      return this.getToken(SysMLv2Parser.FOR, 0);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    LT() {
      return this.getToken(SysMLv2Parser.LT, 0);
    }
    name(i) {
      if (i === void 0) {
        return this.getRuleContexts(NameContext);
      }
      return this.getRuleContext(i, NameContext);
    }
    GT() {
      return this.getToken(SysMLv2Parser.GT, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_aliasMember;
    }
    enterRule(listener) {
      if (listener.enterAliasMember) {
        listener.enterAliasMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAliasMember) {
        listener.exitAliasMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAliasMember) {
        return visitor.visitAliasMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var QualifiedNameContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    name(i) {
      if (i === void 0) {
        return this.getRuleContexts(NameContext);
      }
      return this.getRuleContext(i, NameContext);
    }
    DOLLAR() {
      return this.getToken(SysMLv2Parser.DOLLAR, 0);
    }
    COLON_COLON(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COLON_COLON);
      } else {
        return this.getToken(SysMLv2Parser.COLON_COLON, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_qualifiedName;
    }
    enterRule(listener) {
      if (listener.enterQualifiedName) {
        listener.enterQualifiedName(this);
      }
    }
    exitRule(listener) {
      if (listener.exitQualifiedName) {
        listener.exitQualifiedName(this);
      }
    }
    accept(visitor) {
      if (visitor.visitQualifiedName) {
        return visitor.visitQualifiedName(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ImportRuleContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    IMPORT() {
      return this.getToken(SysMLv2Parser.IMPORT, 0);
    }
    importDeclaration() {
      return this.getRuleContext(0, ImportDeclarationContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    visibilityIndicator() {
      return this.getRuleContext(0, VisibilityIndicatorContext);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_importRule;
    }
    enterRule(listener) {
      if (listener.enterImportRule) {
        listener.enterImportRule(this);
      }
    }
    exitRule(listener) {
      if (listener.exitImportRule) {
        listener.exitImportRule(this);
      }
    }
    accept(visitor) {
      if (visitor.visitImportRule) {
        return visitor.visitImportRule(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ImportDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    membershipImport() {
      return this.getRuleContext(0, MembershipImportContext);
    }
    namespaceImport() {
      return this.getRuleContext(0, NamespaceImportContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_importDeclaration;
    }
    enterRule(listener) {
      if (listener.enterImportDeclaration) {
        listener.enterImportDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitImportDeclaration) {
        listener.exitImportDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitImportDeclaration) {
        return visitor.visitImportDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MembershipImportContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    COLON_COLON() {
      return this.getToken(SysMLv2Parser.COLON_COLON, 0);
    }
    STAR_STAR() {
      return this.getToken(SysMLv2Parser.STAR_STAR, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_membershipImport;
    }
    enterRule(listener) {
      if (listener.enterMembershipImport) {
        listener.enterMembershipImport(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMembershipImport) {
        listener.exitMembershipImport(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMembershipImport) {
        return visitor.visitMembershipImport(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceImportContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    COLON_COLON(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COLON_COLON);
      } else {
        return this.getToken(SysMLv2Parser.COLON_COLON, i);
      }
    }
    STAR() {
      return this.getToken(SysMLv2Parser.STAR, 0);
    }
    STAR_STAR() {
      return this.getToken(SysMLv2Parser.STAR_STAR, 0);
    }
    filterPackage() {
      return this.getRuleContext(0, FilterPackageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespaceImport;
    }
    enterRule(listener) {
      if (listener.enterNamespaceImport) {
        listener.enterNamespaceImport(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespaceImport) {
        listener.exitNamespaceImport(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespaceImport) {
        return visitor.visitNamespaceImport(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FilterPackageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    filterPackageImportDeclaration() {
      return this.getRuleContext(0, FilterPackageImportDeclarationContext);
    }
    filterPackageMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(FilterPackageMemberContext);
      }
      return this.getRuleContext(i, FilterPackageMemberContext);
    }
    filterPackageImport() {
      return this.getRuleContext(0, FilterPackageImportContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_filterPackage;
    }
    enterRule(listener) {
      if (listener.enterFilterPackage) {
        listener.enterFilterPackage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFilterPackage) {
        listener.exitFilterPackage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFilterPackage) {
        return visitor.visitFilterPackage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FilterPackageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LBRACK() {
      return this.getToken(SysMLv2Parser.LBRACK, 0);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    RBRACK() {
      return this.getToken(SysMLv2Parser.RBRACK, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_filterPackageMember;
    }
    enterRule(listener) {
      if (listener.enterFilterPackageMember) {
        listener.enterFilterPackageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFilterPackageMember) {
        listener.exitFilterPackageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFilterPackageMember) {
        return visitor.visitFilterPackageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MemberElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    annotatingElement() {
      return this.getRuleContext(0, AnnotatingElementContext);
    }
    nonFeatureElement() {
      return this.getRuleContext(0, NonFeatureElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_memberElement;
    }
    enterRule(listener) {
      if (listener.enterMemberElement) {
        listener.enterMemberElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMemberElement) {
        listener.exitMemberElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMemberElement) {
        return visitor.visitMemberElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NonFeatureElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    dependency() {
      return this.getRuleContext(0, DependencyContext);
    }
    namespace() {
      return this.getRuleContext(0, NamespaceContext);
    }
    type() {
      return this.getRuleContext(0, TypeContext);
    }
    classifier() {
      return this.getRuleContext(0, ClassifierContext);
    }
    dataType() {
      return this.getRuleContext(0, DataTypeContext);
    }
    class() {
      return this.getRuleContext(0, ClassContext);
    }
    structure() {
      return this.getRuleContext(0, StructureContext);
    }
    metaclass() {
      return this.getRuleContext(0, MetaclassContext);
    }
    association() {
      return this.getRuleContext(0, AssociationContext);
    }
    associationStructure() {
      return this.getRuleContext(0, AssociationStructureContext);
    }
    interaction() {
      return this.getRuleContext(0, InteractionContext);
    }
    behavior() {
      return this.getRuleContext(0, BehaviorContext);
    }
    function() {
      return this.getRuleContext(0, FunctionContext);
    }
    predicate() {
      return this.getRuleContext(0, PredicateContext);
    }
    multiplicity() {
      return this.getRuleContext(0, MultiplicityContext);
    }
    package() {
      return this.getRuleContext(0, PackageContext);
    }
    libraryPackage() {
      return this.getRuleContext(0, LibraryPackageContext);
    }
    specialization() {
      return this.getRuleContext(0, SpecializationContext);
    }
    conjugation() {
      return this.getRuleContext(0, ConjugationContext);
    }
    subclassification() {
      return this.getRuleContext(0, SubclassificationContext);
    }
    disjoining() {
      return this.getRuleContext(0, DisjoiningContext);
    }
    featureInverting() {
      return this.getRuleContext(0, FeatureInvertingContext);
    }
    featureTyping() {
      return this.getRuleContext(0, FeatureTypingContext);
    }
    subsetting() {
      return this.getRuleContext(0, SubsettingContext);
    }
    redefinition() {
      return this.getRuleContext(0, RedefinitionContext);
    }
    typeFeaturing() {
      return this.getRuleContext(0, TypeFeaturingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nonFeatureElement;
    }
    enterRule(listener) {
      if (listener.enterNonFeatureElement) {
        listener.enterNonFeatureElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNonFeatureElement) {
        listener.exitNonFeatureElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNonFeatureElement) {
        return visitor.visitNonFeatureElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    feature() {
      return this.getRuleContext(0, FeatureContext);
    }
    step() {
      return this.getRuleContext(0, StepContext);
    }
    expression() {
      return this.getRuleContext(0, ExpressionContext);
    }
    booleanExpression() {
      return this.getRuleContext(0, BooleanExpressionContext);
    }
    invariant() {
      return this.getRuleContext(0, InvariantContext);
    }
    connector() {
      return this.getRuleContext(0, ConnectorContext);
    }
    bindingConnector() {
      return this.getRuleContext(0, BindingConnectorContext);
    }
    succession() {
      return this.getRuleContext(0, SuccessionContext);
    }
    flow() {
      return this.getRuleContext(0, FlowContext);
    }
    successionFlow() {
      return this.getRuleContext(0, SuccessionFlowContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureElement;
    }
    enterRule(listener) {
      if (listener.enterFeatureElement) {
        listener.enterFeatureElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureElement) {
        listener.exitFeatureElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureElement) {
        return visitor.visitFeatureElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    TYPE() {
      return this.getToken(SysMLv2Parser.TYPE, 0);
    }
    typeDeclaration() {
      return this.getRuleContext(0, TypeDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_type;
    }
    enterRule(listener) {
      if (listener.enterType) {
        listener.enterType(this);
      }
    }
    exitRule(listener) {
      if (listener.exitType) {
        listener.exitType(this);
      }
    }
    accept(visitor) {
      if (visitor.visitType) {
        return visitor.visitType(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ABSTRACT() {
      return this.getToken(SysMLv2Parser.ABSTRACT, 0);
    }
    prefixMetadataMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(PrefixMetadataMemberContext);
      }
      return this.getRuleContext(i, PrefixMetadataMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typePrefix;
    }
    enterRule(listener) {
      if (listener.enterTypePrefix) {
        listener.enterTypePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypePrefix) {
        listener.exitTypePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypePrefix) {
        return visitor.visitTypePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    ownedMultiplicity() {
      return this.getRuleContext(0, OwnedMultiplicityContext);
    }
    specializationPart(i) {
      if (i === void 0) {
        return this.getRuleContexts(SpecializationPartContext);
      }
      return this.getRuleContext(i, SpecializationPartContext);
    }
    conjugationPart(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConjugationPartContext);
      }
      return this.getRuleContext(i, ConjugationPartContext);
    }
    typeRelationshipPart(i) {
      if (i === void 0) {
        return this.getRuleContexts(TypeRelationshipPartContext);
      }
      return this.getRuleContext(i, TypeRelationshipPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typeDeclaration;
    }
    enterRule(listener) {
      if (listener.enterTypeDeclaration) {
        listener.enterTypeDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypeDeclaration) {
        listener.exitTypeDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypeDeclaration) {
        return visitor.visitTypeDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SpecializationPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedSpecialization(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedSpecializationContext);
      }
      return this.getRuleContext(i, OwnedSpecializationContext);
    }
    COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT, 0);
    }
    SPECIALIZES() {
      return this.getToken(SysMLv2Parser.SPECIALIZES, 0);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_specializationPart;
    }
    enterRule(listener) {
      if (listener.enterSpecializationPart) {
        listener.enterSpecializationPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSpecializationPart) {
        listener.exitSpecializationPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSpecializationPart) {
        return visitor.visitSpecializationPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConjugationPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedConjugation() {
      return this.getRuleContext(0, OwnedConjugationContext);
    }
    TILDE() {
      return this.getToken(SysMLv2Parser.TILDE, 0);
    }
    CONJUGATES() {
      return this.getToken(SysMLv2Parser.CONJUGATES, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_conjugationPart;
    }
    enterRule(listener) {
      if (listener.enterConjugationPart) {
        listener.enterConjugationPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConjugationPart) {
        listener.exitConjugationPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConjugationPart) {
        return visitor.visitConjugationPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeRelationshipPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    disjoiningPart() {
      return this.getRuleContext(0, DisjoiningPartContext);
    }
    unioningPart() {
      return this.getRuleContext(0, UnioningPartContext);
    }
    intersectingPart() {
      return this.getRuleContext(0, IntersectingPartContext);
    }
    differencingPart() {
      return this.getRuleContext(0, DifferencingPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typeRelationshipPart;
    }
    enterRule(listener) {
      if (listener.enterTypeRelationshipPart) {
        listener.enterTypeRelationshipPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypeRelationshipPart) {
        listener.exitTypeRelationshipPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypeRelationshipPart) {
        return visitor.visitTypeRelationshipPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DisjoiningPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    DISJOINT() {
      return this.getToken(SysMLv2Parser.DISJOINT, 0);
    }
    FROM() {
      return this.getToken(SysMLv2Parser.FROM, 0);
    }
    ownedDisjoining(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedDisjoiningContext);
      }
      return this.getRuleContext(i, OwnedDisjoiningContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_disjoiningPart;
    }
    enterRule(listener) {
      if (listener.enterDisjoiningPart) {
        listener.enterDisjoiningPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDisjoiningPart) {
        listener.exitDisjoiningPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDisjoiningPart) {
        return visitor.visitDisjoiningPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UnioningPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    UNIONS() {
      return this.getToken(SysMLv2Parser.UNIONS, 0);
    }
    unioning(i) {
      if (i === void 0) {
        return this.getRuleContexts(UnioningContext);
      }
      return this.getRuleContext(i, UnioningContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_unioningPart;
    }
    enterRule(listener) {
      if (listener.enterUnioningPart) {
        listener.enterUnioningPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUnioningPart) {
        listener.exitUnioningPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUnioningPart) {
        return visitor.visitUnioningPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var IntersectingPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    INTERSECTS() {
      return this.getToken(SysMLv2Parser.INTERSECTS, 0);
    }
    intersecting(i) {
      if (i === void 0) {
        return this.getRuleContexts(IntersectingContext);
      }
      return this.getRuleContext(i, IntersectingContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_intersectingPart;
    }
    enterRule(listener) {
      if (listener.enterIntersectingPart) {
        listener.enterIntersectingPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitIntersectingPart) {
        listener.exitIntersectingPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitIntersectingPart) {
        return visitor.visitIntersectingPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DifferencingPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    DIFFERENCES() {
      return this.getToken(SysMLv2Parser.DIFFERENCES, 0);
    }
    differencing(i) {
      if (i === void 0) {
        return this.getRuleContexts(DifferencingContext);
      }
      return this.getRuleContext(i, DifferencingContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_differencingPart;
    }
    enterRule(listener) {
      if (listener.enterDifferencingPart) {
        listener.enterDifferencingPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDifferencingPart) {
        listener.exitDifferencingPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDifferencingPart) {
        return visitor.visitDifferencingPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    typeBodyElement(i) {
      if (i === void 0) {
        return this.getRuleContexts(TypeBodyElementContext);
      }
      return this.getRuleContext(i, TypeBodyElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typeBody;
    }
    enterRule(listener) {
      if (listener.enterTypeBody) {
        listener.enterTypeBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypeBody) {
        listener.exitTypeBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypeBody) {
        return visitor.visitTypeBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeBodyElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nonFeatureMember() {
      return this.getRuleContext(0, NonFeatureMemberContext);
    }
    featureMember() {
      return this.getRuleContext(0, FeatureMemberContext);
    }
    aliasMember() {
      return this.getRuleContext(0, AliasMemberContext);
    }
    importRule() {
      return this.getRuleContext(0, ImportRuleContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typeBodyElement;
    }
    enterRule(listener) {
      if (listener.enterTypeBodyElement) {
        listener.enterTypeBodyElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypeBodyElement) {
        listener.exitTypeBodyElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypeBodyElement) {
        return visitor.visitTypeBodyElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SpecializationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SUBTYPE() {
      return this.getToken(SysMLv2Parser.SUBTYPE, 0);
    }
    specificType() {
      return this.getRuleContext(0, SpecificTypeContext);
    }
    generalType() {
      return this.getRuleContext(0, GeneralTypeContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT, 0);
    }
    SPECIALIZES() {
      return this.getToken(SysMLv2Parser.SPECIALIZES, 0);
    }
    SPECIALIZATION() {
      return this.getToken(SysMLv2Parser.SPECIALIZATION, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_specialization;
    }
    enterRule(listener) {
      if (listener.enterSpecialization) {
        listener.enterSpecialization(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSpecialization) {
        listener.exitSpecialization(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSpecialization) {
        return visitor.visitSpecialization(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedSpecializationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    generalType() {
      return this.getRuleContext(0, GeneralTypeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedSpecialization;
    }
    enterRule(listener) {
      if (listener.enterOwnedSpecialization) {
        listener.enterOwnedSpecialization(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedSpecialization) {
        listener.exitOwnedSpecialization(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedSpecialization) {
        return visitor.visitOwnedSpecialization(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SpecificTypeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_specificType;
    }
    enterRule(listener) {
      if (listener.enterSpecificType) {
        listener.enterSpecificType(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSpecificType) {
        listener.exitSpecificType(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSpecificType) {
        return visitor.visitSpecificType(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var GeneralTypeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_generalType;
    }
    enterRule(listener) {
      if (listener.enterGeneralType) {
        listener.enterGeneralType(this);
      }
    }
    exitRule(listener) {
      if (listener.exitGeneralType) {
        listener.exitGeneralType(this);
      }
    }
    accept(visitor) {
      if (visitor.visitGeneralType) {
        return visitor.visitGeneralType(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConjugationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    CONJUGATE() {
      return this.getToken(SysMLv2Parser.CONJUGATE, 0);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    TILDE() {
      return this.getToken(SysMLv2Parser.TILDE, 0);
    }
    CONJUGATES() {
      return this.getToken(SysMLv2Parser.CONJUGATES, 0);
    }
    CONJUGATION() {
      return this.getToken(SysMLv2Parser.CONJUGATION, 0);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_conjugation;
    }
    enterRule(listener) {
      if (listener.enterConjugation) {
        listener.enterConjugation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConjugation) {
        listener.exitConjugation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConjugation) {
        return visitor.visitConjugation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedConjugationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedConjugation;
    }
    enterRule(listener) {
      if (listener.enterOwnedConjugation) {
        listener.enterOwnedConjugation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedConjugation) {
        listener.exitOwnedConjugation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedConjugation) {
        return visitor.visitOwnedConjugation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DisjoiningContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    DISJOINT() {
      return this.getToken(SysMLv2Parser.DISJOINT, 0);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    FROM() {
      return this.getToken(SysMLv2Parser.FROM, 0);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    DISJOINING() {
      return this.getToken(SysMLv2Parser.DISJOINING, 0);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_disjoining;
    }
    enterRule(listener) {
      if (listener.enterDisjoining) {
        listener.enterDisjoining(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDisjoining) {
        listener.exitDisjoining(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDisjoining) {
        return visitor.visitDisjoining(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedDisjoiningContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedDisjoining;
    }
    enterRule(listener) {
      if (listener.enterOwnedDisjoining) {
        listener.enterOwnedDisjoining(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedDisjoining) {
        listener.exitOwnedDisjoining(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedDisjoining) {
        return visitor.visitOwnedDisjoining(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UnioningContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_unioning;
    }
    enterRule(listener) {
      if (listener.enterUnioning) {
        listener.enterUnioning(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUnioning) {
        listener.exitUnioning(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUnioning) {
        return visitor.visitUnioning(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var IntersectingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_intersecting;
    }
    enterRule(listener) {
      if (listener.enterIntersecting) {
        listener.enterIntersecting(this);
      }
    }
    exitRule(listener) {
      if (listener.exitIntersecting) {
        listener.exitIntersecting(this);
      }
    }
    accept(visitor) {
      if (visitor.visitIntersecting) {
        return visitor.visitIntersecting(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DifferencingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_differencing;
    }
    enterRule(listener) {
      if (listener.enterDifferencing) {
        listener.enterDifferencing(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDifferencing) {
        listener.exitDifferencing(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDifferencing) {
        return visitor.visitDifferencing(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typeFeatureMember() {
      return this.getRuleContext(0, TypeFeatureMemberContext);
    }
    ownedFeatureMember() {
      return this.getRuleContext(0, OwnedFeatureMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureMember;
    }
    enterRule(listener) {
      if (listener.enterFeatureMember) {
        listener.enterFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureMember) {
        listener.exitFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureMember) {
        return visitor.visitFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    MEMBER() {
      return this.getToken(SysMLv2Parser.MEMBER, 0);
    }
    featureElement() {
      return this.getRuleContext(0, FeatureElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typeFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterTypeFeatureMember) {
        listener.enterTypeFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypeFeatureMember) {
        listener.exitTypeFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypeFeatureMember) {
        return visitor.visitTypeFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    featureElement() {
      return this.getRuleContext(0, FeatureElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterOwnedFeatureMember) {
        listener.enterOwnedFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedFeatureMember) {
        listener.exitOwnedFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedFeatureMember) {
        return visitor.visitOwnedFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ClassifierContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    CLASSIFIER() {
      return this.getToken(SysMLv2Parser.CLASSIFIER, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_classifier;
    }
    enterRule(listener) {
      if (listener.enterClassifier) {
        listener.enterClassifier(this);
      }
    }
    exitRule(listener) {
      if (listener.exitClassifier) {
        listener.exitClassifier(this);
      }
    }
    accept(visitor) {
      if (visitor.visitClassifier) {
        return visitor.visitClassifier(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ClassifierDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    ownedMultiplicity() {
      return this.getRuleContext(0, OwnedMultiplicityContext);
    }
    superclassingPart() {
      return this.getRuleContext(0, SuperclassingPartContext);
    }
    conjugationPart() {
      return this.getRuleContext(0, ConjugationPartContext);
    }
    typeRelationshipPart(i) {
      if (i === void 0) {
        return this.getRuleContexts(TypeRelationshipPartContext);
      }
      return this.getRuleContext(i, TypeRelationshipPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_classifierDeclaration;
    }
    enterRule(listener) {
      if (listener.enterClassifierDeclaration) {
        listener.enterClassifierDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitClassifierDeclaration) {
        listener.exitClassifierDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitClassifierDeclaration) {
        return visitor.visitClassifierDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SuperclassingPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedSubclassification(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedSubclassificationContext);
      }
      return this.getRuleContext(i, OwnedSubclassificationContext);
    }
    COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT, 0);
    }
    SPECIALIZES() {
      return this.getToken(SysMLv2Parser.SPECIALIZES, 0);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_superclassingPart;
    }
    enterRule(listener) {
      if (listener.enterSuperclassingPart) {
        listener.enterSuperclassingPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSuperclassingPart) {
        listener.exitSuperclassingPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSuperclassingPart) {
        return visitor.visitSuperclassingPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SubclassificationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SUBCLASSIFIER() {
      return this.getToken(SysMLv2Parser.SUBCLASSIFIER, 0);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT, 0);
    }
    SPECIALIZES() {
      return this.getToken(SysMLv2Parser.SPECIALIZES, 0);
    }
    SPECIALIZATION() {
      return this.getToken(SysMLv2Parser.SPECIALIZATION, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_subclassification;
    }
    enterRule(listener) {
      if (listener.enterSubclassification) {
        listener.enterSubclassification(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSubclassification) {
        listener.exitSubclassification(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSubclassification) {
        return visitor.visitSubclassification(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedSubclassificationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedSubclassification;
    }
    enterRule(listener) {
      if (listener.enterOwnedSubclassification) {
        listener.enterOwnedSubclassification(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedSubclassification) {
        listener.exitOwnedSubclassification(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedSubclassification) {
        return visitor.visitOwnedSubclassification(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    FEATURE() {
      return this.getToken(SysMLv2Parser.FEATURE, 0);
    }
    prefixMetadataMember() {
      return this.getRuleContext(0, PrefixMetadataMemberContext);
    }
    endFeaturePrefix() {
      return this.getRuleContext(0, EndFeaturePrefixContext);
    }
    basicFeaturePrefix() {
      return this.getRuleContext(0, BasicFeaturePrefixContext);
    }
    REF() {
      return this.getToken(SysMLv2Parser.REF, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_feature;
    }
    enterRule(listener) {
      if (listener.enterFeature) {
        listener.enterFeature(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeature) {
        listener.exitFeature(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeature) {
        return visitor.visitFeature(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EndFeaturePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    END() {
      return this.getToken(SysMLv2Parser.END, 0);
    }
    CONST() {
      return this.getToken(SysMLv2Parser.CONST, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_endFeaturePrefix;
    }
    enterRule(listener) {
      if (listener.enterEndFeaturePrefix) {
        listener.enterEndFeaturePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEndFeaturePrefix) {
        listener.exitEndFeaturePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEndFeaturePrefix) {
        return visitor.visitEndFeaturePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BasicFeaturePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureDirection() {
      return this.getRuleContext(0, FeatureDirectionContext);
    }
    DERIVED() {
      return this.getToken(SysMLv2Parser.DERIVED, 0);
    }
    ABSTRACT() {
      return this.getToken(SysMLv2Parser.ABSTRACT, 0);
    }
    COMPOSITE() {
      return this.getToken(SysMLv2Parser.COMPOSITE, 0);
    }
    PORTION() {
      return this.getToken(SysMLv2Parser.PORTION, 0);
    }
    VAR() {
      return this.getToken(SysMLv2Parser.VAR, 0);
    }
    CONST() {
      return this.getToken(SysMLv2Parser.CONST, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_basicFeaturePrefix;
    }
    enterRule(listener) {
      if (listener.enterBasicFeaturePrefix) {
        listener.enterBasicFeaturePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBasicFeaturePrefix) {
        listener.exitBasicFeaturePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBasicFeaturePrefix) {
        return visitor.visitBasicFeaturePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeaturePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    endFeaturePrefix() {
      return this.getRuleContext(0, EndFeaturePrefixContext);
    }
    ownedCrossFeatureMember() {
      return this.getRuleContext(0, OwnedCrossFeatureMemberContext);
    }
    basicFeaturePrefix() {
      return this.getRuleContext(0, BasicFeaturePrefixContext);
    }
    prefixMetadataMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(PrefixMetadataMemberContext);
      }
      return this.getRuleContext(i, PrefixMetadataMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featurePrefix;
    }
    enterRule(listener) {
      if (listener.enterFeaturePrefix) {
        listener.enterFeaturePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeaturePrefix) {
        listener.exitFeaturePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeaturePrefix) {
        return visitor.visitFeaturePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedCrossFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedCrossFeature() {
      return this.getRuleContext(0, OwnedCrossFeatureContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedCrossFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterOwnedCrossFeatureMember) {
        listener.enterOwnedCrossFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedCrossFeatureMember) {
        listener.exitOwnedCrossFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedCrossFeatureMember) {
        return visitor.visitOwnedCrossFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedCrossFeatureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    basicFeaturePrefix() {
      return this.getRuleContext(0, BasicFeaturePrefixContext);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    basicUsagePrefix() {
      return this.getRuleContext(0, BasicUsagePrefixContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedCrossFeature;
    }
    enterRule(listener) {
      if (listener.enterOwnedCrossFeature) {
        listener.enterOwnedCrossFeature(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedCrossFeature) {
        listener.exitOwnedCrossFeature(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedCrossFeature) {
        return visitor.visitOwnedCrossFeature(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureDirectionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    IN() {
      return this.getToken(SysMLv2Parser.IN, 0);
    }
    OUT() {
      return this.getToken(SysMLv2Parser.OUT, 0);
    }
    INOUT() {
      return this.getToken(SysMLv2Parser.INOUT, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureDirection;
    }
    enterRule(listener) {
      if (listener.enterFeatureDirection) {
        listener.enterFeatureDirection(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureDirection) {
        listener.exitFeatureDirection(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureDirection) {
        return visitor.visitFeatureDirection(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureIdentification() {
      return this.getRuleContext(0, FeatureIdentificationContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    conjugationPart() {
      return this.getRuleContext(0, ConjugationPartContext);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    featureRelationshipPart(i) {
      if (i === void 0) {
        return this.getRuleContexts(FeatureRelationshipPartContext);
      }
      return this.getRuleContext(i, FeatureRelationshipPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureDeclaration;
    }
    enterRule(listener) {
      if (listener.enterFeatureDeclaration) {
        listener.enterFeatureDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureDeclaration) {
        listener.exitFeatureDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureDeclaration) {
        return visitor.visitFeatureDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureIdentificationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LT() {
      return this.getToken(SysMLv2Parser.LT, 0);
    }
    name(i) {
      if (i === void 0) {
        return this.getRuleContexts(NameContext);
      }
      return this.getRuleContext(i, NameContext);
    }
    GT() {
      return this.getToken(SysMLv2Parser.GT, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureIdentification;
    }
    enterRule(listener) {
      if (listener.enterFeatureIdentification) {
        listener.enterFeatureIdentification(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureIdentification) {
        listener.exitFeatureIdentification(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureIdentification) {
        return visitor.visitFeatureIdentification(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureRelationshipPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typeRelationshipPart() {
      return this.getRuleContext(0, TypeRelationshipPartContext);
    }
    chainingPart() {
      return this.getRuleContext(0, ChainingPartContext);
    }
    invertingPart() {
      return this.getRuleContext(0, InvertingPartContext);
    }
    typeFeaturingPart() {
      return this.getRuleContext(0, TypeFeaturingPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureRelationshipPart;
    }
    enterRule(listener) {
      if (listener.enterFeatureRelationshipPart) {
        listener.enterFeatureRelationshipPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureRelationshipPart) {
        listener.exitFeatureRelationshipPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureRelationshipPart) {
        return visitor.visitFeatureRelationshipPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ChainingPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    CHAINS() {
      return this.getToken(SysMLv2Parser.CHAINS, 0);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_chainingPart;
    }
    enterRule(listener) {
      if (listener.enterChainingPart) {
        listener.enterChainingPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitChainingPart) {
        listener.exitChainingPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitChainingPart) {
        return visitor.visitChainingPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InvertingPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    INVERSE() {
      return this.getToken(SysMLv2Parser.INVERSE, 0);
    }
    OF() {
      return this.getToken(SysMLv2Parser.OF, 0);
    }
    ownedFeatureInverting() {
      return this.getRuleContext(0, OwnedFeatureInvertingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_invertingPart;
    }
    enterRule(listener) {
      if (listener.enterInvertingPart) {
        listener.enterInvertingPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInvertingPart) {
        listener.exitInvertingPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInvertingPart) {
        return visitor.visitInvertingPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeFeaturingPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    FEATURED() {
      return this.getToken(SysMLv2Parser.FEATURED, 0);
    }
    BY() {
      return this.getToken(SysMLv2Parser.BY, 0);
    }
    ownedTypeFeaturing(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedTypeFeaturingContext);
      }
      return this.getRuleContext(i, OwnedTypeFeaturingContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typeFeaturingPart;
    }
    enterRule(listener) {
      if (listener.enterTypeFeaturingPart) {
        listener.enterTypeFeaturingPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypeFeaturingPart) {
        listener.exitTypeFeaturingPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypeFeaturingPart) {
        return visitor.visitTypeFeaturingPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureSpecializationPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureSpecialization(i) {
      if (i === void 0) {
        return this.getRuleContexts(FeatureSpecializationContext);
      }
      return this.getRuleContext(i, FeatureSpecializationContext);
    }
    multiplicityPart() {
      return this.getRuleContext(0, MultiplicityPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureSpecializationPart;
    }
    enterRule(listener) {
      if (listener.enterFeatureSpecializationPart) {
        listener.enterFeatureSpecializationPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureSpecializationPart) {
        listener.exitFeatureSpecializationPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureSpecializationPart) {
        return visitor.visitFeatureSpecializationPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MultiplicityPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedMultiplicity() {
      return this.getRuleContext(0, OwnedMultiplicityContext);
    }
    ORDERED() {
      return this.getToken(SysMLv2Parser.ORDERED, 0);
    }
    NONUNIQUE() {
      return this.getToken(SysMLv2Parser.NONUNIQUE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_multiplicityPart;
    }
    enterRule(listener) {
      if (listener.enterMultiplicityPart) {
        listener.enterMultiplicityPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMultiplicityPart) {
        listener.exitMultiplicityPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMultiplicityPart) {
        return visitor.visitMultiplicityPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureSpecializationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typings() {
      return this.getRuleContext(0, TypingsContext);
    }
    subsettings() {
      return this.getRuleContext(0, SubsettingsContext);
    }
    references() {
      return this.getRuleContext(0, ReferencesContext);
    }
    crosses() {
      return this.getRuleContext(0, CrossesContext);
    }
    redefinitions() {
      return this.getRuleContext(0, RedefinitionsContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureSpecialization;
    }
    enterRule(listener) {
      if (listener.enterFeatureSpecialization) {
        listener.enterFeatureSpecialization(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureSpecialization) {
        listener.exitFeatureSpecialization(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureSpecialization) {
        return visitor.visitFeatureSpecialization(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypingsContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typedBy() {
      return this.getRuleContext(0, TypedByContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    featureTyping(i) {
      if (i === void 0) {
        return this.getRuleContexts(FeatureTypingContext);
      }
      return this.getRuleContext(i, FeatureTypingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typings;
    }
    enterRule(listener) {
      if (listener.enterTypings) {
        listener.enterTypings(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypings) {
        listener.exitTypings(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypings) {
        return visitor.visitTypings(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypedByContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureTyping() {
      return this.getRuleContext(0, FeatureTypingContext);
    }
    COLON() {
      return this.getToken(SysMLv2Parser.COLON, 0);
    }
    TYPED() {
      return this.getToken(SysMLv2Parser.TYPED, 0);
    }
    BY() {
      return this.getToken(SysMLv2Parser.BY, 0);
    }
    DEFINED() {
      return this.getToken(SysMLv2Parser.DEFINED, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typedBy;
    }
    enterRule(listener) {
      if (listener.enterTypedBy) {
        listener.enterTypedBy(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypedBy) {
        listener.exitTypedBy(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypedBy) {
        return visitor.visitTypedBy(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SubsettingsContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    subsets() {
      return this.getRuleContext(0, SubsetsContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    ownedSubsetting(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedSubsettingContext);
      }
      return this.getRuleContext(i, OwnedSubsettingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_subsettings;
    }
    enterRule(listener) {
      if (listener.enterSubsettings) {
        listener.enterSubsettings(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSubsettings) {
        listener.exitSubsettings(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSubsettings) {
        return visitor.visitSubsettings(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SubsetsContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedSubsetting() {
      return this.getRuleContext(0, OwnedSubsettingContext);
    }
    COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT, 0);
    }
    SUBSETS() {
      return this.getToken(SysMLv2Parser.SUBSETS, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_subsets;
    }
    enterRule(listener) {
      if (listener.enterSubsets) {
        listener.enterSubsets(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSubsets) {
        listener.exitSubsets(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSubsets) {
        return visitor.visitSubsets(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ReferencesContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    COLON_COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_COLON_GT, 0);
    }
    REFERENCES() {
      return this.getToken(SysMLv2Parser.REFERENCES, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_references;
    }
    enterRule(listener) {
      if (listener.enterReferences) {
        listener.enterReferences(this);
      }
    }
    exitRule(listener) {
      if (listener.exitReferences) {
        listener.exitReferences(this);
      }
    }
    accept(visitor) {
      if (visitor.visitReferences) {
        return visitor.visitReferences(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CrossesContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedCrossSubsetting() {
      return this.getRuleContext(0, OwnedCrossSubsettingContext);
    }
    FAT_ARROW() {
      return this.getToken(SysMLv2Parser.FAT_ARROW, 0);
    }
    CROSSES() {
      return this.getToken(SysMLv2Parser.CROSSES, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_crosses;
    }
    enterRule(listener) {
      if (listener.enterCrosses) {
        listener.enterCrosses(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCrosses) {
        listener.exitCrosses(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCrosses) {
        return visitor.visitCrosses(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RedefinitionsContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    redefines() {
      return this.getRuleContext(0, RedefinesContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    ownedRedefinition(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedRedefinitionContext);
      }
      return this.getRuleContext(i, OwnedRedefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_redefinitions;
    }
    enterRule(listener) {
      if (listener.enterRedefinitions) {
        listener.enterRedefinitions(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRedefinitions) {
        listener.exitRedefinitions(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRedefinitions) {
        return visitor.visitRedefinitions(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RedefinesContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedRedefinition() {
      return this.getRuleContext(0, OwnedRedefinitionContext);
    }
    COLON_GT_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT_GT, 0);
    }
    REDEFINES() {
      return this.getToken(SysMLv2Parser.REDEFINES, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_redefines;
    }
    enterRule(listener) {
      if (listener.enterRedefines) {
        listener.enterRedefines(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRedefines) {
        listener.exitRedefines(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRedefines) {
        return visitor.visitRedefines(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureTypingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    TYPING() {
      return this.getToken(SysMLv2Parser.TYPING, 0);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    generalType() {
      return this.getRuleContext(0, GeneralTypeContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    COLON() {
      return this.getToken(SysMLv2Parser.COLON, 0);
    }
    TYPED() {
      return this.getToken(SysMLv2Parser.TYPED, 0);
    }
    BY() {
      return this.getToken(SysMLv2Parser.BY, 0);
    }
    SPECIALIZATION() {
      return this.getToken(SysMLv2Parser.SPECIALIZATION, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    ownedFeatureTyping() {
      return this.getRuleContext(0, OwnedFeatureTypingContext);
    }
    conjugatedPortTyping() {
      return this.getRuleContext(0, ConjugatedPortTypingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureTyping;
    }
    enterRule(listener) {
      if (listener.enterFeatureTyping) {
        listener.enterFeatureTyping(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureTyping) {
        listener.exitFeatureTyping(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureTyping) {
        return visitor.visitFeatureTyping(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedFeatureTypingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedFeatureTyping;
    }
    enterRule(listener) {
      if (listener.enterOwnedFeatureTyping) {
        listener.enterOwnedFeatureTyping(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedFeatureTyping) {
        listener.exitOwnedFeatureTyping(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedFeatureTyping) {
        return visitor.visitOwnedFeatureTyping(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SubsettingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SUBSET() {
      return this.getToken(SysMLv2Parser.SUBSET, 0);
    }
    specificType() {
      return this.getRuleContext(0, SpecificTypeContext);
    }
    generalType() {
      return this.getRuleContext(0, GeneralTypeContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT, 0);
    }
    SUBSETS() {
      return this.getToken(SysMLv2Parser.SUBSETS, 0);
    }
    SPECIALIZATION() {
      return this.getToken(SysMLv2Parser.SPECIALIZATION, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_subsetting;
    }
    enterRule(listener) {
      if (listener.enterSubsetting) {
        listener.enterSubsetting(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSubsetting) {
        listener.exitSubsetting(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSubsetting) {
        return visitor.visitSubsetting(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedSubsettingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedSubsetting;
    }
    enterRule(listener) {
      if (listener.enterOwnedSubsetting) {
        listener.enterOwnedSubsetting(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedSubsetting) {
        listener.exitOwnedSubsetting(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedSubsetting) {
        return visitor.visitOwnedSubsetting(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedReferenceSubsettingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedReferenceSubsetting;
    }
    enterRule(listener) {
      if (listener.enterOwnedReferenceSubsetting) {
        listener.enterOwnedReferenceSubsetting(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedReferenceSubsetting) {
        listener.exitOwnedReferenceSubsetting(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedReferenceSubsetting) {
        return visitor.visitOwnedReferenceSubsetting(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedCrossSubsettingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedCrossSubsetting;
    }
    enterRule(listener) {
      if (listener.enterOwnedCrossSubsetting) {
        listener.enterOwnedCrossSubsetting(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedCrossSubsetting) {
        listener.exitOwnedCrossSubsetting(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedCrossSubsetting) {
        return visitor.visitOwnedCrossSubsetting(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RedefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    REDEFINITION() {
      return this.getToken(SysMLv2Parser.REDEFINITION, 0);
    }
    specificType() {
      return this.getRuleContext(0, SpecificTypeContext);
    }
    generalType() {
      return this.getRuleContext(0, GeneralTypeContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    COLON_GT_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT_GT, 0);
    }
    REDEFINES() {
      return this.getToken(SysMLv2Parser.REDEFINES, 0);
    }
    SPECIALIZATION() {
      return this.getToken(SysMLv2Parser.SPECIALIZATION, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_redefinition;
    }
    enterRule(listener) {
      if (listener.enterRedefinition) {
        listener.enterRedefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRedefinition) {
        listener.exitRedefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRedefinition) {
        return visitor.visitRedefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedRedefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedRedefinition;
    }
    enterRule(listener) {
      if (listener.enterOwnedRedefinition) {
        listener.enterOwnedRedefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedRedefinition) {
        listener.exitOwnedRedefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedRedefinition) {
        return visitor.visitOwnedRedefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureInvertingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    INVERSE() {
      return this.getToken(SysMLv2Parser.INVERSE, 0);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    OF() {
      return this.getToken(SysMLv2Parser.OF, 0);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    INVERTING() {
      return this.getToken(SysMLv2Parser.INVERTING, 0);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureInverting;
    }
    enterRule(listener) {
      if (listener.enterFeatureInverting) {
        listener.enterFeatureInverting(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureInverting) {
        listener.exitFeatureInverting(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureInverting) {
        return visitor.visitFeatureInverting(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedFeatureInvertingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedFeatureInverting;
    }
    enterRule(listener) {
      if (listener.enterOwnedFeatureInverting) {
        listener.enterOwnedFeatureInverting(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedFeatureInverting) {
        listener.exitOwnedFeatureInverting(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedFeatureInverting) {
        return visitor.visitOwnedFeatureInverting(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TypeFeaturingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    FEATURING() {
      return this.getToken(SysMLv2Parser.FEATURING, 0);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    BY() {
      return this.getToken(SysMLv2Parser.BY, 0);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    OF() {
      return this.getToken(SysMLv2Parser.OF, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_typeFeaturing;
    }
    enterRule(listener) {
      if (listener.enterTypeFeaturing) {
        listener.enterTypeFeaturing(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTypeFeaturing) {
        listener.exitTypeFeaturing(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTypeFeaturing) {
        return visitor.visitTypeFeaturing(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedTypeFeaturingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedTypeFeaturing;
    }
    enterRule(listener) {
      if (listener.enterOwnedTypeFeaturing) {
        listener.enterOwnedTypeFeaturing(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedTypeFeaturing) {
        listener.exitOwnedTypeFeaturing(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedTypeFeaturing) {
        return visitor.visitOwnedTypeFeaturing(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DataTypeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    DATATYPE() {
      return this.getToken(SysMLv2Parser.DATATYPE, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_dataType;
    }
    enterRule(listener) {
      if (listener.enterDataType) {
        listener.enterDataType(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDataType) {
        listener.exitDataType(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDataType) {
        return visitor.visitDataType(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ClassContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    CLASS() {
      return this.getToken(SysMLv2Parser.CLASS, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_class;
    }
    enterRule(listener) {
      if (listener.enterClass) {
        listener.enterClass(this);
      }
    }
    exitRule(listener) {
      if (listener.exitClass) {
        listener.exitClass(this);
      }
    }
    accept(visitor) {
      if (visitor.visitClass) {
        return visitor.visitClass(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StructureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    STRUCT() {
      return this.getToken(SysMLv2Parser.STRUCT, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_structure;
    }
    enterRule(listener) {
      if (listener.enterStructure) {
        listener.enterStructure(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStructure) {
        listener.exitStructure(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStructure) {
        return visitor.visitStructure(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AssociationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    ASSOC() {
      return this.getToken(SysMLv2Parser.ASSOC, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_association;
    }
    enterRule(listener) {
      if (listener.enterAssociation) {
        listener.enterAssociation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAssociation) {
        listener.exitAssociation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAssociation) {
        return visitor.visitAssociation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AssociationStructureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    ASSOC() {
      return this.getToken(SysMLv2Parser.ASSOC, 0);
    }
    STRUCT() {
      return this.getToken(SysMLv2Parser.STRUCT, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_associationStructure;
    }
    enterRule(listener) {
      if (listener.enterAssociationStructure) {
        listener.enterAssociationStructure(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAssociationStructure) {
        listener.exitAssociationStructure(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAssociationStructure) {
        return visitor.visitAssociationStructure(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConnectorContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    CONNECTOR() {
      return this.getToken(SysMLv2Parser.CONNECTOR, 0);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    connectorDeclaration() {
      return this.getRuleContext(0, ConnectorDeclarationContext);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_connector;
    }
    enterRule(listener) {
      if (listener.enterConnector) {
        listener.enterConnector(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConnector) {
        listener.exitConnector(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConnector) {
        return visitor.visitConnector(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConnectorDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    binaryConnectorDeclaration() {
      return this.getRuleContext(0, BinaryConnectorDeclarationContext);
    }
    naryConnectorDeclaration() {
      return this.getRuleContext(0, NaryConnectorDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_connectorDeclaration;
    }
    enterRule(listener) {
      if (listener.enterConnectorDeclaration) {
        listener.enterConnectorDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConnectorDeclaration) {
        listener.exitConnectorDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConnectorDeclaration) {
        return visitor.visitConnectorDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BinaryConnectorDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    connectorEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConnectorEndMemberContext);
      }
      return this.getRuleContext(i, ConnectorEndMemberContext);
    }
    TO() {
      return this.getToken(SysMLv2Parser.TO, 0);
    }
    FROM() {
      return this.getToken(SysMLv2Parser.FROM, 0);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_binaryConnectorDeclaration;
    }
    enterRule(listener) {
      if (listener.enterBinaryConnectorDeclaration) {
        listener.enterBinaryConnectorDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBinaryConnectorDeclaration) {
        listener.exitBinaryConnectorDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBinaryConnectorDeclaration) {
        return visitor.visitBinaryConnectorDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NaryConnectorDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LPAREN() {
      return this.getToken(SysMLv2Parser.LPAREN, 0);
    }
    connectorEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConnectorEndMemberContext);
      }
      return this.getRuleContext(i, ConnectorEndMemberContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    RPAREN() {
      return this.getToken(SysMLv2Parser.RPAREN, 0);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_naryConnectorDeclaration;
    }
    enterRule(listener) {
      if (listener.enterNaryConnectorDeclaration) {
        listener.enterNaryConnectorDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNaryConnectorDeclaration) {
        listener.exitNaryConnectorDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNaryConnectorDeclaration) {
        return visitor.visitNaryConnectorDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConnectorEndMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    connectorEnd() {
      return this.getRuleContext(0, ConnectorEndContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_connectorEndMember;
    }
    enterRule(listener) {
      if (listener.enterConnectorEndMember) {
        listener.enterConnectorEndMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConnectorEndMember) {
        listener.exitConnectorEndMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConnectorEndMember) {
        return visitor.visitConnectorEndMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConnectorEndContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    ownedCrossMultiplicityMember() {
      return this.getRuleContext(0, OwnedCrossMultiplicityMemberContext);
    }
    name() {
      return this.getRuleContext(0, NameContext);
    }
    COLON_COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_COLON_GT, 0);
    }
    REFERENCES() {
      return this.getToken(SysMLv2Parser.REFERENCES, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_connectorEnd;
    }
    enterRule(listener) {
      if (listener.enterConnectorEnd) {
        listener.enterConnectorEnd(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConnectorEnd) {
        listener.exitConnectorEnd(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConnectorEnd) {
        return visitor.visitConnectorEnd(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedCrossMultiplicityMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedCrossMultiplicity() {
      return this.getRuleContext(0, OwnedCrossMultiplicityContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedCrossMultiplicityMember;
    }
    enterRule(listener) {
      if (listener.enterOwnedCrossMultiplicityMember) {
        listener.enterOwnedCrossMultiplicityMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedCrossMultiplicityMember) {
        listener.exitOwnedCrossMultiplicityMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedCrossMultiplicityMember) {
        return visitor.visitOwnedCrossMultiplicityMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedCrossMultiplicityContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedMultiplicity() {
      return this.getRuleContext(0, OwnedMultiplicityContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedCrossMultiplicity;
    }
    enterRule(listener) {
      if (listener.enterOwnedCrossMultiplicity) {
        listener.enterOwnedCrossMultiplicity(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedCrossMultiplicity) {
        listener.exitOwnedCrossMultiplicity(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedCrossMultiplicity) {
        return visitor.visitOwnedCrossMultiplicity(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BindingConnectorContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    BINDING() {
      return this.getToken(SysMLv2Parser.BINDING, 0);
    }
    bindingConnectorDeclaration() {
      return this.getRuleContext(0, BindingConnectorDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_bindingConnector;
    }
    enterRule(listener) {
      if (listener.enterBindingConnector) {
        listener.enterBindingConnector(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBindingConnector) {
        listener.exitBindingConnector(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBindingConnector) {
        return visitor.visitBindingConnector(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BindingConnectorDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    OF() {
      return this.getToken(SysMLv2Parser.OF, 0);
    }
    connectorEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConnectorEndMemberContext);
      }
      return this.getRuleContext(i, ConnectorEndMemberContext);
    }
    EQ() {
      return this.getToken(SysMLv2Parser.EQ, 0);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_bindingConnectorDeclaration;
    }
    enterRule(listener) {
      if (listener.enterBindingConnectorDeclaration) {
        listener.enterBindingConnectorDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBindingConnectorDeclaration) {
        listener.exitBindingConnectorDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBindingConnectorDeclaration) {
        return visitor.visitBindingConnectorDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SuccessionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    SUCCESSION() {
      return this.getToken(SysMLv2Parser.SUCCESSION, 0);
    }
    successionDeclaration() {
      return this.getRuleContext(0, SuccessionDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_succession;
    }
    enterRule(listener) {
      if (listener.enterSuccession) {
        listener.enterSuccession(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSuccession) {
        listener.exitSuccession(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSuccession) {
        return visitor.visitSuccession(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SuccessionDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    FIRST() {
      return this.getToken(SysMLv2Parser.FIRST, 0);
    }
    connectorEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConnectorEndMemberContext);
      }
      return this.getRuleContext(i, ConnectorEndMemberContext);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_successionDeclaration;
    }
    enterRule(listener) {
      if (listener.enterSuccessionDeclaration) {
        listener.enterSuccessionDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSuccessionDeclaration) {
        listener.exitSuccessionDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSuccessionDeclaration) {
        return visitor.visitSuccessionDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BehaviorContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    BEHAVIOR() {
      return this.getToken(SysMLv2Parser.BEHAVIOR, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_behavior;
    }
    enterRule(listener) {
      if (listener.enterBehavior) {
        listener.enterBehavior(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBehavior) {
        listener.exitBehavior(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBehavior) {
        return visitor.visitBehavior(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StepContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    STEP() {
      return this.getToken(SysMLv2Parser.STEP, 0);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_step;
    }
    enterRule(listener) {
      if (listener.enterStep) {
        listener.enterStep(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStep) {
        listener.exitStep(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStep) {
        return visitor.visitStep(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FunctionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    FUNCTION() {
      return this.getToken(SysMLv2Parser.FUNCTION, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    functionBody() {
      return this.getRuleContext(0, FunctionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_function;
    }
    enterRule(listener) {
      if (listener.enterFunction) {
        listener.enterFunction(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFunction) {
        listener.exitFunction(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFunction) {
        return visitor.visitFunction(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FunctionBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    functionBodyPart() {
      return this.getRuleContext(0, FunctionBodyPartContext);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_functionBody;
    }
    enterRule(listener) {
      if (listener.enterFunctionBody) {
        listener.enterFunctionBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFunctionBody) {
        listener.exitFunctionBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFunctionBody) {
        return visitor.visitFunctionBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FunctionBodyPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionBodyItemContext);
      }
      return this.getRuleContext(i, DefinitionBodyItemContext);
    }
    typeBodyElement(i) {
      if (i === void 0) {
        return this.getRuleContexts(TypeBodyElementContext);
      }
      return this.getRuleContext(i, TypeBodyElementContext);
    }
    returnFeatureMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ReturnFeatureMemberContext);
      }
      return this.getRuleContext(i, ReturnFeatureMemberContext);
    }
    resultExpressionMember() {
      return this.getRuleContext(0, ResultExpressionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_functionBodyPart;
    }
    enterRule(listener) {
      if (listener.enterFunctionBodyPart) {
        listener.enterFunctionBodyPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFunctionBodyPart) {
        listener.exitFunctionBodyPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFunctionBodyPart) {
        return visitor.visitFunctionBodyPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ReturnFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    RETURN() {
      return this.getToken(SysMLv2Parser.RETURN, 0);
    }
    featureElement() {
      return this.getRuleContext(0, FeatureElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_returnFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterReturnFeatureMember) {
        listener.enterReturnFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitReturnFeatureMember) {
        listener.exitReturnFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitReturnFeatureMember) {
        return visitor.visitReturnFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ResultExpressionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_resultExpressionMember;
    }
    enterRule(listener) {
      if (listener.enterResultExpressionMember) {
        listener.enterResultExpressionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitResultExpressionMember) {
        listener.exitResultExpressionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitResultExpressionMember) {
        return visitor.visitResultExpressionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    EXPR() {
      return this.getToken(SysMLv2Parser.EXPR, 0);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    functionBody() {
      return this.getRuleContext(0, FunctionBodyContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_expression;
    }
    enterRule(listener) {
      if (listener.enterExpression) {
        listener.enterExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitExpression) {
        listener.exitExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitExpression) {
        return visitor.visitExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PredicateContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    PREDICATE() {
      return this.getToken(SysMLv2Parser.PREDICATE, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    functionBody() {
      return this.getRuleContext(0, FunctionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_predicate;
    }
    enterRule(listener) {
      if (listener.enterPredicate) {
        listener.enterPredicate(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPredicate) {
        listener.exitPredicate(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPredicate) {
        return visitor.visitPredicate(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BooleanExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    BOOL() {
      return this.getToken(SysMLv2Parser.BOOL, 0);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    functionBody() {
      return this.getRuleContext(0, FunctionBodyContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_booleanExpression;
    }
    enterRule(listener) {
      if (listener.enterBooleanExpression) {
        listener.enterBooleanExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBooleanExpression) {
        listener.exitBooleanExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBooleanExpression) {
        return visitor.visitBooleanExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InvariantContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    INV() {
      return this.getToken(SysMLv2Parser.INV, 0);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    functionBody() {
      return this.getRuleContext(0, FunctionBodyContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    TRUE() {
      return this.getToken(SysMLv2Parser.TRUE, 0);
    }
    FALSE() {
      return this.getToken(SysMLv2Parser.FALSE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_invariant;
    }
    enterRule(listener) {
      if (listener.enterInvariant) {
        listener.enterInvariant(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInvariant) {
        listener.exitInvariant(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInvariant) {
        return visitor.visitInvariant(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureChainMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureChainMember;
    }
    enterRule(listener) {
      if (listener.enterFeatureChainMember) {
        listener.enterFeatureChainMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureChainMember) {
        listener.exitFeatureChainMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureChainMember) {
        return visitor.visitFeatureChainMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InteractionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    INTERACTION() {
      return this.getToken(SysMLv2Parser.INTERACTION, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interaction;
    }
    enterRule(listener) {
      if (listener.enterInteraction) {
        listener.enterInteraction(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInteraction) {
        listener.exitInteraction(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInteraction) {
        return visitor.visitInteraction(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FlowContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    FLOW() {
      return this.getToken(SysMLv2Parser.FLOW, 0);
    }
    flowDeclaration() {
      return this.getRuleContext(0, FlowDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_flow;
    }
    enterRule(listener) {
      if (listener.enterFlow) {
        listener.enterFlow(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFlow) {
        listener.exitFlow(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFlow) {
        return visitor.visitFlow(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SuccessionFlowContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featurePrefix() {
      return this.getRuleContext(0, FeaturePrefixContext);
    }
    SUCCESSION() {
      return this.getToken(SysMLv2Parser.SUCCESSION, 0);
    }
    FLOW() {
      return this.getToken(SysMLv2Parser.FLOW, 0);
    }
    flowDeclaration() {
      return this.getRuleContext(0, FlowDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_successionFlow;
    }
    enterRule(listener) {
      if (listener.enterSuccessionFlow) {
        listener.enterSuccessionFlow(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSuccessionFlow) {
        listener.exitSuccessionFlow(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSuccessionFlow) {
        return visitor.visitSuccessionFlow(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FlowDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    OF() {
      return this.getToken(SysMLv2Parser.OF, 0);
    }
    payloadFeatureMember() {
      return this.getRuleContext(0, PayloadFeatureMemberContext);
    }
    FROM() {
      return this.getToken(SysMLv2Parser.FROM, 0);
    }
    flowEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(FlowEndMemberContext);
      }
      return this.getRuleContext(i, FlowEndMemberContext);
    }
    TO() {
      return this.getToken(SysMLv2Parser.TO, 0);
    }
    ALL() {
      return this.getToken(SysMLv2Parser.ALL, 0);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    flowPayloadFeatureMember() {
      return this.getRuleContext(0, FlowPayloadFeatureMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_flowDeclaration;
    }
    enterRule(listener) {
      if (listener.enterFlowDeclaration) {
        listener.enterFlowDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFlowDeclaration) {
        listener.exitFlowDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFlowDeclaration) {
        return visitor.visitFlowDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PayloadFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    payloadFeature() {
      return this.getRuleContext(0, PayloadFeatureContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_payloadFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterPayloadFeatureMember) {
        listener.enterPayloadFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPayloadFeatureMember) {
        listener.exitPayloadFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPayloadFeatureMember) {
        return visitor.visitPayloadFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PayloadFeatureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    payloadFeatureSpecializationPart() {
      return this.getRuleContext(0, PayloadFeatureSpecializationPartContext);
    }
    ownedFeatureTyping() {
      return this.getRuleContext(0, OwnedFeatureTypingContext);
    }
    ownedMultiplicity() {
      return this.getRuleContext(0, OwnedMultiplicityContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_payloadFeature;
    }
    enterRule(listener) {
      if (listener.enterPayloadFeature) {
        listener.enterPayloadFeature(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPayloadFeature) {
        listener.exitPayloadFeature(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPayloadFeature) {
        return visitor.visitPayloadFeature(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PayloadFeatureSpecializationPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureSpecialization(i) {
      if (i === void 0) {
        return this.getRuleContexts(FeatureSpecializationContext);
      }
      return this.getRuleContext(i, FeatureSpecializationContext);
    }
    multiplicityPart() {
      return this.getRuleContext(0, MultiplicityPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_payloadFeatureSpecializationPart;
    }
    enterRule(listener) {
      if (listener.enterPayloadFeatureSpecializationPart) {
        listener.enterPayloadFeatureSpecializationPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPayloadFeatureSpecializationPart) {
        listener.exitPayloadFeatureSpecializationPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPayloadFeatureSpecializationPart) {
        return visitor.visitPayloadFeatureSpecializationPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FlowEndMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    flowEnd() {
      return this.getRuleContext(0, FlowEndContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_flowEndMember;
    }
    enterRule(listener) {
      if (listener.enterFlowEndMember) {
        listener.enterFlowEndMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFlowEndMember) {
        listener.exitFlowEndMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFlowEndMember) {
        return visitor.visitFlowEndMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FlowEndContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    DOT(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.DOT);
      } else {
        return this.getToken(SysMLv2Parser.DOT, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_flowEnd;
    }
    enterRule(listener) {
      if (listener.enterFlowEnd) {
        listener.enterFlowEnd(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFlowEnd) {
        listener.exitFlowEnd(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFlowEnd) {
        return visitor.visitFlowEnd(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ValuePartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureValue() {
      return this.getRuleContext(0, FeatureValueContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_valuePart;
    }
    enterRule(listener) {
      if (listener.enterValuePart) {
        listener.enterValuePart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitValuePart) {
        listener.exitValuePart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitValuePart) {
        return visitor.visitValuePart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureValueContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    EQ() {
      return this.getToken(SysMLv2Parser.EQ, 0);
    }
    COLON_EQ() {
      return this.getToken(SysMLv2Parser.COLON_EQ, 0);
    }
    DEFAULT() {
      return this.getToken(SysMLv2Parser.DEFAULT, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureValue;
    }
    enterRule(listener) {
      if (listener.enterFeatureValue) {
        listener.enterFeatureValue(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureValue) {
        listener.exitFeatureValue(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureValue) {
        return visitor.visitFeatureValue(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MultiplicityContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    multiplicitySubset() {
      return this.getRuleContext(0, MultiplicitySubsetContext);
    }
    multiplicityRange() {
      return this.getRuleContext(0, MultiplicityRangeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_multiplicity;
    }
    enterRule(listener) {
      if (listener.enterMultiplicity) {
        listener.enterMultiplicity(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMultiplicity) {
        listener.exitMultiplicity(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMultiplicity) {
        return visitor.visitMultiplicity(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MultiplicitySubsetContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    MULTIPLICITY() {
      return this.getToken(SysMLv2Parser.MULTIPLICITY, 0);
    }
    subsets() {
      return this.getRuleContext(0, SubsetsContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_multiplicitySubset;
    }
    enterRule(listener) {
      if (listener.enterMultiplicitySubset) {
        listener.enterMultiplicitySubset(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMultiplicitySubset) {
        listener.exitMultiplicitySubset(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMultiplicitySubset) {
        return visitor.visitMultiplicitySubset(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MultiplicityRangeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    MULTIPLICITY() {
      return this.getToken(SysMLv2Parser.MULTIPLICITY, 0);
    }
    multiplicityBounds() {
      return this.getRuleContext(0, MultiplicityBoundsContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_multiplicityRange;
    }
    enterRule(listener) {
      if (listener.enterMultiplicityRange) {
        listener.enterMultiplicityRange(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMultiplicityRange) {
        listener.exitMultiplicityRange(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMultiplicityRange) {
        return visitor.visitMultiplicityRange(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedMultiplicityContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedMultiplicityRange() {
      return this.getRuleContext(0, OwnedMultiplicityRangeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedMultiplicity;
    }
    enterRule(listener) {
      if (listener.enterOwnedMultiplicity) {
        listener.enterOwnedMultiplicity(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedMultiplicity) {
        listener.exitOwnedMultiplicity(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedMultiplicity) {
        return visitor.visitOwnedMultiplicity(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OwnedMultiplicityRangeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    multiplicityBounds() {
      return this.getRuleContext(0, MultiplicityBoundsContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ownedMultiplicityRange;
    }
    enterRule(listener) {
      if (listener.enterOwnedMultiplicityRange) {
        listener.enterOwnedMultiplicityRange(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOwnedMultiplicityRange) {
        listener.exitOwnedMultiplicityRange(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOwnedMultiplicityRange) {
        return visitor.visitOwnedMultiplicityRange(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MultiplicityBoundsContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LBRACK() {
      return this.getToken(SysMLv2Parser.LBRACK, 0);
    }
    multiplicityExpressionMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(MultiplicityExpressionMemberContext);
      }
      return this.getRuleContext(i, MultiplicityExpressionMemberContext);
    }
    RBRACK() {
      return this.getToken(SysMLv2Parser.RBRACK, 0);
    }
    DOT_DOT() {
      return this.getToken(SysMLv2Parser.DOT_DOT, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_multiplicityBounds;
    }
    enterRule(listener) {
      if (listener.enterMultiplicityBounds) {
        listener.enterMultiplicityBounds(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMultiplicityBounds) {
        listener.exitMultiplicityBounds(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMultiplicityBounds) {
        return visitor.visitMultiplicityBounds(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MultiplicityExpressionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    literalExpression() {
      return this.getRuleContext(0, LiteralExpressionContext);
    }
    featureReferenceExpression() {
      return this.getRuleContext(0, FeatureReferenceExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_multiplicityExpressionMember;
    }
    enterRule(listener) {
      if (listener.enterMultiplicityExpressionMember) {
        listener.enterMultiplicityExpressionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMultiplicityExpressionMember) {
        listener.exitMultiplicityExpressionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMultiplicityExpressionMember) {
        return visitor.visitMultiplicityExpressionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetaclassContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    typePrefix() {
      return this.getRuleContext(0, TypePrefixContext);
    }
    METACLASS() {
      return this.getToken(SysMLv2Parser.METACLASS, 0);
    }
    classifierDeclaration() {
      return this.getRuleContext(0, ClassifierDeclarationContext);
    }
    typeBody() {
      return this.getRuleContext(0, TypeBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metaclass;
    }
    enterRule(listener) {
      if (listener.enterMetaclass) {
        listener.enterMetaclass(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetaclass) {
        listener.exitMetaclass(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetaclass) {
        return visitor.visitMetaclass(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PrefixMetadataAnnotationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    HASH() {
      return this.getToken(SysMLv2Parser.HASH, 0);
    }
    prefixMetadataFeature() {
      return this.getRuleContext(0, PrefixMetadataFeatureContext);
    }
    prefixMetadataUsage() {
      return this.getRuleContext(0, PrefixMetadataUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_prefixMetadataAnnotation;
    }
    enterRule(listener) {
      if (listener.enterPrefixMetadataAnnotation) {
        listener.enterPrefixMetadataAnnotation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPrefixMetadataAnnotation) {
        listener.exitPrefixMetadataAnnotation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPrefixMetadataAnnotation) {
        return visitor.visitPrefixMetadataAnnotation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PrefixMetadataMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    HASH() {
      return this.getToken(SysMLv2Parser.HASH, 0);
    }
    prefixMetadataFeature() {
      return this.getRuleContext(0, PrefixMetadataFeatureContext);
    }
    prefixMetadataUsage() {
      return this.getRuleContext(0, PrefixMetadataUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_prefixMetadataMember;
    }
    enterRule(listener) {
      if (listener.enterPrefixMetadataMember) {
        listener.enterPrefixMetadataMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPrefixMetadataMember) {
        listener.exitPrefixMetadataMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPrefixMetadataMember) {
        return visitor.visitPrefixMetadataMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PrefixMetadataFeatureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedFeatureTyping() {
      return this.getRuleContext(0, OwnedFeatureTypingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_prefixMetadataFeature;
    }
    enterRule(listener) {
      if (listener.enterPrefixMetadataFeature) {
        listener.enterPrefixMetadataFeature(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPrefixMetadataFeature) {
        listener.exitPrefixMetadataFeature(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPrefixMetadataFeature) {
        return visitor.visitPrefixMetadataFeature(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataFeatureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    metadataFeatureDeclaration() {
      return this.getRuleContext(0, MetadataFeatureDeclarationContext);
    }
    metadataBody() {
      return this.getRuleContext(0, MetadataBodyContext);
    }
    AT_SIGN() {
      return this.getToken(SysMLv2Parser.AT_SIGN, 0);
    }
    METADATA() {
      return this.getToken(SysMLv2Parser.METADATA, 0);
    }
    prefixMetadataMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(PrefixMetadataMemberContext);
      }
      return this.getRuleContext(i, PrefixMetadataMemberContext);
    }
    ABOUT() {
      return this.getToken(SysMLv2Parser.ABOUT, 0);
    }
    annotation(i) {
      if (i === void 0) {
        return this.getRuleContexts(AnnotationContext);
      }
      return this.getRuleContext(i, AnnotationContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataFeature;
    }
    enterRule(listener) {
      if (listener.enterMetadataFeature) {
        listener.enterMetadataFeature(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataFeature) {
        listener.exitMetadataFeature(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataFeature) {
        return visitor.visitMetadataFeature(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataFeatureDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedFeatureTyping() {
      return this.getRuleContext(0, OwnedFeatureTypingContext);
    }
    COLON() {
      return this.getToken(SysMLv2Parser.COLON, 0);
    }
    TYPED() {
      return this.getToken(SysMLv2Parser.TYPED, 0);
    }
    BY() {
      return this.getToken(SysMLv2Parser.BY, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataFeatureDeclaration;
    }
    enterRule(listener) {
      if (listener.enterMetadataFeatureDeclaration) {
        listener.enterMetadataFeatureDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataFeatureDeclaration) {
        listener.exitMetadataFeatureDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataFeatureDeclaration) {
        return visitor.visitMetadataFeatureDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    metadataBodyElement(i) {
      if (i === void 0) {
        return this.getRuleContexts(MetadataBodyElementContext);
      }
      return this.getRuleContext(i, MetadataBodyElementContext);
    }
    definitionMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionMemberContext);
      }
      return this.getRuleContext(i, DefinitionMemberContext);
    }
    metadataBodyUsageMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(MetadataBodyUsageMemberContext);
      }
      return this.getRuleContext(i, MetadataBodyUsageMemberContext);
    }
    aliasMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(AliasMemberContext);
      }
      return this.getRuleContext(i, AliasMemberContext);
    }
    importRule(i) {
      if (i === void 0) {
        return this.getRuleContexts(ImportRuleContext);
      }
      return this.getRuleContext(i, ImportRuleContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataBody;
    }
    enterRule(listener) {
      if (listener.enterMetadataBody) {
        listener.enterMetadataBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataBody) {
        listener.exitMetadataBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataBody) {
        return visitor.visitMetadataBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataBodyElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nonFeatureMember() {
      return this.getRuleContext(0, NonFeatureMemberContext);
    }
    metadataBodyFeatureMember() {
      return this.getRuleContext(0, MetadataBodyFeatureMemberContext);
    }
    aliasMember() {
      return this.getRuleContext(0, AliasMemberContext);
    }
    importRule() {
      return this.getRuleContext(0, ImportRuleContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataBodyElement;
    }
    enterRule(listener) {
      if (listener.enterMetadataBodyElement) {
        listener.enterMetadataBodyElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataBodyElement) {
        listener.exitMetadataBodyElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataBodyElement) {
        return visitor.visitMetadataBodyElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataBodyFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    metadataBodyFeature() {
      return this.getRuleContext(0, MetadataBodyFeatureContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataBodyFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterMetadataBodyFeatureMember) {
        listener.enterMetadataBodyFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataBodyFeatureMember) {
        listener.exitMetadataBodyFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataBodyFeatureMember) {
        return visitor.visitMetadataBodyFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataBodyFeatureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedRedefinition() {
      return this.getRuleContext(0, OwnedRedefinitionContext);
    }
    metadataBody() {
      return this.getRuleContext(0, MetadataBodyContext);
    }
    FEATURE() {
      return this.getToken(SysMLv2Parser.FEATURE, 0);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    COLON_GT_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT_GT, 0);
    }
    REDEFINES() {
      return this.getToken(SysMLv2Parser.REDEFINES, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataBodyFeature;
    }
    enterRule(listener) {
      if (listener.enterMetadataBodyFeature) {
        listener.enterMetadataBodyFeature(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataBodyFeature) {
        listener.exitMetadataBodyFeature(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataBodyFeature) {
        return visitor.visitMetadataBodyFeature(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PackageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    packageDeclaration() {
      return this.getRuleContext(0, PackageDeclarationContext);
    }
    packageBody() {
      return this.getRuleContext(0, PackageBodyContext);
    }
    prefixMetadataMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(PrefixMetadataMemberContext);
      }
      return this.getRuleContext(i, PrefixMetadataMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_package;
    }
    enterRule(listener) {
      if (listener.enterPackage) {
        listener.enterPackage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPackage) {
        listener.exitPackage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPackage) {
        return visitor.visitPackage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var LibraryPackageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LIBRARY() {
      return this.getToken(SysMLv2Parser.LIBRARY, 0);
    }
    packageDeclaration() {
      return this.getRuleContext(0, PackageDeclarationContext);
    }
    packageBody() {
      return this.getRuleContext(0, PackageBodyContext);
    }
    STANDARD() {
      return this.getToken(SysMLv2Parser.STANDARD, 0);
    }
    prefixMetadataMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(PrefixMetadataMemberContext);
      }
      return this.getRuleContext(i, PrefixMetadataMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_libraryPackage;
    }
    enterRule(listener) {
      if (listener.enterLibraryPackage) {
        listener.enterLibraryPackage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitLibraryPackage) {
        listener.exitLibraryPackage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitLibraryPackage) {
        return visitor.visitLibraryPackage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PackageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    PACKAGE() {
      return this.getToken(SysMLv2Parser.PACKAGE, 0);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_packageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterPackageDeclaration) {
        listener.enterPackageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPackageDeclaration) {
        listener.exitPackageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPackageDeclaration) {
        return visitor.visitPackageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PackageBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    packageBodyElement(i) {
      if (i === void 0) {
        return this.getRuleContexts(PackageBodyElementContext);
      }
      return this.getRuleContext(i, PackageBodyElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_packageBody;
    }
    enterRule(listener) {
      if (listener.enterPackageBody) {
        listener.enterPackageBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPackageBody) {
        listener.exitPackageBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPackageBody) {
        return visitor.visitPackageBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ElementFilterMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    FILTER() {
      return this.getToken(SysMLv2Parser.FILTER, 0);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_elementFilterMember;
    }
    enterRule(listener) {
      if (listener.enterElementFilterMember) {
        listener.enterElementFilterMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitElementFilterMember) {
        listener.exitElementFilterMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitElementFilterMember) {
        return visitor.visitElementFilterMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DependencyDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName(i) {
      if (i === void 0) {
        return this.getRuleContexts(QualifiedNameContext);
      }
      return this.getRuleContext(i, QualifiedNameContext);
    }
    TO() {
      return this.getToken(SysMLv2Parser.TO, 0);
    }
    FROM() {
      return this.getToken(SysMLv2Parser.FROM, 0);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_dependencyDeclaration;
    }
    enterRule(listener) {
      if (listener.enterDependencyDeclaration) {
        listener.enterDependencyDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDependencyDeclaration) {
        listener.exitDependencyDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDependencyDeclaration) {
        return visitor.visitDependencyDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AnnotatingMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    annotatingElement() {
      return this.getRuleContext(0, AnnotatingElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_annotatingMember;
    }
    enterRule(listener) {
      if (listener.enterAnnotatingMember) {
        listener.enterAnnotatingMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAnnotatingMember) {
        listener.exitAnnotatingMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAnnotatingMember) {
        return visitor.visitAnnotatingMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PackageBodyElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    packageMember() {
      return this.getRuleContext(0, PackageMemberContext);
    }
    elementFilterMember() {
      return this.getRuleContext(0, ElementFilterMemberContext);
    }
    aliasMember() {
      return this.getRuleContext(0, AliasMemberContext);
    }
    importRule() {
      return this.getRuleContext(0, ImportRuleContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_packageBodyElement;
    }
    enterRule(listener) {
      if (listener.enterPackageBodyElement) {
        listener.enterPackageBodyElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPackageBodyElement) {
        listener.exitPackageBodyElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPackageBodyElement) {
        return visitor.visitPackageBodyElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PackageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    definitionElement() {
      return this.getRuleContext(0, DefinitionElementContext);
    }
    usageElement() {
      return this.getRuleContext(0, UsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_packageMember;
    }
    enterRule(listener) {
      if (listener.enterPackageMember) {
        listener.enterPackageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPackageMember) {
        listener.exitPackageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPackageMember) {
        return visitor.visitPackageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    package() {
      return this.getRuleContext(0, PackageContext);
    }
    libraryPackage() {
      return this.getRuleContext(0, LibraryPackageContext);
    }
    annotatingElement() {
      return this.getRuleContext(0, AnnotatingElementContext);
    }
    dependency() {
      return this.getRuleContext(0, DependencyContext);
    }
    attributeDefinition() {
      return this.getRuleContext(0, AttributeDefinitionContext);
    }
    enumerationDefinition() {
      return this.getRuleContext(0, EnumerationDefinitionContext);
    }
    occurrenceDefinition() {
      return this.getRuleContext(0, OccurrenceDefinitionContext);
    }
    individualDefinition() {
      return this.getRuleContext(0, IndividualDefinitionContext);
    }
    itemDefinition() {
      return this.getRuleContext(0, ItemDefinitionContext);
    }
    partDefinition() {
      return this.getRuleContext(0, PartDefinitionContext);
    }
    connectionDefinition() {
      return this.getRuleContext(0, ConnectionDefinitionContext);
    }
    flowDefinition() {
      return this.getRuleContext(0, FlowDefinitionContext);
    }
    interfaceDefinition() {
      return this.getRuleContext(0, InterfaceDefinitionContext);
    }
    portDefinition() {
      return this.getRuleContext(0, PortDefinitionContext);
    }
    actionDefinition() {
      return this.getRuleContext(0, ActionDefinitionContext);
    }
    calculationDefinition() {
      return this.getRuleContext(0, CalculationDefinitionContext);
    }
    stateDefinition() {
      return this.getRuleContext(0, StateDefinitionContext);
    }
    constraintDefinition() {
      return this.getRuleContext(0, ConstraintDefinitionContext);
    }
    requirementDefinition() {
      return this.getRuleContext(0, RequirementDefinitionContext);
    }
    concernDefinition() {
      return this.getRuleContext(0, ConcernDefinitionContext);
    }
    caseDefinition() {
      return this.getRuleContext(0, CaseDefinitionContext);
    }
    analysisCaseDefinition() {
      return this.getRuleContext(0, AnalysisCaseDefinitionContext);
    }
    verificationCaseDefinition() {
      return this.getRuleContext(0, VerificationCaseDefinitionContext);
    }
    useCaseDefinition() {
      return this.getRuleContext(0, UseCaseDefinitionContext);
    }
    viewDefinition() {
      return this.getRuleContext(0, ViewDefinitionContext);
    }
    viewpointDefinition() {
      return this.getRuleContext(0, ViewpointDefinitionContext);
    }
    renderingDefinition() {
      return this.getRuleContext(0, RenderingDefinitionContext);
    }
    metadataDefinition() {
      return this.getRuleContext(0, MetadataDefinitionContext);
    }
    allocationDefinition() {
      return this.getRuleContext(0, AllocationDefinitionContext);
    }
    extendedDefinition() {
      return this.getRuleContext(0, ExtendedDefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definitionElement;
    }
    enterRule(listener) {
      if (listener.enterDefinitionElement) {
        listener.enterDefinitionElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinitionElement) {
        listener.exitDefinitionElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinitionElement) {
        return visitor.visitDefinitionElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nonOccurrenceUsageElement() {
      return this.getRuleContext(0, NonOccurrenceUsageElementContext);
    }
    occurrenceUsageElement() {
      return this.getRuleContext(0, OccurrenceUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_usageElement;
    }
    enterRule(listener) {
      if (listener.enterUsageElement) {
        listener.enterUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUsageElement) {
        listener.exitUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUsageElement) {
        return visitor.visitUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BasicDefinitionPrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ABSTRACT() {
      return this.getToken(SysMLv2Parser.ABSTRACT, 0);
    }
    VARIATION() {
      return this.getToken(SysMLv2Parser.VARIATION, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_basicDefinitionPrefix;
    }
    enterRule(listener) {
      if (listener.enterBasicDefinitionPrefix) {
        listener.enterBasicDefinitionPrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBasicDefinitionPrefix) {
        listener.exitBasicDefinitionPrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBasicDefinitionPrefix) {
        return visitor.visitBasicDefinitionPrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionExtensionKeywordContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    prefixMetadataMember() {
      return this.getRuleContext(0, PrefixMetadataMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definitionExtensionKeyword;
    }
    enterRule(listener) {
      if (listener.enterDefinitionExtensionKeyword) {
        listener.enterDefinitionExtensionKeyword(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinitionExtensionKeyword) {
        listener.exitDefinitionExtensionKeyword(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinitionExtensionKeyword) {
        return visitor.visitDefinitionExtensionKeyword(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionPrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    basicDefinitionPrefix() {
      return this.getRuleContext(0, BasicDefinitionPrefixContext);
    }
    definitionExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionExtensionKeywordContext);
      }
      return this.getRuleContext(i, DefinitionExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definitionPrefix;
    }
    enterRule(listener) {
      if (listener.enterDefinitionPrefix) {
        listener.enterDefinitionPrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinitionPrefix) {
        listener.exitDefinitionPrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinitionPrefix) {
        return visitor.visitDefinitionPrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    definitionBody() {
      return this.getRuleContext(0, DefinitionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definition;
    }
    enterRule(listener) {
      if (listener.enterDefinition) {
        listener.enterDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinition) {
        listener.exitDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinition) {
        return visitor.visitDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    subclassificationPart() {
      return this.getRuleContext(0, SubclassificationPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definitionDeclaration;
    }
    enterRule(listener) {
      if (listener.enterDefinitionDeclaration) {
        listener.enterDefinitionDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinitionDeclaration) {
        listener.exitDefinitionDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinitionDeclaration) {
        return visitor.visitDefinitionDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    definitionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionBodyItemContext);
      }
      return this.getRuleContext(i, DefinitionBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definitionBody;
    }
    enterRule(listener) {
      if (listener.enterDefinitionBody) {
        listener.enterDefinitionBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinitionBody) {
        listener.exitDefinitionBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinitionBody) {
        return visitor.visitDefinitionBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    importRule() {
      return this.getRuleContext(0, ImportRuleContext);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    definitionBodyItemContent() {
      return this.getRuleContext(0, DefinitionBodyItemContentContext);
    }
    endOccurrenceUsageElement() {
      return this.getRuleContext(0, EndOccurrenceUsageElementContext);
    }
    sourceSuccessionMember() {
      return this.getRuleContext(0, SourceSuccessionMemberContext);
    }
    occurrenceUsageElement() {
      return this.getRuleContext(0, OccurrenceUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definitionBodyItem;
    }
    enterRule(listener) {
      if (listener.enterDefinitionBodyItem) {
        listener.enterDefinitionBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinitionBodyItem) {
        listener.exitDefinitionBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinitionBodyItem) {
        return visitor.visitDefinitionBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionBodyItemContentContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ALIAS() {
      return this.getToken(SysMLv2Parser.ALIAS, 0);
    }
    FOR() {
      return this.getToken(SysMLv2Parser.FOR, 0);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    LT() {
      return this.getToken(SysMLv2Parser.LT, 0);
    }
    name(i) {
      if (i === void 0) {
        return this.getRuleContexts(NameContext);
      }
      return this.getRuleContext(i, NameContext);
    }
    GT() {
      return this.getToken(SysMLv2Parser.GT, 0);
    }
    VARIANT() {
      return this.getToken(SysMLv2Parser.VARIANT, 0);
    }
    variantUsageElement() {
      return this.getRuleContext(0, VariantUsageElementContext);
    }
    definitionElement() {
      return this.getRuleContext(0, DefinitionElementContext);
    }
    nonOccurrenceUsageElement() {
      return this.getRuleContext(0, NonOccurrenceUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definitionBodyItemContent;
    }
    enterRule(listener) {
      if (listener.enterDefinitionBodyItemContent) {
        listener.enterDefinitionBodyItemContent(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinitionBodyItemContent) {
        listener.exitDefinitionBodyItemContent(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinitionBodyItemContent) {
        return visitor.visitDefinitionBodyItemContent(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefinitionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    definitionElement() {
      return this.getRuleContext(0, DefinitionElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_definitionMember;
    }
    enterRule(listener) {
      if (listener.enterDefinitionMember) {
        listener.enterDefinitionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefinitionMember) {
        listener.exitDefinitionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefinitionMember) {
        return visitor.visitDefinitionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var VariantUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    VARIANT() {
      return this.getToken(SysMLv2Parser.VARIANT, 0);
    }
    variantUsageElement() {
      return this.getRuleContext(0, VariantUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_variantUsageMember;
    }
    enterRule(listener) {
      if (listener.enterVariantUsageMember) {
        listener.enterVariantUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitVariantUsageMember) {
        listener.exitVariantUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitVariantUsageMember) {
        return visitor.visitVariantUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NonOccurrenceUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    nonOccurrenceUsageElement() {
      return this.getRuleContext(0, NonOccurrenceUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nonOccurrenceUsageMember;
    }
    enterRule(listener) {
      if (listener.enterNonOccurrenceUsageMember) {
        listener.enterNonOccurrenceUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNonOccurrenceUsageMember) {
        listener.exitNonOccurrenceUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNonOccurrenceUsageMember) {
        return visitor.visitNonOccurrenceUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StructureUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    structureUsageElement() {
      return this.getRuleContext(0, StructureUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_structureUsageMember;
    }
    enterRule(listener) {
      if (listener.enterStructureUsageMember) {
        listener.enterStructureUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStructureUsageMember) {
        listener.exitStructureUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStructureUsageMember) {
        return visitor.visitStructureUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BehaviorUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    behaviorUsageElement() {
      return this.getRuleContext(0, BehaviorUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_behaviorUsageMember;
    }
    enterRule(listener) {
      if (listener.enterBehaviorUsageMember) {
        listener.enterBehaviorUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBehaviorUsageMember) {
        listener.exitBehaviorUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBehaviorUsageMember) {
        return visitor.visitBehaviorUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RefPrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureDirection() {
      return this.getRuleContext(0, FeatureDirectionContext);
    }
    DERIVED() {
      return this.getToken(SysMLv2Parser.DERIVED, 0);
    }
    CONSTANT() {
      return this.getToken(SysMLv2Parser.CONSTANT, 0);
    }
    ABSTRACT() {
      return this.getToken(SysMLv2Parser.ABSTRACT, 0);
    }
    VARIATION() {
      return this.getToken(SysMLv2Parser.VARIATION, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_refPrefix;
    }
    enterRule(listener) {
      if (listener.enterRefPrefix) {
        listener.enterRefPrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRefPrefix) {
        listener.exitRefPrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRefPrefix) {
        return visitor.visitRefPrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BasicUsagePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    refPrefix() {
      return this.getRuleContext(0, RefPrefixContext);
    }
    REF() {
      return this.getToken(SysMLv2Parser.REF, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_basicUsagePrefix;
    }
    enterRule(listener) {
      if (listener.enterBasicUsagePrefix) {
        listener.enterBasicUsagePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBasicUsagePrefix) {
        listener.exitBasicUsagePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBasicUsagePrefix) {
        return visitor.visitBasicUsagePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EndUsagePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    END() {
      return this.getToken(SysMLv2Parser.END, 0);
    }
    ownedCrossFeatureMember() {
      return this.getRuleContext(0, OwnedCrossFeatureMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_endUsagePrefix;
    }
    enterRule(listener) {
      if (listener.enterEndUsagePrefix) {
        listener.enterEndUsagePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEndUsagePrefix) {
        listener.exitEndUsagePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEndUsagePrefix) {
        return visitor.visitEndUsagePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UsageExtensionKeywordContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    prefixMetadataMember() {
      return this.getRuleContext(0, PrefixMetadataMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_usageExtensionKeyword;
    }
    enterRule(listener) {
      if (listener.enterUsageExtensionKeyword) {
        listener.enterUsageExtensionKeyword(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUsageExtensionKeyword) {
        listener.exitUsageExtensionKeyword(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUsageExtensionKeyword) {
        return visitor.visitUsageExtensionKeyword(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UnextendedUsagePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    endUsagePrefix() {
      return this.getRuleContext(0, EndUsagePrefixContext);
    }
    basicUsagePrefix() {
      return this.getRuleContext(0, BasicUsagePrefixContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_unextendedUsagePrefix;
    }
    enterRule(listener) {
      if (listener.enterUnextendedUsagePrefix) {
        listener.enterUnextendedUsagePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUnextendedUsagePrefix) {
        listener.exitUnextendedUsagePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUnextendedUsagePrefix) {
        return visitor.visitUnextendedUsagePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UsagePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    unextendedUsagePrefix() {
      return this.getRuleContext(0, UnextendedUsagePrefixContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_usagePrefix;
    }
    enterRule(listener) {
      if (listener.enterUsagePrefix) {
        listener.enterUsagePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUsagePrefix) {
        listener.exitUsagePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUsagePrefix) {
        return visitor.visitUsagePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageCompletion() {
      return this.getRuleContext(0, UsageCompletionContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_usage;
    }
    enterRule(listener) {
      if (listener.enterUsage) {
        listener.enterUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUsage) {
        listener.exitUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUsage) {
        return visitor.visitUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UsageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_usageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterUsageDeclaration) {
        listener.enterUsageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUsageDeclaration) {
        listener.exitUsageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUsageDeclaration) {
        return visitor.visitUsageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UsageCompletionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_usageCompletion;
    }
    enterRule(listener) {
      if (listener.enterUsageCompletion) {
        listener.enterUsageCompletion(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUsageCompletion) {
        listener.exitUsageCompletion(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUsageCompletion) {
        return visitor.visitUsageCompletion(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UsageBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionBody() {
      return this.getRuleContext(0, DefinitionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_usageBody;
    }
    enterRule(listener) {
      if (listener.enterUsageBody) {
        listener.enterUsageBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUsageBody) {
        listener.exitUsageBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUsageBody) {
        return visitor.visitUsageBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefaultReferenceUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    refPrefix() {
      return this.getRuleContext(0, RefPrefixContext);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_defaultReferenceUsage;
    }
    enterRule(listener) {
      if (listener.enterDefaultReferenceUsage) {
        listener.enterDefaultReferenceUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefaultReferenceUsage) {
        listener.exitDefaultReferenceUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefaultReferenceUsage) {
        return visitor.visitDefaultReferenceUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ReferenceUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    REF() {
      return this.getToken(SysMLv2Parser.REF, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    endUsagePrefix() {
      return this.getRuleContext(0, EndUsagePrefixContext);
    }
    refPrefix() {
      return this.getRuleContext(0, RefPrefixContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_referenceUsage;
    }
    enterRule(listener) {
      if (listener.enterReferenceUsage) {
        listener.enterReferenceUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitReferenceUsage) {
        listener.exitReferenceUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitReferenceUsage) {
        return visitor.visitReferenceUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EndFeatureUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    endUsagePrefix() {
      return this.getRuleContext(0, EndUsagePrefixContext);
    }
    featureDeclaration() {
      return this.getRuleContext(0, FeatureDeclarationContext);
    }
    usageCompletion() {
      return this.getRuleContext(0, UsageCompletionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_endFeatureUsage;
    }
    enterRule(listener) {
      if (listener.enterEndFeatureUsage) {
        listener.enterEndFeatureUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEndFeatureUsage) {
        listener.exitEndFeatureUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEndFeatureUsage) {
        return visitor.visitEndFeatureUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var VariantReferenceContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    featureSpecialization(i) {
      if (i === void 0) {
        return this.getRuleContexts(FeatureSpecializationContext);
      }
      return this.getRuleContext(i, FeatureSpecializationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_variantReference;
    }
    enterRule(listener) {
      if (listener.enterVariantReference) {
        listener.enterVariantReference(this);
      }
    }
    exitRule(listener) {
      if (listener.exitVariantReference) {
        listener.exitVariantReference(this);
      }
    }
    accept(visitor) {
      if (visitor.visitVariantReference) {
        return visitor.visitVariantReference(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NonOccurrenceUsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    referenceUsage() {
      return this.getRuleContext(0, ReferenceUsageContext);
    }
    endFeatureUsage() {
      return this.getRuleContext(0, EndFeatureUsageContext);
    }
    attributeUsage() {
      return this.getRuleContext(0, AttributeUsageContext);
    }
    enumerationUsage() {
      return this.getRuleContext(0, EnumerationUsageContext);
    }
    bindingConnectorAsUsage() {
      return this.getRuleContext(0, BindingConnectorAsUsageContext);
    }
    successionAsUsage() {
      return this.getRuleContext(0, SuccessionAsUsageContext);
    }
    extendedUsage() {
      return this.getRuleContext(0, ExtendedUsageContext);
    }
    defaultReferenceUsage() {
      return this.getRuleContext(0, DefaultReferenceUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nonOccurrenceUsageElement;
    }
    enterRule(listener) {
      if (listener.enterNonOccurrenceUsageElement) {
        listener.enterNonOccurrenceUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNonOccurrenceUsageElement) {
        listener.exitNonOccurrenceUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNonOccurrenceUsageElement) {
        return visitor.visitNonOccurrenceUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EndOccurrenceUsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    END() {
      return this.getToken(SysMLv2Parser.END, 0);
    }
    occurrenceUsageElement() {
      return this.getRuleContext(0, OccurrenceUsageElementContext);
    }
    name() {
      return this.getRuleContext(0, NameContext);
    }
    ownedCrossMultiplicityMember() {
      return this.getRuleContext(0, OwnedCrossMultiplicityMemberContext);
    }
    NONUNIQUE() {
      return this.getToken(SysMLv2Parser.NONUNIQUE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_endOccurrenceUsageElement;
    }
    enterRule(listener) {
      if (listener.enterEndOccurrenceUsageElement) {
        listener.enterEndOccurrenceUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEndOccurrenceUsageElement) {
        listener.exitEndOccurrenceUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEndOccurrenceUsageElement) {
        return visitor.visitEndOccurrenceUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OccurrenceUsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    structureUsageElement() {
      return this.getRuleContext(0, StructureUsageElementContext);
    }
    behaviorUsageElement() {
      return this.getRuleContext(0, BehaviorUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_occurrenceUsageElement;
    }
    enterRule(listener) {
      if (listener.enterOccurrenceUsageElement) {
        listener.enterOccurrenceUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOccurrenceUsageElement) {
        listener.exitOccurrenceUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOccurrenceUsageElement) {
        return visitor.visitOccurrenceUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StructureUsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsage() {
      return this.getRuleContext(0, OccurrenceUsageContext);
    }
    individualUsage() {
      return this.getRuleContext(0, IndividualUsageContext);
    }
    portionUsage() {
      return this.getRuleContext(0, PortionUsageContext);
    }
    eventOccurrenceUsage() {
      return this.getRuleContext(0, EventOccurrenceUsageContext);
    }
    itemUsage() {
      return this.getRuleContext(0, ItemUsageContext);
    }
    partUsage() {
      return this.getRuleContext(0, PartUsageContext);
    }
    viewUsage() {
      return this.getRuleContext(0, ViewUsageContext);
    }
    renderingUsage() {
      return this.getRuleContext(0, RenderingUsageContext);
    }
    portUsage() {
      return this.getRuleContext(0, PortUsageContext);
    }
    connectionUsage() {
      return this.getRuleContext(0, ConnectionUsageContext);
    }
    interfaceUsage() {
      return this.getRuleContext(0, InterfaceUsageContext);
    }
    allocationUsage() {
      return this.getRuleContext(0, AllocationUsageContext);
    }
    message() {
      return this.getRuleContext(0, MessageContext);
    }
    flowUsage() {
      return this.getRuleContext(0, FlowUsageContext);
    }
    successionFlowUsage() {
      return this.getRuleContext(0, SuccessionFlowUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_structureUsageElement;
    }
    enterRule(listener) {
      if (listener.enterStructureUsageElement) {
        listener.enterStructureUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStructureUsageElement) {
        listener.exitStructureUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStructureUsageElement) {
        return visitor.visitStructureUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BehaviorUsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    actionUsage() {
      return this.getRuleContext(0, ActionUsageContext);
    }
    calculationUsage() {
      return this.getRuleContext(0, CalculationUsageContext);
    }
    stateUsage() {
      return this.getRuleContext(0, StateUsageContext);
    }
    constraintUsage() {
      return this.getRuleContext(0, ConstraintUsageContext);
    }
    requirementUsage() {
      return this.getRuleContext(0, RequirementUsageContext);
    }
    concernUsage() {
      return this.getRuleContext(0, ConcernUsageContext);
    }
    caseUsage() {
      return this.getRuleContext(0, CaseUsageContext);
    }
    analysisCaseUsage() {
      return this.getRuleContext(0, AnalysisCaseUsageContext);
    }
    verificationCaseUsage() {
      return this.getRuleContext(0, VerificationCaseUsageContext);
    }
    useCaseUsage() {
      return this.getRuleContext(0, UseCaseUsageContext);
    }
    viewpointUsage() {
      return this.getRuleContext(0, ViewpointUsageContext);
    }
    performActionUsage() {
      return this.getRuleContext(0, PerformActionUsageContext);
    }
    exhibitStateUsage() {
      return this.getRuleContext(0, ExhibitStateUsageContext);
    }
    includeUseCaseUsage() {
      return this.getRuleContext(0, IncludeUseCaseUsageContext);
    }
    assertConstraintUsage() {
      return this.getRuleContext(0, AssertConstraintUsageContext);
    }
    satisfyRequirementUsage() {
      return this.getRuleContext(0, SatisfyRequirementUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_behaviorUsageElement;
    }
    enterRule(listener) {
      if (listener.enterBehaviorUsageElement) {
        listener.enterBehaviorUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBehaviorUsageElement) {
        listener.exitBehaviorUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBehaviorUsageElement) {
        return visitor.visitBehaviorUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var VariantUsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    variantReference() {
      return this.getRuleContext(0, VariantReferenceContext);
    }
    referenceUsage() {
      return this.getRuleContext(0, ReferenceUsageContext);
    }
    attributeUsage() {
      return this.getRuleContext(0, AttributeUsageContext);
    }
    bindingConnectorAsUsage() {
      return this.getRuleContext(0, BindingConnectorAsUsageContext);
    }
    successionAsUsage() {
      return this.getRuleContext(0, SuccessionAsUsageContext);
    }
    occurrenceUsage() {
      return this.getRuleContext(0, OccurrenceUsageContext);
    }
    individualUsage() {
      return this.getRuleContext(0, IndividualUsageContext);
    }
    portionUsage() {
      return this.getRuleContext(0, PortionUsageContext);
    }
    eventOccurrenceUsage() {
      return this.getRuleContext(0, EventOccurrenceUsageContext);
    }
    itemUsage() {
      return this.getRuleContext(0, ItemUsageContext);
    }
    partUsage() {
      return this.getRuleContext(0, PartUsageContext);
    }
    viewUsage() {
      return this.getRuleContext(0, ViewUsageContext);
    }
    renderingUsage() {
      return this.getRuleContext(0, RenderingUsageContext);
    }
    portUsage() {
      return this.getRuleContext(0, PortUsageContext);
    }
    connectionUsage() {
      return this.getRuleContext(0, ConnectionUsageContext);
    }
    interfaceUsage() {
      return this.getRuleContext(0, InterfaceUsageContext);
    }
    allocationUsage() {
      return this.getRuleContext(0, AllocationUsageContext);
    }
    message() {
      return this.getRuleContext(0, MessageContext);
    }
    flowUsage() {
      return this.getRuleContext(0, FlowUsageContext);
    }
    successionFlowUsage() {
      return this.getRuleContext(0, SuccessionFlowUsageContext);
    }
    behaviorUsageElement() {
      return this.getRuleContext(0, BehaviorUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_variantUsageElement;
    }
    enterRule(listener) {
      if (listener.enterVariantUsageElement) {
        listener.enterVariantUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitVariantUsageElement) {
        listener.exitVariantUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitVariantUsageElement) {
        return visitor.visitVariantUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SubclassificationPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedSubclassification(i) {
      if (i === void 0) {
        return this.getRuleContexts(OwnedSubclassificationContext);
      }
      return this.getRuleContext(i, OwnedSubclassificationContext);
    }
    COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT, 0);
    }
    SPECIALIZES() {
      return this.getToken(SysMLv2Parser.SPECIALIZES, 0);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_subclassificationPart;
    }
    enterRule(listener) {
      if (listener.enterSubclassificationPart) {
        listener.enterSubclassificationPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSubclassificationPart) {
        listener.exitSubclassificationPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSubclassificationPart) {
        return visitor.visitSubclassificationPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AttributeDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionPrefix() {
      return this.getRuleContext(0, DefinitionPrefixContext);
    }
    ATTRIBUTE() {
      return this.getToken(SysMLv2Parser.ATTRIBUTE, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_attributeDefinition;
    }
    enterRule(listener) {
      if (listener.enterAttributeDefinition) {
        listener.enterAttributeDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAttributeDefinition) {
        listener.exitAttributeDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAttributeDefinition) {
        return visitor.visitAttributeDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AttributeUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usagePrefix() {
      return this.getRuleContext(0, UsagePrefixContext);
    }
    ATTRIBUTE() {
      return this.getToken(SysMLv2Parser.ATTRIBUTE, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_attributeUsage;
    }
    enterRule(listener) {
      if (listener.enterAttributeUsage) {
        listener.enterAttributeUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAttributeUsage) {
        listener.exitAttributeUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAttributeUsage) {
        return visitor.visitAttributeUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EnumerationDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ENUM() {
      return this.getToken(SysMLv2Parser.ENUM, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    enumerationBody() {
      return this.getRuleContext(0, EnumerationBodyContext);
    }
    definitionExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionExtensionKeywordContext);
      }
      return this.getRuleContext(i, DefinitionExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_enumerationDefinition;
    }
    enterRule(listener) {
      if (listener.enterEnumerationDefinition) {
        listener.enterEnumerationDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEnumerationDefinition) {
        listener.exitEnumerationDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEnumerationDefinition) {
        return visitor.visitEnumerationDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EnumerationBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    annotatingMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(AnnotatingMemberContext);
      }
      return this.getRuleContext(i, AnnotatingMemberContext);
    }
    enumerationUsageMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(EnumerationUsageMemberContext);
      }
      return this.getRuleContext(i, EnumerationUsageMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_enumerationBody;
    }
    enterRule(listener) {
      if (listener.enterEnumerationBody) {
        listener.enterEnumerationBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEnumerationBody) {
        listener.exitEnumerationBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEnumerationBody) {
        return visitor.visitEnumerationBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EnumerationUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    enumeratedValue() {
      return this.getRuleContext(0, EnumeratedValueContext);
    }
    prefixMetadataMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(PrefixMetadataMemberContext);
      }
      return this.getRuleContext(i, PrefixMetadataMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_enumerationUsageMember;
    }
    enterRule(listener) {
      if (listener.enterEnumerationUsageMember) {
        listener.enterEnumerationUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEnumerationUsageMember) {
        listener.exitEnumerationUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEnumerationUsageMember) {
        return visitor.visitEnumerationUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EnumeratedValueContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    ENUM() {
      return this.getToken(SysMLv2Parser.ENUM, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_enumeratedValue;
    }
    enterRule(listener) {
      if (listener.enterEnumeratedValue) {
        listener.enterEnumeratedValue(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEnumeratedValue) {
        listener.exitEnumeratedValue(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEnumeratedValue) {
        return visitor.visitEnumeratedValue(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EnumerationUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usagePrefix() {
      return this.getRuleContext(0, UsagePrefixContext);
    }
    ENUM() {
      return this.getToken(SysMLv2Parser.ENUM, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_enumerationUsage;
    }
    enterRule(listener) {
      if (listener.enterEnumerationUsage) {
        listener.enterEnumerationUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEnumerationUsage) {
        listener.exitEnumerationUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEnumerationUsage) {
        return visitor.visitEnumerationUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OccurrenceDefinitionPrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    basicDefinitionPrefix() {
      return this.getRuleContext(0, BasicDefinitionPrefixContext);
    }
    INDIVIDUAL() {
      return this.getToken(SysMLv2Parser.INDIVIDUAL, 0);
    }
    emptyMultiplicityMember() {
      return this.getRuleContext(0, EmptyMultiplicityMemberContext);
    }
    definitionExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionExtensionKeywordContext);
      }
      return this.getRuleContext(i, DefinitionExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_occurrenceDefinitionPrefix;
    }
    enterRule(listener) {
      if (listener.enterOccurrenceDefinitionPrefix) {
        listener.enterOccurrenceDefinitionPrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOccurrenceDefinitionPrefix) {
        listener.exitOccurrenceDefinitionPrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOccurrenceDefinitionPrefix) {
        return visitor.visitOccurrenceDefinitionPrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OccurrenceDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    OCCURRENCE() {
      return this.getToken(SysMLv2Parser.OCCURRENCE, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_occurrenceDefinition;
    }
    enterRule(listener) {
      if (listener.enterOccurrenceDefinition) {
        listener.enterOccurrenceDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOccurrenceDefinition) {
        listener.exitOccurrenceDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOccurrenceDefinition) {
        return visitor.visitOccurrenceDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var IndividualDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    INDIVIDUAL() {
      return this.getToken(SysMLv2Parser.INDIVIDUAL, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    emptyMultiplicityMember() {
      return this.getRuleContext(0, EmptyMultiplicityMemberContext);
    }
    basicDefinitionPrefix() {
      return this.getRuleContext(0, BasicDefinitionPrefixContext);
    }
    definitionExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionExtensionKeywordContext);
      }
      return this.getRuleContext(i, DefinitionExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_individualDefinition;
    }
    enterRule(listener) {
      if (listener.enterIndividualDefinition) {
        listener.enterIndividualDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitIndividualDefinition) {
        listener.exitIndividualDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitIndividualDefinition) {
        return visitor.visitIndividualDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EmptyMultiplicityMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    emptyMultiplicity_() {
      return this.getRuleContext(0, EmptyMultiplicity_Context);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_emptyMultiplicityMember;
    }
    enterRule(listener) {
      if (listener.enterEmptyMultiplicityMember) {
        listener.enterEmptyMultiplicityMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEmptyMultiplicityMember) {
        listener.exitEmptyMultiplicityMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEmptyMultiplicityMember) {
        return visitor.visitEmptyMultiplicityMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OccurrenceUsagePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    basicUsagePrefix() {
      return this.getRuleContext(0, BasicUsagePrefixContext);
    }
    INDIVIDUAL() {
      return this.getToken(SysMLv2Parser.INDIVIDUAL, 0);
    }
    portionKind() {
      return this.getRuleContext(0, PortionKindContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_occurrenceUsagePrefix;
    }
    enterRule(listener) {
      if (listener.enterOccurrenceUsagePrefix) {
        listener.enterOccurrenceUsagePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOccurrenceUsagePrefix) {
        listener.exitOccurrenceUsagePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOccurrenceUsagePrefix) {
        return visitor.visitOccurrenceUsagePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var OccurrenceUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    OCCURRENCE() {
      return this.getToken(SysMLv2Parser.OCCURRENCE, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_occurrenceUsage;
    }
    enterRule(listener) {
      if (listener.enterOccurrenceUsage) {
        listener.enterOccurrenceUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitOccurrenceUsage) {
        listener.exitOccurrenceUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitOccurrenceUsage) {
        return visitor.visitOccurrenceUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var IndividualUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    basicUsagePrefix() {
      return this.getRuleContext(0, BasicUsagePrefixContext);
    }
    INDIVIDUAL() {
      return this.getToken(SysMLv2Parser.INDIVIDUAL, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_individualUsage;
    }
    enterRule(listener) {
      if (listener.enterIndividualUsage) {
        listener.enterIndividualUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitIndividualUsage) {
        listener.exitIndividualUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitIndividualUsage) {
        return visitor.visitIndividualUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PortionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    basicUsagePrefix() {
      return this.getRuleContext(0, BasicUsagePrefixContext);
    }
    portionKind() {
      return this.getRuleContext(0, PortionKindContext);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    INDIVIDUAL() {
      return this.getToken(SysMLv2Parser.INDIVIDUAL, 0);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_portionUsage;
    }
    enterRule(listener) {
      if (listener.enterPortionUsage) {
        listener.enterPortionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPortionUsage) {
        listener.exitPortionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPortionUsage) {
        return visitor.visitPortionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PortionKindContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SNAPSHOT() {
      return this.getToken(SysMLv2Parser.SNAPSHOT, 0);
    }
    TIMESLICE() {
      return this.getToken(SysMLv2Parser.TIMESLICE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_portionKind;
    }
    enterRule(listener) {
      if (listener.enterPortionKind) {
        listener.enterPortionKind(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPortionKind) {
        listener.exitPortionKind(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPortionKind) {
        return visitor.visitPortionKind(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EventOccurrenceUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    EVENT() {
      return this.getToken(SysMLv2Parser.EVENT, 0);
    }
    usageCompletion() {
      return this.getRuleContext(0, UsageCompletionContext);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    OCCURRENCE() {
      return this.getToken(SysMLv2Parser.OCCURRENCE, 0);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_eventOccurrenceUsage;
    }
    enterRule(listener) {
      if (listener.enterEventOccurrenceUsage) {
        listener.enterEventOccurrenceUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEventOccurrenceUsage) {
        listener.exitEventOccurrenceUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEventOccurrenceUsage) {
        return visitor.visitEventOccurrenceUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SourceSuccessionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    sourceSuccession() {
      return this.getRuleContext(0, SourceSuccessionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_sourceSuccessionMember;
    }
    enterRule(listener) {
      if (listener.enterSourceSuccessionMember) {
        listener.enterSourceSuccessionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSourceSuccessionMember) {
        listener.exitSourceSuccessionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSourceSuccessionMember) {
        return visitor.visitSourceSuccessionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SourceSuccessionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    sourceEndMember() {
      return this.getRuleContext(0, SourceEndMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_sourceSuccession;
    }
    enterRule(listener) {
      if (listener.enterSourceSuccession) {
        listener.enterSourceSuccession(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSourceSuccession) {
        listener.exitSourceSuccession(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSourceSuccession) {
        return visitor.visitSourceSuccession(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SourceEndMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    sourceEnd() {
      return this.getRuleContext(0, SourceEndContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_sourceEndMember;
    }
    enterRule(listener) {
      if (listener.enterSourceEndMember) {
        listener.enterSourceEndMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSourceEndMember) {
        listener.exitSourceEndMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSourceEndMember) {
        return visitor.visitSourceEndMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SourceEndContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedMultiplicity() {
      return this.getRuleContext(0, OwnedMultiplicityContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_sourceEnd;
    }
    enterRule(listener) {
      if (listener.enterSourceEnd) {
        listener.enterSourceEnd(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSourceEnd) {
        listener.exitSourceEnd(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSourceEnd) {
        return visitor.visitSourceEnd(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ItemDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    ITEM() {
      return this.getToken(SysMLv2Parser.ITEM, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_itemDefinition;
    }
    enterRule(listener) {
      if (listener.enterItemDefinition) {
        listener.enterItemDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitItemDefinition) {
        listener.exitItemDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitItemDefinition) {
        return visitor.visitItemDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ItemUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    ITEM() {
      return this.getToken(SysMLv2Parser.ITEM, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_itemUsage;
    }
    enterRule(listener) {
      if (listener.enterItemUsage) {
        listener.enterItemUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitItemUsage) {
        listener.exitItemUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitItemUsage) {
        return visitor.visitItemUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PartDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    PART() {
      return this.getToken(SysMLv2Parser.PART, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_partDefinition;
    }
    enterRule(listener) {
      if (listener.enterPartDefinition) {
        listener.enterPartDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPartDefinition) {
        listener.exitPartDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPartDefinition) {
        return visitor.visitPartDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PartUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    PART() {
      return this.getToken(SysMLv2Parser.PART, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_partUsage;
    }
    enterRule(listener) {
      if (listener.enterPartUsage) {
        listener.enterPartUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPartUsage) {
        listener.exitPartUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPartUsage) {
        return visitor.visitPartUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PortDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionPrefix() {
      return this.getRuleContext(0, DefinitionPrefixContext);
    }
    PORT() {
      return this.getToken(SysMLv2Parser.PORT, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    conjugatedPortDefinitionMember() {
      return this.getRuleContext(0, ConjugatedPortDefinitionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_portDefinition;
    }
    enterRule(listener) {
      if (listener.enterPortDefinition) {
        listener.enterPortDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPortDefinition) {
        listener.exitPortDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPortDefinition) {
        return visitor.visitPortDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConjugatedPortDefinitionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    conjugatedPortDefinition() {
      return this.getRuleContext(0, ConjugatedPortDefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_conjugatedPortDefinitionMember;
    }
    enterRule(listener) {
      if (listener.enterConjugatedPortDefinitionMember) {
        listener.enterConjugatedPortDefinitionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConjugatedPortDefinitionMember) {
        listener.exitConjugatedPortDefinitionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConjugatedPortDefinitionMember) {
        return visitor.visitConjugatedPortDefinitionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConjugatedPortDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    portConjugation() {
      return this.getRuleContext(0, PortConjugationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_conjugatedPortDefinition;
    }
    enterRule(listener) {
      if (listener.enterConjugatedPortDefinition) {
        listener.enterConjugatedPortDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConjugatedPortDefinition) {
        listener.exitConjugatedPortDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConjugatedPortDefinition) {
        return visitor.visitConjugatedPortDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PortUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    PORT() {
      return this.getToken(SysMLv2Parser.PORT, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_portUsage;
    }
    enterRule(listener) {
      if (listener.enterPortUsage) {
        listener.enterPortUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPortUsage) {
        listener.exitPortUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPortUsage) {
        return visitor.visitPortUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConjugatedPortTypingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    TILDE() {
      return this.getToken(SysMLv2Parser.TILDE, 0);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_conjugatedPortTyping;
    }
    enterRule(listener) {
      if (listener.enterConjugatedPortTyping) {
        listener.enterConjugatedPortTyping(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConjugatedPortTyping) {
        listener.exitConjugatedPortTyping(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConjugatedPortTyping) {
        return visitor.visitConjugatedPortTyping(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConnectionDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    CONNECTION() {
      return this.getToken(SysMLv2Parser.CONNECTION, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_connectionDefinition;
    }
    enterRule(listener) {
      if (listener.enterConnectionDefinition) {
        listener.enterConnectionDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConnectionDefinition) {
        listener.exitConnectionDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConnectionDefinition) {
        return visitor.visitConnectionDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConnectionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    CONNECTION() {
      return this.getToken(SysMLv2Parser.CONNECTION, 0);
    }
    CONNECT() {
      return this.getToken(SysMLv2Parser.CONNECT, 0);
    }
    connectorPart() {
      return this.getRuleContext(0, ConnectorPartContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_connectionUsage;
    }
    enterRule(listener) {
      if (listener.enterConnectionUsage) {
        listener.enterConnectionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConnectionUsage) {
        listener.exitConnectionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConnectionUsage) {
        return visitor.visitConnectionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConnectorPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    binaryConnectorPart() {
      return this.getRuleContext(0, BinaryConnectorPartContext);
    }
    naryConnectorPart() {
      return this.getRuleContext(0, NaryConnectorPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_connectorPart;
    }
    enterRule(listener) {
      if (listener.enterConnectorPart) {
        listener.enterConnectorPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConnectorPart) {
        listener.exitConnectorPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConnectorPart) {
        return visitor.visitConnectorPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BinaryConnectorPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    connectorEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConnectorEndMemberContext);
      }
      return this.getRuleContext(i, ConnectorEndMemberContext);
    }
    TO() {
      return this.getToken(SysMLv2Parser.TO, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_binaryConnectorPart;
    }
    enterRule(listener) {
      if (listener.enterBinaryConnectorPart) {
        listener.enterBinaryConnectorPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBinaryConnectorPart) {
        listener.exitBinaryConnectorPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBinaryConnectorPart) {
        return visitor.visitBinaryConnectorPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NaryConnectorPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LPAREN() {
      return this.getToken(SysMLv2Parser.LPAREN, 0);
    }
    connectorEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConnectorEndMemberContext);
      }
      return this.getRuleContext(i, ConnectorEndMemberContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    RPAREN() {
      return this.getToken(SysMLv2Parser.RPAREN, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_naryConnectorPart;
    }
    enterRule(listener) {
      if (listener.enterNaryConnectorPart) {
        listener.enterNaryConnectorPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNaryConnectorPart) {
        listener.exitNaryConnectorPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNaryConnectorPart) {
        return visitor.visitNaryConnectorPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BindingConnectorAsUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usagePrefix() {
      return this.getRuleContext(0, UsagePrefixContext);
    }
    BIND() {
      return this.getToken(SysMLv2Parser.BIND, 0);
    }
    connectorEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConnectorEndMemberContext);
      }
      return this.getRuleContext(i, ConnectorEndMemberContext);
    }
    EQ() {
      return this.getToken(SysMLv2Parser.EQ, 0);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    BINDING() {
      return this.getToken(SysMLv2Parser.BINDING, 0);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_bindingConnectorAsUsage;
    }
    enterRule(listener) {
      if (listener.enterBindingConnectorAsUsage) {
        listener.enterBindingConnectorAsUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBindingConnectorAsUsage) {
        listener.exitBindingConnectorAsUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBindingConnectorAsUsage) {
        return visitor.visitBindingConnectorAsUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SuccessionAsUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usagePrefix() {
      return this.getRuleContext(0, UsagePrefixContext);
    }
    FIRST() {
      return this.getToken(SysMLv2Parser.FIRST, 0);
    }
    connectorEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ConnectorEndMemberContext);
      }
      return this.getRuleContext(i, ConnectorEndMemberContext);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    SUCCESSION() {
      return this.getToken(SysMLv2Parser.SUCCESSION, 0);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_successionAsUsage;
    }
    enterRule(listener) {
      if (listener.enterSuccessionAsUsage) {
        listener.enterSuccessionAsUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSuccessionAsUsage) {
        listener.exitSuccessionAsUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSuccessionAsUsage) {
        return visitor.visitSuccessionAsUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    INTERFACE() {
      return this.getToken(SysMLv2Parser.INTERFACE, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    interfaceBody() {
      return this.getRuleContext(0, InterfaceBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceDefinition;
    }
    enterRule(listener) {
      if (listener.enterInterfaceDefinition) {
        listener.enterInterfaceDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceDefinition) {
        listener.exitInterfaceDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceDefinition) {
        return visitor.visitInterfaceDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    interfaceBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(InterfaceBodyItemContext);
      }
      return this.getRuleContext(i, InterfaceBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceBody;
    }
    enterRule(listener) {
      if (listener.enterInterfaceBody) {
        listener.enterInterfaceBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceBody) {
        listener.exitInterfaceBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceBody) {
        return visitor.visitInterfaceBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionMember() {
      return this.getRuleContext(0, DefinitionMemberContext);
    }
    variantUsageMember() {
      return this.getRuleContext(0, VariantUsageMemberContext);
    }
    interfaceNonOccurrenceUsageMember() {
      return this.getRuleContext(0, InterfaceNonOccurrenceUsageMemberContext);
    }
    interfaceOccurrenceUsageMember() {
      return this.getRuleContext(0, InterfaceOccurrenceUsageMemberContext);
    }
    sourceSuccessionMember() {
      return this.getRuleContext(0, SourceSuccessionMemberContext);
    }
    aliasMember() {
      return this.getRuleContext(0, AliasMemberContext);
    }
    importRule() {
      return this.getRuleContext(0, ImportRuleContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceBodyItem;
    }
    enterRule(listener) {
      if (listener.enterInterfaceBodyItem) {
        listener.enterInterfaceBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceBodyItem) {
        listener.exitInterfaceBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceBodyItem) {
        return visitor.visitInterfaceBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceNonOccurrenceUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    interfaceNonOccurrenceUsageElement() {
      return this.getRuleContext(0, InterfaceNonOccurrenceUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceNonOccurrenceUsageMember;
    }
    enterRule(listener) {
      if (listener.enterInterfaceNonOccurrenceUsageMember) {
        listener.enterInterfaceNonOccurrenceUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceNonOccurrenceUsageMember) {
        listener.exitInterfaceNonOccurrenceUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceNonOccurrenceUsageMember) {
        return visitor.visitInterfaceNonOccurrenceUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceNonOccurrenceUsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    referenceUsage() {
      return this.getRuleContext(0, ReferenceUsageContext);
    }
    attributeUsage() {
      return this.getRuleContext(0, AttributeUsageContext);
    }
    enumerationUsage() {
      return this.getRuleContext(0, EnumerationUsageContext);
    }
    bindingConnectorAsUsage() {
      return this.getRuleContext(0, BindingConnectorAsUsageContext);
    }
    successionAsUsage() {
      return this.getRuleContext(0, SuccessionAsUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceNonOccurrenceUsageElement;
    }
    enterRule(listener) {
      if (listener.enterInterfaceNonOccurrenceUsageElement) {
        listener.enterInterfaceNonOccurrenceUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceNonOccurrenceUsageElement) {
        listener.exitInterfaceNonOccurrenceUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceNonOccurrenceUsageElement) {
        return visitor.visitInterfaceNonOccurrenceUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceOccurrenceUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    interfaceOccurrenceUsageElement() {
      return this.getRuleContext(0, InterfaceOccurrenceUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceOccurrenceUsageMember;
    }
    enterRule(listener) {
      if (listener.enterInterfaceOccurrenceUsageMember) {
        listener.enterInterfaceOccurrenceUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceOccurrenceUsageMember) {
        listener.exitInterfaceOccurrenceUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceOccurrenceUsageMember) {
        return visitor.visitInterfaceOccurrenceUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceOccurrenceUsageElementContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    defaultInterfaceEnd() {
      return this.getRuleContext(0, DefaultInterfaceEndContext);
    }
    endOccurrenceUsageElement() {
      return this.getRuleContext(0, EndOccurrenceUsageElementContext);
    }
    structureUsageElement() {
      return this.getRuleContext(0, StructureUsageElementContext);
    }
    behaviorUsageElement() {
      return this.getRuleContext(0, BehaviorUsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceOccurrenceUsageElement;
    }
    enterRule(listener) {
      if (listener.enterInterfaceOccurrenceUsageElement) {
        listener.enterInterfaceOccurrenceUsageElement(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceOccurrenceUsageElement) {
        listener.exitInterfaceOccurrenceUsageElement(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceOccurrenceUsageElement) {
        return visitor.visitInterfaceOccurrenceUsageElement(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefaultInterfaceEndContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    END() {
      return this.getToken(SysMLv2Parser.END, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_defaultInterfaceEnd;
    }
    enterRule(listener) {
      if (listener.enterDefaultInterfaceEnd) {
        listener.enterDefaultInterfaceEnd(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefaultInterfaceEnd) {
        listener.exitDefaultInterfaceEnd(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefaultInterfaceEnd) {
        return visitor.visitDefaultInterfaceEnd(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    INTERFACE() {
      return this.getToken(SysMLv2Parser.INTERFACE, 0);
    }
    interfaceUsageDeclaration() {
      return this.getRuleContext(0, InterfaceUsageDeclarationContext);
    }
    interfaceBody() {
      return this.getRuleContext(0, InterfaceBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceUsage;
    }
    enterRule(listener) {
      if (listener.enterInterfaceUsage) {
        listener.enterInterfaceUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceUsage) {
        listener.exitInterfaceUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceUsage) {
        return visitor.visitInterfaceUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceUsageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    CONNECT() {
      return this.getToken(SysMLv2Parser.CONNECT, 0);
    }
    interfacePart() {
      return this.getRuleContext(0, InterfacePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceUsageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterInterfaceUsageDeclaration) {
        listener.enterInterfaceUsageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceUsageDeclaration) {
        listener.exitInterfaceUsageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceUsageDeclaration) {
        return visitor.visitInterfaceUsageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfacePartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    binaryInterfacePart() {
      return this.getRuleContext(0, BinaryInterfacePartContext);
    }
    naryInterfacePart() {
      return this.getRuleContext(0, NaryInterfacePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfacePart;
    }
    enterRule(listener) {
      if (listener.enterInterfacePart) {
        listener.enterInterfacePart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfacePart) {
        listener.exitInterfacePart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfacePart) {
        return visitor.visitInterfacePart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var BinaryInterfacePartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    interfaceEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(InterfaceEndMemberContext);
      }
      return this.getRuleContext(i, InterfaceEndMemberContext);
    }
    TO() {
      return this.getToken(SysMLv2Parser.TO, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_binaryInterfacePart;
    }
    enterRule(listener) {
      if (listener.enterBinaryInterfacePart) {
        listener.enterBinaryInterfacePart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitBinaryInterfacePart) {
        listener.exitBinaryInterfacePart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitBinaryInterfacePart) {
        return visitor.visitBinaryInterfacePart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NaryInterfacePartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LPAREN() {
      return this.getToken(SysMLv2Parser.LPAREN, 0);
    }
    interfaceEndMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(InterfaceEndMemberContext);
      }
      return this.getRuleContext(i, InterfaceEndMemberContext);
    }
    COMMA(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COMMA);
      } else {
        return this.getToken(SysMLv2Parser.COMMA, i);
      }
    }
    RPAREN() {
      return this.getToken(SysMLv2Parser.RPAREN, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_naryInterfacePart;
    }
    enterRule(listener) {
      if (listener.enterNaryInterfacePart) {
        listener.enterNaryInterfacePart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNaryInterfacePart) {
        listener.exitNaryInterfacePart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNaryInterfacePart) {
        return visitor.visitNaryInterfacePart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceEndMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    interfaceEnd() {
      return this.getRuleContext(0, InterfaceEndContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceEndMember;
    }
    enterRule(listener) {
      if (listener.enterInterfaceEndMember) {
        listener.enterInterfaceEndMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceEndMember) {
        listener.exitInterfaceEndMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceEndMember) {
        return visitor.visitInterfaceEndMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InterfaceEndContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    ownedCrossMultiplicityMember() {
      return this.getRuleContext(0, OwnedCrossMultiplicityMemberContext);
    }
    name() {
      return this.getRuleContext(0, NameContext);
    }
    COLON_COLON_GT() {
      return this.getToken(SysMLv2Parser.COLON_COLON_GT, 0);
    }
    REFERENCES() {
      return this.getToken(SysMLv2Parser.REFERENCES, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_interfaceEnd;
    }
    enterRule(listener) {
      if (listener.enterInterfaceEnd) {
        listener.enterInterfaceEnd(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInterfaceEnd) {
        listener.exitInterfaceEnd(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInterfaceEnd) {
        return visitor.visitInterfaceEnd(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AllocationDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    ALLOCATION() {
      return this.getToken(SysMLv2Parser.ALLOCATION, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_allocationDefinition;
    }
    enterRule(listener) {
      if (listener.enterAllocationDefinition) {
        listener.enterAllocationDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAllocationDefinition) {
        listener.exitAllocationDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAllocationDefinition) {
        return visitor.visitAllocationDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AllocationUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    allocationUsageDeclaration() {
      return this.getRuleContext(0, AllocationUsageDeclarationContext);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_allocationUsage;
    }
    enterRule(listener) {
      if (listener.enterAllocationUsage) {
        listener.enterAllocationUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAllocationUsage) {
        listener.exitAllocationUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAllocationUsage) {
        return visitor.visitAllocationUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AllocationUsageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ALLOCATION() {
      return this.getToken(SysMLv2Parser.ALLOCATION, 0);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    ALLOCATE() {
      return this.getToken(SysMLv2Parser.ALLOCATE, 0);
    }
    connectorPart() {
      return this.getRuleContext(0, ConnectorPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_allocationUsageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterAllocationUsageDeclaration) {
        listener.enterAllocationUsageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAllocationUsageDeclaration) {
        listener.exitAllocationUsageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAllocationUsageDeclaration) {
        return visitor.visitAllocationUsageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FlowDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    FLOW() {
      return this.getToken(SysMLv2Parser.FLOW, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_flowDefinition;
    }
    enterRule(listener) {
      if (listener.enterFlowDefinition) {
        listener.enterFlowDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFlowDefinition) {
        listener.exitFlowDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFlowDefinition) {
        return visitor.visitFlowDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MessageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    MESSAGE() {
      return this.getToken(SysMLv2Parser.MESSAGE, 0);
    }
    messageDeclaration() {
      return this.getRuleContext(0, MessageDeclarationContext);
    }
    definitionBody() {
      return this.getRuleContext(0, DefinitionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_message;
    }
    enterRule(listener) {
      if (listener.enterMessage) {
        listener.enterMessage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMessage) {
        listener.exitMessage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMessage) {
        return visitor.visitMessage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MessageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    OF() {
      return this.getToken(SysMLv2Parser.OF, 0);
    }
    flowPayloadFeatureMember() {
      return this.getRuleContext(0, FlowPayloadFeatureMemberContext);
    }
    FROM() {
      return this.getToken(SysMLv2Parser.FROM, 0);
    }
    messageEventMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(MessageEventMemberContext);
      }
      return this.getRuleContext(i, MessageEventMemberContext);
    }
    TO() {
      return this.getToken(SysMLv2Parser.TO, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_messageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterMessageDeclaration) {
        listener.enterMessageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMessageDeclaration) {
        listener.exitMessageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMessageDeclaration) {
        return visitor.visitMessageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MessageEventMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    messageEvent() {
      return this.getRuleContext(0, MessageEventContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_messageEventMember;
    }
    enterRule(listener) {
      if (listener.enterMessageEventMember) {
        listener.enterMessageEventMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMessageEventMember) {
        listener.exitMessageEventMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMessageEventMember) {
        return visitor.visitMessageEventMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MessageEventContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_messageEvent;
    }
    enterRule(listener) {
      if (listener.enterMessageEvent) {
        listener.enterMessageEvent(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMessageEvent) {
        listener.exitMessageEvent(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMessageEvent) {
        return visitor.visitMessageEvent(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FlowUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    FLOW() {
      return this.getToken(SysMLv2Parser.FLOW, 0);
    }
    flowDeclaration() {
      return this.getRuleContext(0, FlowDeclarationContext);
    }
    definitionBody() {
      return this.getRuleContext(0, DefinitionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_flowUsage;
    }
    enterRule(listener) {
      if (listener.enterFlowUsage) {
        listener.enterFlowUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFlowUsage) {
        listener.exitFlowUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFlowUsage) {
        return visitor.visitFlowUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SuccessionFlowUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    SUCCESSION() {
      return this.getToken(SysMLv2Parser.SUCCESSION, 0);
    }
    FLOW() {
      return this.getToken(SysMLv2Parser.FLOW, 0);
    }
    flowDeclaration() {
      return this.getRuleContext(0, FlowDeclarationContext);
    }
    definitionBody() {
      return this.getRuleContext(0, DefinitionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_successionFlowUsage;
    }
    enterRule(listener) {
      if (listener.enterSuccessionFlowUsage) {
        listener.enterSuccessionFlowUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSuccessionFlowUsage) {
        listener.exitSuccessionFlowUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSuccessionFlowUsage) {
        return visitor.visitSuccessionFlowUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FlowPayloadFeatureMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    flowPayloadFeature() {
      return this.getRuleContext(0, FlowPayloadFeatureContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_flowPayloadFeatureMember;
    }
    enterRule(listener) {
      if (listener.enterFlowPayloadFeatureMember) {
        listener.enterFlowPayloadFeatureMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFlowPayloadFeatureMember) {
        listener.exitFlowPayloadFeatureMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFlowPayloadFeatureMember) {
        return visitor.visitFlowPayloadFeatureMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FlowPayloadFeatureContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    payloadFeature() {
      return this.getRuleContext(0, PayloadFeatureContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_flowPayloadFeature;
    }
    enterRule(listener) {
      if (listener.enterFlowPayloadFeature) {
        listener.enterFlowPayloadFeature(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFlowPayloadFeature) {
        listener.exitFlowPayloadFeature(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFlowPayloadFeature) {
        return visitor.visitFlowPayloadFeature(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    ACTION() {
      return this.getToken(SysMLv2Parser.ACTION, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionDefinition;
    }
    enterRule(listener) {
      if (listener.enterActionDefinition) {
        listener.enterActionDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionDefinition) {
        listener.exitActionDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionDefinition) {
        return visitor.visitActionDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    actionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(ActionBodyItemContext);
      }
      return this.getRuleContext(i, ActionBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionBody;
    }
    enterRule(listener) {
      if (listener.enterActionBody) {
        listener.enterActionBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionBody) {
        listener.exitActionBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionBody) {
        return visitor.visitActionBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nonBehaviorBodyItem() {
      return this.getRuleContext(0, NonBehaviorBodyItemContext);
    }
    initialNodeMember() {
      return this.getRuleContext(0, InitialNodeMemberContext);
    }
    actionTargetSuccessionMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ActionTargetSuccessionMemberContext);
      }
      return this.getRuleContext(i, ActionTargetSuccessionMemberContext);
    }
    actionBehaviorMember() {
      return this.getRuleContext(0, ActionBehaviorMemberContext);
    }
    sourceSuccessionMember() {
      return this.getRuleContext(0, SourceSuccessionMemberContext);
    }
    guardedSuccessionMember() {
      return this.getRuleContext(0, GuardedSuccessionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionBodyItem;
    }
    enterRule(listener) {
      if (listener.enterActionBodyItem) {
        listener.enterActionBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionBodyItem) {
        listener.exitActionBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionBodyItem) {
        return visitor.visitActionBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NonBehaviorBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    importRule() {
      return this.getRuleContext(0, ImportRuleContext);
    }
    aliasMember() {
      return this.getRuleContext(0, AliasMemberContext);
    }
    definitionMember() {
      return this.getRuleContext(0, DefinitionMemberContext);
    }
    variantUsageMember() {
      return this.getRuleContext(0, VariantUsageMemberContext);
    }
    nonOccurrenceUsageMember() {
      return this.getRuleContext(0, NonOccurrenceUsageMemberContext);
    }
    structureUsageMember() {
      return this.getRuleContext(0, StructureUsageMemberContext);
    }
    sourceSuccessionMember() {
      return this.getRuleContext(0, SourceSuccessionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nonBehaviorBodyItem;
    }
    enterRule(listener) {
      if (listener.enterNonBehaviorBodyItem) {
        listener.enterNonBehaviorBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNonBehaviorBodyItem) {
        listener.exitNonBehaviorBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNonBehaviorBodyItem) {
        return visitor.visitNonBehaviorBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionBehaviorMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    actionNodeMember() {
      return this.getRuleContext(0, ActionNodeMemberContext);
    }
    behaviorUsageMember() {
      return this.getRuleContext(0, BehaviorUsageMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionBehaviorMember;
    }
    enterRule(listener) {
      if (listener.enterActionBehaviorMember) {
        listener.enterActionBehaviorMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionBehaviorMember) {
        listener.exitActionBehaviorMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionBehaviorMember) {
        return visitor.visitActionBehaviorMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var InitialNodeMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    FIRST() {
      return this.getToken(SysMLv2Parser.FIRST, 0);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_initialNodeMember;
    }
    enterRule(listener) {
      if (listener.enterInitialNodeMember) {
        listener.enterInitialNodeMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitInitialNodeMember) {
        listener.exitInitialNodeMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitInitialNodeMember) {
        return visitor.visitInitialNodeMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionNodeMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    actionNode() {
      return this.getRuleContext(0, ActionNodeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionNodeMember;
    }
    enterRule(listener) {
      if (listener.enterActionNodeMember) {
        listener.enterActionNodeMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionNodeMember) {
        listener.exitActionNodeMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionNodeMember) {
        return visitor.visitActionNodeMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionTargetSuccessionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    actionTargetSuccession() {
      return this.getRuleContext(0, ActionTargetSuccessionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionTargetSuccessionMember;
    }
    enterRule(listener) {
      if (listener.enterActionTargetSuccessionMember) {
        listener.enterActionTargetSuccessionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionTargetSuccessionMember) {
        listener.exitActionTargetSuccessionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionTargetSuccessionMember) {
        return visitor.visitActionTargetSuccessionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var GuardedSuccessionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    guardedSuccession() {
      return this.getRuleContext(0, GuardedSuccessionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_guardedSuccessionMember;
    }
    enterRule(listener) {
      if (listener.enterGuardedSuccessionMember) {
        listener.enterGuardedSuccessionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitGuardedSuccessionMember) {
        listener.exitGuardedSuccessionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitGuardedSuccessionMember) {
        return visitor.visitGuardedSuccessionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    ACTION() {
      return this.getToken(SysMLv2Parser.ACTION, 0);
    }
    actionUsageDeclaration() {
      return this.getRuleContext(0, ActionUsageDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionUsage;
    }
    enterRule(listener) {
      if (listener.enterActionUsage) {
        listener.enterActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionUsage) {
        listener.exitActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionUsage) {
        return visitor.visitActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionUsageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionUsageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterActionUsageDeclaration) {
        listener.enterActionUsageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionUsageDeclaration) {
        listener.exitActionUsageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionUsageDeclaration) {
        return visitor.visitActionUsageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PerformActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    PERFORM() {
      return this.getToken(SysMLv2Parser.PERFORM, 0);
    }
    performActionUsageDeclaration() {
      return this.getRuleContext(0, PerformActionUsageDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_performActionUsage;
    }
    enterRule(listener) {
      if (listener.enterPerformActionUsage) {
        listener.enterPerformActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPerformActionUsage) {
        listener.exitPerformActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPerformActionUsage) {
        return visitor.visitPerformActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PerformActionUsageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    ACTION() {
      return this.getToken(SysMLv2Parser.ACTION, 0);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_performActionUsageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterPerformActionUsageDeclaration) {
        listener.enterPerformActionUsageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPerformActionUsageDeclaration) {
        listener.exitPerformActionUsageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPerformActionUsageDeclaration) {
        return visitor.visitPerformActionUsageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    controlNode() {
      return this.getRuleContext(0, ControlNodeContext);
    }
    sendNode() {
      return this.getRuleContext(0, SendNodeContext);
    }
    acceptNode() {
      return this.getRuleContext(0, AcceptNodeContext);
    }
    assignmentNode() {
      return this.getRuleContext(0, AssignmentNodeContext);
    }
    terminateNode() {
      return this.getRuleContext(0, TerminateNodeContext);
    }
    ifNode() {
      return this.getRuleContext(0, IfNodeContext);
    }
    whileLoopNode() {
      return this.getRuleContext(0, WhileLoopNodeContext);
    }
    forLoopNode() {
      return this.getRuleContext(0, ForLoopNodeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionNode;
    }
    enterRule(listener) {
      if (listener.enterActionNode) {
        listener.enterActionNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionNode) {
        listener.exitActionNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionNode) {
        return visitor.visitActionNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionNodeUsageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ACTION() {
      return this.getToken(SysMLv2Parser.ACTION, 0);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionNodeUsageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterActionNodeUsageDeclaration) {
        listener.enterActionNodeUsageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionNodeUsageDeclaration) {
        listener.exitActionNodeUsageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionNodeUsageDeclaration) {
        return visitor.visitActionNodeUsageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionNodePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    actionNodeUsageDeclaration() {
      return this.getRuleContext(0, ActionNodeUsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionNodePrefix;
    }
    enterRule(listener) {
      if (listener.enterActionNodePrefix) {
        listener.enterActionNodePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionNodePrefix) {
        listener.exitActionNodePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionNodePrefix) {
        return visitor.visitActionNodePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ControlNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    mergeNode() {
      return this.getRuleContext(0, MergeNodeContext);
    }
    decisionNode() {
      return this.getRuleContext(0, DecisionNodeContext);
    }
    joinNode() {
      return this.getRuleContext(0, JoinNodeContext);
    }
    forkNode() {
      return this.getRuleContext(0, ForkNodeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_controlNode;
    }
    enterRule(listener) {
      if (listener.enterControlNode) {
        listener.enterControlNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitControlNode) {
        listener.exitControlNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitControlNode) {
        return visitor.visitControlNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ControlNodePrefixContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    refPrefix() {
      return this.getRuleContext(0, RefPrefixContext);
    }
    INDIVIDUAL() {
      return this.getToken(SysMLv2Parser.INDIVIDUAL, 0);
    }
    portionKind() {
      return this.getRuleContext(0, PortionKindContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_controlNodePrefix;
    }
    enterRule(listener) {
      if (listener.enterControlNodePrefix) {
        listener.enterControlNodePrefix(this);
      }
    }
    exitRule(listener) {
      if (listener.exitControlNodePrefix) {
        listener.exitControlNodePrefix(this);
      }
    }
    accept(visitor) {
      if (visitor.visitControlNodePrefix) {
        return visitor.visitControlNodePrefix(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MergeNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    controlNodePrefix() {
      return this.getRuleContext(0, ControlNodePrefixContext);
    }
    MERGE() {
      return this.getToken(SysMLv2Parser.MERGE, 0);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_mergeNode;
    }
    enterRule(listener) {
      if (listener.enterMergeNode) {
        listener.enterMergeNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMergeNode) {
        listener.exitMergeNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMergeNode) {
        return visitor.visitMergeNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DecisionNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    controlNodePrefix() {
      return this.getRuleContext(0, ControlNodePrefixContext);
    }
    DECIDE() {
      return this.getToken(SysMLv2Parser.DECIDE, 0);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_decisionNode;
    }
    enterRule(listener) {
      if (listener.enterDecisionNode) {
        listener.enterDecisionNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDecisionNode) {
        listener.exitDecisionNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDecisionNode) {
        return visitor.visitDecisionNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var JoinNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    controlNodePrefix() {
      return this.getRuleContext(0, ControlNodePrefixContext);
    }
    JOIN() {
      return this.getToken(SysMLv2Parser.JOIN, 0);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_joinNode;
    }
    enterRule(listener) {
      if (listener.enterJoinNode) {
        listener.enterJoinNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitJoinNode) {
        listener.exitJoinNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitJoinNode) {
        return visitor.visitJoinNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ForkNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    controlNodePrefix() {
      return this.getRuleContext(0, ControlNodePrefixContext);
    }
    FORK() {
      return this.getToken(SysMLv2Parser.FORK, 0);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_forkNode;
    }
    enterRule(listener) {
      if (listener.enterForkNode) {
        listener.enterForkNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitForkNode) {
        listener.exitForkNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitForkNode) {
        return visitor.visitForkNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AcceptNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    acceptNodeDeclaration() {
      return this.getRuleContext(0, AcceptNodeDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_acceptNode;
    }
    enterRule(listener) {
      if (listener.enterAcceptNode) {
        listener.enterAcceptNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAcceptNode) {
        listener.exitAcceptNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAcceptNode) {
        return visitor.visitAcceptNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AcceptNodeDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ACCEPT() {
      return this.getToken(SysMLv2Parser.ACCEPT, 0);
    }
    acceptParameterPart() {
      return this.getRuleContext(0, AcceptParameterPartContext);
    }
    actionNodeUsageDeclaration() {
      return this.getRuleContext(0, ActionNodeUsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_acceptNodeDeclaration;
    }
    enterRule(listener) {
      if (listener.enterAcceptNodeDeclaration) {
        listener.enterAcceptNodeDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAcceptNodeDeclaration) {
        listener.exitAcceptNodeDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAcceptNodeDeclaration) {
        return visitor.visitAcceptNodeDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AcceptParameterPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    payloadParameterMember() {
      return this.getRuleContext(0, PayloadParameterMemberContext);
    }
    VIA() {
      return this.getToken(SysMLv2Parser.VIA, 0);
    }
    nodeParameterMember() {
      return this.getRuleContext(0, NodeParameterMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_acceptParameterPart;
    }
    enterRule(listener) {
      if (listener.enterAcceptParameterPart) {
        listener.enterAcceptParameterPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAcceptParameterPart) {
        listener.exitAcceptParameterPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAcceptParameterPart) {
        return visitor.visitAcceptParameterPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PayloadParameterMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    payloadParameter() {
      return this.getRuleContext(0, PayloadParameterContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_payloadParameterMember;
    }
    enterRule(listener) {
      if (listener.enterPayloadParameterMember) {
        listener.enterPayloadParameterMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPayloadParameterMember) {
        listener.exitPayloadParameterMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPayloadParameterMember) {
        return visitor.visitPayloadParameterMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PayloadParameterContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    payloadFeature() {
      return this.getRuleContext(0, PayloadFeatureContext);
    }
    triggerValuePart() {
      return this.getRuleContext(0, TriggerValuePartContext);
    }
    identification() {
      return this.getRuleContext(0, IdentificationContext);
    }
    payloadFeatureSpecializationPart() {
      return this.getRuleContext(0, PayloadFeatureSpecializationPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_payloadParameter;
    }
    enterRule(listener) {
      if (listener.enterPayloadParameter) {
        listener.enterPayloadParameter(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPayloadParameter) {
        listener.exitPayloadParameter(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPayloadParameter) {
        return visitor.visitPayloadParameter(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TriggerValuePartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    triggerFeatureValue() {
      return this.getRuleContext(0, TriggerFeatureValueContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_triggerValuePart;
    }
    enterRule(listener) {
      if (listener.enterTriggerValuePart) {
        listener.enterTriggerValuePart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTriggerValuePart) {
        listener.exitTriggerValuePart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTriggerValuePart) {
        return visitor.visitTriggerValuePart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TriggerFeatureValueContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    triggerExpression() {
      return this.getRuleContext(0, TriggerExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_triggerFeatureValue;
    }
    enterRule(listener) {
      if (listener.enterTriggerFeatureValue) {
        listener.enterTriggerFeatureValue(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTriggerFeatureValue) {
        listener.exitTriggerFeatureValue(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTriggerFeatureValue) {
        return visitor.visitTriggerFeatureValue(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TriggerExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    argumentMember() {
      return this.getRuleContext(0, ArgumentMemberContext);
    }
    AT() {
      return this.getToken(SysMLv2Parser.AT, 0);
    }
    AFTER() {
      return this.getToken(SysMLv2Parser.AFTER, 0);
    }
    WHEN() {
      return this.getToken(SysMLv2Parser.WHEN, 0);
    }
    argumentExpressionMember() {
      return this.getRuleContext(0, ArgumentExpressionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_triggerExpression;
    }
    enterRule(listener) {
      if (listener.enterTriggerExpression) {
        listener.enterTriggerExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTriggerExpression) {
        listener.exitTriggerExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTriggerExpression) {
        return visitor.visitTriggerExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SendNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    SEND() {
      return this.getToken(SysMLv2Parser.SEND, 0);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    actionNodeUsageDeclaration() {
      return this.getRuleContext(0, ActionNodeUsageDeclarationContext);
    }
    actionUsageDeclaration() {
      return this.getRuleContext(0, ActionUsageDeclarationContext);
    }
    nodeParameterMember() {
      return this.getRuleContext(0, NodeParameterMemberContext);
    }
    emptyParameterMember() {
      return this.getRuleContext(0, EmptyParameterMemberContext);
    }
    senderReceiverPart() {
      return this.getRuleContext(0, SenderReceiverPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_sendNode;
    }
    enterRule(listener) {
      if (listener.enterSendNode) {
        listener.enterSendNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSendNode) {
        listener.exitSendNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSendNode) {
        return visitor.visitSendNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SendNodeDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEND() {
      return this.getToken(SysMLv2Parser.SEND, 0);
    }
    nodeParameterMember() {
      return this.getRuleContext(0, NodeParameterMemberContext);
    }
    actionNodeUsageDeclaration() {
      return this.getRuleContext(0, ActionNodeUsageDeclarationContext);
    }
    senderReceiverPart() {
      return this.getRuleContext(0, SenderReceiverPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_sendNodeDeclaration;
    }
    enterRule(listener) {
      if (listener.enterSendNodeDeclaration) {
        listener.enterSendNodeDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSendNodeDeclaration) {
        listener.exitSendNodeDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSendNodeDeclaration) {
        return visitor.visitSendNodeDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SenderReceiverPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    VIA() {
      return this.getToken(SysMLv2Parser.VIA, 0);
    }
    nodeParameterMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(NodeParameterMemberContext);
      }
      return this.getRuleContext(i, NodeParameterMemberContext);
    }
    TO() {
      return this.getToken(SysMLv2Parser.TO, 0);
    }
    emptyParameterMember() {
      return this.getRuleContext(0, EmptyParameterMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_senderReceiverPart;
    }
    enterRule(listener) {
      if (listener.enterSenderReceiverPart) {
        listener.enterSenderReceiverPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSenderReceiverPart) {
        listener.exitSenderReceiverPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSenderReceiverPart) {
        return visitor.visitSenderReceiverPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NodeParameterMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nodeParameter() {
      return this.getRuleContext(0, NodeParameterContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nodeParameterMember;
    }
    enterRule(listener) {
      if (listener.enterNodeParameterMember) {
        listener.enterNodeParameterMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNodeParameterMember) {
        listener.exitNodeParameterMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNodeParameterMember) {
        return visitor.visitNodeParameterMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NodeParameterContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureBinding() {
      return this.getRuleContext(0, FeatureBindingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nodeParameter;
    }
    enterRule(listener) {
      if (listener.enterNodeParameter) {
        listener.enterNodeParameter(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNodeParameter) {
        listener.exitNodeParameter(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNodeParameter) {
        return visitor.visitNodeParameter(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FeatureBindingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_featureBinding;
    }
    enterRule(listener) {
      if (listener.enterFeatureBinding) {
        listener.enterFeatureBinding(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFeatureBinding) {
        listener.exitFeatureBinding(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFeatureBinding) {
        return visitor.visitFeatureBinding(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EmptyParameterMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    emptyUsage_() {
      return this.getRuleContext(0, EmptyUsage_Context);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_emptyParameterMember;
    }
    enterRule(listener) {
      if (listener.enterEmptyParameterMember) {
        listener.enterEmptyParameterMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEmptyParameterMember) {
        listener.exitEmptyParameterMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEmptyParameterMember) {
        return visitor.visitEmptyParameterMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AssignmentNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    assignmentNodeDeclaration() {
      return this.getRuleContext(0, AssignmentNodeDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_assignmentNode;
    }
    enterRule(listener) {
      if (listener.enterAssignmentNode) {
        listener.enterAssignmentNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAssignmentNode) {
        listener.exitAssignmentNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAssignmentNode) {
        return visitor.visitAssignmentNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AssignmentNodeDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ASSIGN() {
      return this.getToken(SysMLv2Parser.ASSIGN, 0);
    }
    assignmentTargetMember() {
      return this.getRuleContext(0, AssignmentTargetMemberContext);
    }
    featureChainMember() {
      return this.getRuleContext(0, FeatureChainMemberContext);
    }
    COLON_EQ() {
      return this.getToken(SysMLv2Parser.COLON_EQ, 0);
    }
    nodeParameterMember() {
      return this.getRuleContext(0, NodeParameterMemberContext);
    }
    actionNodeUsageDeclaration() {
      return this.getRuleContext(0, ActionNodeUsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_assignmentNodeDeclaration;
    }
    enterRule(listener) {
      if (listener.enterAssignmentNodeDeclaration) {
        listener.enterAssignmentNodeDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAssignmentNodeDeclaration) {
        listener.exitAssignmentNodeDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAssignmentNodeDeclaration) {
        return visitor.visitAssignmentNodeDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AssignmentTargetMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    assignmentTargetParameter() {
      return this.getRuleContext(0, AssignmentTargetParameterContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_assignmentTargetMember;
    }
    enterRule(listener) {
      if (listener.enterAssignmentTargetMember) {
        listener.enterAssignmentTargetMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAssignmentTargetMember) {
        listener.exitAssignmentTargetMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAssignmentTargetMember) {
        return visitor.visitAssignmentTargetMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AssignmentTargetParameterContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    assignmentTargetBinding() {
      return this.getRuleContext(0, AssignmentTargetBindingContext);
    }
    DOT() {
      return this.getToken(SysMLv2Parser.DOT, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_assignmentTargetParameter;
    }
    enterRule(listener) {
      if (listener.enterAssignmentTargetParameter) {
        listener.enterAssignmentTargetParameter(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAssignmentTargetParameter) {
        listener.exitAssignmentTargetParameter(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAssignmentTargetParameter) {
        return visitor.visitAssignmentTargetParameter(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AssignmentTargetBindingContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nonFeatureChainPrimaryExpression() {
      return this.getRuleContext(0, NonFeatureChainPrimaryExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_assignmentTargetBinding;
    }
    enterRule(listener) {
      if (listener.enterAssignmentTargetBinding) {
        listener.enterAssignmentTargetBinding(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAssignmentTargetBinding) {
        listener.exitAssignmentTargetBinding(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAssignmentTargetBinding) {
        return visitor.visitAssignmentTargetBinding(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TerminateNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    TERMINATE() {
      return this.getToken(SysMLv2Parser.TERMINATE, 0);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    actionNodeUsageDeclaration() {
      return this.getRuleContext(0, ActionNodeUsageDeclarationContext);
    }
    nodeParameterMember() {
      return this.getRuleContext(0, NodeParameterMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_terminateNode;
    }
    enterRule(listener) {
      if (listener.enterTerminateNode) {
        listener.enterTerminateNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTerminateNode) {
        listener.exitTerminateNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTerminateNode) {
        return visitor.visitTerminateNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var IfNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    actionNodePrefix() {
      return this.getRuleContext(0, ActionNodePrefixContext);
    }
    IF() {
      return this.getToken(SysMLv2Parser.IF, 0);
    }
    expressionParameterMember() {
      return this.getRuleContext(0, ExpressionParameterMemberContext);
    }
    actionBodyParameterMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ActionBodyParameterMemberContext);
      }
      return this.getRuleContext(i, ActionBodyParameterMemberContext);
    }
    ELSE() {
      return this.getToken(SysMLv2Parser.ELSE, 0);
    }
    ifNodeParameterMember() {
      return this.getRuleContext(0, IfNodeParameterMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ifNode;
    }
    enterRule(listener) {
      if (listener.enterIfNode) {
        listener.enterIfNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitIfNode) {
        listener.exitIfNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitIfNode) {
        return visitor.visitIfNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ExpressionParameterMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_expressionParameterMember;
    }
    enterRule(listener) {
      if (listener.enterExpressionParameterMember) {
        listener.enterExpressionParameterMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitExpressionParameterMember) {
        listener.exitExpressionParameterMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitExpressionParameterMember) {
        return visitor.visitExpressionParameterMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionBodyParameterMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    actionBodyParameter() {
      return this.getRuleContext(0, ActionBodyParameterContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionBodyParameterMember;
    }
    enterRule(listener) {
      if (listener.enterActionBodyParameterMember) {
        listener.enterActionBodyParameterMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionBodyParameterMember) {
        listener.exitActionBodyParameterMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionBodyParameterMember) {
        return visitor.visitActionBodyParameterMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionBodyParameterContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    ACTION() {
      return this.getToken(SysMLv2Parser.ACTION, 0);
    }
    actionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(ActionBodyItemContext);
      }
      return this.getRuleContext(i, ActionBodyItemContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionBodyParameter;
    }
    enterRule(listener) {
      if (listener.enterActionBodyParameter) {
        listener.enterActionBodyParameter(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionBodyParameter) {
        listener.exitActionBodyParameter(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionBodyParameter) {
        return visitor.visitActionBodyParameter(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var IfNodeParameterMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ifNode() {
      return this.getRuleContext(0, IfNodeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_ifNodeParameterMember;
    }
    enterRule(listener) {
      if (listener.enterIfNodeParameterMember) {
        listener.enterIfNodeParameterMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitIfNodeParameterMember) {
        listener.exitIfNodeParameterMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitIfNodeParameterMember) {
        return visitor.visitIfNodeParameterMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var WhileLoopNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    actionNodePrefix() {
      return this.getRuleContext(0, ActionNodePrefixContext);
    }
    actionBodyParameterMember() {
      return this.getRuleContext(0, ActionBodyParameterMemberContext);
    }
    WHILE() {
      return this.getToken(SysMLv2Parser.WHILE, 0);
    }
    expressionParameterMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(ExpressionParameterMemberContext);
      }
      return this.getRuleContext(i, ExpressionParameterMemberContext);
    }
    LOOP() {
      return this.getToken(SysMLv2Parser.LOOP, 0);
    }
    emptyParameterMember() {
      return this.getRuleContext(0, EmptyParameterMemberContext);
    }
    UNTIL() {
      return this.getToken(SysMLv2Parser.UNTIL, 0);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_whileLoopNode;
    }
    enterRule(listener) {
      if (listener.enterWhileLoopNode) {
        listener.enterWhileLoopNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitWhileLoopNode) {
        listener.exitWhileLoopNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitWhileLoopNode) {
        return visitor.visitWhileLoopNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ForLoopNodeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    actionNodePrefix() {
      return this.getRuleContext(0, ActionNodePrefixContext);
    }
    FOR() {
      return this.getToken(SysMLv2Parser.FOR, 0);
    }
    forVariableDeclarationMember() {
      return this.getRuleContext(0, ForVariableDeclarationMemberContext);
    }
    IN() {
      return this.getToken(SysMLv2Parser.IN, 0);
    }
    nodeParameterMember() {
      return this.getRuleContext(0, NodeParameterMemberContext);
    }
    actionBodyParameterMember() {
      return this.getRuleContext(0, ActionBodyParameterMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_forLoopNode;
    }
    enterRule(listener) {
      if (listener.enterForLoopNode) {
        listener.enterForLoopNode(this);
      }
    }
    exitRule(listener) {
      if (listener.exitForLoopNode) {
        listener.exitForLoopNode(this);
      }
    }
    accept(visitor) {
      if (visitor.visitForLoopNode) {
        return visitor.visitForLoopNode(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ForVariableDeclarationMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_forVariableDeclarationMember;
    }
    enterRule(listener) {
      if (listener.enterForVariableDeclarationMember) {
        listener.enterForVariableDeclarationMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitForVariableDeclarationMember) {
        listener.exitForVariableDeclarationMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitForVariableDeclarationMember) {
        return visitor.visitForVariableDeclarationMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActionTargetSuccessionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    targetSuccession() {
      return this.getRuleContext(0, TargetSuccessionContext);
    }
    guardedTargetSuccession() {
      return this.getRuleContext(0, GuardedTargetSuccessionContext);
    }
    defaultTargetSuccession() {
      return this.getRuleContext(0, DefaultTargetSuccessionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actionTargetSuccession;
    }
    enterRule(listener) {
      if (listener.enterActionTargetSuccession) {
        listener.enterActionTargetSuccession(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActionTargetSuccession) {
        listener.exitActionTargetSuccession(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActionTargetSuccession) {
        return visitor.visitActionTargetSuccession(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TargetSuccessionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    sourceEndMember() {
      return this.getRuleContext(0, SourceEndMemberContext);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    connectorEndMember() {
      return this.getRuleContext(0, ConnectorEndMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_targetSuccession;
    }
    enterRule(listener) {
      if (listener.enterTargetSuccession) {
        listener.enterTargetSuccession(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTargetSuccession) {
        listener.exitTargetSuccession(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTargetSuccession) {
        return visitor.visitTargetSuccession(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var GuardedTargetSuccessionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    guardExpressionMember() {
      return this.getRuleContext(0, GuardExpressionMemberContext);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    transitionSuccessionMember() {
      return this.getRuleContext(0, TransitionSuccessionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_guardedTargetSuccession;
    }
    enterRule(listener) {
      if (listener.enterGuardedTargetSuccession) {
        listener.enterGuardedTargetSuccession(this);
      }
    }
    exitRule(listener) {
      if (listener.exitGuardedTargetSuccession) {
        listener.exitGuardedTargetSuccession(this);
      }
    }
    accept(visitor) {
      if (visitor.visitGuardedTargetSuccession) {
        return visitor.visitGuardedTargetSuccession(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DefaultTargetSuccessionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ELSE() {
      return this.getToken(SysMLv2Parser.ELSE, 0);
    }
    transitionSuccessionMember() {
      return this.getRuleContext(0, TransitionSuccessionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_defaultTargetSuccession;
    }
    enterRule(listener) {
      if (listener.enterDefaultTargetSuccession) {
        listener.enterDefaultTargetSuccession(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDefaultTargetSuccession) {
        listener.exitDefaultTargetSuccession(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDefaultTargetSuccession) {
        return visitor.visitDefaultTargetSuccession(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var GuardedSuccessionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    FIRST() {
      return this.getToken(SysMLv2Parser.FIRST, 0);
    }
    featureChainMember() {
      return this.getRuleContext(0, FeatureChainMemberContext);
    }
    guardExpressionMember() {
      return this.getRuleContext(0, GuardExpressionMemberContext);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    transitionSuccessionMember() {
      return this.getRuleContext(0, TransitionSuccessionMemberContext);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    SUCCESSION() {
      return this.getToken(SysMLv2Parser.SUCCESSION, 0);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_guardedSuccession;
    }
    enterRule(listener) {
      if (listener.enterGuardedSuccession) {
        listener.enterGuardedSuccession(this);
      }
    }
    exitRule(listener) {
      if (listener.exitGuardedSuccession) {
        listener.exitGuardedSuccession(this);
      }
    }
    accept(visitor) {
      if (visitor.visitGuardedSuccession) {
        return visitor.visitGuardedSuccession(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    STATE() {
      return this.getToken(SysMLv2Parser.STATE, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    stateDefBody() {
      return this.getRuleContext(0, StateDefBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateDefinition;
    }
    enterRule(listener) {
      if (listener.enterStateDefinition) {
        listener.enterStateDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateDefinition) {
        listener.exitStateDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateDefinition) {
        return visitor.visitStateDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateDefBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    PARALLEL() {
      return this.getToken(SysMLv2Parser.PARALLEL, 0);
    }
    stateBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(StateBodyItemContext);
      }
      return this.getRuleContext(i, StateBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateDefBody;
    }
    enterRule(listener) {
      if (listener.enterStateDefBody) {
        listener.enterStateDefBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateDefBody) {
        listener.exitStateDefBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateDefBody) {
        return visitor.visitStateDefBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    nonBehaviorBodyItem() {
      return this.getRuleContext(0, NonBehaviorBodyItemContext);
    }
    behaviorUsageMember() {
      return this.getRuleContext(0, BehaviorUsageMemberContext);
    }
    sourceSuccessionMember() {
      return this.getRuleContext(0, SourceSuccessionMemberContext);
    }
    targetTransitionUsageMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(TargetTransitionUsageMemberContext);
      }
      return this.getRuleContext(i, TargetTransitionUsageMemberContext);
    }
    transitionUsageMember() {
      return this.getRuleContext(0, TransitionUsageMemberContext);
    }
    entryActionMember() {
      return this.getRuleContext(0, EntryActionMemberContext);
    }
    entryTransitionMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(EntryTransitionMemberContext);
      }
      return this.getRuleContext(i, EntryTransitionMemberContext);
    }
    doActionMember() {
      return this.getRuleContext(0, DoActionMemberContext);
    }
    exitActionMember() {
      return this.getRuleContext(0, ExitActionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateBodyItem;
    }
    enterRule(listener) {
      if (listener.enterStateBodyItem) {
        listener.enterStateBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateBodyItem) {
        listener.exitStateBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateBodyItem) {
        return visitor.visitStateBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EntryActionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    ENTRY() {
      return this.getToken(SysMLv2Parser.ENTRY, 0);
    }
    stateActionUsage() {
      return this.getRuleContext(0, StateActionUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_entryActionMember;
    }
    enterRule(listener) {
      if (listener.enterEntryActionMember) {
        listener.enterEntryActionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEntryActionMember) {
        listener.exitEntryActionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEntryActionMember) {
        return visitor.visitEntryActionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var DoActionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    DO() {
      return this.getToken(SysMLv2Parser.DO, 0);
    }
    stateActionUsage() {
      return this.getRuleContext(0, StateActionUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_doActionMember;
    }
    enterRule(listener) {
      if (listener.enterDoActionMember) {
        listener.enterDoActionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitDoActionMember) {
        listener.exitDoActionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitDoActionMember) {
        return visitor.visitDoActionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ExitActionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    EXIT() {
      return this.getToken(SysMLv2Parser.EXIT, 0);
    }
    stateActionUsage() {
      return this.getRuleContext(0, StateActionUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_exitActionMember;
    }
    enterRule(listener) {
      if (listener.enterExitActionMember) {
        listener.enterExitActionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitExitActionMember) {
        listener.exitExitActionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitExitActionMember) {
        return visitor.visitExitActionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EntryTransitionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    guardedTargetSuccession() {
      return this.getRuleContext(0, GuardedTargetSuccessionContext);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    transitionSuccessionMember() {
      return this.getRuleContext(0, TransitionSuccessionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_entryTransitionMember;
    }
    enterRule(listener) {
      if (listener.enterEntryTransitionMember) {
        listener.enterEntryTransitionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEntryTransitionMember) {
        listener.exitEntryTransitionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEntryTransitionMember) {
        return visitor.visitEntryTransitionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    emptyActionUsage_() {
      return this.getRuleContext(0, EmptyActionUsage_Context);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    statePerformActionUsage() {
      return this.getRuleContext(0, StatePerformActionUsageContext);
    }
    stateAcceptActionUsage() {
      return this.getRuleContext(0, StateAcceptActionUsageContext);
    }
    stateSendActionUsage() {
      return this.getRuleContext(0, StateSendActionUsageContext);
    }
    stateAssignmentActionUsage() {
      return this.getRuleContext(0, StateAssignmentActionUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateActionUsage;
    }
    enterRule(listener) {
      if (listener.enterStateActionUsage) {
        listener.enterStateActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateActionUsage) {
        listener.exitStateActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateActionUsage) {
        return visitor.visitStateActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StatePerformActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    performActionUsageDeclaration() {
      return this.getRuleContext(0, PerformActionUsageDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_statePerformActionUsage;
    }
    enterRule(listener) {
      if (listener.enterStatePerformActionUsage) {
        listener.enterStatePerformActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStatePerformActionUsage) {
        listener.exitStatePerformActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStatePerformActionUsage) {
        return visitor.visitStatePerformActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateAcceptActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    acceptNodeDeclaration() {
      return this.getRuleContext(0, AcceptNodeDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateAcceptActionUsage;
    }
    enterRule(listener) {
      if (listener.enterStateAcceptActionUsage) {
        listener.enterStateAcceptActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateAcceptActionUsage) {
        listener.exitStateAcceptActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateAcceptActionUsage) {
        return visitor.visitStateAcceptActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateSendActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    sendNodeDeclaration() {
      return this.getRuleContext(0, SendNodeDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateSendActionUsage;
    }
    enterRule(listener) {
      if (listener.enterStateSendActionUsage) {
        listener.enterStateSendActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateSendActionUsage) {
        listener.exitStateSendActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateSendActionUsage) {
        return visitor.visitStateSendActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateAssignmentActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    assignmentNodeDeclaration() {
      return this.getRuleContext(0, AssignmentNodeDeclarationContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateAssignmentActionUsage;
    }
    enterRule(listener) {
      if (listener.enterStateAssignmentActionUsage) {
        listener.enterStateAssignmentActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateAssignmentActionUsage) {
        listener.exitStateAssignmentActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateAssignmentActionUsage) {
        return visitor.visitStateAssignmentActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TransitionUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    transitionUsage() {
      return this.getRuleContext(0, TransitionUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_transitionUsageMember;
    }
    enterRule(listener) {
      if (listener.enterTransitionUsageMember) {
        listener.enterTransitionUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTransitionUsageMember) {
        listener.exitTransitionUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTransitionUsageMember) {
        return visitor.visitTransitionUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TargetTransitionUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    targetTransitionUsage() {
      return this.getRuleContext(0, TargetTransitionUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_targetTransitionUsageMember;
    }
    enterRule(listener) {
      if (listener.enterTargetTransitionUsageMember) {
        listener.enterTargetTransitionUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTargetTransitionUsageMember) {
        listener.exitTargetTransitionUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTargetTransitionUsageMember) {
        return visitor.visitTargetTransitionUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    STATE() {
      return this.getToken(SysMLv2Parser.STATE, 0);
    }
    actionUsageDeclaration() {
      return this.getRuleContext(0, ActionUsageDeclarationContext);
    }
    stateUsageBody() {
      return this.getRuleContext(0, StateUsageBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateUsage;
    }
    enterRule(listener) {
      if (listener.enterStateUsage) {
        listener.enterStateUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateUsage) {
        listener.exitStateUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateUsage) {
        return visitor.visitStateUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StateUsageBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    PARALLEL() {
      return this.getToken(SysMLv2Parser.PARALLEL, 0);
    }
    stateBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(StateBodyItemContext);
      }
      return this.getRuleContext(i, StateBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stateUsageBody;
    }
    enterRule(listener) {
      if (listener.enterStateUsageBody) {
        listener.enterStateUsageBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStateUsageBody) {
        listener.exitStateUsageBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStateUsageBody) {
        return visitor.visitStateUsageBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ExhibitStateUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    EXHIBIT() {
      return this.getToken(SysMLv2Parser.EXHIBIT, 0);
    }
    stateUsageBody() {
      return this.getRuleContext(0, StateUsageBodyContext);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    STATE() {
      return this.getToken(SysMLv2Parser.STATE, 0);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_exhibitStateUsage;
    }
    enterRule(listener) {
      if (listener.enterExhibitStateUsage) {
        listener.enterExhibitStateUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitExhibitStateUsage) {
        listener.exitExhibitStateUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitExhibitStateUsage) {
        return visitor.visitExhibitStateUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TransitionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    TRANSITION() {
      return this.getToken(SysMLv2Parser.TRANSITION, 0);
    }
    featureChainMember() {
      return this.getRuleContext(0, FeatureChainMemberContext);
    }
    emptyParameterMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(EmptyParameterMemberContext);
      }
      return this.getRuleContext(i, EmptyParameterMemberContext);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    transitionSuccessionMember() {
      return this.getRuleContext(0, TransitionSuccessionMemberContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    FIRST() {
      return this.getToken(SysMLv2Parser.FIRST, 0);
    }
    triggerActionMember() {
      return this.getRuleContext(0, TriggerActionMemberContext);
    }
    guardExpressionMember() {
      return this.getRuleContext(0, GuardExpressionMemberContext);
    }
    effectBehaviorMember() {
      return this.getRuleContext(0, EffectBehaviorMemberContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_transitionUsage;
    }
    enterRule(listener) {
      if (listener.enterTransitionUsage) {
        listener.enterTransitionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTransitionUsage) {
        listener.exitTransitionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTransitionUsage) {
        return visitor.visitTransitionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TargetTransitionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    emptyParameterMember(i) {
      if (i === void 0) {
        return this.getRuleContexts(EmptyParameterMemberContext);
      }
      return this.getRuleContext(i, EmptyParameterMemberContext);
    }
    THEN() {
      return this.getToken(SysMLv2Parser.THEN, 0);
    }
    transitionSuccessionMember() {
      return this.getRuleContext(0, TransitionSuccessionMemberContext);
    }
    actionBody() {
      return this.getRuleContext(0, ActionBodyContext);
    }
    TRANSITION() {
      return this.getToken(SysMLv2Parser.TRANSITION, 0);
    }
    triggerActionMember() {
      return this.getRuleContext(0, TriggerActionMemberContext);
    }
    guardExpressionMember() {
      return this.getRuleContext(0, GuardExpressionMemberContext);
    }
    effectBehaviorMember() {
      return this.getRuleContext(0, EffectBehaviorMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_targetTransitionUsage;
    }
    enterRule(listener) {
      if (listener.enterTargetTransitionUsage) {
        listener.enterTargetTransitionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTargetTransitionUsage) {
        listener.exitTargetTransitionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTargetTransitionUsage) {
        return visitor.visitTargetTransitionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TriggerActionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ACCEPT() {
      return this.getToken(SysMLv2Parser.ACCEPT, 0);
    }
    triggerAction() {
      return this.getRuleContext(0, TriggerActionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_triggerActionMember;
    }
    enterRule(listener) {
      if (listener.enterTriggerActionMember) {
        listener.enterTriggerActionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTriggerActionMember) {
        listener.exitTriggerActionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTriggerActionMember) {
        return visitor.visitTriggerActionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TriggerActionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    acceptParameterPart() {
      return this.getRuleContext(0, AcceptParameterPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_triggerAction;
    }
    enterRule(listener) {
      if (listener.enterTriggerAction) {
        listener.enterTriggerAction(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTriggerAction) {
        listener.exitTriggerAction(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTriggerAction) {
        return visitor.visitTriggerAction(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var GuardExpressionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    IF() {
      return this.getToken(SysMLv2Parser.IF, 0);
    }
    ownedExpression() {
      return this.getRuleContext(0, OwnedExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_guardExpressionMember;
    }
    enterRule(listener) {
      if (listener.enterGuardExpressionMember) {
        listener.enterGuardExpressionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitGuardExpressionMember) {
        listener.exitGuardExpressionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitGuardExpressionMember) {
        return visitor.visitGuardExpressionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EffectBehaviorMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    DO() {
      return this.getToken(SysMLv2Parser.DO, 0);
    }
    effectBehaviorUsage() {
      return this.getRuleContext(0, EffectBehaviorUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_effectBehaviorMember;
    }
    enterRule(listener) {
      if (listener.enterEffectBehaviorMember) {
        listener.enterEffectBehaviorMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEffectBehaviorMember) {
        listener.exitEffectBehaviorMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEffectBehaviorMember) {
        return visitor.visitEffectBehaviorMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EffectBehaviorUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    emptyActionUsage_() {
      return this.getRuleContext(0, EmptyActionUsage_Context);
    }
    transitionPerformActionUsage() {
      return this.getRuleContext(0, TransitionPerformActionUsageContext);
    }
    transitionAcceptActionUsage() {
      return this.getRuleContext(0, TransitionAcceptActionUsageContext);
    }
    transitionSendActionUsage() {
      return this.getRuleContext(0, TransitionSendActionUsageContext);
    }
    transitionAssignmentActionUsage() {
      return this.getRuleContext(0, TransitionAssignmentActionUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_effectBehaviorUsage;
    }
    enterRule(listener) {
      if (listener.enterEffectBehaviorUsage) {
        listener.enterEffectBehaviorUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEffectBehaviorUsage) {
        listener.exitEffectBehaviorUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEffectBehaviorUsage) {
        return visitor.visitEffectBehaviorUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TransitionPerformActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    performActionUsageDeclaration() {
      return this.getRuleContext(0, PerformActionUsageDeclarationContext);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    actionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(ActionBodyItemContext);
      }
      return this.getRuleContext(i, ActionBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_transitionPerformActionUsage;
    }
    enterRule(listener) {
      if (listener.enterTransitionPerformActionUsage) {
        listener.enterTransitionPerformActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTransitionPerformActionUsage) {
        listener.exitTransitionPerformActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTransitionPerformActionUsage) {
        return visitor.visitTransitionPerformActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TransitionAcceptActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    acceptNodeDeclaration() {
      return this.getRuleContext(0, AcceptNodeDeclarationContext);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    actionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(ActionBodyItemContext);
      }
      return this.getRuleContext(i, ActionBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_transitionAcceptActionUsage;
    }
    enterRule(listener) {
      if (listener.enterTransitionAcceptActionUsage) {
        listener.enterTransitionAcceptActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTransitionAcceptActionUsage) {
        listener.exitTransitionAcceptActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTransitionAcceptActionUsage) {
        return visitor.visitTransitionAcceptActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TransitionSendActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    sendNodeDeclaration() {
      return this.getRuleContext(0, SendNodeDeclarationContext);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    actionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(ActionBodyItemContext);
      }
      return this.getRuleContext(i, ActionBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_transitionSendActionUsage;
    }
    enterRule(listener) {
      if (listener.enterTransitionSendActionUsage) {
        listener.enterTransitionSendActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTransitionSendActionUsage) {
        listener.exitTransitionSendActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTransitionSendActionUsage) {
        return visitor.visitTransitionSendActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TransitionAssignmentActionUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    assignmentNodeDeclaration() {
      return this.getRuleContext(0, AssignmentNodeDeclarationContext);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    actionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(ActionBodyItemContext);
      }
      return this.getRuleContext(i, ActionBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_transitionAssignmentActionUsage;
    }
    enterRule(listener) {
      if (listener.enterTransitionAssignmentActionUsage) {
        listener.enterTransitionAssignmentActionUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTransitionAssignmentActionUsage) {
        listener.exitTransitionAssignmentActionUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTransitionAssignmentActionUsage) {
        return visitor.visitTransitionAssignmentActionUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TransitionSuccessionMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    transitionSuccession() {
      return this.getRuleContext(0, TransitionSuccessionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_transitionSuccessionMember;
    }
    enterRule(listener) {
      if (listener.enterTransitionSuccessionMember) {
        listener.enterTransitionSuccessionMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTransitionSuccessionMember) {
        listener.exitTransitionSuccessionMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTransitionSuccessionMember) {
        return visitor.visitTransitionSuccessionMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var TransitionSuccessionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    emptyEndMember() {
      return this.getRuleContext(0, EmptyEndMemberContext);
    }
    connectorEndMember() {
      return this.getRuleContext(0, ConnectorEndMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_transitionSuccession;
    }
    enterRule(listener) {
      if (listener.enterTransitionSuccession) {
        listener.enterTransitionSuccession(this);
      }
    }
    exitRule(listener) {
      if (listener.exitTransitionSuccession) {
        listener.exitTransitionSuccession(this);
      }
    }
    accept(visitor) {
      if (visitor.visitTransitionSuccession) {
        return visitor.visitTransitionSuccession(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EmptyEndMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    emptyFeature_() {
      return this.getRuleContext(0, EmptyFeature_Context);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_emptyEndMember;
    }
    enterRule(listener) {
      if (listener.enterEmptyEndMember) {
        listener.enterEmptyEndMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEmptyEndMember) {
        listener.exitEmptyEndMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEmptyEndMember) {
        return visitor.visitEmptyEndMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CalculationDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    CALC() {
      return this.getToken(SysMLv2Parser.CALC, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    calculationBody() {
      return this.getRuleContext(0, CalculationBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_calculationDefinition;
    }
    enterRule(listener) {
      if (listener.enterCalculationDefinition) {
        listener.enterCalculationDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCalculationDefinition) {
        listener.exitCalculationDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCalculationDefinition) {
        return visitor.visitCalculationDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CalculationUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    CALC() {
      return this.getToken(SysMLv2Parser.CALC, 0);
    }
    actionUsageDeclaration() {
      return this.getRuleContext(0, ActionUsageDeclarationContext);
    }
    calculationBody() {
      return this.getRuleContext(0, CalculationBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_calculationUsage;
    }
    enterRule(listener) {
      if (listener.enterCalculationUsage) {
        listener.enterCalculationUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCalculationUsage) {
        listener.exitCalculationUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCalculationUsage) {
        return visitor.visitCalculationUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CalculationBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    calculationBodyPart() {
      return this.getRuleContext(0, CalculationBodyPartContext);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_calculationBody;
    }
    enterRule(listener) {
      if (listener.enterCalculationBody) {
        listener.enterCalculationBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCalculationBody) {
        listener.exitCalculationBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCalculationBody) {
        return visitor.visitCalculationBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CalculationBodyPartContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    calculationBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(CalculationBodyItemContext);
      }
      return this.getRuleContext(i, CalculationBodyItemContext);
    }
    resultExpressionMember() {
      return this.getRuleContext(0, ResultExpressionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_calculationBodyPart;
    }
    enterRule(listener) {
      if (listener.enterCalculationBodyPart) {
        listener.enterCalculationBodyPart(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCalculationBodyPart) {
        listener.exitCalculationBodyPart(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCalculationBodyPart) {
        return visitor.visitCalculationBodyPart(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CalculationBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    actionBodyItem() {
      return this.getRuleContext(0, ActionBodyItemContext);
    }
    returnParameterMember() {
      return this.getRuleContext(0, ReturnParameterMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_calculationBodyItem;
    }
    enterRule(listener) {
      if (listener.enterCalculationBodyItem) {
        listener.enterCalculationBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCalculationBodyItem) {
        listener.exitCalculationBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCalculationBodyItem) {
        return visitor.visitCalculationBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ReturnParameterMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    RETURN() {
      return this.getToken(SysMLv2Parser.RETURN, 0);
    }
    usageElement() {
      return this.getRuleContext(0, UsageElementContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_returnParameterMember;
    }
    enterRule(listener) {
      if (listener.enterReturnParameterMember) {
        listener.enterReturnParameterMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitReturnParameterMember) {
        listener.exitReturnParameterMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitReturnParameterMember) {
        return visitor.visitReturnParameterMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConstraintDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    CONSTRAINT() {
      return this.getToken(SysMLv2Parser.CONSTRAINT, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    calculationBody() {
      return this.getRuleContext(0, CalculationBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_constraintDefinition;
    }
    enterRule(listener) {
      if (listener.enterConstraintDefinition) {
        listener.enterConstraintDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConstraintDefinition) {
        listener.exitConstraintDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConstraintDefinition) {
        return visitor.visitConstraintDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConstraintUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    CONSTRAINT() {
      return this.getToken(SysMLv2Parser.CONSTRAINT, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    calculationBody() {
      return this.getRuleContext(0, CalculationBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_constraintUsage;
    }
    enterRule(listener) {
      if (listener.enterConstraintUsage) {
        listener.enterConstraintUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConstraintUsage) {
        listener.exitConstraintUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConstraintUsage) {
        return visitor.visitConstraintUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AssertConstraintUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    ASSERT() {
      return this.getToken(SysMLv2Parser.ASSERT, 0);
    }
    calculationBody() {
      return this.getRuleContext(0, CalculationBodyContext);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    CONSTRAINT() {
      return this.getToken(SysMLv2Parser.CONSTRAINT, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    NOT() {
      return this.getToken(SysMLv2Parser.NOT, 0);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_assertConstraintUsage;
    }
    enterRule(listener) {
      if (listener.enterAssertConstraintUsage) {
        listener.enterAssertConstraintUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAssertConstraintUsage) {
        listener.exitAssertConstraintUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAssertConstraintUsage) {
        return visitor.visitAssertConstraintUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConstraintUsageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_constraintUsageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterConstraintUsageDeclaration) {
        listener.enterConstraintUsageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConstraintUsageDeclaration) {
        listener.exitConstraintUsageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConstraintUsageDeclaration) {
        return visitor.visitConstraintUsageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    REQUIREMENT() {
      return this.getToken(SysMLv2Parser.REQUIREMENT, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementDefinition;
    }
    enterRule(listener) {
      if (listener.enterRequirementDefinition) {
        listener.enterRequirementDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementDefinition) {
        listener.exitRequirementDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementDefinition) {
        return visitor.visitRequirementDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    requirementBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(RequirementBodyItemContext);
      }
      return this.getRuleContext(i, RequirementBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementBody;
    }
    enterRule(listener) {
      if (listener.enterRequirementBody) {
        listener.enterRequirementBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementBody) {
        listener.exitRequirementBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementBody) {
        return visitor.visitRequirementBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionBodyItem() {
      return this.getRuleContext(0, DefinitionBodyItemContext);
    }
    subjectMember() {
      return this.getRuleContext(0, SubjectMemberContext);
    }
    requirementConstraintMember() {
      return this.getRuleContext(0, RequirementConstraintMemberContext);
    }
    framedConcernMember() {
      return this.getRuleContext(0, FramedConcernMemberContext);
    }
    requirementVerificationMember() {
      return this.getRuleContext(0, RequirementVerificationMemberContext);
    }
    actorMember() {
      return this.getRuleContext(0, ActorMemberContext);
    }
    stakeholderMember() {
      return this.getRuleContext(0, StakeholderMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementBodyItem;
    }
    enterRule(listener) {
      if (listener.enterRequirementBodyItem) {
        listener.enterRequirementBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementBodyItem) {
        listener.exitRequirementBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementBodyItem) {
        return visitor.visitRequirementBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SubjectMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    subjectUsage() {
      return this.getRuleContext(0, SubjectUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_subjectMember;
    }
    enterRule(listener) {
      if (listener.enterSubjectMember) {
        listener.enterSubjectMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSubjectMember) {
        listener.exitSubjectMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSubjectMember) {
        return visitor.visitSubjectMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SubjectUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SUBJECT() {
      return this.getToken(SysMLv2Parser.SUBJECT, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_subjectUsage;
    }
    enterRule(listener) {
      if (listener.enterSubjectUsage) {
        listener.enterSubjectUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSubjectUsage) {
        listener.exitSubjectUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSubjectUsage) {
        return visitor.visitSubjectUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementConstraintMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    requirementKind() {
      return this.getRuleContext(0, RequirementKindContext);
    }
    requirementConstraintUsage() {
      return this.getRuleContext(0, RequirementConstraintUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementConstraintMember;
    }
    enterRule(listener) {
      if (listener.enterRequirementConstraintMember) {
        listener.enterRequirementConstraintMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementConstraintMember) {
        listener.exitRequirementConstraintMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementConstraintMember) {
        return visitor.visitRequirementConstraintMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementKindContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ASSUME() {
      return this.getToken(SysMLv2Parser.ASSUME, 0);
    }
    REQUIRE() {
      return this.getToken(SysMLv2Parser.REQUIRE, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementKind;
    }
    enterRule(listener) {
      if (listener.enterRequirementKind) {
        listener.enterRequirementKind(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementKind) {
        listener.exitRequirementKind(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementKind) {
        return visitor.visitRequirementKind(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementConstraintUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    calculationBody() {
      return this.getRuleContext(0, CalculationBodyContext);
    }
    CONSTRAINT() {
      return this.getToken(SysMLv2Parser.CONSTRAINT, 0);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementConstraintUsage;
    }
    enterRule(listener) {
      if (listener.enterRequirementConstraintUsage) {
        listener.enterRequirementConstraintUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementConstraintUsage) {
        listener.exitRequirementConstraintUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementConstraintUsage) {
        return visitor.visitRequirementConstraintUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FramedConcernMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    FRAME() {
      return this.getToken(SysMLv2Parser.FRAME, 0);
    }
    framedConcernUsage() {
      return this.getRuleContext(0, FramedConcernUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_framedConcernMember;
    }
    enterRule(listener) {
      if (listener.enterFramedConcernMember) {
        listener.enterFramedConcernMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFramedConcernMember) {
        listener.exitFramedConcernMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFramedConcernMember) {
        return visitor.visitFramedConcernMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FramedConcernUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    calculationBody() {
      return this.getRuleContext(0, CalculationBodyContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    calculationUsageDeclaration() {
      return this.getRuleContext(0, CalculationUsageDeclarationContext);
    }
    CONCERN() {
      return this.getToken(SysMLv2Parser.CONCERN, 0);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_framedConcernUsage;
    }
    enterRule(listener) {
      if (listener.enterFramedConcernUsage) {
        listener.enterFramedConcernUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFramedConcernUsage) {
        listener.exitFramedConcernUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFramedConcernUsage) {
        return visitor.visitFramedConcernUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActorMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    actorUsage() {
      return this.getRuleContext(0, ActorUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actorMember;
    }
    enterRule(listener) {
      if (listener.enterActorMember) {
        listener.enterActorMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActorMember) {
        listener.exitActorMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActorMember) {
        return visitor.visitActorMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ActorUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ACTOR() {
      return this.getToken(SysMLv2Parser.ACTOR, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_actorUsage;
    }
    enterRule(listener) {
      if (listener.enterActorUsage) {
        listener.enterActorUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitActorUsage) {
        listener.exitActorUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitActorUsage) {
        return visitor.visitActorUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StakeholderMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    stakeholderUsage() {
      return this.getRuleContext(0, StakeholderUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stakeholderMember;
    }
    enterRule(listener) {
      if (listener.enterStakeholderMember) {
        listener.enterStakeholderMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStakeholderMember) {
        listener.exitStakeholderMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStakeholderMember) {
        return visitor.visitStakeholderMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var StakeholderUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    STAKEHOLDER() {
      return this.getToken(SysMLv2Parser.STAKEHOLDER, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_stakeholderUsage;
    }
    enterRule(listener) {
      if (listener.enterStakeholderUsage) {
        listener.enterStakeholderUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitStakeholderUsage) {
        listener.exitStakeholderUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitStakeholderUsage) {
        return visitor.visitStakeholderUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    REQUIREMENT() {
      return this.getToken(SysMLv2Parser.REQUIREMENT, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementUsage;
    }
    enterRule(listener) {
      if (listener.enterRequirementUsage) {
        listener.enterRequirementUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementUsage) {
        listener.exitRequirementUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementUsage) {
        return visitor.visitRequirementUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SatisfyRequirementUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    SATISFY() {
      return this.getToken(SysMLv2Parser.SATISFY, 0);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    REQUIREMENT() {
      return this.getToken(SysMLv2Parser.REQUIREMENT, 0);
    }
    ASSERT() {
      return this.getToken(SysMLv2Parser.ASSERT, 0);
    }
    NOT() {
      return this.getToken(SysMLv2Parser.NOT, 0);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    BY() {
      return this.getToken(SysMLv2Parser.BY, 0);
    }
    satisfactionSubjectMember() {
      return this.getRuleContext(0, SatisfactionSubjectMemberContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_satisfyRequirementUsage;
    }
    enterRule(listener) {
      if (listener.enterSatisfyRequirementUsage) {
        listener.enterSatisfyRequirementUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSatisfyRequirementUsage) {
        listener.exitSatisfyRequirementUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSatisfyRequirementUsage) {
        return visitor.visitSatisfyRequirementUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SatisfactionSubjectMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    satisfactionParameter() {
      return this.getRuleContext(0, SatisfactionParameterContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_satisfactionSubjectMember;
    }
    enterRule(listener) {
      if (listener.enterSatisfactionSubjectMember) {
        listener.enterSatisfactionSubjectMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSatisfactionSubjectMember) {
        listener.exitSatisfactionSubjectMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSatisfactionSubjectMember) {
        return visitor.visitSatisfactionSubjectMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SatisfactionParameterContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    satisfactionFeatureValue() {
      return this.getRuleContext(0, SatisfactionFeatureValueContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_satisfactionParameter;
    }
    enterRule(listener) {
      if (listener.enterSatisfactionParameter) {
        listener.enterSatisfactionParameter(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSatisfactionParameter) {
        listener.exitSatisfactionParameter(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSatisfactionParameter) {
        return visitor.visitSatisfactionParameter(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SatisfactionFeatureValueContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    satisfactionReferenceExpression() {
      return this.getRuleContext(0, SatisfactionReferenceExpressionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_satisfactionFeatureValue;
    }
    enterRule(listener) {
      if (listener.enterSatisfactionFeatureValue) {
        listener.enterSatisfactionFeatureValue(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSatisfactionFeatureValue) {
        listener.exitSatisfactionFeatureValue(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSatisfactionFeatureValue) {
        return visitor.visitSatisfactionFeatureValue(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var SatisfactionReferenceExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    featureChainMember() {
      return this.getRuleContext(0, FeatureChainMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_satisfactionReferenceExpression;
    }
    enterRule(listener) {
      if (listener.enterSatisfactionReferenceExpression) {
        listener.enterSatisfactionReferenceExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitSatisfactionReferenceExpression) {
        listener.exitSatisfactionReferenceExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitSatisfactionReferenceExpression) {
        return visitor.visitSatisfactionReferenceExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConcernDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    CONCERN() {
      return this.getToken(SysMLv2Parser.CONCERN, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_concernDefinition;
    }
    enterRule(listener) {
      if (listener.enterConcernDefinition) {
        listener.enterConcernDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConcernDefinition) {
        listener.exitConcernDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConcernDefinition) {
        return visitor.visitConcernDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ConcernUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    CONCERN() {
      return this.getToken(SysMLv2Parser.CONCERN, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_concernUsage;
    }
    enterRule(listener) {
      if (listener.enterConcernUsage) {
        listener.enterConcernUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitConcernUsage) {
        listener.exitConcernUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitConcernUsage) {
        return visitor.visitConcernUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CaseDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    CASE() {
      return this.getToken(SysMLv2Parser.CASE, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_caseDefinition;
    }
    enterRule(listener) {
      if (listener.enterCaseDefinition) {
        listener.enterCaseDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCaseDefinition) {
        listener.exitCaseDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCaseDefinition) {
        return visitor.visitCaseDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CaseUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    CASE() {
      return this.getToken(SysMLv2Parser.CASE, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_caseUsage;
    }
    enterRule(listener) {
      if (listener.enterCaseUsage) {
        listener.enterCaseUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCaseUsage) {
        listener.exitCaseUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCaseUsage) {
        return visitor.visitCaseUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CaseBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    caseBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(CaseBodyItemContext);
      }
      return this.getRuleContext(i, CaseBodyItemContext);
    }
    resultExpressionMember() {
      return this.getRuleContext(0, ResultExpressionMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_caseBody;
    }
    enterRule(listener) {
      if (listener.enterCaseBody) {
        listener.enterCaseBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCaseBody) {
        listener.exitCaseBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCaseBody) {
        return visitor.visitCaseBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CaseBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    actionBodyItem() {
      return this.getRuleContext(0, ActionBodyItemContext);
    }
    returnParameterMember() {
      return this.getRuleContext(0, ReturnParameterMemberContext);
    }
    subjectMember() {
      return this.getRuleContext(0, SubjectMemberContext);
    }
    actorMember() {
      return this.getRuleContext(0, ActorMemberContext);
    }
    objectiveMember() {
      return this.getRuleContext(0, ObjectiveMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_caseBodyItem;
    }
    enterRule(listener) {
      if (listener.enterCaseBodyItem) {
        listener.enterCaseBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCaseBodyItem) {
        listener.exitCaseBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCaseBodyItem) {
        return visitor.visitCaseBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ObjectiveMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    OBJECTIVE() {
      return this.getToken(SysMLv2Parser.OBJECTIVE, 0);
    }
    objectiveRequirementUsage() {
      return this.getRuleContext(0, ObjectiveRequirementUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_objectiveMember;
    }
    enterRule(listener) {
      if (listener.enterObjectiveMember) {
        listener.enterObjectiveMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitObjectiveMember) {
        listener.exitObjectiveMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitObjectiveMember) {
        return visitor.visitObjectiveMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ObjectiveRequirementUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_objectiveRequirementUsage;
    }
    enterRule(listener) {
      if (listener.enterObjectiveRequirementUsage) {
        listener.enterObjectiveRequirementUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitObjectiveRequirementUsage) {
        listener.exitObjectiveRequirementUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitObjectiveRequirementUsage) {
        return visitor.visitObjectiveRequirementUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AnalysisCaseDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    ANALYSIS() {
      return this.getToken(SysMLv2Parser.ANALYSIS, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_analysisCaseDefinition;
    }
    enterRule(listener) {
      if (listener.enterAnalysisCaseDefinition) {
        listener.enterAnalysisCaseDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAnalysisCaseDefinition) {
        listener.exitAnalysisCaseDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAnalysisCaseDefinition) {
        return visitor.visitAnalysisCaseDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var AnalysisCaseUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    ANALYSIS() {
      return this.getToken(SysMLv2Parser.ANALYSIS, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_analysisCaseUsage;
    }
    enterRule(listener) {
      if (listener.enterAnalysisCaseUsage) {
        listener.enterAnalysisCaseUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitAnalysisCaseUsage) {
        listener.exitAnalysisCaseUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitAnalysisCaseUsage) {
        return visitor.visitAnalysisCaseUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var VerificationCaseDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    VERIFICATION() {
      return this.getToken(SysMLv2Parser.VERIFICATION, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_verificationCaseDefinition;
    }
    enterRule(listener) {
      if (listener.enterVerificationCaseDefinition) {
        listener.enterVerificationCaseDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitVerificationCaseDefinition) {
        listener.exitVerificationCaseDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitVerificationCaseDefinition) {
        return visitor.visitVerificationCaseDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var VerificationCaseUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    VERIFICATION() {
      return this.getToken(SysMLv2Parser.VERIFICATION, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_verificationCaseUsage;
    }
    enterRule(listener) {
      if (listener.enterVerificationCaseUsage) {
        listener.enterVerificationCaseUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitVerificationCaseUsage) {
        listener.exitVerificationCaseUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitVerificationCaseUsage) {
        return visitor.visitVerificationCaseUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementVerificationMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    VERIFY() {
      return this.getToken(SysMLv2Parser.VERIFY, 0);
    }
    requirementVerificationUsage() {
      return this.getRuleContext(0, RequirementVerificationUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementVerificationMember;
    }
    enterRule(listener) {
      if (listener.enterRequirementVerificationMember) {
        listener.enterRequirementVerificationMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementVerificationMember) {
        listener.exitRequirementVerificationMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementVerificationMember) {
        return visitor.visitRequirementVerificationMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RequirementVerificationUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    featureSpecialization(i) {
      if (i === void 0) {
        return this.getRuleContexts(FeatureSpecializationContext);
      }
      return this.getRuleContext(i, FeatureSpecializationContext);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    REQUIREMENT() {
      return this.getToken(SysMLv2Parser.REQUIREMENT, 0);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_requirementVerificationUsage;
    }
    enterRule(listener) {
      if (listener.enterRequirementVerificationUsage) {
        listener.enterRequirementVerificationUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRequirementVerificationUsage) {
        listener.exitRequirementVerificationUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRequirementVerificationUsage) {
        return visitor.visitRequirementVerificationUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UseCaseDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    USE() {
      return this.getToken(SysMLv2Parser.USE, 0);
    }
    CASE() {
      return this.getToken(SysMLv2Parser.CASE, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_useCaseDefinition;
    }
    enterRule(listener) {
      if (listener.enterUseCaseDefinition) {
        listener.enterUseCaseDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUseCaseDefinition) {
        listener.exitUseCaseDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUseCaseDefinition) {
        return visitor.visitUseCaseDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var UseCaseUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    USE() {
      return this.getToken(SysMLv2Parser.USE, 0);
    }
    CASE() {
      return this.getToken(SysMLv2Parser.CASE, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_useCaseUsage;
    }
    enterRule(listener) {
      if (listener.enterUseCaseUsage) {
        listener.enterUseCaseUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitUseCaseUsage) {
        listener.exitUseCaseUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitUseCaseUsage) {
        return visitor.visitUseCaseUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var IncludeUseCaseUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    INCLUDE() {
      return this.getToken(SysMLv2Parser.INCLUDE, 0);
    }
    caseBody() {
      return this.getRuleContext(0, CaseBodyContext);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    USE() {
      return this.getToken(SysMLv2Parser.USE, 0);
    }
    CASE() {
      return this.getToken(SysMLv2Parser.CASE, 0);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_includeUseCaseUsage;
    }
    enterRule(listener) {
      if (listener.enterIncludeUseCaseUsage) {
        listener.enterIncludeUseCaseUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitIncludeUseCaseUsage) {
        listener.exitIncludeUseCaseUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitIncludeUseCaseUsage) {
        return visitor.visitIncludeUseCaseUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    VIEW() {
      return this.getToken(SysMLv2Parser.VIEW, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    viewDefinitionBody() {
      return this.getRuleContext(0, ViewDefinitionBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewDefinition;
    }
    enterRule(listener) {
      if (listener.enterViewDefinition) {
        listener.enterViewDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewDefinition) {
        listener.exitViewDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewDefinition) {
        return visitor.visitViewDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewDefinitionBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    viewDefinitionBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(ViewDefinitionBodyItemContext);
      }
      return this.getRuleContext(i, ViewDefinitionBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewDefinitionBody;
    }
    enterRule(listener) {
      if (listener.enterViewDefinitionBody) {
        listener.enterViewDefinitionBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewDefinitionBody) {
        listener.exitViewDefinitionBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewDefinitionBody) {
        return visitor.visitViewDefinitionBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewDefinitionBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionBodyItem() {
      return this.getRuleContext(0, DefinitionBodyItemContext);
    }
    elementFilterMember() {
      return this.getRuleContext(0, ElementFilterMemberContext);
    }
    viewRenderingMember() {
      return this.getRuleContext(0, ViewRenderingMemberContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewDefinitionBodyItem;
    }
    enterRule(listener) {
      if (listener.enterViewDefinitionBodyItem) {
        listener.enterViewDefinitionBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewDefinitionBodyItem) {
        listener.exitViewDefinitionBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewDefinitionBodyItem) {
        return visitor.visitViewDefinitionBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewRenderingMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    memberPrefix() {
      return this.getRuleContext(0, MemberPrefixContext);
    }
    RENDER() {
      return this.getToken(SysMLv2Parser.RENDER, 0);
    }
    viewRenderingUsage() {
      return this.getRuleContext(0, ViewRenderingUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewRenderingMember;
    }
    enterRule(listener) {
      if (listener.enterViewRenderingMember) {
        listener.enterViewRenderingMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewRenderingMember) {
        listener.exitViewRenderingMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewRenderingMember) {
        return visitor.visitViewRenderingMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewRenderingUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedReferenceSubsetting() {
      return this.getRuleContext(0, OwnedReferenceSubsettingContext);
    }
    usageBody() {
      return this.getRuleContext(0, UsageBodyContext);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    RENDERING() {
      return this.getToken(SysMLv2Parser.RENDERING, 0);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewRenderingUsage;
    }
    enterRule(listener) {
      if (listener.enterViewRenderingUsage) {
        listener.enterViewRenderingUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewRenderingUsage) {
        listener.exitViewRenderingUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewRenderingUsage) {
        return visitor.visitViewRenderingUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    VIEW() {
      return this.getToken(SysMLv2Parser.VIEW, 0);
    }
    viewBody() {
      return this.getRuleContext(0, ViewBodyContext);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewUsage;
    }
    enterRule(listener) {
      if (listener.enterViewUsage) {
        listener.enterViewUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewUsage) {
        listener.exitViewUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewUsage) {
        return visitor.visitViewUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewBodyContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    SEMI() {
      return this.getToken(SysMLv2Parser.SEMI, 0);
    }
    LBRACE() {
      return this.getToken(SysMLv2Parser.LBRACE, 0);
    }
    RBRACE() {
      return this.getToken(SysMLv2Parser.RBRACE, 0);
    }
    viewBodyItem(i) {
      if (i === void 0) {
        return this.getRuleContexts(ViewBodyItemContext);
      }
      return this.getRuleContext(i, ViewBodyItemContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewBody;
    }
    enterRule(listener) {
      if (listener.enterViewBody) {
        listener.enterViewBody(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewBody) {
        listener.exitViewBody(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewBody) {
        return visitor.visitViewBody(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewBodyItemContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    definitionBodyItem() {
      return this.getRuleContext(0, DefinitionBodyItemContext);
    }
    elementFilterMember() {
      return this.getRuleContext(0, ElementFilterMemberContext);
    }
    viewRenderingMember() {
      return this.getRuleContext(0, ViewRenderingMemberContext);
    }
    expose() {
      return this.getRuleContext(0, ExposeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewBodyItem;
    }
    enterRule(listener) {
      if (listener.enterViewBodyItem) {
        listener.enterViewBodyItem(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewBodyItem) {
        listener.exitViewBodyItem(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewBodyItem) {
        return visitor.visitViewBodyItem(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ExposeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    EXPOSE() {
      return this.getToken(SysMLv2Parser.EXPOSE, 0);
    }
    relationshipBody() {
      return this.getRuleContext(0, RelationshipBodyContext);
    }
    membershipExpose() {
      return this.getRuleContext(0, MembershipExposeContext);
    }
    namespaceExpose() {
      return this.getRuleContext(0, NamespaceExposeContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_expose;
    }
    enterRule(listener) {
      if (listener.enterExpose) {
        listener.enterExpose(this);
      }
    }
    exitRule(listener) {
      if (listener.exitExpose) {
        listener.exitExpose(this);
      }
    }
    accept(visitor) {
      if (visitor.visitExpose) {
        return visitor.visitExpose(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MembershipExposeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    membershipImport() {
      return this.getRuleContext(0, MembershipImportContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_membershipExpose;
    }
    enterRule(listener) {
      if (listener.enterMembershipExpose) {
        listener.enterMembershipExpose(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMembershipExpose) {
        listener.exitMembershipExpose(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMembershipExpose) {
        return visitor.visitMembershipExpose(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceExposeContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    namespaceImport() {
      return this.getRuleContext(0, NamespaceImportContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespaceExpose;
    }
    enterRule(listener) {
      if (listener.enterNamespaceExpose) {
        listener.enterNamespaceExpose(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespaceExpose) {
        listener.exitNamespaceExpose(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespaceExpose) {
        return visitor.visitNamespaceExpose(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewpointDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    VIEWPOINT() {
      return this.getToken(SysMLv2Parser.VIEWPOINT, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definitionDeclaration() {
      return this.getRuleContext(0, DefinitionDeclarationContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewpointDefinition;
    }
    enterRule(listener) {
      if (listener.enterViewpointDefinition) {
        listener.enterViewpointDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewpointDefinition) {
        listener.exitViewpointDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewpointDefinition) {
        return visitor.visitViewpointDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ViewpointUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    VIEWPOINT() {
      return this.getToken(SysMLv2Parser.VIEWPOINT, 0);
    }
    constraintUsageDeclaration() {
      return this.getRuleContext(0, ConstraintUsageDeclarationContext);
    }
    requirementBody() {
      return this.getRuleContext(0, RequirementBodyContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_viewpointUsage;
    }
    enterRule(listener) {
      if (listener.enterViewpointUsage) {
        listener.enterViewpointUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitViewpointUsage) {
        listener.exitViewpointUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitViewpointUsage) {
        return visitor.visitViewpointUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RenderingDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceDefinitionPrefix() {
      return this.getRuleContext(0, OccurrenceDefinitionPrefixContext);
    }
    RENDERING() {
      return this.getToken(SysMLv2Parser.RENDERING, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_renderingDefinition;
    }
    enterRule(listener) {
      if (listener.enterRenderingDefinition) {
        listener.enterRenderingDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRenderingDefinition) {
        listener.exitRenderingDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRenderingDefinition) {
        return visitor.visitRenderingDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var RenderingUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    occurrenceUsagePrefix() {
      return this.getRuleContext(0, OccurrenceUsagePrefixContext);
    }
    RENDERING() {
      return this.getToken(SysMLv2Parser.RENDERING, 0);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_renderingUsage;
    }
    enterRule(listener) {
      if (listener.enterRenderingUsage) {
        listener.enterRenderingUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitRenderingUsage) {
        listener.exitRenderingUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitRenderingUsage) {
        return visitor.visitRenderingUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    METADATA() {
      return this.getToken(SysMLv2Parser.METADATA, 0);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    ABSTRACT() {
      return this.getToken(SysMLv2Parser.ABSTRACT, 0);
    }
    definitionExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionExtensionKeywordContext);
      }
      return this.getRuleContext(i, DefinitionExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataDefinition;
    }
    enterRule(listener) {
      if (listener.enterMetadataDefinition) {
        listener.enterMetadataDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataDefinition) {
        listener.exitMetadataDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataDefinition) {
        return visitor.visitMetadataDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PrefixMetadataUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedFeatureTyping() {
      return this.getRuleContext(0, OwnedFeatureTypingContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_prefixMetadataUsage;
    }
    enterRule(listener) {
      if (listener.enterPrefixMetadataUsage) {
        listener.enterPrefixMetadataUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPrefixMetadataUsage) {
        listener.exitPrefixMetadataUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPrefixMetadataUsage) {
        return visitor.visitPrefixMetadataUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataBodyUsageMemberContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    metadataBodyUsage() {
      return this.getRuleContext(0, MetadataBodyUsageContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataBodyUsageMember;
    }
    enterRule(listener) {
      if (listener.enterMetadataBodyUsageMember) {
        listener.enterMetadataBodyUsageMember(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataBodyUsageMember) {
        listener.exitMetadataBodyUsageMember(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataBodyUsageMember) {
        return visitor.visitMetadataBodyUsageMember(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var MetadataBodyUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    ownedRedefinition() {
      return this.getRuleContext(0, OwnedRedefinitionContext);
    }
    metadataBody() {
      return this.getRuleContext(0, MetadataBodyContext);
    }
    REF() {
      return this.getToken(SysMLv2Parser.REF, 0);
    }
    featureSpecializationPart() {
      return this.getRuleContext(0, FeatureSpecializationPartContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    COLON_GT_GT() {
      return this.getToken(SysMLv2Parser.COLON_GT_GT, 0);
    }
    REDEFINES() {
      return this.getToken(SysMLv2Parser.REDEFINES, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_metadataBodyUsage;
    }
    enterRule(listener) {
      if (listener.enterMetadataBodyUsage) {
        listener.enterMetadataBodyUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitMetadataBodyUsage) {
        listener.exitMetadataBodyUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitMetadataBodyUsage) {
        return visitor.visitMetadataBodyUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ExtendedDefinitionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    DEF() {
      return this.getToken(SysMLv2Parser.DEF, 0);
    }
    definition() {
      return this.getRuleContext(0, DefinitionContext);
    }
    basicDefinitionPrefix() {
      return this.getRuleContext(0, BasicDefinitionPrefixContext);
    }
    definitionExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(DefinitionExtensionKeywordContext);
      }
      return this.getRuleContext(i, DefinitionExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_extendedDefinition;
    }
    enterRule(listener) {
      if (listener.enterExtendedDefinition) {
        listener.enterExtendedDefinition(this);
      }
    }
    exitRule(listener) {
      if (listener.exitExtendedDefinition) {
        listener.exitExtendedDefinition(this);
      }
    }
    accept(visitor) {
      if (visitor.visitExtendedDefinition) {
        return visitor.visitExtendedDefinition(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var ExtendedUsageContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    unextendedUsagePrefix() {
      return this.getRuleContext(0, UnextendedUsagePrefixContext);
    }
    usage() {
      return this.getRuleContext(0, UsageContext);
    }
    usageExtensionKeyword(i) {
      if (i === void 0) {
        return this.getRuleContexts(UsageExtensionKeywordContext);
      }
      return this.getRuleContext(i, UsageExtensionKeywordContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_extendedUsage;
    }
    enterRule(listener) {
      if (listener.enterExtendedUsage) {
        listener.enterExtendedUsage(this);
      }
    }
    exitRule(listener) {
      if (listener.exitExtendedUsage) {
        listener.exitExtendedUsage(this);
      }
    }
    accept(visitor) {
      if (visitor.visitExtendedUsage) {
        return visitor.visitExtendedUsage(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FilterPackageImportDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    membershipImport() {
      return this.getRuleContext(0, MembershipImportContext);
    }
    namespaceImportDirect() {
      return this.getRuleContext(0, NamespaceImportDirectContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_filterPackageImportDeclaration;
    }
    enterRule(listener) {
      if (listener.enterFilterPackageImportDeclaration) {
        listener.enterFilterPackageImportDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFilterPackageImportDeclaration) {
        listener.exitFilterPackageImportDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFilterPackageImportDeclaration) {
        return visitor.visitFilterPackageImportDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NamespaceImportDirectContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    qualifiedName() {
      return this.getRuleContext(0, QualifiedNameContext);
    }
    COLON_COLON(i) {
      if (i === void 0) {
        return this.getTokens(SysMLv2Parser.COLON_COLON);
      } else {
        return this.getToken(SysMLv2Parser.COLON_COLON, i);
      }
    }
    STAR() {
      return this.getToken(SysMLv2Parser.STAR, 0);
    }
    STAR_STAR() {
      return this.getToken(SysMLv2Parser.STAR_STAR, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_namespaceImportDirect;
    }
    enterRule(listener) {
      if (listener.enterNamespaceImportDirect) {
        listener.enterNamespaceImportDirect(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNamespaceImportDirect) {
        listener.exitNamespaceImportDirect(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNamespaceImportDirect) {
        return visitor.visitNamespaceImportDirect(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var CalculationUsageDeclarationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    usageDeclaration() {
      return this.getRuleContext(0, UsageDeclarationContext);
    }
    valuePart() {
      return this.getRuleContext(0, ValuePartContext);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_calculationUsageDeclaration;
    }
    enterRule(listener) {
      if (listener.enterCalculationUsageDeclaration) {
        listener.enterCalculationUsageDeclaration(this);
      }
    }
    exitRule(listener) {
      if (listener.exitCalculationUsageDeclaration) {
        listener.exitCalculationUsageDeclaration(this);
      }
    }
    accept(visitor) {
      if (visitor.visitCalculationUsageDeclaration) {
        return visitor.visitCalculationUsageDeclaration(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EmptyActionUsage_Context = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_emptyActionUsage_;
    }
    enterRule(listener) {
      if (listener.enterEmptyActionUsage_) {
        listener.enterEmptyActionUsage_(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEmptyActionUsage_) {
        listener.exitEmptyActionUsage_(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEmptyActionUsage_) {
        return visitor.visitEmptyActionUsage_(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EmptyFeature_Context = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_emptyFeature_;
    }
    enterRule(listener) {
      if (listener.enterEmptyFeature_) {
        listener.enterEmptyFeature_(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEmptyFeature_) {
        listener.exitEmptyFeature_(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEmptyFeature_) {
        return visitor.visitEmptyFeature_(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EmptyMultiplicity_Context = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_emptyMultiplicity_;
    }
    enterRule(listener) {
      if (listener.enterEmptyMultiplicity_) {
        listener.enterEmptyMultiplicity_(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEmptyMultiplicity_) {
        listener.exitEmptyMultiplicity_(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEmptyMultiplicity_) {
        return visitor.visitEmptyMultiplicity_(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var EmptyUsage_Context = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_emptyUsage_;
    }
    enterRule(listener) {
      if (listener.enterEmptyUsage_) {
        listener.enterEmptyUsage_(this);
      }
    }
    exitRule(listener) {
      if (listener.exitEmptyUsage_) {
        listener.exitEmptyUsage_(this);
      }
    }
    accept(visitor) {
      if (visitor.visitEmptyUsage_) {
        return visitor.visitEmptyUsage_(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var FilterPackageImportContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    IDENTIFIER() {
      return this.getToken(SysMLv2Parser.IDENTIFIER, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_filterPackageImport;
    }
    enterRule(listener) {
      if (listener.enterFilterPackageImport) {
        listener.enterFilterPackageImport(this);
      }
    }
    exitRule(listener) {
      if (listener.exitFilterPackageImport) {
        listener.exitFilterPackageImport(this);
      }
    }
    accept(visitor) {
      if (visitor.visitFilterPackageImport) {
        return visitor.visitFilterPackageImport(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var NonFeatureChainPrimaryExpressionContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    IDENTIFIER() {
      return this.getToken(SysMLv2Parser.IDENTIFIER, 0);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_nonFeatureChainPrimaryExpression;
    }
    enterRule(listener) {
      if (listener.enterNonFeatureChainPrimaryExpression) {
        listener.enterNonFeatureChainPrimaryExpression(this);
      }
    }
    exitRule(listener) {
      if (listener.exitNonFeatureChainPrimaryExpression) {
        listener.exitNonFeatureChainPrimaryExpression(this);
      }
    }
    accept(visitor) {
      if (visitor.visitNonFeatureChainPrimaryExpression) {
        return visitor.visitNonFeatureChainPrimaryExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };
  var PortConjugationContext = class extends ParserRuleContext {
    constructor(parent, invokingState) {
      super(parent, invokingState);
    }
    get ruleIndex() {
      return SysMLv2Parser.RULE_portConjugation;
    }
    enterRule(listener) {
      if (listener.enterPortConjugation) {
        listener.enterPortConjugation(this);
      }
    }
    exitRule(listener) {
      if (listener.exitPortConjugation) {
        listener.exitPortConjugation(this);
      }
    }
    accept(visitor) {
      if (visitor.visitPortConjugation) {
        return visitor.visitPortConjugation(this);
      } else {
        return visitor.visitChildren(this);
      }
    }
  };

  // server/src/parser/dfaSnapshot.ts
  var DFA_SNAPSHOT = [{ "d": 5, "s0": 0, "s": [{ "e": [0, 1, 14, 2, 15, 2, 17, 3, 18, 4, 20, 5, 21, 6, 24, 7, 25, 8, 26, 9, 27, 10] }, { "e": [13, 11, 54, 12, 78, 13, 79, 14, 101, 15, 113, 16, 153, 17, 155, 18, 169, 19, 174, 20, 179, 21, 180, 22, 187, 23, 188, 21, 190, 23, 197, 24, 198, 25, 199, 26, 200, 27, 201, 28, 202, 27, 203, 29, 204, 26, 206, 30, 207, 23, 209, 23, 210, 31, 212, 32, 213, 33, 215, 34, 217, 35] }, { "e": [198, 25, 206, 30, 213, 33] }, { "e": [180, 36, 187, 23, 198, 25, 199, 37, 203, 38, 206, 30, 209, 23, 212, 39, 213, 33, 217, 35] }, { "e": [198, 25, 199, 37, 200, 40, 202, 40, 203, 38, 206, 30, 217, 35] }, { "e": [13, 11, 54, 12, 153, 17, 187, 41, 190, 41, 198, 25, 200, 40, 210, 31, 212, 39, 217, 35] }, { "e": [13, 11, 54, 12, 174, 20, 179, 42, 188, 42, 198, 25, 203, 38, 204, 37, 212, 39, 217, 35] }, { "e": [179, 42, 217, 35] }, { "e": [54, 12, 179, 42, 187, 41, 188, 42, 190, 41, 198, 25, 203, 38, 206, 30] }, { "e": [206, 30] }, { "e": [188, 42] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }], "prec": 1, "precEdges": [0, 1, 14, 2, 15, 2, 17, 3, 18, 4, 20, 5, 21, 6, 24, 7, 25, 8, 26, 9, 27, 10] }, { "d": 7, "s0": 0, "s": [{ "e": [13, 1, 54, 2, 78, 3, 79, 4, 101, 5, 153, 6, 169, 7, 179, 8, 180, 9, 187, 10, 188, 8, 190, 10, 197, 11, 198, 12, 199, 13, 200, 14, 201, 15, 202, 14, 203, 16, 204, 13, 206, 17, 207, 10, 209, 10, 210, 18, 213, 19, 215, 20, 217, 21] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [219, 22] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [219, 23] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [184, 24, 198, 25, 201, 26, 203, 27] }, { "e": [], "a": 1, "p": 3 }, { "e": [219, 22] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 28, 222, 29, 223, 29] }, { "e": [219, 30] }, { "e": [198, 25, 201, 26, 203, 31] }, { "e": [198, 25, 201, 26, 212, 32] }, { "e": [197, 33, 198, 25, 201, 26, 203, 34] }, { "e": [219, 35] }, { "e": [219, 36] }, { "e": [219, 37] }, { "e": [219, 30] }, { "e": [198, 25, 201, 26, 203, 38] }, { "e": [213, 29] }, { "e": [198, 39] }, { "e": [219, 35] }, { "e": [198, 25] }] }, { "d": 9, "s0": 0, "s": [{ "e": [65, 1, 106, 2, 109, 3, 157, 1, 197, 4, 219, 5, 221, 6, 222, 7, 223, 8] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 1 }, { "e": [14, 9, 197, 10, 202, 11, 219, 12, 222, 13] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 7 }, { "e": [], "a": 1, "p": 8 }, { "e": [], "a": 1, "p": 8 }, { "e": [], "a": 1, "p": 8 }, { "e": [], "a": 1, "p": 8 }] }, { "d": 11, "s0": 0, "s": [{ "e": [198, 1, 219, 2, 221, 3] }, { "e": [], "a": 1, "p": 3 }, { "e": [184, 4, 198, 5, 201, 6, 203, 7, 208, 8] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 2] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 16, "s0": 0, "s": [{ "e": [85, 1, 207, 2, 219, 3, 220, 3] }, { "e": [], "a": 1, "p": 3 }, { "e": [219, 4, 220, 4] }, { "e": [], "a": 1, "p": 3 }, { "e": [209, 5] }, { "e": [219, 6] }, { "e": [186, 7, 205, 8, 206, 9, 215, 10] }, { "e": [219, 11] }, { "e": [219, 12] }, { "e": [103, 13, 118, 14] }, { "e": [55, 15] }, { "e": [215, 16] }, { "e": [215, 17] }, { "e": [46, 18] }, { "e": [46, 19] }, { "e": [224, 20] }, { "e": [177, 21] }, { "e": [55, 22, 126, 23] }, { "e": [207, 24] }, { "e": [219, 25] }, { "e": [20, 26, 147, 27] }, { "e": [219, 28] }, { "e": [224, 29] }, { "e": [219, 30] }, { "e": [219, 31] }, { "e": [206, 32, 215, 33] }, { "e": [219, 34] }, { "e": [], "a": 1, "p": 1 }, { "e": [208, 35] }, { "e": [20, 36] }, { "e": [208, 37] }, { "e": [209, 38] }, { "e": [12, 39, 26, 40, 33, 41, 103, 42, 118, 14, 163, 43, 166, 44, 167, 45, 170, 46, 171, 47] }, { "e": [20, 48, 217, 32] }, { "e": [186, 49, 205, 50] }, { "e": [219, 51] }, { "e": [126, 52] }, { "e": [222, 53, 223, 53] }, { "e": [219, 54] }, { "e": [46, 55] }, { "e": [46, 56] }, { "e": [46, 57] }, { "e": [46, 18] }, { "e": [27, 58] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [46, 59] }, { "e": [46, 60] }, { "e": [46, 61] }, { "e": [219, 62] }, { "e": [219, 63] }, { "e": [219, 64] }, { "e": [101, 65] }, { "e": [219, 66] }, { "e": [206, 67, 212, 68] }, { "e": [206, 32] }, { "e": [219, 69] }, { "e": [219, 70] }, { "e": [219, 71] }, { "e": [46, 72] }, { "e": [219, 73] }, { "e": [219, 74] }, { "e": [219, 75] }, { "e": [205, 76] }, { "e": [184, 77, 206, 78] }, { "e": [184, 79, 206, 78] }, { "e": [219, 80] }, { "e": [47, 81, 206, 82, 208, 83] }, { "e": [18, 84, 126, 23] }, { "e": [219, 85] }, { "e": [206, 32] }, { "e": [215, 86] }, { "e": [215, 87] }, { "e": [219, 88] }, { "e": [206, 32] }, { "e": [186, 89, 206, 32, 215, 90] }, { "e": [206, 32, 215, 91] }, { "e": [219, 92] }, { "e": [219, 63] }, { "e": [134, 93] }, { "e": [219, 64] }, { "e": [184, 94, 206, 95] }, { "e": [219, 96] }, { "e": [18, 84, 20, 97, 217, 98] }, { "e": [219, 96, 222, 99] }, { "e": [], "a": 1, "p": 1 }, { "e": [213, 53] }, { "e": [20, 100, 42, 101, 81, 102, 135, 103, 217, 32] }, { "e": [55, 104, 141, 105, 147, 106, 217, 32] }, { "e": [215, 107] }, { "e": [219, 108] }, { "e": [69, 109, 130, 110, 217, 32] }, { "e": [74, 111, 217, 32] }, { "e": [206, 33] }, { "e": [207, 112] }, { "e": [219, 80] }, { "e": [217, 113] }, { "e": [203, 114] }, { "e": [126, 52, 219, 115] }, { "e": [134, 116, 217, 117] }, { "e": [206, 82, 212, 118] }, { "e": [219, 119] }, { "e": [215, 120] }, { "e": [219, 121] }, { "e": [205, 122, 219, 123] }, { "e": [224, 87] }, { "e": [219, 124] }, { "e": [206, 87] }, { "e": [6, 125, 15, 126, 82, 127, 110, 128, 147, 129] }, { "e": [215, 90] }, { "e": [211, 130] }, { "e": [219, 131] }, { "e": [33, 132] }, { "e": [220, 133] }, { "e": [111, 134, 217, 135] }, { "e": [219, 136] }, { "e": [186, 137] }, { "e": [219, 138] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 139] }, { "e": [205, 140, 208, 141] }, { "e": [219, 142] }, { "e": [205, 143] }, { "e": [219, 144] }, { "e": [205, 145] }, { "e": [205, 146] }, { "e": [219, 147] }, { "e": [42, 148] }, { "e": [163, 149] }, { "e": [219, 150] }, { "e": [219, 151] }, { "e": [219, 152] }, { "e": [206, 90] }, { "e": [219, 153] }, { "e": [209, 154] }, { "e": [219, 155] }, { "e": [116, 156] }, { "e": [206, 82] }, { "e": [219, 157] }, { "e": [205, 158] }, { "e": [213, 99] }, { "e": [219, 159] }, { "e": [219, 160] }, { "e": [188, 161] }, { "e": [219, 162] }, { "e": [206, 86] }, { "e": [219, 163] }, { "e": [219, 164] }, { "e": [206, 107, 212, 165] }, { "e": [215, 166] }, { "e": [27, 167] }, { "e": [215, 168] }, { "e": [205, 169] }, { "e": [184, 170, 206, 90] }, { "e": [205, 171] }, { "e": [219, 172] }, { "e": [212, 173] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [184, 174, 206, 82, 208, 83] }, { "e": [219, 175] }, { "e": [206, 86] }, { "e": [200, 176] }, { "e": [197, 177, 219, 178] }, { "e": [206, 86] }, { "e": [206, 86, 208, 179] }, { "e": [206, 87] }, { "e": [222, 180] }, { "e": [219, 181] }, { "e": [219, 182] }, { "e": [55, 183, 217, 107] }, { "e": [219, 184] }, { "e": [219, 152] }, { "e": [219, 185] }, { "e": [205, 186] }, { "e": [199, 187] }, { "e": [219, 157] }, { "e": [215, 188] }, { "e": [219, 189] }, { "e": [197, 190] }, { "e": [217, 191] }, { "e": [219, 192, 222, 193] }, { "e": [182, 194] }, { "e": [179, 195] }, { "e": [186, 196] }, { "e": [224, 168] }, { "e": [206, 107] }, { "e": [206, 91] }, { "e": [219, 197] }, { "e": [213, 198] }, { "e": [20, 199, 55, 200, 120, 201, 147, 202, 217, 203] }, { "e": [199, 176, 206, 86] }, { "e": [222, 204] }, { "e": [135, 103] }, { "e": [199, 205, 203, 206] }, { "e": [199, 205, 204, 205, 206, 86] }, { "e": [222, 207] }, { "e": [109, 208, 219, 209] }, { "e": [219, 210] }, { "e": [215, 211] }, { "e": [107, 212] }, { "e": [126, 213] }, { "e": [224, 188] }, { "e": [219, 214] }, { "e": [219, 215] }, { "e": [134, 116, 217, 216] }, { "e": [198, 217, 204, 218] }, { "e": [219, 219, 223, 193] }, { "e": [219, 220] }, { "e": [213, 221] }, { "e": [174, 195, 217, 222] }, { "e": [179, 195] }, { "e": [212, 223] }, { "e": [18, 224, 126, 225, 211, 226, 217, 227] }, { "e": [206, 228] }, { "e": [219, 229] }, { "e": [215, 230] }, { "e": [47, 231] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [198, 232, 199, 233] }, { "e": [222, 204] }, { "e": [199, 205, 206, 86] }, { "e": [199, 205] }, { "e": [206, 107] }, { "e": [82, 127, 217, 32] }, { "e": [222, 234] }, { "e": [42, 235] }, { "e": [219, 236] }, { "e": [219, 237] }, { "e": [134, 93, 217, 238] }, { "e": [103, 239] }, { "e": [208, 240] }, { "e": [115, 241, 217, 188] }, { "e": [219, 242] }, { "e": [204, 161] }, { "e": [197, 243, 219, 244] }, { "e": [182, 245] }, { "e": [215, 246] }, { "e": [208, 247] }, { "e": [215, 248] }, { "e": [134, 249, 217, 250] }, { "e": [46, 251] }, { "e": [222, 252, 223, 252] }, { "e": [219, 253] }, { "e": [203, 254, 206, 188] }, { "e": [202, 255] }, { "e": [180, 233, 199, 233] }, { "e": [222, 256] }, { "e": [219, 257] }, { "e": [222, 258, 223, 258] }, { "e": [217, 211, 219, 259] }, { "e": [207, 260] }, { "e": [134, 261] }, { "e": [207, 262] }, { "e": [206, 188, 212, 263] }, { "e": [205, 264] }, { "e": [219, 265] }, { "e": [222, 266] }, { "e": [213, 267] }, { "e": [187, 268] }, { "e": [206, 211, 212, 269] }, { "e": [208, 270] }, { "e": [220, 271] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 272] }, { "e": [219, 273] }, { "e": [219, 274] }, { "e": [206, 188] }, { "e": [198, 217] }, { "e": [206, 222] }, { "e": [222, 275] }, { "e": [219, 276] }, { "e": [219, 277, 221, 278] }, { "e": [209, 279] }, { "e": [209, 280] }, { "e": [213, 252] }, { "e": [206, 230] }, { "e": [217, 211] }, { "e": [213, 258] }, { "e": [184, 281, 206, 248] }, { "e": [206, 248] }, { "e": [219, 138] }, { "e": [219, 282] }, { "e": [219, 277] }, { "e": [186, 283] }, { "e": [219, 284] }, { "e": [215, 285] }, { "e": [177, 286, 217, 287] }, { "e": [219, 288] }, { "e": [111, 289, 217, 290] }, { "e": [208, 291] }, { "e": [219, 155] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 292] }, { "e": [101, 293] }, { "e": [219, 294] }, { "e": [184, 295, 206, 285] }, { "e": [219, 294] }] }, { "d": 19, "s0": 0, "s": [{ "e": [206, 1] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 24, "s0": 0, "s": [{ "e": [75, 1, 219, 2] }, { "e": [], "a": 1, "p": 1 }, { "e": [155, 3] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 28, "s0": 0, "s": [{ "e": [49, 1, 193, 2] }, { "e": [75, 3, 219, 4] }, { "e": [219, 5] }, { "e": [219, 6] }, { "e": [155, 7] }, { "e": [49, 1] }, { "e": [155, 7] }, { "e": [219, 8] }, { "e": [184, 9, 206, 10] }, { "e": [219, 8] }, { "e": [], "a": 1, "p": 1, "r": 1 }] }, { "d": 30, "s0": 0, "s": [{ "e": [2, 1] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 35, "s0": 0, "s": [{ "e": [224, 1] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 50, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [2, 2, 4, 3, 10, 4, 13, 5, 20, 6, 25, 7, 37, 8, 38, 9, 47, 10, 49, 11, 54, 12, 75, 13, 78, 14, 79, 15, 81, 16, 101, 17, 113, 18, 118, 19, 126, 20, 149, 21, 153, 22, 155, 23, 169, 24, 176, 25, 179, 26, 180, 27, 184, 28, 185, 29, 187, 30, 188, 26, 190, 30, 193, 31, 197, 32, 198, 33, 199, 34, 200, 35, 201, 36, 202, 35, 203, 37, 204, 38, 205, 39, 206, 40, 207, 41, 208, 42, 209, 30, 210, 43, 212, 44, 213, 45, 215, 46, 217, 47, 219, 48, 224, 49] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [180, 50, 199, 51, 219, 52] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 53, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [184, 2] }, { "e": [180, 3, 199, 4, 219, 5] }, { "e": [206, 6] }, { "e": [], "a": 1, "p": 2 }, { "e": [184, 2, 206, 6] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 56, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [184, 2] }, { "e": [199, 3, 219, 4] }, { "e": [206, 5] }, { "e": [184, 2] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 117, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 120, "s0": 0, "s": [{ "e": [193, 1, 219, 2] }, { "e": [], "a": 1, "p": 2 }, { "e": [206, 3] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 121, "s0": 0, "s": [{ "e": [193, 1, 219, 2] }, { "e": [], "a": 1, "p": 2 }, { "e": [205, 3, 206, 4] }, { "e": [219, 5] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1, "r": 1 }] }, { "d": 123, "s0": 0, "s": [{ "e": [75, 1, 205, 2, 206, 3] }, { "e": [], "a": 1, "p": 3 }, { "e": [219, 4] }, { "e": [], "a": 1, "p": 3 }, { "e": [206, 5, 212, 6] }, { "e": [57, 7, 217, 8] }, { "e": [222, 9] }, { "e": [219, 10] }, { "e": [118, 11, 120, 12, 217, 13] }, { "e": [213, 14] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [206, 5] }] }, { "d": 124, "s0": 0, "s": [{ "e": [205, 1, 206, -1, 212, 2, 219, 3] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 131, "s0": 0, "s": [{ "e": [10, 1, 37, 2, 47, 3, 81, 4, 126, 5, 149, 6, 205, 7, 206, 8, 208, 9, 212, 10, 215, 11] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [219, 12] }, { "e": [219, 13] }, { "e": [219, 14] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }] }, { "d": 132, "s0": 0, "s": [{ "e": [10, 1, 37, 2, 47, 3, 81, 4, 206, 5, 208, 6, 212, 7, 215, 8] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [199, 9, 222, 9] }, { "e": [], "a": 1, "p": 2 }, { "e": [182, 10, 213, 11] }, { "e": [199, 12, 222, 12] }, { "e": [37, 13, 107, 14, 114, 15, 205, 16, 206, 17, 208, 18, 215, 19] }, { "e": [213, 11] }, { "e": [], "a": 1, "p": 1 }, { "e": [114, 20, 206, 17] }, { "e": [206, 17] }, { "e": [219, 21] }, { "e": [5, 22, 15, 23, 20, 24, 57, 25, 82, 26, 86, 27, 110, 28, 115, 29, 118, 30, 120, 31, 128, 32, 135, 33, 217, 34] }, { "e": [219, 35] }, { "e": [20, 36, 57, 37, 166, 38, 177, 39, 219, 40] }, { "e": [206, 17] }, { "e": [215, 41] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [42, 42] }, { "e": [126, 43, 219, 44] }, { "e": [219, 45] }, { "e": [163, 46] }, { "e": [219, 47] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 48] }, { "e": [219, 49] }, { "e": [92, 50] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [5, 51, 38, 52, 59, 53, 86, 54, 92, 55, 118, 56, 120, 57, 134, 58, 153, 59, 163, 60, 193, 61, 217, 62] }, { "e": [203, 63] }, { "e": [126, 64, 177, 64, 219, 65] }, { "e": [219, 66] }, { "e": [20, 36] }, { "e": [219, 67] }, { "e": [177, 68] }, { "e": [219, 40] }, { "e": [219, 69] }, { "e": [219, 70] }, { "e": [126, 71, 205, 72] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [27, 73] }, { "e": [205, 74] }, { "e": [149, 75, 186, 75, 205, 76, 206, 77, 215, 78] }, { "e": [205, 79] }, { "e": [219, 80] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 81] }, { "e": [219, 82] }, { "e": [205, 83] }, { "e": [205, 84] }, { "e": [208, 85] }, { "e": [219, 86] }, { "e": [215, 87] }, { "e": [208, 88] }, { "e": [219, 89] }, { "e": [219, 90] }, { "e": [219, 91] }, { "e": [219, 92] }, { "e": [219, 93] }, { "e": [219, 94] }, { "e": [10, 95, 20, 96, 22, 97, 37, 98, 86, 99, 110, 28, 115, 100, 118, 101, 119, 102, 120, 103, 136, 104, 217, 105] }, { "e": [5, 106, 20, 107, 57, 108, 118, 109, 119, 110, 120, 111, 136, 112, 211, 113, 217, 77] }, { "e": [218, 114, 219, 115] }, { "e": [205, 116] }, { "e": [206, 17] }, { "e": [208, 117] }, { "e": [219, 118] }, { "e": [219, 119] }, { "e": [197, 120, 222, 121] }, { "e": [208, 85] }, { "e": [197, 122] }, { "e": [222, 123, 223, 123] }, { "e": [208, 88] }, { "e": [206, 124, 208, 88, 212, 125] }, { "e": [186, 126] }, { "e": [37, 127] }, { "e": [212, 128, 215, 78] }, { "e": [206, 77, 212, 128, 215, 78] }, { "e": [219, 129] }, { "e": [126, 43, 219, 44] }, { "e": [219, 130] }, { "e": [219, 131] }, { "e": [219, 47] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 48] }, { "e": [5, 132, 219, 133] }, { "e": [219, 49] }, { "e": [219, 134] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 135] }, { "e": [126, 136] }, { "e": [219, 137] }, { "e": [219, 138] }, { "e": [219, 139] }, { "e": [219, 140] }, { "e": [219, 141] }, { "e": [219, 142] }, { "e": [219, 143] }, { "e": [206, 77, 212, 144] }, { "e": [219, 145] }, { "e": [222, 146, 223, 146] }, { "e": [215, 147] }, { "e": [212, 148] }, { "e": [219, 149] }, { "e": [206, 150, 212, 151] }, { "e": [219, 152] }, { "e": [206, 124] }, { "e": [20, 96, 22, 97, 37, 98, 42, 153, 86, 99, 136, 104, 173, 154, 217, 155] }, { "e": [199, 156, 222, 156] }, { "e": [219, 157] }, { "e": [219, 158] }, { "e": [199, 159, 222, 159] }, { "e": [184, 160] }, { "e": [203, 161] }, { "e": [203, 162] }, { "e": [219, 163] }, { "e": [203, 164] }, { "e": [25, 165, 184, 166] }, { "e": [206, 78] }, { "e": [219, 167] }, { "e": [205, 168] }, { "e": [126, 169, 205, 170, 215, 171] }, { "e": [203, 172] }, { "e": [126, 173] }, { "e": [25, 174, 184, 175] }, { "e": [206, 78, 215, 176] }, { "e": [206, 77] }, { "e": [199, 177, 222, 177] }, { "e": [206, 77] }, { "e": [206, 178, 212, 179] }, { "e": [165, 180, 217, 178] }, { "e": [222, 181] }, { "e": [201, 182] }, { "e": [217, 183, 219, 40] }, { "e": [219, 184] }, { "e": [188, 185] }, { "e": [219, 186] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [182, 187, 213, 188] }, { "e": [212, 189] }, { "e": [203, 190] }, { "e": [182, 191, 213, 192] }, { "e": [219, 193] }, { "e": [219, 194] }, { "e": [219, 195] }, { "e": [206, 196] }, { "e": [219, 197] }, { "e": [219, 198] }, { "e": [219, 134] }, { "e": [206, 78, 208, 199] }, { "e": [219, 200] }, { "e": [219, 201] }, { "e": [219, 202] }, { "e": [5, 203, 20, 204, 61, 205, 118, 206, 120, 207, 211, 208, 217, 78] }, { "e": [219, 209] }, { "e": [219, 210] }, { "e": [219, 211] }, { "e": [219, 141] }, { "e": [217, 78, 219, 212] }, { "e": [213, 213] }, { "e": [20, 214, 217, 215] }, { "e": [219, 216] }, { "e": [20, 217] }, { "e": [213, 218] }, { "e": [219, 219] }, { "e": [5, 22, 118, 30, 217, 220] }, { "e": [213, 121] }, { "e": [109, 221, 219, 222] }, { "e": [215, 223] }, { "e": [199, 224, 222, 224] }, { "e": [206, 124] }, { "e": [222, 225] }, { "e": [219, 226] }, { "e": [199, 227, 222, 227] }, { "e": [206, 77, 215, 78] }, { "e": [203, 228] }, { "e": [208, 229] }, { "e": [155, 230, 203, 162] }, { "e": [42, 153, 61, 231, 118, 101, 217, 105] }, { "e": [126, 232] }, { "e": [203, 233, 215, 234] }, { "e": [65, 235, 222, 235, 223, 235] }, { "e": [212, 236] }, { "e": [215, 171] }, { "e": [206, 78, 212, 237, 215, 171] }, { "e": [219, 238] }, { "e": [126, 239, 219, 240] }, { "e": [143, 241] }, { "e": [219, 242] }, { "e": [219, 243] }, { "e": [219, 244] }, { "e": [126, 245] }, { "e": [206, 78] }, { "e": [203, 246] }, { "e": [208, 247] }, { "e": [206, 77] }, { "e": [126, 64, 177, 64] }, { "e": [118, 101, 217, 248] }, { "e": [180, 249, 213, 146] }, { "e": [219, 250] }, { "e": [206, 251] }, { "e": [198, 121, 201, 182] }, { "e": [217, 62] }, { "e": [198, 252] }, { "e": [13, 185, 179, 185, 184, 253, 188, 185, 198, 252] }, { "e": [219, 254] }, { "e": [213, 188] }, { "e": [182, 255] }, { "e": [155, 256] }, { "e": [213, 192] }, { "e": [219, 257] }, { "e": [219, 258] }, { "e": [219, 259] }, { "e": [143, 260] }, { "e": [219, 261] }, { "e": [219, 262] }, { "e": [134, 263, 217, 196] }, { "e": [206, 78, 212, 264] }, { "e": [222, 265] }, { "e": [222, 266] }, { "e": [206, 171] }, { "e": [219, 267] }, { "e": [126, 268, 186, 269] }, { "e": [219, 270] }, { "e": [126, 271, 177, 271, 205, 272] }, { "e": [126, 273] }, { "e": [215, 274] }, { "e": [219, 275] }, { "e": [219, 276] }, { "e": [157, 277, 222, 277] }, { "e": [217, 62] }, { "e": [222, 278] }, { "e": [206, 147] }, { "e": [57, 37, 217, 279] }, { "e": [174, 280, 217, 196] }, { "e": [219, 222] }, { "e": [207, 281, 209, 281] }, { "e": [222, 282] }, { "e": [219, 283] }, { "e": [155, 284] }, { "e": [203, 285, 206, 124] }, { "e": [203, 286] }, { "e": [219, 287] }, { "e": [206, 196] }, { "e": [215, 234] }, { "e": [219, 288] }, { "e": [219, 289] }, { "e": [213, 290] }, { "e": [213, 291] }, { "e": [206, 171, 208, 292] }, { "e": [219, 293] }, { "e": [219, 294] }, { "e": [126, 295] }, { "e": [219, 296] }, { "e": [219, 297] }, { "e": [219, 298] }, { "e": [217, 171, 219, 299] }, { "e": [206, 78] }, { "e": [215, 300] }, { "e": [206, 176] }, { "e": [213, 146] }, { "e": [217, 301] }, { "e": [197, 302] }, { "e": [223, 303] }, { "e": [213, 304] }, { "e": [203, 305] }, { "e": [219, 306] }, { "e": [219, 307] }, { "e": [219, 308] }, { "e": [215, 309] }, { "e": [177, 310] }, { "e": [180, 311, 213, 235] }, { "e": [206, 78] }, { "e": [215, 171] }, { "e": [222, 312, 223, 312] }, { "e": [208, 292] }, { "e": [184, 313, 208, 292] }, { "e": [219, 314] }, { "e": [212, 315] }, { "e": [206, 171] }, { "e": [206, 171] }, { "e": [208, 316] }, { "e": [134, 317, 217, 78] }, { "e": [118, 56] }, { "e": [219, 318] }, { "e": [217, 196] }, { "e": [206, 196] }, { "e": [219, 319] }, { "e": [206, 77] }, { "e": [203, 285, 206, 124] }, { "e": [206, 77] }, { "e": [143, 320] }, { "e": [219, 321] }, { "e": [222, 322] }, { "e": [206, 171, 212, 323] }, { "e": [219, 294] }, { "e": [206, 171] }, { "e": [222, 324] }, { "e": [157, 325] }, { "e": [219, 326] }, { "e": [188, 327] }, { "e": [203, 305, 206, 77] }, { "e": [219, 328] }, { "e": [215, 329] }, { "e": [213, 235] }, { "e": [219, 330] }, { "e": [213, 331] }, { "e": [206, 274] }, { "e": [177, 332] }, { "e": [219, 333] }, { "e": [206, 334, 215, 335] }, { "e": [20, 336, 217, 234] }, { "e": [180, 337, 213, 312] }, { "e": [206, 171] }, { "e": [219, 338] }, { "e": [13, 327, 184, 339, 188, 327, 198, 252] }, { "e": [143, 320, 217, 196] }, { "e": [54, 340, 217, 334] }, { "e": [126, 341] }, { "e": [222, 342] }, { "e": [215, 343] }, { "e": [219, 333] }, { "e": [219, 344] }, { "e": [219, 345] }, { "e": [213, 312] }, { "e": [147, 346, 217, 300] }, { "e": [206, 335] }, { "e": [208, 347] }, { "e": [219, 348] }, { "e": [219, 349] }, { "e": [126, 350] }, { "e": [203, 351] }, { "e": [219, 352] }, { "e": [219, 353] }, { "e": [208, 354] }, { "e": [206, 329] }, { "e": [219, 355] }, { "e": [203, 356] }, { "e": [219, 357] }, { "e": [206, 343] }] }, { "d": 133, "s0": 0, "s": [{ "e": [10, 1, 37, 2, 47, 3, 81, 4, 205, 5, 206, 6, 208, 7, 212, 8, 215, 9] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [219, 10] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [215, 11] }, { "e": [219, 12] }, { "e": [177, 13] }, { "e": [219, 14] }, { "e": [208, 15] }, { "e": [222, 16] }, { "e": [206, 17] }, { "e": [217, 18] }, { "e": [5, 19] }, { "e": [], "a": 1, "p": 1, "r": 1 }] }, { "d": 134, "s0": 0, "s": [{ "e": [186, 1, 205, 2, 206, 3, 215, 4] }, { "e": [219, 5] }, { "e": [219, 6] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [184, 7, 206, 8] }, { "e": [184, 9, 206, 8] }, { "e": [219, 5] }, { "e": [20, 10, 118, 11, 217, 12] }, { "e": [219, 6] }, { "e": [126, 13, 219, 14] }, { "e": [219, 15] }, { "e": [217, 16] }, { "e": [219, 17] }, { "e": [212, 18] }, { "e": [186, 19, 205, 20] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [184, 21, 208, 22] }, { "e": [222, 23] }, { "e": [219, 24] }, { "e": [219, 25] }, { "e": [219, 17] }, { "e": [222, 26] }, { "e": [213, 27] }, { "e": [215, 28] }, { "e": [215, 28] }, { "e": [206, 29] }, { "e": [205, 30] }, { "e": [20, 31, 118, 32, 217, 33] }, { "e": [118, 34, 217, 35] }, { "e": [219, 36] }, { "e": [126, 37] }, { "e": [219, 38] }, { "e": [110, 39, 118, 34, 217, 40] }, { "e": [219, 15] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [184, 41, 206, 29] }, { "e": [219, 42] }, { "e": [126, 43, 205, 44] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 36] }, { "e": [208, 45] }, { "e": [219, 46] }, { "e": [219, 47] }, { "e": [222, 48] }, { "e": [215, 49] }, { "e": [206, 28] }, { "e": [206, 28, 212, 50] }, { "e": [20, 51, 217, 28] }, { "e": [219, 52] }, { "e": [219, 53] }, { "e": [180, 54, 213, 48] }, { "e": [126, 55] }, { "e": [222, 56] }, { "e": [219, 57] }, { "e": [213, 48] }, { "e": [208, 58] }, { "e": [222, 59, 223, 59] }, { "e": [206, 49, 212, 60] }, { "e": [219, 61] }, { "e": [213, 59] }] }, { "d": 136, "s0": 0, "s": [{ "e": [206, 1] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 137, "s0": 0, "s": [{ "e": [114, 1, 186, 2, 206, 3] }, { "e": [206, 4] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [128, 5, 217, 6] }, { "e": [92, 7] }, { "e": [134, 8] }, { "e": [219, 9] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [205, 10] }, { "e": [219, 11] }, { "e": [206, 12] }, { "e": [115, 13, 120, 14] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 15] }, { "e": [205, 16] }, { "e": [218, 17, 219, 18] }, { "e": [219, 19] }, { "e": [206, 12] }, { "e": [206, 12] }] }, { "d": 138, "s0": 0, "s": [{ "e": [37, 1, 107, 2, 114, 3, 186, 4, 205, 5, 206, 6, 208, 7, 215, 8] }, { "e": [], "a": 1, "p": 3 }, { "e": [114, 9, 186, 10, 206, 11] }, { "e": [206, 12] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [206, 11] }, { "e": [219, 13] }, { "e": [103, 14, 128, 15, 217, 16] }, { "e": [217, 17] }, { "e": [184, 18, 206, 19] }, { "e": [46, 20] }, { "e": [92, 21] }, { "e": [118, 22, 134, 23] }, { "e": [118, 24] }, { "e": [219, 13] }, { "e": [20, 25] }, { "e": [207, 26, 219, 27] }, { "e": [219, 28] }, { "e": [], "a": 1, "p": 2, "r": 1 }, { "e": [], "a": 1, "p": 2, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [126, 29] }, { "e": [219, 30] }, { "e": [186, 31, 215, 32] }, { "e": [205, 33] }, { "e": [219, 34] }, { "e": [209, 35] }, { "e": [219, 36] }, { "e": [177, 37, 217, 38] }, { "e": [219, 39] }, { "e": [184, 40, 208, 41] }, { "e": [219, 27] }, { "e": [215, 32] }, { "e": [219, 42] }, { "e": [111, 43, 217, 44] }, { "e": [206, 45] }, { "e": [219, 34] }, { "e": [222, 46] }, { "e": [208, 47] }, { "e": [219, 48] }, { "e": [116, 49] }, { "e": [103, 50, 115, 51, 118, 52, 120, 53, 217, 54] }, { "e": [206, 55] }, { "e": [219, 56] }, { "e": [212, 57] }, { "e": [], "a": 1, "p": 2, "r": 1 }, { "e": [46, 58] }, { "e": [], "a": 1, "p": 2, "r": 1 }, { "e": [219, 59] }, { "e": [219, 60] }, { "e": [], "a": 1, "p": 2, "r": 1 }, { "e": [118, 52] }, { "e": [101, 61] }, { "e": [199, 62] }, { "e": [207, 63] }, { "e": [205, 64] }, { "e": [205, 65] }, { "e": [219, 66] }, { "e": [213, 67] }, { "e": [219, 68] }, { "e": [219, 69] }, { "e": [218, 70, 219, 71] }, { "e": [184, 72, 206, 32] }, { "e": [107, 73] }, { "e": [209, 74] }, { "e": [215, 75] }, { "e": [219, 76] }, { "e": [206, 45] }, { "e": [219, 66] }, { "e": [206, 45] }, { "e": [219, 77] }, { "e": [20, 78, 118, 79, 217, 45] }, { "e": [206, 45] }, { "e": [186, 80] }, { "e": [126, 81] }, { "e": [219, 82] }, { "e": [219, 83] }, { "e": [219, 84] }, { "e": [205, 85] }, { "e": [215, 86] }, { "e": [208, 87] }, { "e": [219, 88] }, { "e": [177, 89, 217, 90] }, { "e": [222, 91] }, { "e": [206, 75] }, { "e": [219, 92] }, { "e": [111, 93, 217, 94] }, { "e": [206, 75, 212, 95] }, { "e": [208, 96] }, { "e": [219, 48] }, { "e": [], "a": 1, "p": 2, "r": 1 }, { "e": [219, 97] }, { "e": [219, 98] }, { "e": [180, 99, 213, 91] }, { "e": [101, 100] }, { "e": [222, 101] }, { "e": [219, 102] }, { "e": [213, 91] }, { "e": [184, 103, 206, 86] }, { "e": [219, 102] }] }, { "d": 178, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [153, 2, 155, 3, 184, 4, 203, 5, 206, 6, 208, 7, 215, 8] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 207, "s0": 0, "s": [{ "e": [75, 1, 112, 2, 219, 3] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [75, 4, 203, 5] }, { "e": [219, 6] }, { "e": [], "a": 1, "p": 2 }, { "e": [203, 7] }, { "e": [219, 8] }, { "e": [155, 9] }, { "e": [219, 10] }, { "e": [], "a": 1, "p": 1, "r": 1 }] }, { "d": 209, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 213, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [54, 2, 75, 3, 153, 4, 205, 5] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 214, "s0": 0, "s": [{ "e": [75, 1, 169, 2, 206, 3] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 225, "s0": 0, "s": [{ "e": [199, 1, 222, 1] }, { "e": [182, 2, 213, 3] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 227, "s0": 0, "s": [{ "e": [193, 1] }, { "e": [219, 2] }, { "e": [], "a": 1, "p": 1, "r": 1 }] }, { "d": 228, "s0": 0, "s": [{ "e": [193, 1] }, { "e": [219, 2] }, { "e": [], "a": 1, "p": 1, "r": 1 }] }, { "d": 234, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [2, 2, 206, 3, 215, 4] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 238, "s0": 0, "s": [{ "e": [206, 1, 215, 2] }, { "e": [], "a": 1, "p": 1 }, { "e": [217, 3, 219, 4] }, { "e": [], "a": 1, "p": 2, "r": 1 }, { "e": [208, 5, 215, 6] }, { "e": [65, 7, 157, 7, 197, 8, 219, 9, 221, 7, 222, 7, 223, 7] }, { "e": [217, 2, 219, 10] }, { "e": [206, 2] }, { "e": [219, 11] }, { "e": [184, 12, 206, 2] }, { "e": [208, 13] }, { "e": [184, 14, 201, 15] }, { "e": [219, 9] }, { "e": [223, 16] }, { "e": [219, 11] }, { "e": [219, 17] }, { "e": [206, 6] }, { "e": [184, 18, 198, 7] }, { "e": [219, 17] }] }, { "d": 239, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [208, 2, 215, 3] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 240, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 254, "s0": 0, "s": [{ "e": [3, 1, 5, 2, 8, 3, 11, 4, 12, 5, 20, 6, 22, 7, 26, 8, 31, 9, 33, 10, 37, 11, 38, 12, 49, 13, 55, 14, 59, 15, 69, 16, 80, 17, 83, 18, 85, 19, 86, 20, 92, 21, 95, 22, 103, 23, 111, 24, 116, 25, 118, 26, 120, 27, 123, 28, 125, 28, 134, 29, 143, 30, 163, 31, 166, 32, 167, 33, 170, 34, 171, 35, 193, 36, 211, 37, 219, 38, 224, 39] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [80, 17] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 255, "s0": 0, "s": [{ "e": [3, 1, 5, 2, 11, 3, 12, 4, 20, 5, 22, 6, 26, 7, 31, 8, 33, 9, 37, 10, 38, 11, 49, 12, 55, 13, 59, 14, 83, 15, 85, 16, 86, 17, 92, 18, 95, 19, 103, 20, 111, 21, 116, 22, 118, 23, 120, 24, 134, 25, 143, 26, 163, 27, 166, 28, 167, 29, 170, 30, 171, 31, 193, 32, 211, 33, 219, 34, 224, 35] }, { "e": [118, 23] }, { "e": [46, 36, 219, 37] }, { "e": [46, 38, 219, 39] }, { "e": [46, 40, 219, 41] }, { "e": [46, 42, 219, 43] }, { "e": [], "a": 1, "p": 2 }, { "e": [46, 44, 186, 45] }, { "e": [], "a": 1, "p": 1 }, { "e": [46, 46] }, { "e": [], "a": 1, "p": 2 }, { "e": [46, 47, 215, 48] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [46, 49] }, { "e": [46, 50, 118, 23, 219, 51] }, { "e": [], "a": 1, "p": 2 }, { "e": [46, 52] }, { "e": [46, 53, 219, 54] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [46, 55, 219, 56] }, { "e": [], "a": 1, "p": 1 }, { "e": [46, 57, 219, 58] }, { "e": [46, 59] }, { "e": [46, 60, 219, 61] }, { "e": [46, 62, 219, 63] }, { "e": [27, 64] }, { "e": [118, 23] }, { "e": [46, 65, 219, 66] }, { "e": [46, 67, 219, 68] }, { "e": [46, 69] }, { "e": [219, 70] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [46, 71, 219, 72] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [38, 11, 49, 12, 118, 23] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 256, "s0": 0, "s": [{ "e": [3, 1, 5, 2, 11, 3, 12, 4, 20, 5, 26, 6, 31, 7, 33, 8, 38, 9, 49, 10, 55, 11, 59, 12, 83, 13, 86, 14, 92, 15, 95, 16, 103, 17, 111, 18, 116, 19, 118, 20, 120, 21, 134, 22, 143, 23, 163, 24, 166, 25, 167, 26, 170, 27, 171, 28, 193, 29, 211, 30, 224, 31] }, { "e": [118, 20] }, { "e": [], "a": 1, "p": 15 }, { "e": [], "a": 1, "p": 29 }, { "e": [], "a": 1, "p": 22 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 16 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 20 }, { "e": [], "a": 1, "p": 11 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 6 }, { "e": [46, 32, 118, 20] }, { "e": [], "a": 1, "p": 13 }, { "e": [], "a": 1, "p": 9 }, { "e": [], "a": 1, "p": 2 }, { "e": [46, 33] }, { "e": [], "a": 1, "p": 7 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 10 }, { "e": [], "a": 1, "p": 14 }, { "e": [], "a": 1, "p": 19 }, { "e": [], "a": 1, "p": 17 }, { "e": [], "a": 1, "p": 24 }, { "e": [118, 20] }, { "e": [], "a": 1, "p": 23 }, { "e": [], "a": 1, "p": 25 }, { "e": [], "a": 1, "p": 26 }, { "e": [219, 34] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 8 }, { "e": [], "a": 1, "p": 28 }, { "e": [49, 10] }] }, { "d": 257, "s0": 0, "s": [{ "e": [3, 1, 5, 2, 11, 3, 12, 4, 20, 5, 22, 6, 26, 7, 37, 8, 83, 9, 85, 10, 92, 11, 111, 12, 118, 13, 134, 14, 143, 15, 163, 16, 166, 1, 167, 17, 170, 18, 177, 19, 193, 20, 205, 21, 219, 22] }, { "e": [118, 13] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 23] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [38, 24, 118, 13] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 266, "s0": 0, "s": [{ "e": [5, 1, 10, 2, 15, 3, 20, 4, 22, 5, 23, 6, 37, 7, 38, 8, 42, 9, 55, 10, 57, 11, 60, 12, 61, 13, 70, 14, 81, 15, 84, 15, 86, 16, 92, 17, 100, 18, 115, 15, 118, 19, 119, 20, 120, 21, 126, 22, 128, 23, 134, 24, 136, 25, 138, 26, 143, 27, 154, 26, 165, 28, 166, 29, 170, 30, 177, 22, 193, 31, 211, 32, 219, 33] }, { "e": [46, 34, 219, 35] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 4 }, { "e": [219, 36] }, { "e": [219, 37] }, { "e": [], "a": 1, "p": 2 }, { "e": [193, 38, 219, 39] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 2 }, { "e": [92, 40, 120, 41, 219, 33] }, { "e": [205, 42, 219, 43] }, { "e": [186, 44] }, { "e": [], "a": 1, "p": 4 }, { "e": [46, 45, 126, 46, 177, 46, 219, 47] }, { "e": [], "a": 1, "p": 4 }, { "e": [126, 48, 177, 48, 219, 49] }, { "e": [], "a": 1, "p": 2 }, { "e": [92, 40] }, { "e": [207, 50, 219, 51] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [46, 52, 219, 53] }, { "e": [], "a": 1, "p": 2 }, { "e": [20, 4, 118, 19] }, { "e": [219, 54] }, { "e": [219, 55] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [219, 56] }, { "e": [205, 57, 206, 58] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [20, 4, 49, 59, 118, 19, 193, 31] }, { "e": [176, 60, 219, 61] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 269, "s0": 0, "s": [{ "e": [5, 1, 20, 2, 22, 3, 23, 4, 55, 5, 57, 6, 70, 7, 81, 8, 115, 8, 118, 9, 126, 10, 143, 11, 165, 12, 166, 13, 177, 10, 193, 14, 211, 15, 219, 16] }, { "e": [], "a": 1, "p": 3 }, { "e": [126, 17, 177, 17, 219, 18] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 2 }, { "e": [20, 2] }, { "e": [219, 19] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [20, 2, 49, 20] }, { "e": [], "a": 1, "p": 3 }] }, { "d": 274, "s0": 0, "s": [{ "e": [5, 1, 10, 2, 11, 3, 12, 4, 15, 5, 16, 6, 20, 7, 22, 8, 23, 9, 26, 10, 37, 11, 38, 12, 42, 13, 60, 14, 61, 15, 70, 16, 71, 17, 72, 18, 82, 19, 83, 20, 86, 21, 92, 22, 97, 23, 100, 24, 111, 25, 118, 26, 119, 27, 120, 28, 128, 29, 134, 30, 136, 31, 138, 32, 143, 33, 151, 34, 154, 32, 163, 35, 167, 36, 170, 37, 173, 38, 193, 39, 219, 40] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [92, 41] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 278, "s0": 0, "s": [{ "e": [4, 1, 37, 2, 46, -1, 47, 3, 70, 4, 112, 5, 117, 6, 126, 7, 137, 8, 149, 9, 177, 7, 186, 9, 205, 10, 206, 11, 208, 12, 212, 13, 215, 14] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [219, 15] }, { "e": [], "a": 1, "p": 2 }, { "e": [219, 16] }, { "e": [218, 17, 219, 18] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [199, 19, 222, 19] }, { "e": [], "a": 1, "p": 2 }, { "e": [184, 20, 206, 21, 208, 22, 212, 23, 215, 24] }, { "e": [37, 25, 184, 26, 206, 21, 208, 22, 212, 23, 215, 24] }, { "e": [219, 27] }, { "e": [10, 28, 37, 25, 47, 29, 81, 30, 126, 31, 149, 32, 184, 33, 206, 21, 208, 22, 212, 23, 215, 24] }, { "e": [182, 34, 213, 35] }, { "e": [219, 15] }, { "e": [5, 36, 6, 37, 8, 38, 15, 39, 18, 40, 20, 41, 38, 42, 42, 43, 57, 44, 61, 45, 63, 46, 71, 47, 81, 48, 82, 49, 86, 50, 92, 51, 103, 52, 110, 53, 115, 48, 118, 54, 119, 55, 120, 56, 128, 57, 133, 40, 134, 58, 135, 59, 138, 60, 143, 61, 147, 62, 153, 63, 165, 64, 173, 65, 193, 66, 217, 67, 219, 68] }, { "e": [106, 69, 219, 70, 222, 71, 223, 71] }, { "e": [199, 72, 222, 72] }, { "e": [5, 73, 20, 74, 55, 75, 61, 76, 63, 77, 70, 78, 81, 79, 118, 80, 119, 81, 120, 82, 126, 83, 136, 84, 147, 85, 154, 86, 165, 87, 166, 88, 177, 83, 193, 89, 211, 90, 217, 91] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 16] }, { "e": [206, 21] }, { "e": [], "a": 1, "p": 1 }, { "e": [223, 71] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 92] }, { "e": [219, 93] }, { "e": [219, 18] }, { "e": [199, 94, 222, 94] }, { "e": [107, 95, 114, 96, 186, 97, 205, 98, 206, 21, 215, 24] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [42, 99] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [126, 100, 219, 101] }, { "e": [219, 102] }, { "e": [215, 103, 219, 104] }, { "e": [219, 105] }, { "e": [143, 106] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [112, 107, 219, 108] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [163, 109] }, { "e": [205, 110, 219, 111] }, { "e": [186, 112] }, { "e": [46, 113] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [46, 114, 219, 115] }, { "e": [5, 116, 219, 117] }, { "e": [219, 118] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [207, 119, 219, 120] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [46, 121, 219, 122] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [5, 123] }, { "e": [20, 124, 118, 125] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 126] }, { "e": [0, 127, 3, 128, 5, 129, 11, 130, 12, 131, 20, 132, 22, 133, 23, 134, 26, 135, 31, 136, 38, 137, 59, 138, 71, 139, 83, 140, 86, 141, 92, 142, 103, 143, 116, 144, 118, 145, 119, 146, 120, 147, 134, 148, 135, 149, 138, 150, 143, 151, 153, 152, 163, 153, 167, 154, 170, 155, 193, 156, 217, 157] }, { "e": [177, 158, 186, 159, 205, 160] }, { "e": [219, 161] }, { "e": [184, 162, 197, 163, 199, 164, 202, 164, 203, 165, 204, 164, 206, 21] }, { "e": [199, 164, 204, 164, 206, 21, 212, 166] }, { "e": [182, 167, 213, 168] }, { "e": [219, 169] }, { "e": [126, 170, 177, 170, 219, 171] }, { "e": [224, 172] }, { "e": [143, 173] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 174] }, { "e": [92, 175, 219, 176] }, { "e": [126, 177, 177, 177, 219, 178] }, { "e": [219, 179] }, { "e": [126, 180, 177, 180, 219, 181] }, { "e": [219, 182] }, { "e": [134, 183, 219, 184] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 185] }, { "e": [20, 186, 118, 187] }, { "e": [20, 74] }, { "e": [219, 188] }, { "e": [219, 189] }, { "e": [61, 45, 134, 58, 217, 67] }, { "e": [206, 190, 215, 191] }, { "e": [206, 190] }, { "e": [213, 35] }, { "e": [186, 192, 206, 21] }, { "e": [206, 21] }, { "e": [219, 193] }, { "e": [219, 194] }, { "e": [215, 195, 219, 196] }, { "e": [219, 197] }, { "e": [126, 198, 186, 199, 205, 200, 208, 201, 212, 202] }, { "e": [37, 203, 205, 204] }, { "e": [55, 205, 219, 206] }, { "e": [215, 103] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 207] }, { "e": [219, 208] }, { "e": [75, 209, 203, 210] }, { "e": [27, 211] }, { "e": [219, 212] }, { "e": [205, 213] }, { "e": [219, 214] }, { "e": [207, 215, 219, 216] }, { "e": [219, 217] }, { "e": [149, 218, 186, 218, 205, 219, 206, 220, 212, 221, 215, 222] }, { "e": [219, 223] }, { "e": [126, 224, 184, 225, 203, 226, 206, 227] }, { "e": [126, 228, 177, 228, 205, 229, 206, 220] }, { "e": [220, 230] }, { "e": [177, 231, 205, 232, 215, 233] }, { "e": [219, 234] }, { "e": [215, 235] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 236] }, { "e": [219, 237] }, { "e": [20, 41] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 238] }, { "e": [22, 133] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 239] }, { "e": [219, 240] }, { "e": [219, 241] }, { "e": [197, 242] }, { "e": [219, 70] }, { "e": [219, 243] }, { "e": [219, 244, 222, 71, 223, 71] }, { "e": [219, 245] }, { "e": [219, 246] }, { "e": [199, 247, 222, 247] }, { "e": [37, 25, 107, 248, 114, 249, 206, 21, 208, 250, 215, 251] }, { "e": [149, 252, 206, 253, 212, 254] }, { "e": [219, 255] }, { "e": [126, 256, 186, 257, 205, 258, 208, 259, 212, 260] }, { "e": [20, 74, 177, 83, 217, 261] }, { "e": [219, 262] }, { "e": [206, 263] }, { "e": [126, 264, 208, 265, 219, 266] }, { "e": [208, 267] }, { "e": [219, 268] }, { "e": [126, 269, 149, 270, 177, 269, 186, 270, 205, 271, 212, 272, 215, 273] }, { "e": [126, 274, 184, 275, 203, 276, 206, 253] }, { "e": [219, 277] }, { "e": [126, 278, 177, 278, 205, 279, 206, 280, 215, 281] }, { "e": [184, 282, 208, 267, 215, 283] }, { "e": [219, 284] }, { "e": [25, 285, 184, 286] }, { "e": [215, 287] }, { "e": [219, 288] }, { "e": [219, 289] }, { "e": [20, 74] }, { "e": [215, 290] }, { "e": [20, 41, 115, 48, 118, 54, 217, 291] }, { "e": [81, 292] }, { "e": [219, 293] }, { "e": [184, 294, 206, 190] }, { "e": [184, 295, 206, 190] }, { "e": [197, 296, 219, 297] }, { "e": [215, 195] }, { "e": [47, 298, 184, 299, 208, 201] }, { "e": [219, 300] }, { "e": [219, 301] }, { "e": [219, 302] }, { "e": [106, 303, 197, 304, 219, 305, 222, 306, 223, 306] }, { "e": [199, 307, 222, 307] }, { "e": [219, 308] }, { "e": [219, 309] }, { "e": [224, 103] }, { "e": [79, 310, 187, 310, 188, 310, 190, 310, 199, 310, 203, 311, 204, 310, 207, 310, 209, 310] }, { "e": [117, 312, 126, 313, 206, 227, 215, 314] }, { "e": [75, 315] }, { "e": [219, 316] }, { "e": [219, 317] }, { "e": [219, 318] }, { "e": [37, 319] }, { "e": [219, 320] }, { "e": [205, 321, 212, 322] }, { "e": [219, 323] }, { "e": [186, 324, 215, 325] }, { "e": [215, 326] }, { "e": [219, 327] }, { "e": [219, 328] }, { "e": [5, 329, 10, 330, 15, 39, 20, 41, 22, 331, 37, 332, 38, 42, 42, 43, 61, 45, 70, 333, 86, 50, 103, 334, 110, 53, 115, 335, 118, 54, 119, 55, 120, 56, 134, 58, 136, 336, 143, 61, 193, 337, 217, 338] }, { "e": [222, 339] }, { "e": [5, 340, 20, 341, 22, 342, 37, 343, 57, 344, 60, 345, 61, 346, 86, 347, 118, 348, 119, 349, 120, 350, 128, 351, 136, 352, 211, 353, 217, 220] }, { "e": [206, 227] }, { "e": [219, 354] }, { "e": [219, 117] }, { "e": [219, 355] }, { "e": [10, 330, 15, 39, 42, 43, 61, 45, 82, 49, 92, 51, 118, 54, 119, 55, 120, 56, 134, 58, 135, 356, 143, 61, 163, 357, 217, 338] }, { "e": [219, 358] }, { "e": [218, 359, 219, 360] }, { "e": [209, 361] }, { "e": [219, 362] }, { "e": [219, 363] }, { "e": [18, 364, 20, 365, 55, 366, 120, 367, 126, 368, 134, 369, 147, 370, 211, 371, 217, 227] }, { "e": [215, 372] }, { "e": [58, 373, 143, 374, 156, 375, 217, 227] }, { "e": [186, 376] }, { "e": [205, 377] }, { "e": [203, 378, 208, 379] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [221, 380] }, { "e": [198, 71, 201, 381, 203, 382] }, { "e": [180, 164, 184, 383, 199, 164, 202, 164, 206, 21] }, { "e": [199, 164, 206, 21, 215, 384] }, { "e": [199, 385, 204, 385, 213, 71] }, { "e": [213, 168] }, { "e": [114, 386, 206, 21] }, { "e": [206, 21] }, { "e": [219, 387] }, { "e": [20, 388, 57, 389, 166, 390, 177, 391] }, { "e": [219, 392] }, { "e": [5, 393, 60, 394, 61, 76, 63, 77, 92, 395, 93, 396, 118, 80, 119, 81, 153, 397, 217, 398] }, { "e": [222, 399] }, { "e": [47, 400, 184, 401, 206, 402, 208, 259] }, { "e": [219, 403] }, { "e": [219, 404] }, { "e": [219, 405] }, { "e": [65, 406, 197, 407, 219, 408, 222, 406, 223, 406] }, { "e": [199, 409, 222, 409] }, { "e": [5, 36, 118, 54, 138, 60, 217, 67] }, { "e": [126, 410] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 411] }, { "e": [219, 412] }, { "e": [126, 413, 205, 414] }, { "e": [65, 415, 157, 415, 219, 416, 222, 415, 223, 415] }, { "e": [212, 417, 215, 273] }, { "e": [219, 418] }, { "e": [219, 419] }, { "e": [219, 420] }, { "e": [222, 421] }, { "e": [5, 422, 20, 423, 22, 424, 37, 425, 61, 426, 86, 427, 118, 428, 119, 429, 120, 430, 128, 431, 136, 432, 166, 433, 211, 434, 217, 280] }, { "e": [219, 435] }, { "e": [219, 179] }, { "e": [219, 436] }, { "e": [205, 437, 215, 281] }, { "e": [219, 438] }, { "e": [218, 439, 219, 440] }, { "e": [5, 393, 10, 441, 20, 74, 22, 442, 37, 443, 86, 444, 100, 445, 115, 446, 118, 80, 119, 81, 120, 82, 136, 84, 217, 398] }, { "e": [60, 447, 81, 448, 115, 448, 120, 449, 217, 280] }, { "e": [219, 182] }, { "e": [177, 450, 217, 451] }, { "e": [205, 452] }, { "e": [219, 453] }, { "e": [219, 184] }, { "e": [138, 454, 217, 280] }, { "e": [186, 455, 206, 456] }, { "e": [205, 457, 206, 456, 215, 458] }, { "e": [217, 172, 219, 459] }, { "e": [92, 142, 120, 147, 217, 157] }, { "e": [92, 460] }, { "e": [184, 461, 206, 190] }, { "e": [219, 193] }, { "e": [219, 194] }, { "e": [219, 462] }, { "e": [179, 463, 203, 464] }, { "e": [222, 306, 223, 306] }, { "e": [219, 197] }, { "e": [208, 201] }, { "e": [184, 465, 206, 466, 208, 201, 212, 467] }, { "e": [47, 298, 184, 468, 206, 466, 208, 201, 212, 467] }, { "e": [219, 469] }, { "e": [219, 470, 222, 471] }, { "e": [197, 472, 200, 473, 204, 473] }, { "e": [199, 473, 204, 473, 206, 466, 212, 474] }, { "e": [213, 475] }, { "e": [203, 476] }, { "e": [37, 203] }, { "e": [197, 477, 219, 478, 222, 479, 223, 479] }, { "e": [219, 480] }, { "e": [215, 314] }, { "e": [219, 481] }, { "e": [128, 482, 143, 483, 156, 484, 217, 227] }, { "e": [219, 485] }, { "e": [203, 486] }, { "e": [155, 487] }, { "e": [186, 488] }, { "e": [212, 489, 219, 490] }, { "e": [37, 319, 212, 491] }, { "e": [219, 492] }, { "e": [222, 493] }, { "e": [209, 494] }, { "e": [219, 495] }, { "e": [177, 496, 217, 497] }, { "e": [20, 498, 42, 499, 55, 500, 118, 501, 120, 502, 217, 497] }, { "e": [184, 503, 208, 504, 212, 505, 215, 222] }, { "e": [184, 506, 206, 220, 208, 504, 212, 505, 215, 222] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 507] }, { "e": [219, 508] }, { "e": [219, 509] }, { "e": [219, 510] }, { "e": [46, 113] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 511] }, { "e": [219, 512] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [213, 513] }, { "e": [219, 514] }, { "e": [126, 515, 219, 516] }, { "e": [219, 517] }, { "e": [219, 518] }, { "e": [219, 519] }, { "e": [111, 520] }, { "e": [143, 521] }, { "e": [219, 522] }, { "e": [126, 523, 219, 524] }, { "e": [219, 525] }, { "e": [177, 526, 219, 527] }, { "e": [92, 528] }, { "e": [219, 529] }, { "e": [219, 530] }, { "e": [206, 227] }, { "e": [126, 224, 206, 227] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [27, 531] }, { "e": [206, 220, 215, 532] }, { "e": [219, 533] }, { "e": [126, 534, 206, 220, 212, 535] }, { "e": [219, 120] }, { "e": [215, 233] }, { "e": [215, 233] }, { "e": [42, 536] }, { "e": [126, 537, 219, 538] }, { "e": [224, 233] }, { "e": [219, 539] }, { "e": [219, 540] }, { "e": [207, 541] }, { "e": [219, 542] }, { "e": [219, 543] }, { "e": [55, 544, 143, 545, 156, 546, 217, 497] }, { "e": [5, 547] }, { "e": [219, 548] }, { "e": [219, 549] }, { "e": [219, 550] }, { "e": [219, 551] }, { "e": [219, 552] }, { "e": [219, 553] }, { "e": [198, 71] }, { "e": [219, 554, 222, 555] }, { "e": [219, 556] }, { "e": [219, 244] }, { "e": [119, 557] }, { "e": [219, 558, 222, 559] }, { "e": [206, 21] }, { "e": [203, 560] }, { "e": [126, 561, 177, 561, 219, 562] }, { "e": [219, 563] }, { "e": [20, 388] }, { "e": [219, 564] }, { "e": [212, 565] }, { "e": [219, 169] }, { "e": [111, 566] }, { "e": [186, 567] }, { "e": [], "a": 1, "p": 1 }, { "e": [5, 568] }, { "e": [5, 569, 11, 570, 70, 333, 86, 50, 110, 53, 118, 54, 119, 55, 120, 56, 163, 357, 167, 571, 193, 572, 217, 573] }, { "e": [182, 574] }, { "e": [219, 408, 222, 406] }, { "e": [219, 255] }, { "e": [18, 575, 20, 74, 22, 442, 37, 443, 86, 444, 118, 80, 119, 81, 120, 82, 128, 576, 136, 84, 211, 577, 217, 578] }, { "e": [184, 579, 208, 259] }, { "e": [184, 580, 206, 402, 208, 259, 215, 581] }, { "e": [208, 259] }, { "e": [206, 402, 212, 582] }, { "e": [219, 583] }, { "e": [184, 584, 197, 585, 200, 586, 203, 587, 206, 402] }, { "e": [213, 588] }, { "e": [219, 589] }, { "e": [215, 590] }, { "e": [203, 591] }, { "e": [219, 592] }, { "e": [219, 593] }, { "e": [206, 451, 212, 594] }, { "e": [184, 595, 203, 596, 206, 451] }, { "e": [222, 597] }, { "e": [212, 598, 215, 273] }, { "e": [184, 599, 208, 600, 212, 598] }, { "e": [184, 601, 206, 280, 208, 600, 212, 598, 215, 273] }, { "e": [182, 602, 213, 603] }, { "e": [219, 604] }, { "e": [126, 605, 177, 605, 219, 606] }, { "e": [219, 607] }, { "e": [219, 608] }, { "e": [143, 609] }, { "e": [219, 610] }, { "e": [126, 611, 177, 611, 219, 612] }, { "e": [219, 613] }, { "e": [126, 614, 219, 615] }, { "e": [92, 616] }, { "e": [219, 617] }, { "e": [20, 423] }, { "e": [219, 618] }, { "e": [206, 253] }, { "e": [126, 274, 206, 253] }, { "e": [219, 619] }, { "e": [206, 280, 212, 620, 215, 281] }, { "e": [219, 621] }, { "e": [126, 622, 206, 280] }, { "e": [219, 623] }, { "e": [219, 624] }, { "e": [219, 625] }, { "e": [205, 626, 219, 627] }, { "e": [219, 628] }, { "e": [219, 629] }, { "e": [111, 630] }, { "e": [92, 631, 219, 632] }, { "e": [219, 633] }, { "e": [219, 634] }, { "e": [18, 575, 126, 83, 138, 635, 177, 83, 217, 261] }, { "e": [219, 636] }, { "e": [203, 637, 215, 638] }, { "e": [219, 639] }, { "e": [219, 640] }, { "e": [165, 87, 217, 578] }, { "e": [219, 641] }, { "e": [118, 642, 217, 456] }, { "e": [208, 643] }, { "e": [219, 644] }, { "e": [219, 293] }, { "e": [188, 645] }, { "e": [109, 646, 197, 647, 219, 648] }, { "e": [219, 649] }, { "e": [219, 301] }, { "e": [15, 39, 18, 40, 20, 41, 22, 331, 37, 332, 42, 43, 86, 50, 118, 54, 119, 55, 120, 56, 128, 650, 133, 40, 135, 149, 136, 336, 143, 61, 173, 65, 217, 651] }, { "e": [199, 652, 222, 652] }, { "e": [219, 302] }, { "e": [197, 653] }, { "e": [203, 654] }, { "e": [201, 655] }, { "e": [219, 656] }, { "e": [197, 657, 219, 658, 223, 306] }, { "e": [219, 659] }, { "e": [107, 660, 205, 661] }, { "e": [219, 662] }, { "e": [197, 663] }, { "e": [13, 310, 184, 664, 187, 310, 188, 310, 190, 310, 200, 310, 203, 665, 209, 310, 217, 227] }, { "e": [13, 310, 204, 310, 217, 227] }, { "e": [188, 310, 217, 227] }, { "e": [206, 227] }, { "e": [219, 666] }, { "e": [219, 667] }, { "e": [220, 668] }, { "e": [203, 669] }, { "e": [219, 670] }, { "e": [219, 671] }, { "e": [219, 672] }, { "e": [222, 673] }, { "e": [176, 674, 203, 675] }, { "e": [199, 676, 222, 676] }, { "e": [212, 322] }, { "e": [213, 677] }, { "e": [219, 216] }, { "e": [215, 325] }, { "e": [219, 678] }, { "e": [42, 43, 111, 679, 118, 54, 163, 357, 217, 651] }, { "e": [219, 680] }, { "e": [219, 681] }, { "e": [224, 326] }, { "e": [46, 682, 219, 683] }, { "e": [219, 684] }, { "e": [219, 327] }, { "e": [219, 685] }, { "e": [199, 686, 222, 686] }, { "e": [219, 328] }, { "e": [155, 687, 184, 688] }, { "e": [203, 689, 208, 690] }, { "e": [155, 691, 203, 692] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [25, 693, 184, 694] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [206, 220] }, { "e": [206, 222] }, { "e": [219, 695] }, { "e": [186, 696, 205, 697] }, { "e": [208, 698] }, { "e": [203, 699] }, { "e": [205, 700] }, { "e": [219, 701] }, { "e": [219, 702] }, { "e": [205, 703] }, { "e": [219, 704] }, { "e": [126, 705, 149, 706, 205, 707, 212, 708, 215, 709] }, { "e": [184, 710, 203, 711] }, { "e": [219, 712] }, { "e": [126, 713, 177, 713, 205, 714, 206, 222] }, { "e": [126, 715] }, { "e": [25, 716, 184, 717] }, { "e": [206, 222, 215, 718] }, { "e": [46, 719, 219, 720] }, { "e": [81, 721, 120, 722, 217, 220] }, { "e": [206, 220] }, { "e": [219, 723] }, { "e": [199, 724, 222, 724] }, { "e": [215, 725] }, { "e": [219, 726] }, { "e": [186, 727, 205, 728] }, { "e": [215, 729] }, { "e": [208, 730] }, { "e": [220, 731] }, { "e": [47, 732] }, { "e": [215, 733] }, { "e": [224, 372] }, { "e": [219, 734] }, { "e": [70, 735] }, { "e": [219, 736] }, { "e": [206, 737, 215, 738] }, { "e": [70, 739, 153, 740] }, { "e": [184, 741, 206, 742] }, { "e": [206, 742, 215, 743] }, { "e": [208, 379] }, { "e": [203, 744] }, { "e": [198, 71, 201, 381, 203, 745] }, { "e": [198, 71] }, { "e": [201, 381, 203, 746] }, { "e": [219, 747] }, { "e": [180, 385, 213, 71] }, { "e": [213, 71] }, { "e": [219, 748] }, { "e": [219, 749] }, { "e": [205, 750] }, { "e": [205, 751] }, { "e": [208, 752] }, { "e": [222, 753] }, { "e": [219, 754] }, { "e": [219, 755] }, { "e": [219, 169] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 756] }, { "e": [46, 757] }, { "e": [219, 758] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [222, 759] }, { "e": [], "a": 1, "p": 1 }, { "e": [92, 175] }, { "e": [219, 760] }, { "e": [20, 41, 118, 54, 134, 58, 193, 572, 217, 761] }, { "e": [219, 403] }, { "e": [219, 404] }, { "e": [165, 762, 217, 402] }, { "e": [219, 763] }, { "e": [203, 764] }, { "e": [219, 408] }, { "e": [219, 765] }, { "e": [219, 766] }, { "e": [219, 767] }, { "e": [107, 768, 186, 769, 205, 770] }, { "e": [206, 253] }, { "e": [20, 771, 217, 280, 219, 772] }, { "e": [219, 773] }, { "e": [206, 280] }, { "e": [126, 774] }, { "e": [219, 775] }, { "e": [219, 416] }, { "e": [219, 776] }, { "e": [213, 777] }, { "e": [222, 778] }, { "e": [219, 419] }, { "e": [219, 779] }, { "e": [219, 420] }, { "e": [222, 780] }, { "e": [114, 781, 215, 273] }, { "e": [206, 273] }, { "e": [219, 782] }, { "e": [126, 783, 186, 784, 205, 785] }, { "e": [208, 786] }, { "e": [203, 787] }, { "e": [219, 788] }, { "e": [205, 789] }, { "e": [219, 790] }, { "e": [126, 791, 177, 791, 205, 792, 212, 793, 215, 794] }, { "e": [184, 795, 203, 796] }, { "e": [219, 797] }, { "e": [126, 798, 177, 798, 205, 799, 206, 273] }, { "e": [126, 800] }, { "e": [25, 801, 184, 802] }, { "e": [206, 273, 215, 803] }, { "e": [215, 281] }, { "e": [222, 804] }, { "e": [206, 280] }, { "e": [219, 805] }, { "e": [184, 806] }, { "e": [203, 807, 208, 808] }, { "e": [155, 809, 203, 810] }, { "e": [219, 811] }, { "e": [205, 812] }, { "e": [112, 813] }, { "e": [126, 814] }, { "e": [219, 815] }, { "e": [219, 816] }, { "e": [205, 817] }, { "e": [177, 818, 205, 819] }, { "e": [208, 820] }, { "e": [219, 821] }, { "e": [206, 253] }, { "e": [219, 822] }, { "e": [134, 823, 217, 253] }, { "e": [215, 824] }, { "e": [184, 825, 206, 456] }, { "e": [206, 456, 215, 458] }, { "e": [219, 826] }, { "e": [157, 827] }, { "e": [126, 828] }, { "e": [109, 829, 219, 830] }, { "e": [174, 463, 217, 227] }, { "e": [219, 831] }, { "e": [179, 463, 217, 227] }, { "e": [187, 463] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [182, 832, 213, 833] }, { "e": [221, 834] }, { "e": [219, 835] }, { "e": [219, 836, 222, 837] }, { "e": [184, 838, 198, 306, 201, 839, 203, 840] }, { "e": [219, 841] }, { "e": [184, 842, 199, 473, 200, 473, 206, 466] }, { "e": [199, 843, 204, 843, 213, 306] }, { "e": [186, 844] }, { "e": [219, 845] }, { "e": [155, 846] }, { "e": [222, 847] }, { "e": [219, 478] }, { "e": [219, 480] }, { "e": [205, 848] }, { "e": [206, 849, 215, 850] }, { "e": [70, 851, 153, 852] }, { "e": [219, 853] }, { "e": [155, 854] }, { "e": [203, 855] }, { "e": [212, 856] }, { "e": [213, 857] }, { "e": [219, 858] }, { "e": [219, 859] }, { "e": [213, 860] }, { "e": [205, 861, 215, 862] }, { "e": [208, 863] }, { "e": [219, 864] }, { "e": [205, 865] }, { "e": [215, 866] }, { "e": [219, 867] }, { "e": [205, 868] }, { "e": [205, 869] }, { "e": [184, 870, 203, 871] }, { "e": [182, 872, 213, 873] }, { "e": [219, 874] }, { "e": [219, 875] }, { "e": [219, 876] }, { "e": [219, 877] }, { "e": [219, 878] }, { "e": [219, 879] }, { "e": [219, 880] }, { "e": [219, 511] }, { "e": [206, 222, 208, 881] }, { "e": [219, 882] }, { "e": [219, 883] }, { "e": [219, 884] }, { "e": [219, 885] }, { "e": [219, 886] }, { "e": [206, 222] }, { "e": [126, 887] }, { "e": [219, 888] }, { "e": [212, 889] }, { "e": [219, 890] }, { "e": [219, 891] }, { "e": [219, 892] }, { "e": [222, 893] }, { "e": [5, 894, 20, 895, 61, 896, 118, 897, 119, 898, 120, 899, 211, 900, 217, 222] }, { "e": [219, 525] }, { "e": [219, 901] }, { "e": [205, 902] }, { "e": [219, 903] }, { "e": [219, 904] }, { "e": [219, 905] }, { "e": [219, 906] }, { "e": [219, 529] }, { "e": [217, 222, 219, 907] }, { "e": [219, 908] }, { "e": [205, 909] }, { "e": [92, 910] }, { "e": [219, 911] }, { "e": [215, 532] }, { "e": [213, 912] }, { "e": [219, 913] }, { "e": [47, 914, 206, 233, 208, 915] }, { "e": [219, 916] }, { "e": [219, 917] }, { "e": [115, 918, 217, 233] }, { "e": [222, 919, 223, 919] }, { "e": [209, 920] }, { "e": [219, 921] }, { "e": [217, 233, 219, 922] }, { "e": [206, 923] }, { "e": [219, 924] }, { "e": [206, 925] }, { "e": [143, 374, 156, 926] }, { "e": [42, 927, 58, 928, 62, 929, 217, 737] }, { "e": [219, 930] }, { "e": [219, 931] }, { "e": [219, 550] }, { "e": [165, 64, 217, 932] }, { "e": [118, 933, 217, 742] }, { "e": [219, 934] }, { "e": [219, 935] }, { "e": [219, 556] }, { "e": [184, 936, 203, 937] }, { "e": [206, 21] }, { "e": [208, 938] }, { "e": [219, 939] }, { "e": [219, 940] }, { "e": [197, 941] }, { "e": [213, 942] }, { "e": [206, 280] }, { "e": [205, 943] }, { "e": [205, 944] }, { "e": [219, 945] }, { "e": [49, 946] }, { "e": [213, 947] }, { "e": [215, 948] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [20, 949] }, { "e": [180, 950, 184, 951, 213, 406] }, { "e": [219, 952] }, { "e": [198, 406] }, { "e": [200, 586, 203, 953] }, { "e": [203, 954, 206, 402] }, { "e": [186, 769] }, { "e": [219, 955] }, { "e": [219, 956] }, { "e": [126, 957] }, { "e": [177, 958] }, { "e": [206, 280] }, { "e": [219, 959] }, { "e": [213, 415] }, { "e": [206, 451] }, { "e": [206, 280] }, { "e": [182, 960, 213, 961] }, { "e": [184, 962, 203, 963] }, { "e": [213, 603] }, { "e": [206, 280] }, { "e": [206, 273, 208, 964] }, { "e": [219, 965] }, { "e": [219, 966] }, { "e": [219, 967] }, { "e": [219, 968] }, { "e": [219, 969] }, { "e": [126, 970] }, { "e": [219, 971] }, { "e": [215, 794] }, { "e": [219, 972] }, { "e": [219, 973] }, { "e": [222, 974] }, { "e": [5, 975, 20, 976, 61, 977, 118, 978, 120, 979, 211, 980, 217, 273] }, { "e": [219, 613] }, { "e": [219, 981] }, { "e": [215, 982] }, { "e": [219, 983] }, { "e": [219, 984] }, { "e": [219, 985] }, { "e": [219, 986] }, { "e": [219, 617] }, { "e": [217, 273, 219, 987] }, { "e": [213, 988] }, { "e": [215, 281] }, { "e": [219, 989] }, { "e": [219, 990] }, { "e": [219, 991] }, { "e": [219, 992] }, { "e": [219, 993] }, { "e": [37, 994] }, { "e": [219, 995] }, { "e": [219, 996] }, { "e": [219, 997] }, { "e": [206, 281] }, { "e": [126, 998] }, { "e": [219, 999] }, { "e": [219, 1e3] }, { "e": [219, 1001] }, { "e": [223, 1002] }, { "e": [205, 1003] }, { "e": [215, 638] }, { "e": [219, 1004] }, { "e": [20, 1005, 138, 1006, 217, 287] }, { "e": [219, 640] }, { "e": [205, 1007, 212, 1008] }, { "e": [206, 290] }, { "e": [219, 1009] }, { "e": [198, 646] }, { "e": [13, 645, 179, 645, 184, 1010, 188, 645, 198, 646] }, { "e": [188, 1011] }, { "e": [199, 1012, 222, 1012] }, { "e": [107, 1013, 206, 466, 215, 1014] }, { "e": [198, 306] }, { "e": [201, 655] }, { "e": [203, 1015] }, { "e": [198, 306, 201, 655] }, { "e": [219, 656] }, { "e": [219, 1016, 222, 1017, 223, 1017] }, { "e": [219, 1018] }, { "e": [200, 1019] }, { "e": [219, 658] }, { "e": [219, 1020, 222, 1021] }, { "e": [219, 1022] }, { "e": [184, 1023, 206, 466] }, { "e": [219, 1024] }, { "e": [198, 1025, 204, 1026] }, { "e": [219, 1027] }, { "e": [143, 483, 156, 1028, 217, 227] }, { "e": [54, 1029, 58, 1030, 143, 1031, 156, 1032, 217, 849] }, { "e": [219, 1033] }, { "e": [219, 1034] }, { "e": [155, 1035] }, { "e": [219, 1036] }, { "e": [219, 1037] }, { "e": [222, 1038] }, { "e": [219, 490] }, { "e": [203, 675] }, { "e": [155, 1039] }, { "e": [37, 319] }, { "e": [219, 1040] }, { "e": [217, 220, 219, 1041] }, { "e": [219, 1042] }, { "e": [212, 1043] }, { "e": [219, 1044] }, { "e": [55, 1045, 219, 1046] }, { "e": [215, 1047] }, { "e": [219, 1048] }, { "e": [219, 1049] }, { "e": [219, 685] }, { "e": [219, 1050] }, { "e": [199, 1051, 222, 1051] }, { "e": [206, 220, 215, 222] }, { "e": [184, 1052, 206, 220] }, { "e": [203, 1053] }, { "e": [203, 689, 208, 690] }, { "e": [203, 1054, 206, 466] }, { "e": [203, 1055] }, { "e": [155, 691, 203, 692] }, { "e": [203, 1056, 215, 1057] }, { "e": [65, 1058, 222, 1058, 223, 1058] }, { "e": [184, 1059, 208, 881] }, { "e": [208, 881] }, { "e": [203, 1060] }, { "e": [155, 1061] }, { "e": [212, 1062] }, { "e": [219, 1063] }, { "e": [37, 1064] }, { "e": [222, 1065] }, { "e": [215, 709] }, { "e": [212, 1066] }, { "e": [206, 222, 212, 1066, 215, 709] }, { "e": [213, 1067] }, { "e": [219, 1068] }, { "e": [126, 1069, 177, 1069, 219, 1070] }, { "e": [143, 1071] }, { "e": [219, 1072] }, { "e": [219, 1073] }, { "e": [219, 1074] }, { "e": [219, 1075] }, { "e": [126, 1076, 203, 711, 206, 222] }, { "e": [219, 1077] }, { "e": [206, 222, 215, 1078] }, { "e": [206, 222] }, { "e": [215, 1079] }, { "e": [203, 1080] }, { "e": [208, 1081] }, { "e": [215, 1082] }, { "e": [219, 1083] }, { "e": [219, 1084] }, { "e": [177, 1085, 205, 1086] }, { "e": [206, 220] }, { "e": [187, 1087, 188, 1087, 190, 1087] }, { "e": [219, 1088] }, { "e": [219, 1088, 222, 1089, 223, 1089] }, { "e": [184, 1090, 206, 233, 208, 915] }, { "e": [184, 1091, 206, 233] }, { "e": [219, 1092] }, { "e": [206, 233, 212, 1093] }, { "e": [219, 1094] }, { "e": [203, 1095, 206, 233] }, { "e": [208, 1096] }, { "e": [143, 545, 156, 1097] }, { "e": [153, 1098] }, { "e": [54, 1099, 143, 374] }, { "e": [219, 549] }, { "e": [215, 1100] }, { "e": [219, 1101] }, { "e": [219, 1102] }, { "e": [4, 1103] }, { "e": [206, 235] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 1104] }, { "e": [206, 1105] }, { "e": [198, 71, 201, 381, 203, 1106] }, { "e": [219, 747] }, { "e": [219, 1107] }, { "e": [222, 1108, 223, 1108] }, { "e": [215, 1109] }, { "e": [212, 1110] }, { "e": [219, 1111] }, { "e": [206, 253] }, { "e": [219, 1112] }, { "e": [219, 1113] }, { "e": [215, 1114] }, { "e": [219, 1115] }, { "e": [206, 253] }, { "e": [217, 456, 219, 1116] }, { "e": [219, 1117] }, { "e": [222, 1118] }, { "e": [219, 763] }, { "e": [201, 1119] }, { "e": [219, 767] }, { "e": [219, 767] }, { "e": [184, 1120, 206, 402] }, { "e": [184, 1121, 206, 402] }, { "e": [219, 1122] }, { "e": [219, 1123] }, { "e": [206, 280] }, { "e": [222, 1124] }, { "e": [114, 1125, 206, 280, 215, 273] }, { "e": [219, 779] }, { "e": [219, 1126] }, { "e": [65, 1127, 219, 1128, 222, 1127, 223, 1127] }, { "e": [208, 964] }, { "e": [184, 1129, 208, 964, 215, 1130] }, { "e": [208, 964] }, { "e": [203, 1131] }, { "e": [155, 1132] }, { "e": [219, 1133] }, { "e": [37, 1134] }, { "e": [212, 1135] }, { "e": [206, 273, 212, 1135, 215, 794] }, { "e": [213, 1136] }, { "e": [219, 1137] }, { "e": [126, 1138, 177, 1138, 219, 1139] }, { "e": [143, 1140] }, { "e": [126, 1141, 219, 1142] }, { "e": [126, 1143, 219, 1144] }, { "e": [219, 1145] }, { "e": [126, 1146, 203, 796, 206, 273] }, { "e": [60, 1147, 120, 1148, 217, 273] }, { "e": [206, 273, 215, 982] }, { "e": [206, 273] }, { "e": [215, 1149] }, { "e": [203, 1150] }, { "e": [208, 1151] }, { "e": [206, 280] }, { "e": [203, 1152] }, { "e": [203, 807, 208, 808] }, { "e": [203, 1153, 206, 402] }, { "e": [203, 1154] }, { "e": [155, 809, 203, 810] }, { "e": [212, 1155, 219, 1156] }, { "e": [37, 994] }, { "e": [75, 1157] }, { "e": [212, 1158] }, { "e": [219, 1159] }, { "e": [206, 281] }, { "e": [212, 1160] }, { "e": [206, 281] }, { "e": [206, 283] }, { "e": [219, 1161] }, { "e": [177, 1162] }, { "e": [219, 1163] }, { "e": [219, 1164] }, { "e": [219, 1165] }, { "e": [222, 1166] }, { "e": [206, 1167] }, { "e": [219, 830] }, { "e": [219, 1168] }, { "e": [213, 833] }, { "e": [114, 1169] }, { "e": [177, 1170, 217, 466] }, { "e": [219, 1171] }, { "e": [198, 306, 201, 839] }, { "e": [198, 306, 201, 839, 212, 1172] }, { "e": [198, 306, 201, 839, 203, 1173] }, { "e": [219, 1174] }, { "e": [180, 843, 213, 306] }, { "e": [213, 306] }, { "e": [184, 1175, 206, 466] }, { "e": [219, 845] }, { "e": [203, 1176] }, { "e": [198, 479, 199, 1177] }, { "e": [222, 847] }, { "e": [206, 314] }, { "e": [219, 668] }, { "e": [219, 1178] }, { "e": [5, 1179] }, { "e": [219, 1180] }, { "e": [219, 1181, 220, 1181] }, { "e": [54, 1182] }, { "e": [206, 314] }, { "e": [219, 1183] }, { "e": [203, 1184] }, { "e": [206, 1185] }, { "e": [182, 1186] }, { "e": [212, 1187, 219, 1188] }, { "e": [215, 862] }, { "e": [177, 1189] }, { "e": [101, 1190] }, { "e": [199, 1191] }, { "e": [206, 326] }, { "e": [224, 866] }, { "e": [187, 1192] }, { "e": [20, 1193, 42, 1194, 55, 1195, 118, 1196, 120, 1197, 217, 326] }, { "e": [206, 326] }, { "e": [206, 326] }, { "e": [206, 220, 215, 222] }, { "e": [213, 873] }, { "e": [219, 1198] }, { "e": [219, 1199] }, { "e": [219, 1200] }, { "e": [219, 1201] }, { "e": [219, 1202] }, { "e": [134, 1203, 217, 227] }, { "e": [206, 222, 212, 1204] }, { "e": [219, 882] }, { "e": [219, 1205] }, { "e": [219, 1206] }, { "e": [222, 1207] }, { "e": [206, 222] }, { "e": [212, 1208] }, { "e": [213, 1209] }, { "e": [222, 1210] }, { "e": [206, 222, 215, 709] }, { "e": [206, 709] }, { "e": [219, 1211] }, { "e": [126, 1212, 186, 1213] }, { "e": [219, 1214] }, { "e": [126, 1215, 177, 1215, 205, 1216] }, { "e": [203, 1217] }, { "e": [126, 1218, 177, 1218, 205, 1219, 206, 709] }, { "e": [206, 709, 215, 1220] }, { "e": [219, 1221] }, { "e": [215, 1078] }, { "e": [120, 1222, 217, 222] }, { "e": [20, 1223, 217, 222] }, { "e": [219, 1224] }, { "e": [65, 1225, 157, 1225, 222, 1225] }, { "e": [6, 1226, 15, 1227, 147, 1228] }, { "e": [215, 1229] }, { "e": [126, 1230] }, { "e": [219, 1231] }, { "e": [219, 1232] }, { "e": [222, 1233] }, { "e": [203, 1234] }, { "e": [206, 233, 212, 1235] }, { "e": [219, 916] }, { "e": [219, 917] }, { "e": [205, 1236] }, { "e": [219, 1237] }, { "e": [205, 1238] }, { "e": [219, 1239] }, { "e": [219, 1240, 221, 1241] }, { "e": [70, 735] }, { "e": [219, 1242] }, { "e": [219, 1243] }, { "e": [219, 1244] }, { "e": [206, 1245] }, { "e": [206, 738] }, { "e": [172, 1246, 219, 1247] }, { "e": [212, 1248] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [219, 935] }, { "e": [126, 1249, 203, 937, 206, 1250] }, { "e": [206, 1251, 212, 1252] }, { "e": [165, 1253, 217, 1251] }, { "e": [222, 1254] }, { "e": [201, 1255] }, { "e": [212, 1256] }, { "e": [10, 1257] }, { "e": [110, 1258, 147, 1259, 217, 497] }, { "e": [155, 1260] }, { "e": [208, 1261] }, { "e": [186, 1262] }, { "e": [213, 406] }, { "e": [219, 1263] }, { "e": [219, 955] }, { "e": [219, 956] }, { "e": [208, 1264] }, { "e": [208, 1265] }, { "e": [213, 961] }, { "e": [206, 280] }, { "e": [206, 280, 215, 273] }, { "e": [206, 273, 212, 1266] }, { "e": [184, 1267, 206, 273] }, { "e": [219, 966] }, { "e": [165, 1268, 217, 273] }, { "e": [219, 1269] }, { "e": [219, 1270] }, { "e": [206, 273] }, { "e": [212, 1271] }, { "e": [222, 1272] }, { "e": [206, 273, 215, 794] }, { "e": [206, 794] }, { "e": [219, 1273] }, { "e": [186, 1274] }, { "e": [219, 1275] }, { "e": [219, 1276] }, { "e": [205, 1277] }, { "e": [219, 1278] }, { "e": [126, 1279, 177, 1279, 205, 1280, 206, 794] }, { "e": [206, 794, 215, 1281] }, { "e": [219, 1282] }, { "e": [111, 1283] }, { "e": [219, 1284] }, { "e": [20, 1285, 217, 273] }, { "e": [219, 1286] }, { "e": [157, 1287, 222, 1287] }, { "e": [219, 1288] }, { "e": [219, 1289] }, { "e": [219, 1290] }, { "e": [222, 1291] }, { "e": [203, 1292] }, { "e": [219, 1293] }, { "e": [199, 1294, 222, 1294] }, { "e": [206, 281] }, { "e": [222, 1295] }, { "e": [206, 1296] }, { "e": [219, 1297] }, { "e": [126, 1298] }, { "e": [205, 1299] }, { "e": [212, 1300] }, { "e": [213, 1301] }, { "e": [217, 398] }, { "e": [13, 1011, 184, 1302, 188, 1011, 198, 646] }, { "e": [206, 466] }, { "e": [219, 1303] }, { "e": [198, 306, 201, 655] }, { "e": [219, 1304] }, { "e": [219, 1018] }, { "e": [198, 306] }, { "e": [219, 1022] }, { "e": [219, 1305] }, { "e": [197, 1306, 219, 1307] }, { "e": [206, 850, 215, 1308] }, { "e": [219, 1309] }, { "e": [206, 1310, 215, 1311] }, { "e": [70, 1312, 153, 1313] }, { "e": [137, 1314] }, { "e": [203, 1315] }, { "e": [219, 1316] }, { "e": [71, 47, 217, 1317] }, { "e": [222, 1318] }, { "e": [222, 1319] }, { "e": [176, 1320, 203, 1321] }, { "e": [219, 1322] }, { "e": [219, 1323] }, { "e": [213, 1324] }, { "e": [223, 1325] }, { "e": [219, 1326] }, { "e": [219, 1327] }, { "e": [224, 1047] }, { "e": [46, 1328, 219, 1329] }, { "e": [219, 1330] }, { "e": [203, 1331] }, { "e": [155, 687] }, { "e": [203, 1054, 206, 466] }, { "e": [203, 1055, 206, 220] }, { "e": [215, 1057] }, { "e": [219, 1332] }, { "e": [219, 1333] }, { "e": [206, 222] }, { "e": [203, 1334] }, { "e": [213, 1335] }, { "e": [222, 1336] }, { "e": [206, 222] }, { "e": [182, 1337, 213, 1338] }, { "e": [206, 709, 208, 1339] }, { "e": [219, 1340] }, { "e": [219, 1341] }, { "e": [126, 1342] }, { "e": [219, 1343] }, { "e": [219, 1344] }, { "e": [219, 1345] }, { "e": [219, 1346] }, { "e": [219, 1347] }, { "e": [217, 709, 219, 1348] }, { "e": [206, 222] }, { "e": [219, 1349] }, { "e": [126, 1350] }, { "e": [215, 1351] }, { "e": [206, 718] }, { "e": [219, 1352] }, { "e": [42, 1353] }, { "e": [219, 1354] }, { "e": [5, 1355] }, { "e": [219, 1356] }, { "e": [212, 1357] }, { "e": [206, 532] }, { "e": [212, 1358, 217, 233] }, { "e": [219, 1359] }, { "e": [219, 1360] }, { "e": [219, 1361] }, { "e": [213, 919] }, { "e": [219, 1362] }, { "e": [206, 233] }, { "e": [184, 1363, 206, 733] }, { "e": [206, 733] }, { "e": [206, 372] }, { "e": [215, 1364] }, { "e": [187, 1365] }, { "e": [54, 1366] }, { "e": [219, 1367] }, { "e": [153, 740, 205, 1368] }, { "e": [222, 1369] }, { "e": [219, 1370] }, { "e": [119, 557, 217, 1371] }, { "e": [20, 388, 217, 578] }, { "e": [219, 1372] }, { "e": [20, 1373] }, { "e": [213, 1374] }, { "e": [219, 1375] }, { "e": [222, 1376] }, { "e": [219, 1377] }, { "e": [215, 1378] }, { "e": [219, 1379] }, { "e": [219, 1380] }, { "e": [222, 1381] }, { "e": [219, 1382] }, { "e": [203, 1383] }, { "e": [222, 1384] }, { "e": [222, 1385] }, { "e": [219, 1386] }, { "e": [219, 1128] }, { "e": [20, 1387] }, { "e": [206, 273] }, { "e": [203, 1388] }, { "e": [222, 1389] }, { "e": [182, 1390, 213, 1391] }, { "e": [206, 794, 208, 1392] }, { "e": [219, 1393] }, { "e": [126, 1394] }, { "e": [215, 1395] }, { "e": [219, 1396] }, { "e": [215, 1397] }, { "e": [219, 1398] }, { "e": [219, 1399] }, { "e": [217, 794, 219, 1400] }, { "e": [206, 273] }, { "e": [219, 1401] }, { "e": [177, 1402] }, { "e": [126, 1403] }, { "e": [215, 1404] }, { "e": [206, 803] }, { "e": [155, 1405] }, { "e": [203, 1153, 206, 402] }, { "e": [203, 1154, 206, 280] }, { "e": [213, 1406] }, { "e": [219, 1407] }, { "e": [203, 1408] }, { "e": [213, 1409] }, { "e": [213, 1410] }, { "e": [71, 1411, 138, 635, 217, 398] }, { "e": [215, 1412] }, { "e": [219, 1413] }, { "e": [219, 1414] }, { "e": [222, 1415] }, { "e": [215, 1416] }, { "e": [219, 1168] }, { "e": [208, 1417] }, { "e": [213, 1017] }, { "e": [206, 220] }, { "e": [202, 1418] }, { "e": [180, 1177, 199, 1177] }, { "e": [115, 1419, 217, 850] }, { "e": [206, 1420] }, { "e": [143, 1031, 156, 1421] }, { "e": [42, 1422, 54, 1423, 58, 1424, 62, 1425, 217, 1310] }, { "e": [219, 1426] }, { "e": [219, 1427] }, { "e": [106, 1428] }, { "e": [219, 1429] }, { "e": [206, 1185] }, { "e": [5, 1430, 86, 141] }, { "e": [213, 1431] }, { "e": [213, 1432] }, { "e": [219, 1433] }, { "e": [219, 1434] }, { "e": [208, 1435] }, { "e": [184, 1436, 206, 325] }, { "e": [107, 1437] }, { "e": [217, 326] }, { "e": [205, 1438] }, { "e": [215, 1439] }, { "e": [219, 1440] }, { "e": [205, 1441] }, { "e": [205, 1442] }, { "e": [219, 1443] }, { "e": [177, 1444] }, { "e": [180, 1445, 213, 1058] }, { "e": [219, 1446] }, { "e": [206, 222] }, { "e": [213, 1447] }, { "e": [222, 1448] }, { "e": [206, 222, 215, 709] }, { "e": [219, 1449, 222, 1450, 223, 1450] }, { "e": [208, 1339] }, { "e": [184, 1451, 208, 1339] }, { "e": [219, 1452] }, { "e": [212, 1453] }, { "e": [206, 709] }, { "e": [206, 709] }, { "e": [206, 709, 215, 1454] }, { "e": [206, 709] }, { "e": [208, 1455] }, { "e": [177, 1456] }, { "e": [219, 1457] }, { "e": [134, 1458, 217, 222] }, { "e": [212, 1459] }, { "e": [215, 1460] }, { "e": [205, 1461] }, { "e": [219, 1462] }, { "e": [206, 532] }, { "e": [222, 1463] }, { "e": [219, 1464] }, { "e": [206, 233] }, { "e": [213, 1089] }, { "e": [206, 729] }, { "e": [215, 1465] }, { "e": [219, 1240] }, { "e": [115, 1466, 217, 235] }, { "e": [222, 1467] }, { "e": [219, 1468] }, { "e": [203, 1469, 209, 1470] }, { "e": [219, 1471] }, { "e": [213, 1472] }, { "e": [206, 1250] }, { "e": [37, 332, 118, 54] }, { "e": [180, 1473, 213, 1108] }, { "e": [219, 1474] }, { "e": [206, 1475] }, { "e": [198, 1476, 201, 1255] }, { "e": [213, 1477] }, { "e": [155, 1478] }, { "e": [168, 1479, 217, 1114] }, { "e": [205, 1480] }, { "e": [184, 1481, 206, 1482] }, { "e": [206, 948] }, { "e": [184, 1483, 206, 581] }, { "e": [219, 1484] }, { "e": [206, 590] }, { "e": [206, 590, 212, 1485] }, { "e": [180, 1486, 184, 1487, 213, 1127] }, { "e": [219, 1488] }, { "e": [219, 1489] }, { "e": [213, 1490] }, { "e": [222, 1491] }, { "e": [206, 273, 215, 794] }, { "e": [219, 1492, 222, 1493, 223, 1493] }, { "e": [184, 1494, 208, 1392] }, { "e": [219, 1495] }, { "e": [120, 1496, 217, 794] }, { "e": [206, 794] }, { "e": [60, 1497, 120, 1498, 217, 794] }, { "e": [206, 794, 215, 1397] }, { "e": [206, 794] }, { "e": [208, 1499] }, { "e": [206, 982] }, { "e": [219, 1500] }, { "e": [219, 1501] }, { "e": [134, 1502, 217, 273] }, { "e": [219, 1503] }, { "e": [219, 1156] }, { "e": [155, 1504] }, { "e": [219, 1505] }, { "e": [208, 1506] }, { "e": [206, 281, 215, 1507] }, { "e": [219, 1508] }, { "e": [20, 1509, 147, 1510, 217, 638] }, { "e": [208, 1511] }, { "e": [215, 1512] }, { "e": [213, 1513] }, { "e": [166, 1514, 217, 458] }, { "e": [197, 1515] }, { "e": [222, 1516] }, { "e": [219, 1517] }, { "e": [54, 1029, 143, 1031] }, { "e": [219, 1181] }, { "e": [215, 1518] }, { "e": [219, 1519] }, { "e": [219, 1520] }, { "e": [219, 1521] }, { "e": [4, 1522] }, { "e": [206, 850] }, { "e": [219, 1523] }, { "e": [206, 1185] }, { "e": [], "a": 1, "p": 1, "r": 1 }, { "e": [206, 227] }, { "e": [219, 1188] }, { "e": [203, 1321] }, { "e": [203, 1321, 206, 220, 215, 1524] }, { "e": [222, 1525] }, { "e": [219, 1323] }, { "e": [206, 220] }, { "e": [219, 1526] }, { "e": [55, 1527, 219, 1528] }, { "e": [215, 1529] }, { "e": [219, 1530] }, { "e": [219, 1531] }, { "e": [206, 220] }, { "e": [219, 1532] }, { "e": [222, 1533] }, { "e": [203, 1334, 206, 222] }, { "e": [219, 1534] }, { "e": [213, 1338] }, { "e": [184, 1535, 206, 709] }, { "e": [206, 709, 212, 1536] }, { "e": [219, 1341] }, { "e": [206, 709] }, { "e": [222, 1537] }, { "e": [120, 1538, 217, 709] }, { "e": [65, 1539, 157, 1539] }, { "e": [219, 1540] }, { "e": [208, 1541] }, { "e": [219, 1542] }, { "e": [222, 1543] }, { "e": [219, 1544] }, { "e": [219, 1545] }, { "e": [206, 1546] }, { "e": [213, 1547] }, { "e": [213, 1233] }, { "e": [18, 1548, 126, 1549, 211, 1550, 217, 233] }, { "e": [219, 1551] }, { "e": [212, 1552, 217, 1553] }, { "e": [206, 738] }, { "e": [219, 1554] }, { "e": [219, 1555] }, { "e": [169, 1556] }, { "e": [215, 1557] }, { "e": [222, 1558] }, { "e": [206, 1109] }, { "e": [57, 1559, 217, 1560] }, { "e": [206, 1561] }, { "e": [215, 590] }, { "e": [219, 1562] }, { "e": [219, 1563] }, { "e": [219, 1564] }, { "e": [219, 1380] }, { "e": [217, 932] }, { "e": [219, 1382] }, { "e": [198, 406, 201, 1119] }, { "e": [219, 1565] }, { "e": [222, 1566] }, { "e": [219, 1386] }, { "e": [186, 1567] }, { "e": [203, 1388, 206, 273] }, { "e": [219, 1568] }, { "e": [213, 1391] }, { "e": [184, 1569, 206, 794] }, { "e": [206, 794, 212, 1570] }, { "e": [219, 1393] }, { "e": [206, 794] }, { "e": [126, 1571] }, { "e": [111, 1572] }, { "e": [219, 1573] }, { "e": [65, 1574, 157, 1574] }, { "e": [212, 1575] }, { "e": [208, 1576] }, { "e": [219, 1577] }, { "e": [206, 280] }, { "e": [212, 1578, 219, 1579] }, { "e": [155, 1580, 203, 1408] }, { "e": [219, 1581] }, { "e": [20, 1582, 217, 281] }, { "e": [75, 1583, 203, 1584] }, { "e": [126, 1585] }, { "e": [219, 1586] }, { "e": [222, 1587] }, { "e": [138, 1588, 177, 1589, 217, 824] }, { "e": [215, 1416] }, { "e": [20, 1590] }, { "e": [219, 1591] }, { "e": [198, 1025] }, { "e": [206, 1308] }, { "e": [219, 1592] }, { "e": [206, 1311] }, { "e": [206, 1593] }, { "e": [206, 1311] }, { "e": [172, 1594, 219, 1595] }, { "e": [197, 1596] }, { "e": [86, 1597, 217, 220] }, { "e": [206, 862, 212, 1598] }, { "e": [206, 1047] }, { "e": [224, 1439] }, { "e": [187, 1599] }, { "e": [20, 1600, 42, 1601, 55, 1602, 118, 1603, 120, 1604, 217, 1047] }, { "e": [206, 1047] }, { "e": [206, 1047] }, { "e": [215, 1605] }, { "e": [213, 1058] }, { "e": [203, 1606] }, { "e": [219, 1449] }, { "e": [219, 1607] }, { "e": [213, 1608] }, { "e": [219, 1609] }, { "e": [206, 1220] }, { "e": [212, 1610] }, { "e": [222, 1611] }, { "e": [177, 1612] }, { "e": [182, 1613] }, { "e": [179, 1614] }, { "e": [206, 1082] }, { "e": [153, 1615, 217, 227] }, { "e": [206, 532] }, { "e": [42, 1616] }, { "e": [219, 1617] }, { "e": [219, 1618] }, { "e": [206, 1364] }, { "e": [219, 1619] }, { "e": [217, 737] }, { "e": [207, 1470, 209, 1470] }, { "e": [54, 1620, 153, 740] }, { "e": [219, 1621] }, { "e": [166, 1622, 217, 743] }, { "e": [213, 1108] }, { "e": [219, 563] }, { "e": [217, 1623] }, { "e": [217, 261] }, { "e": [184, 1624] }, { "e": [206, 1378] }, { "e": [206, 1114] }, { "e": [213, 1385] }, { "e": [213, 1127] }, { "e": [219, 1625] }, { "e": [203, 1626] }, { "e": [219, 1492] }, { "e": [219, 1627] }, { "e": [219, 1628] }, { "e": [219, 1629] }, { "e": [177, 1630] }, { "e": [206, 1281] }, { "e": [222, 1631] }, { "e": [222, 1632] }, { "e": [177, 1633] }, { "e": [222, 1634] }, { "e": [203, 1635] }, { "e": [219, 1636] }, { "e": [203, 1637] }, { "e": [177, 1638] }, { "e": [219, 1639] }, { "e": [219, 1640] }, { "e": [219, 1641] }, { "e": [126, 1642] }, { "e": [206, 824, 212, 1643] }, { "e": [219, 1644] }, { "e": [219, 1645] }, { "e": [219, 1646] }, { "e": [201, 1647] }, { "e": [187, 1648] }, { "e": [54, 1423] }, { "e": [219, 1649] }, { "e": [54, 1650, 153, 1313, 205, 1651] }, { "e": [219, 1652] }, { "e": [219, 1653] }, { "e": [219, 1654] }, { "e": [223, 1655] }, { "e": [219, 1656] }, { "e": [219, 1657] }, { "e": [224, 1529] }, { "e": [46, 1658, 219, 1659] }, { "e": [219, 1660] }, { "e": [20, 1661, 147, 1662, 217, 1057] }, { "e": [219, 1663] }, { "e": [180, 1664, 213, 1450] }, { "e": [206, 709] }, { "e": [177, 1665] }, { "e": [222, 1666] }, { "e": [206, 1079] }, { "e": [219, 1667] }, { "e": [222, 1668] }, { "e": [109, 1669, 219, 1670] }, { "e": [5, 1671] }, { "e": [215, 1672] }, { "e": [208, 1673] }, { "e": [215, 1674] }, { "e": [213, 1467] }, { "e": [137, 1675] }, { "e": [78, 1676] }, { "e": [20, 1677] }, { "e": [118, 145] }, { "e": [219, 1678] }, { "e": [184, 1679, 206, 1130] }, { "e": [219, 1680] }, { "e": [180, 1681, 213, 1493] }, { "e": [215, 1682] }, { "e": [206, 1397] }, { "e": [219, 1683] }, { "e": [213, 1684] }, { "e": [206, 1149] }, { "e": [219, 1685] }, { "e": [213, 1686] }, { "e": [219, 1687] }, { "e": [203, 1688] }, { "e": [219, 1689] }, { "e": [219, 1690] }, { "e": [203, 1691] }, { "e": [155, 1692] }, { "e": [208, 1693] }, { "e": [219, 1694] }, { "e": [219, 1695] }, { "e": [205, 1696] }, { "e": [184, 1697, 208, 1698] }, { "e": [186, 1699, 205, 1700] }, { "e": [219, 1701] }, { "e": [222, 1702] }, { "e": [203, 1703] }, { "e": [137, 1704] }, { "e": [219, 1705] }, { "e": [208, 1706] }, { "e": [186, 1707] }, { "e": [213, 1525] }, { "e": [217, 1047] }, { "e": [205, 1708] }, { "e": [215, 1709] }, { "e": [219, 1710] }, { "e": [205, 1711] }, { "e": [205, 1712] }, { "e": [126, 1713] }, { "e": [219, 1714] }, { "e": [155, 1715] }, { "e": [222, 1716] }, { "e": [219, 1717] }, { "e": [213, 1718] }, { "e": [215, 1719] }, { "e": [213, 1720] }, { "e": [174, 1614, 217, 1721] }, { "e": [179, 1614] }, { "e": [219, 1462] }, { "e": [219, 1722] }, { "e": [222, 1723, 223, 1723] }, { "e": [217, 1465, 219, 1724] }, { "e": [106, 1725] }, { "e": [219, 1726] }, { "e": [219, 1727] }, { "e": [215, 1728] }, { "e": [219, 1625] }, { "e": [155, 1729] }, { "e": [222, 1730] }, { "e": [60, 1731, 217, 1395] }, { "e": [212, 1732] }, { "e": [206, 982] }, { "e": [215, 1733] }, { "e": [219, 1579] }, { "e": [203, 1635, 206, 280] }, { "e": [219, 1734] }, { "e": [206, 1735] }, { "e": [208, 1736] }, { "e": [219, 1737] }, { "e": [219, 1738] }, { "e": [219, 1739] }, { "e": [208, 1740] }, { "e": [213, 1587] }, { "e": [219, 1741] }, { "e": [219, 1645] }, { "e": [222, 1742, 223, 1742] }, { "e": [219, 1743] }, { "e": [219, 1744] }, { "e": [198, 1745, 201, 1647] }, { "e": [212, 1746, 217, 1747] }, { "e": [219, 1748] }, { "e": [106, 1749] }, { "e": [169, 1750] }, { "e": [219, 1751] }, { "e": [219, 1752] }, { "e": [219, 1753] }, { "e": [55, 1754, 219, 1755] }, { "e": [215, 1756] }, { "e": [219, 1757] }, { "e": [219, 1758] }, { "e": [219, 1759] }, { "e": [126, 1760] }, { "e": [212, 1761] }, { "e": [213, 1450] }, { "e": [212, 1762] }, { "e": [206, 1078, 215, 1763] }, { "e": [147, 1764, 217, 1351] }, { "e": [206, 1082] }, { "e": [217, 497] }, { "e": [187, 1765] }, { "e": [206, 1465, 212, 1766] }, { "e": [208, 1767] }, { "e": [219, 1768] }, { "e": [203, 1769] }, { "e": [186, 1770] }, { "e": [10, 1771, 217, 220] }, { "e": [212, 1772] }, { "e": [213, 1493] }, { "e": [111, 1773] }, { "e": [222, 1774] }, { "e": [147, 1775, 217, 1404] }, { "e": [203, 1688, 206, 280] }, { "e": [5, 1776] }, { "e": [222, 1777, 223, 1777] }, { "e": [155, 1778] }, { "e": [203, 1779] }, { "e": [203, 1780] }, { "e": [219, 1781] }, { "e": [206, 1512] }, { "e": [206, 1512, 212, 1782] }, { "e": [184, 1783, 215, 1784] }, { "e": [215, 1784] }, { "e": [206, 1014] }, { "e": [219, 1785] }, { "e": [217, 1310] }, { "e": [207, 1786, 209, 1786] }, { "e": [219, 1787] }, { "e": [219, 1788] }, { "e": [184, 1789, 198, 1790] }, { "e": [37, 1791] }, { "e": [206, 1529] }, { "e": [224, 1709] }, { "e": [187, 1792] }, { "e": [20, 1793, 42, 1794, 55, 1795, 118, 1796, 120, 1797, 217, 1529] }, { "e": [206, 1529] }, { "e": [206, 1529] }, { "e": [208, 1798] }, { "e": [219, 1799] }, { "e": [222, 1800] }, { "e": [222, 1801] }, { "e": [20, 1802, 217, 1078] }, { "e": [219, 1803] }, { "e": [222, 1804] }, { "e": [219, 1805] }, { "e": [219, 1806, 221, 1807] }, { "e": [197, 1808] }, { "e": [219, 1809] }, { "e": [219, 1810] }, { "e": [219, 1811] }, { "e": [222, 1812] }, { "e": [219, 1813] }, { "e": [213, 1814] }, { "e": [219, 1815] }, { "e": [219, 1816] }, { "e": [206, 1507] }, { "e": [219, 1817] }, { "e": [219, 1818] }, { "e": [219, 1819] }, { "e": [203, 1820] }, { "e": [219, 1821] }, { "e": [219, 1743] }, { "e": [165, 1822, 217, 1416] }, { "e": [213, 1702] }, { "e": [219, 1823] }, { "e": [197, 1824] }, { "e": [78, 1825] }, { "e": [219, 1751] }, { "e": [169, 1826] }, { "e": [219, 1827] }, { "e": [223, 1828] }, { "e": [219, 1829] }, { "e": [219, 1830] }, { "e": [224, 1756] }, { "e": [46, 1831, 219, 1832] }, { "e": [219, 1833] }, { "e": [219, 1834] }, { "e": [208, 1835] }, { "e": [213, 1836] }, { "e": [213, 1837] }, { "e": [177, 1838] }, { "e": [126, 1839] }, { "e": [217, 1465] }, { "e": [213, 1723] }, { "e": [184, 1840, 206, 1674] }, { "e": [206, 1674] }, { "e": [198, 1841] }, { "e": [188, 1842] }, { "e": [184, 1843, 215, 1844] }, { "e": [203, 1845] }, { "e": [213, 1846] }, { "e": [206, 1682] }, { "e": [206, 1397] }, { "e": [126, 1847] }, { "e": [205, 1848] }, { "e": [203, 1849] }, { "e": [206, 1296] }, { "e": [206, 1412] }, { "e": [219, 1850] }, { "e": [213, 1742] }, { "e": [20, 1851] }, { "e": [54, 1650] }, { "e": [198, 1852] }, { "e": [219, 1853] }, { "e": [219, 1854] }, { "e": [176, 1855] }, { "e": [217, 1529] }, { "e": [205, 1856] }, { "e": [215, 1857] }, { "e": [219, 1858] }, { "e": [205, 1859] }, { "e": [205, 1860] }, { "e": [203, 1861] }, { "e": [219, 1862] }, { "e": [219, 1863] }, { "e": [206, 1454] }, { "e": [219, 1864] }, { "e": [219, 1865] }, { "e": [219, 1806] }, { "e": [155, 1866] }, { "e": [219, 1867] }, { "e": [219, 1810] }, { "e": [165, 1868, 217, 1557] }, { "e": [219, 1869] }, { "e": [219, 1870] }, { "e": [219, 1871] }, { "e": [219, 1872] }, { "e": [219, 1873] }, { "e": [206, 1412] }, { "e": [219, 1874] }, { "e": [155, 1875] }, { "e": [203, 1876] }, { "e": [153, 852] }, { "e": [219, 1877] }, { "e": [219, 1878] }, { "e": [55, 1879, 219, 1880] }, { "e": [215, 1881] }, { "e": [219, 1882] }, { "e": [219, 1883] }, { "e": [219, 1884] }, { "e": [203, 1885] }, { "e": [203, 1886] }, { "e": [208, 1887] }, { "e": [208, 1888] }, { "e": [219, 1889] }, { "e": [13, 1842, 54, 1620, 184, 1890] }, { "e": [20, 1891] }, { "e": [155, 1892] }, { "e": [203, 1893] }, { "e": [208, 1894] }, { "e": [206, 1895, 215, 1896] }, { "e": [206, 1296] }, { "e": [186, 1897, 206, 1784] }, { "e": [219, 1898] }, { "e": [219, 1899] }, { "e": [203, 1900] }, { "e": [206, 1756] }, { "e": [224, 1857] }, { "e": [187, 1901] }, { "e": [20, 1902, 42, 1903, 55, 1904, 118, 1905, 120, 1906, 217, 1756] }, { "e": [206, 1756] }, { "e": [206, 1756] }, { "e": [206, 1605] }, { "e": [219, 1907] }, { "e": [219, 1908] }, { "e": [222, 1909, 223, 1909] }, { "e": [219, 1910] }, { "e": [153, 740] }, { "e": [219, 1867] }, { "e": [219, 1911] }, { "e": [219, 1912] }, { "e": [219, 1913] }, { "e": [219, 1914] }, { "e": [5, 1915, 71, 1411] }, { "e": [81, 1916, 217, 1895] }, { "e": [219, 1917] }, { "e": [153, 1313] }, { "e": [188, 1918] }, { "e": [219, 1919] }, { "e": [223, 1920] }, { "e": [219, 1921] }, { "e": [219, 1922] }, { "e": [224, 1881] }, { "e": [46, 1923, 219, 1924] }, { "e": [219, 1925] }, { "e": [206, 1605] }, { "e": [203, 1886, 206, 222] }, { "e": [206, 1763] }, { "e": [203, 1926] }, { "e": [186, 1927] }, { "e": [184, 1928] }, { "e": [203, 1893, 206, 273] }, { "e": [203, 1929] }, { "e": [219, 1816] }, { "e": [92, 1930, 219, 1931] }, { "e": [184, 1932, 206, 1784] }, { "e": [219, 1933] }, { "e": [155, 1934] }, { "e": [217, 1756] }, { "e": [205, 1935] }, { "e": [215, 1936] }, { "e": [219, 1937] }, { "e": [205, 1938] }, { "e": [205, 1939] }, { "e": [219, 1940] }, { "e": [219, 1941] }, { "e": [219, 1942] }, { "e": [219, 1943] }, { "e": [208, 1944] }, { "e": [208, 1945] }, { "e": [219, 1917] }, { "e": [13, 1918, 54, 1650, 184, 1946] }, { "e": [219, 1947] }, { "e": [219, 1948] }, { "e": [55, 1949, 219, 1950] }, { "e": [215, 1951] }, { "e": [219, 1952] }, { "e": [219, 1953] }, { "e": [206, 1719] }, { "e": [184, 1954, 206, 1844] }, { "e": [203, 1955] }, { "e": [206, 1733] }, { "e": [219, 1956] }, { "e": [219, 1957] }, { "e": [219, 1933] }, { "e": [176, 1958] }, { "e": [206, 1881] }, { "e": [224, 1936] }, { "e": [187, 1959] }, { "e": [20, 1960, 42, 1961, 55, 1962, 118, 1963, 120, 1964, 217, 1881] }, { "e": [206, 1881] }, { "e": [206, 1881] }, { "e": [219, 1941] }, { "e": [219, 1965] }, { "e": [203, 1966] }, { "e": [203, 1967] }, { "e": [219, 1968] }, { "e": [223, 1969] }, { "e": [219, 1970] }, { "e": [219, 1971] }, { "e": [224, 1951] }, { "e": [46, 1972] }, { "e": [219, 1973] }, { "e": [215, 1974] }, { "e": [219, 1975] }, { "e": [219, 1976] }, { "e": [203, 1977] }, { "e": [217, 1881] }, { "e": [205, 1978] }, { "e": [215, 1979] }, { "e": [219, 1980] }, { "e": [205, 1981] }, { "e": [10, 1982, 217, 1728] }, { "e": [206, 1896] }, { "e": [206, 1896] }, { "e": [219, 1983] }, { "e": [219, 1984] }, { "e": [55, 1985, 219, 1986] }, { "e": [215, 1987] }, { "e": [219, 1988] }, { "e": [219, 1989] }, { "e": [215, 1990] }, { "e": [206, 1951] }, { "e": [224, 1979] }, { "e": [187, 1991] }, { "e": [20, 1992, 42, 1993, 55, 1994, 120, 1995, 217, 1951] }, { "e": [206, 1951] }, { "e": [203, 1996] }, { "e": [20, 1997, 217, 1524] }, { "e": [223, 1998] }, { "e": [219, 1999] }, { "e": [219, 2e3] }, { "e": [224, 1987] }, { "e": [219, 2001] }, { "e": [219, 2002] }, { "e": [177, 2003] }, { "e": [217, 1951] }, { "e": [205, 2004] }, { "e": [215, 2005] }, { "e": [205, 2006] }, { "e": [155, 2007, 203, 1996] }, { "e": [219, 2008] }, { "e": [219, 2009] }, { "e": [55, 2010, 219, 2011] }, { "e": [219, 2012] }, { "e": [219, 2013] }, { "e": [208, 2014] }, { "e": [206, 1987] }, { "e": [224, 2005] }, { "e": [187, 2015] }, { "e": [206, 1987] }, { "e": [184, 2016] }, { "e": [222, 2017] }, { "e": [223, 2018] }, { "e": [219, 2019] }, { "e": [199, 2020, 206, 1990] }, { "e": [217, 1987] }, { "e": [203, 2021] }, { "e": [223, 2017] }, { "e": [219, 2022] }, { "e": [203, 2021, 206, 1974] }] }, { "d": 279, "s0": 0, "s": [{ "e": [85, 1, 126, 2, 176, 3, 177, 2, 186, 4, 205, 5, 207, 6, 219, 7, 220, 7] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 283, "s0": 0, "s": [{ "e": [20, 1, 22, 2, 23, 3, 57, 4, 70, 5, 81, 6, 85, 7, 115, 6, 126, 8, 128, 9, 166, 10, 177, 8, 193, 11, 205, 12, 219, 13] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 5 }, { "e": [193, 11, 219, 14] }, { "e": [], "a": 1, "p": 6 }, { "e": [20, 1, 219, 13] }, { "e": [], "a": 1, "p": 8 }, { "e": [], "a": 1, "p": 8 }, { "e": [219, 15] }, { "e": [20, 1] }, { "e": [219, 16] }, { "e": [], "a": 1, "p": 8 }, { "e": [], "a": 1, "p": 8 }, { "e": [205, 17, 206, 18] }, { "e": [], "a": 1, "p": 1 }, { "e": [20, 1, 176, 19, 219, 20] }, { "e": [219, 21] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 7 }, { "e": [], "a": 1, "p": 7 }, { "e": [206, 18, 212, 22] }, { "e": [222, 23] }, { "e": [213, 24] }, { "e": [206, 18] }] }, { "d": 287, "s0": 0, "s": [{ "e": [3, 1, 5, 2, 10, 3, 11, 4, 12, 5, 15, 6, 26, 7, 37, 8, 38, 9, 42, 10, 60, 11, 61, 12, 81, 13, 83, 14, 84, 13, 86, 15, 92, 16, 100, 17, 111, 18, 115, 13, 118, 19, 119, 20, 120, 21, 128, 22, 134, 23, 136, 24, 138, 25, 143, 26, 154, 25, 163, 27, 166, 1, 167, 28, 170, 29, 193, 30] }, { "e": [118, 19] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [92, 16, 120, 21] }, { "e": [219, 31] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [92, 16] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [219, 32] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 33] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [38, 9, 118, 19, 193, 30] }] }, { "d": 288, "s0": 0, "s": [{ "e": [3, 1, 10, 2, 11, 3, 37, 4, 38, 5, 60, 6, 71, 7, 81, 8, 83, 9, 84, 8, 86, 10, 92, 11, 100, 12, 111, 13, 115, 8, 118, 14, 120, 15, 128, 16, 138, 17, 151, 18, 154, 17, 166, 1, 170, 19, 193, 20] }, { "e": [118, 14] }, { "e": [], "a": 1, "p": 12 }, { "e": [], "a": 1, "p": 12 }, { "e": [], "a": 1, "p": 10 }, { "e": [], "a": 1, "p": 10 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 14 }, { "e": [92, 11, 118, 14, 120, 15] }, { "e": [219, 21] }, { "e": [], "a": 1, "p": 11 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 13 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 6 }, { "e": [], "a": 1, "p": 9 }, { "e": [92, 11] }, { "e": [219, 22] }, { "e": [], "a": 1, "p": 15 }, { "e": [], "a": 1, "p": 7 }, { "e": [219, 23] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 3 }, { "e": [38, 5, 118, 14, 193, 20] }] }, { "d": 289, "s0": 0, "s": [{ "e": [5, 1, 12, 2, 15, 3, 26, 4, 42, 5, 61, 6, 82, 7, 119, 8, 134, 9, 136, 10, 143, 11, 163, 12, 167, 13] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 8 }, { "e": [42, 14] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 13 }, { "e": [], "a": 1, "p": 14 }, { "e": [], "a": 1, "p": 12 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 16 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 10 }, { "e": [], "a": 1, "p": 9 }, { "e": [], "a": 1, "p": 15 }] }, { "d": 290, "s0": 0, "s": [{ "e": [20, 1, 118, 2] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 11 }] }, { "d": 293, "s0": 0, "s": [{ "e": [55, 1, 59, 2, 219, 3] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 312, "s0": 0, "s": [{ "e": [5, 1, 73, 2, 143, 3, 153, 4] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 326, "s0": 0, "s": [{ "e": [20, 1, 42, 2, 55, 3, 57, 4, 71, 5, 86, 6] }, { "e": [177, 7, 219, 8] }, { "e": [215, 9] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 10] }, { "e": [112, 11, 219, 12] }, { "e": [219, 13] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 4 }, { "e": [205, 14, 206, 15] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 4 }, { "e": [218, 16, 219, 17] }, { "e": [], "a": 1, "p": 4 }, { "e": [219, 18] }, { "e": [206, 15, 212, 19] }, { "e": [206, 15] }, { "e": [222, 20] }, { "e": [182, 21, 213, 22] }, { "e": [199, 23] }, { "e": [206, 15] }, { "e": [213, 22] }] }, { "d": 327, "s0": 0, "s": [{ "e": [20, 1] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 328, "s0": 0, "s": [{ "e": [42, 1, 57, 2, 71, 3, 86, 4] }, { "e": [], "a": 1, "p": 4 }, { "e": [219, 5] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [205, 6, 206, 7] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 332, "s0": 0, "s": [{ "e": [205, 1, 219, 2] }, { "e": [], "a": 1, "p": 1 }, { "e": [186, 3, 205, 4] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 336, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [176, 2, 203, 3] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 344, "s0": 0, "s": [{ "e": [112, 1, 219, 2] }, { "e": [], "a": 1, "p": 1 }, { "e": [112, 1] }] }, { "d": 347, "s0": 0, "s": [{ "e": [153, 1, 217, 2] }, { "e": [5, 3, 73, 4, 219, 5] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [206, 6] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 349, "s0": 0, "s": [{ "e": [5, 1, 16, 2, 26, 3, 70, 4, 71, 5, 72, 6, 82, 7, 93, 8, 97, 9, 135, 10, 151, 11, 153, 12, 217, 13] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [5, 14, 219, 15] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [206, 16] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 350, "s0": 0, "s": [{ "e": [5, 1, 15, 2, 16, 3, 20, 4, 26, 5, 42, 6, 55, 7, 70, 8, 71, 9, 72, 10, 73, 11, 81, 12, 82, 13, 93, 14, 97, 15, 115, 12, 118, 16, 151, 17, 153, 18, 173, 19, 211, 20, 224, 21] }, { "e": [219, 22] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 1 }, { "e": [186, 23, 219, 24] }, { "e": [215, 25] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 26] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [20, 27, 92, 28, 118, 29, 219, 30] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 1 }, { "e": [71, 31] }, { "e": [5, 32, 73, 11] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [153, 33, 206, 34] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [126, 35, 186, 36, 205, 37, 206, 38, 208, 39] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [219, 40] }, { "e": [219, 41] }, { "e": [219, 42] }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 43] }, { "e": [212, 44] }, { "e": [184, 45, 206, 38, 212, 44] }, { "e": [184, 46, 206, 38, 212, 44] }, { "e": [197, 47, 203, 48] }, { "e": [199, 49, 222, 49] }, { "e": [219, 41] }, { "e": [219, 42] }, { "e": [219, 50] }, { "e": [219, 51] }, { "e": [213, 52] }, { "e": [184, 53, 203, 54] }, { "e": [206, 38] }, { "e": [206, 38, 208, 39] }, { "e": [219, 50] }, { "e": [219, 55] }, { "e": [197, 56] }, { "e": [219, 57] }, { "e": [198, 58] }, { "e": [198, 59] }, { "e": [206, 38] }] }, { "d": 352, "s0": 0, "s": [{ "e": [20, 1, 55, 2, 70, 3, 71, 4, 81, 5, 115, 5, 118, 6, 128, 7, 151, 8, 211, 9, 224, 10] }, { "e": [219, 11] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 5 }, { "e": [75, 12, 112, 13, 219, 14] }, { "e": [20, 15, 92, 16, 118, 17, 219, 18] }, { "e": [219, 19] }, { "e": [219, 20] }, { "e": [71, 21] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 6 }, { "e": [], "a": 1, "p": 6 }, { "e": [], "a": 1, "p": 6 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 6 }, { "e": [], "a": 1, "p": 6 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 6 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 6 }] }, { "d": 353, "s0": 0, "s": [{ "e": [5, 1, 15, 2, 16, 3, 26, 4, 42, 5, 72, 6, 73, 7, 82, 8, 93, 9, 97, 10, 173, 11] }, { "e": [219, 12] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [4, 13, 137, 14, 149, 15, 205, 16, 206, 17, 212, 18, 215, 19] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 20] }, { "e": [219, 21] }, { "e": [], "a": 1, "p": 2 }, { "e": [222, 22] }, { "e": [], "a": 1, "p": 2 }, { "e": [212, 23] }, { "e": [206, 17, 215, 19] }, { "e": [182, 24] }, { "e": [222, 25] }, { "e": [222, 26] }, { "e": [213, 27] }, { "e": [213, 28] }, { "e": [206, 17] }, { "e": [206, 17] }] }, { "d": 360, "s0": 0, "s": [{ "e": [5, 1, 16, 2, 72, 3, 73, 4, 93, 5, 97, 6, 173, 7] }, { "e": [219, 8] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 8 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 7 }, { "e": [], "a": 1, "p": 7 }, { "e": [4, 9, 137, 10] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 363, "s0": 0, "s": [{ "e": [73, 1, 93, 2] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 3 }] }, { "d": 373, "s0": 0, "s": [{ "e": [19, 1, 172, 2] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 375, "s0": 0, "s": [{ "e": [19, 1, 172, 2, 219, 3] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [54, 4, 153, 5, 205, 6] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 7] }, { "e": [169, 8, 206, 9] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 380, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 386, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [185, 2] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 404, "s0": 0, "s": [{ "e": [143, 1, 153, 2, 156, 3, 217, 4] }, { "e": [], "a": 1, "p": 2 }, { "e": [143, 5] }, { "e": [70, 6, 219, 7] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 405, "s0": 0, "s": [{ "e": [54, 1, 143, 2] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 406, "s0": 0, "s": [{ "e": [42, 1, 54, 2, 55, 3, 58, 4, 62, 5, 128, 6, 143, 7, 153, 8, 156, 9] }, { "e": [215, 10] }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 6 }, { "e": [219, 11] }, { "e": [219, 12] }, { "e": [143, 13] }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 408, "s0": 0, "s": [{ "e": [5, 1, 219, 2] }, { "e": [219, 3] }, { "e": [], "a": 1, "p": 2 }, { "e": [206, 4] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 417, "s0": 0, "s": [{ "e": [70, 1, 219, 2, 220, 2] }, { "e": [], "a": 1, "p": 1 }, { "e": [70, 1, 153, 3] }, { "e": [], "a": 1, "p": 2 }] }, { "d": 428, "s0": 0, "s": [{ "e": [137, 1] }, { "e": [], "a": 1, "p": 4 }] }, { "d": 438, "s0": 0, "s": [{ "e": [20, 1, 42, 2, 55, 3, 81, 4, 135, 5, 197, 6, 217, 7, 219, 8] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [79, 9, 179, 10, 184, 11, 187, 12, 188, 10, 190, 12, 199, 13, 203, 14, 204, 13, 207, 12, 209, 12] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 440, "s0": 0, "s": [{ "e": [20, 1, 42, 2, 55, 3, 81, 4, 135, 5] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }] }, { "d": 448, "s0": 0, "s": [{ "e": [10, 1, 18, 2, 20, 3, 55, 4, 74, 5, 120, 6, 126, 7, 133, 2, 134, 8, 141, 9, 147, 10, 168, 11, 193, 12, 211, 13] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 7 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 453, "s0": 0, "s": [{ "e": [42, 1] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 458, "s0": 0, "s": [{ "e": [33, 1] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 469, "s0": 0, "s": [{ "e": [5, 1, 6, 2, 15, 3, 20, 4, 26, 5, 55, 6, 70, 7, 71, 8, 73, 9, 81, 10, 82, 11, 93, 12, 110, 13, 118, 14, 135, 15, 147, 16, 153, 17, 211, 18, 217, 19, 224, 20] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [219, 21] }, { "e": [], "a": 1, "p": 2 }, { "e": [26, 5] }, { "e": [215, 22] }, { "e": [], "a": 1, "p": 1 }] }, { "d": 472, "s0": 0, "s": [{ "e": [5, 1, 6, 2, 15, 3, 20, 4, 26, 5, 55, 6, 70, 7, 71, 8, 73, 9, 81, 10, 82, 11, 93, 12, 110, 13, 118, 14, 135, 15, 147, 16, 153, 17, 211, 18, 224, 19] }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 5 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 3 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 485, "s0": 0, "s": [{ "e": [69, 1, 130, 2] }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 3 }] }, { "d": 495, "s0": 0, "s": [{ "e": [63, 1, 69, 2, 136, 3, 170, 4] }, { "e": [], "a": 1, "p": 4 }, { "e": [], "a": 1, "p": 2 }, { "e": [], "a": 1, "p": 1 }, { "e": [], "a": 1, "p": 1 }] }, { "d": 496, "s0": 0, "s": [{ "e": [219, 1] }, { "e": [184, 2, 206, 3] }, { "e": [180, 4, 199, 5] }, { "e": [], "a": 1, "p": 1 }, { "e": [206, 3] }, { "e": [], "a": 1, "p": 2 }] }];

  // server/src/parser/dfaLoader.ts
  var _loaded = false;
  var _everLoaded = false;
  var _dfaStatesCleaned = false;
  function isDfaPreSeeded() {
    return _loaded;
  }
  function hasStaleDfaStates() {
    return _everLoaded && !_dfaStatesCleaned;
  }
  function markDfaNotPreSeeded() {
    _loaded = false;
  }
  function clearAllDFAStates() {
    const dfas = SysMLv2Parser.decisionsToDFA;
    for (const dfa of dfas) {
      if (!dfa.s0) continue;
      if (dfa.isPrecedenceDfa) {
        dfa.s0 = DFAState.fromState(-1);
      } else {
        dfa.s0 = void 0;
      }
      if (dfa.states && typeof dfa.states.clear === "function") {
        dfa.states.clear();
      }
    }
    _dfaStatesCleaned = true;
  }
  function loadDFASnapshot() {
    if (_loaded) return 0;
    void SysMLv2Parser._ATN;
    const dfas = SysMLv2Parser.decisionsToDFA;
    let totalStates = 0;
    for (const snap of DFA_SNAPSHOT) {
      loadDecision(dfas, snap);
      totalStates += snap.s.length;
    }
    _loaded = true;
    _everLoaded = true;
    return totalStates;
  }
  function loadDecision(dfas, snap) {
    const dfa = dfas[snap.d];
    if (!dfa) return;
    const emptyConfigs = new ATNConfigSet();
    const states = new Array(snap.s.length);
    for (let i = 0; i < snap.s.length; i++) {
      const ss = snap.s[i];
      const state = DFAState.fromState(i);
      state.configs = emptyConfigs;
      state.isAcceptState = ss.a === 1;
      if (ss.p !== void 0) {
        state.prediction = ss.p;
      }
      state.requiresFullContext = ss.r === 1;
      states[i] = state;
    }
    const errorState = ATNSimulator.ERROR;
    for (let i = 0; i < snap.s.length; i++) {
      const ss = snap.s[i];
      const state = states[i];
      const e = ss.e;
      for (let j = 0; j < e.length; j += 2) {
        const tokenIndex = e[j];
        const targetIdx = e[j + 1];
        state.edges[tokenIndex] = targetIdx === -1 ? errorState : states[targetIdx];
      }
    }
    if (snap.prec) {
      if (!dfa.s0) {
        dfa.s0 = DFAState.fromState(-1);
      }
      if (snap.precEdges) {
        const pe = snap.precEdges;
        for (let j = 0; j < pe.length; j += 2) {
          const precedence = pe[j];
          const stateIdx = pe[j + 1];
          dfa.s0.edges[precedence] = states[stateIdx];
        }
      }
    } else {
      dfa.s0 = states[snap.s0];
    }
  }

  // server/src/parser/errorListener.ts
  var SysMLErrorListener = class extends BaseErrorListener {
    errors = [];
    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, _e) {
      const token = offendingSymbol;
      const length = token?.text?.length ?? 1;
      this.errors.push({
        // ANTLR lines are 1-based, convert to 0-based for LSP.
        // Clamp to 0 to guard against edge cases (e.g. EOF at line 0).
        line: Math.max(0, line - 1),
        column: charPositionInLine,
        message: msg,
        offendingSymbol: token,
        length
      });
    }
    getErrors() {
      return this.errors;
    }
    clear() {
      this.errors = [];
    }
    hasErrors() {
      return this.errors.length > 0;
    }
  };

  // server/src/parser/parseDocument.ts
  function parseDocument(text) {
    const result = parseDocumentCore(text);
    if (result.errors.length > 0 && hasStaleDfaStates()) {
      markDfaNotPreSeeded();
      clearAllDFAStates();
      return parseDocumentLL(text, result.lexer, result.tokenStream);
    }
    if (isDfaPreSeeded()) {
      markDfaNotPreSeeded();
    }
    return result;
  }
  function parseDocumentCore(text) {
    const inputStream = CharStream.fromString(text);
    const lexer = new SysMLv2Lexer(inputStream);
    const tokenStream = new CommonTokenStream(lexer);
    const lexStart = Date.now();
    tokenStream.fill();
    const lexMs = Date.now() - lexStart;
    const parser = new SysMLv2Parser(tokenStream);
    const errorListener = new SysMLErrorListener();
    lexer.removeErrorListeners();
    parser.removeErrorListeners();
    let tree = null;
    const parseStart = Date.now();
    try {
      parser.interpreter.predictionMode = PredictionMode.SLL;
      parser.errorHandler = new BailErrorStrategy();
      tree = parser.rootNamespace();
    } catch {
      tree = null;
    }
    if (!tree) {
      tokenStream.seek(0);
      parser.reset();
      parser.interpreter.predictionMode = PredictionMode.LL;
      parser.errorHandler = new DefaultErrorStrategy();
      parser.addErrorListener(errorListener);
      try {
        tree = parser.rootNamespace();
      } catch {
      }
    }
    const parseMs = Date.now() - parseStart;
    return {
      tree,
      tokenStream,
      parser,
      lexer,
      errors: errorListener.getErrors(),
      timing: { lexMs, parseMs }
    };
  }
  function parseDocumentLL(text, prevLexer, prevTokenStream) {
    let lexer;
    let tokenStream;
    let lexMs;
    if (prevLexer && prevTokenStream) {
      lexer = prevLexer;
      tokenStream = prevTokenStream;
      tokenStream.seek(0);
      lexMs = 0;
    } else {
      const inputStream = CharStream.fromString(text);
      lexer = new SysMLv2Lexer(inputStream);
      tokenStream = new CommonTokenStream(lexer);
      const lexStart = Date.now();
      tokenStream.fill();
      lexMs = Date.now() - lexStart;
    }
    const parser = new SysMLv2Parser(tokenStream);
    const errorListener = new SysMLErrorListener();
    lexer.removeErrorListeners();
    parser.removeErrorListeners();
    parser.addErrorListener(errorListener);
    let tree = null;
    const parseStart = Date.now();
    parser.interpreter.predictionMode = PredictionMode.LL;
    parser.errorHandler = new DefaultErrorStrategy();
    try {
      tree = parser.rootNamespace();
    } catch {
    }
    const parseMs = Date.now() - parseStart;
    return {
      tree,
      tokenStream,
      parser,
      lexer,
      errors: errorListener.getErrors(),
      timing: { lexMs, parseMs }
    };
  }
  var _batchLexer;
  var _batchParser;
  var _batchBailStrategy = new BailErrorStrategy();
  var _batchDefaultStrategy = new DefaultErrorStrategy();
  function getBatchLexer(input) {
    if (!_batchLexer) {
      _batchLexer = new SysMLv2Lexer(input);
    } else {
      _batchLexer.inputStream = input;
      _batchLexer.reset();
    }
    _batchLexer.removeErrorListeners();
    return _batchLexer;
  }
  function getBatchParser(tokenStream) {
    if (!_batchParser) {
      _batchParser = new SysMLv2Parser(tokenStream);
    } else {
      _batchParser.tokenStream = tokenStream;
    }
    _batchParser.removeErrorListeners();
    return _batchParser;
  }
  function parseDocumentBatch(text) {
    const inputStream = CharStream.fromString(text);
    const lexer = getBatchLexer(inputStream);
    const tokenStream = new CommonTokenStream(lexer);
    const lexStart = Date.now();
    tokenStream.fill();
    const lexMs = Date.now() - lexStart;
    const parser = getBatchParser(tokenStream);
    const errorListener = new SysMLErrorListener();
    let tree = null;
    const parseStart = Date.now();
    parser.addErrorListener(errorListener);
    try {
      parser.interpreter.predictionMode = PredictionMode.SLL;
      parser.errorHandler = _batchBailStrategy;
      tree = parser.rootNamespace();
    } catch {
      tree = null;
    }
    if (!tree) {
      errorListener.clear();
      tokenStream.seek(0);
      parser.reset();
      parser.addErrorListener(errorListener);
      parser.interpreter.predictionMode = PredictionMode.LL;
      parser.errorHandler = _batchDefaultStrategy;
      try {
        tree = parser.rootNamespace();
      } catch {
      }
    }
    const parseMs = Date.now() - parseStart;
    const errors = errorListener.getErrors();
    if (errors.length > 0 && hasStaleDfaStates()) {
      markDfaNotPreSeeded();
      clearAllDFAStates();
      return parseDocumentBatchLL(text, lexer, tokenStream, lexMs);
    }
    if (isDfaPreSeeded()) {
      markDfaNotPreSeeded();
    }
    return {
      tree,
      tokenStream,
      parser,
      lexer,
      errors,
      timing: { lexMs, parseMs }
    };
  }
  function parseDocumentBatchLL(_text, lexer, tokenStream, lexMs) {
    tokenStream.seek(0);
    const parser = getBatchParser(tokenStream);
    const errorListener = new SysMLErrorListener();
    parser.addErrorListener(errorListener);
    let tree = null;
    const parseStart = Date.now();
    parser.interpreter.predictionMode = PredictionMode.LL;
    parser.errorHandler = _batchDefaultStrategy;
    try {
      tree = parser.rootNamespace();
    } catch {
    }
    const parseMs = Date.now() - parseStart;
    return {
      tree,
      tokenStream,
      parser,
      lexer,
      errors: errorListener.getErrors(),
      timing: { lexMs, parseMs }
    };
  }

  // server/src/parser/positionUtils.ts
  function tokenToPosition(token) {
    return {
      line: (token.line ?? 1) - 1,
      character: token.column ?? 0
    };
  }
  function tokenToRange(token) {
    const start = tokenToPosition(token);
    const length = token.text?.length ?? 1;
    return {
      start,
      end: { line: start.line, character: start.character + length }
    };
  }
  function contextToRange(ctx) {
    const startToken = ctx.start;
    const stopToken = ctx.stop ?? ctx.start;
    if (!startToken) {
      return { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
    }
    const start = {
      line: (startToken.line ?? 1) - 1,
      character: startToken.column ?? 0
    };
    const end = stopToken ? {
      line: (stopToken.line ?? 1) - 1,
      character: (stopToken.column ?? 0) + (stopToken.text?.length ?? 1)
    } : { line: start.line, character: start.character + 1 };
    return { start, end };
  }

  // server/src/utils/sysmlKeywords.ts
  var SYSML_KEYWORDS_ARRAY = SysMLv2Lexer.literalNames.filter((n2) => n2 != null).map((n2) => n2.replace(/^'|'$/g, "")).filter((n2) => /^[a-z]+$/.test(n2)).sort();
  var SYSML_KEYWORDS = new Set(SYSML_KEYWORDS_ARRAY);

  // server/src/symbols/scope.ts
  var Scope = class {
    constructor(id, parent = null) {
      this.id = id;
      this.parent = parent;
    }
    id;
    parent;
    /** Symbols declared directly in this scope (name → symbol) */
    symbols = /* @__PURE__ */ new Map();
    /**
     * Define a new symbol in this scope.
     */
    define(symbol) {
      this.symbols.set(symbol.name, symbol);
    }
    /**
     * Look up a symbol by name in this scope only (no parent chain).
     */
    lookupLocal(name) {
      return this.symbols.get(name);
    }
    /**
     * Look up a symbol by name, walking up the parent scope chain.
     */
    resolve(name) {
      const local = this.symbols.get(name);
      if (local) {
        return local;
      }
      return this.parent?.resolve(name);
    }
    /**
     * Look up a qualified name (e.g., "Pkg::SubPkg::Type").
     */
    resolveQualified(qualifiedName) {
      const parts = qualifiedName.split("::");
      if (parts.length === 1) {
        return this.resolve(parts[0]);
      }
      const current = this.resolve(parts[0]);
      if (!current) {
        return void 0;
      }
      return current;
    }
    /**
     * Get all symbols in this scope (not including parent scopes).
     */
    getLocalSymbols() {
      return Array.from(this.symbols.values());
    }
    /**
     * Get all symbols reachable from this scope (including parent chain).
     */
    getAllVisibleSymbols() {
      const result = /* @__PURE__ */ new Map();
      let scope = this;
      while (scope) {
        for (const [name, symbol] of scope.symbols) {
          if (!result.has(name)) {
            result.set(name, symbol);
          }
        }
        scope = scope.parent;
      }
      return Array.from(result.values());
    }
  };

  // server/src/symbols/sysmlElements.ts
  function isDefinition(kind) {
    return kind.endsWith(" def");
  }
  function isUsage(kind) {
    return !isDefinition(kind) && kind !== "package" /* Package */ && kind !== "import" /* Import */ && kind !== "comment" /* Comment */ && kind !== "doc" /* Doc */ && kind !== "alias" /* Alias */ && kind !== "unknown" /* Unknown */;
  }
  function toMetaclassName(kind) {
    switch (kind) {
      case "package" /* Package */:
        return "Package";
      case "part def" /* PartDef */:
        return "PartDefinition";
      case "part" /* PartUsage */:
        return "PartUsage";
      case "attribute def" /* AttributeDef */:
        return "AttributeDefinition";
      case "attribute" /* AttributeUsage */:
        return "AttributeUsage";
      case "port def" /* PortDef */:
        return "PortDefinition";
      case "port" /* PortUsage */:
        return "PortUsage";
      case "connection def" /* ConnectionDef */:
        return "ConnectionDefinition";
      case "connection" /* ConnectionUsage */:
        return "ConnectionUsage";
      case "interface def" /* InterfaceDef */:
        return "InterfaceDefinition";
      case "interface" /* InterfaceUsage */:
        return "InterfaceUsage";
      case "action def" /* ActionDef */:
        return "ActionDefinition";
      case "action" /* ActionUsage */:
        return "ActionUsage";
      case "perform action" /* PerformActionUsage */:
        return "PerformActionUsage";
      case "state def" /* StateDef */:
        return "StateDefinition";
      case "state" /* StateUsage */:
        return "StateUsage";
      case "exhibit state" /* ExhibitStateUsage */:
        return "ExhibitStateUsage";
      case "transition" /* TransitionUsage */:
        return "TransitionUsage";
      case "requirement def" /* RequirementDef */:
        return "RequirementDefinition";
      case "requirement" /* RequirementUsage */:
        return "RequirementUsage";
      case "constraint def" /* ConstraintDef */:
        return "ConstraintDefinition";
      case "constraint" /* ConstraintUsage */:
        return "ConstraintUsage";
      case "item def" /* ItemDef */:
        return "ItemDefinition";
      case "item" /* ItemUsage */:
        return "ItemUsage";
      case "allocation def" /* AllocationDef */:
        return "AllocationDefinition";
      case "allocation" /* AllocationUsage */:
        return "AllocationUsage";
      case "use case def" /* UseCaseDef */:
        return "UseCaseDefinition";
      case "use case" /* UseCaseUsage */:
        return "UseCaseUsage";
      case "include use case" /* IncludeUseCaseUsage */:
        return "IncludeUseCaseUsage";
      case "actor" /* ActorUsage */:
        return "ActorUsage";
      // SysML v2 doesn't have a dedicated ActorUsage metaclass, but this is conventional
      case "subject" /* SubjectUsage */:
        return "SubjectUsage";
      case "stakeholder" /* StakeholderUsage */:
        return "StakeholderUsage";
      case "enum def" /* EnumDef */:
        return "EnumerationDefinition";
      case "enum" /* EnumUsage */:
        return "EnumerationUsage";
      case "calc def" /* CalcDef */:
        return "CalculationDefinition";
      case "calc" /* CalcUsage */:
        return "CalculationUsage";
      case "view def" /* ViewDef */:
        return "ViewDefinition";
      case "view" /* ViewUsage */:
        return "ViewUsage";
      case "viewpoint def" /* ViewpointDef */:
        return "ViewpointDefinition";
      case "viewpoint" /* ViewpointUsage */:
        return "ViewpointUsage";
      case "occurrence def" /* OccurrenceDef */:
        return "OccurrenceDefinition";
      case "occurrence" /* OccurrenceUsage */:
        return "OccurrenceUsage";
      case "ref" /* RefUsage */:
        return "ReferenceUsage";
      case "metadata def" /* MetadataDef */:
        return "MetadataDefinition";
      case "rendering def" /* RenderingDef */:
        return "RenderingDefinition";
      case "analysis case def" /* AnalysisCaseDef */:
        return "AnalysisCaseDefinition";
      case "verification case def" /* VerificationCaseDef */:
        return "VerificationCaseDefinition";
      case "comment" /* Comment */:
        return "Comment";
      case "doc" /* Doc */:
        return "Documentation";
      case "alias" /* Alias */:
        return "Alias";
      case "import" /* Import */:
        return "Import";
      default:
        return "Element";
    }
  }

  // server/src/symbols/symbolTable.ts
  var RULE_INDEX_TO_KIND = /* @__PURE__ */ new Map([
    [SysMLv2Parser.RULE_package, "package" /* Package */],
    // 178
    [SysMLv2Parser.RULE_libraryPackage, "package" /* Package */],
    // 179
    [SysMLv2Parser.RULE_partDefinition, "part def" /* PartDef */],
    // 246
    [SysMLv2Parser.RULE_attributeDefinition, "attribute def" /* AttributeDef */],
    // 223
    [SysMLv2Parser.RULE_portDefinition, "port def" /* PortDef */],
    // 248
    [SysMLv2Parser.RULE_connectionDefinition, "connection def" /* ConnectionDef */],
    // 253
    [SysMLv2Parser.RULE_interfaceDefinition, "interface def" /* InterfaceDef */],
    // 260
    [SysMLv2Parser.RULE_actionDefinition, "action def" /* ActionDef */],
    // 287
    [SysMLv2Parser.RULE_stateDefinition, "state def" /* StateDef */],
    // 343
    [SysMLv2Parser.RULE_requirementDefinition, "requirement def" /* RequirementDef */],
    // 384
    [SysMLv2Parser.RULE_constraintDefinition, "constraint def" /* ConstraintDef */],
    // 380
    [SysMLv2Parser.RULE_itemDefinition, "item def" /* ItemDef */],
    // 244
    [SysMLv2Parser.RULE_allocationDefinition, "allocation def" /* AllocationDef */],
    // 275
    [SysMLv2Parser.RULE_useCaseDefinition, "use case def" /* UseCaseDef */],
    // 418
    [SysMLv2Parser.RULE_enumerationDefinition, "enum def" /* EnumDef */],
    // 225
    [SysMLv2Parser.RULE_enumeratedValue, "enum" /* EnumUsage */],
    // 228
    [SysMLv2Parser.RULE_enumerationUsage, "enum" /* EnumUsage */],
    // 229
    [SysMLv2Parser.RULE_calculationDefinition, "calc def" /* CalcDef */],
    // 374
    [SysMLv2Parser.RULE_viewDefinition, "view def" /* ViewDef */],
    // 421
    [SysMLv2Parser.RULE_viewpointDefinition, "viewpoint def" /* ViewpointDef */],
    // 432
    [SysMLv2Parser.RULE_metadataDefinition, "metadata def" /* MetadataDef */],
    // 436
    [SysMLv2Parser.RULE_partUsage, "part" /* PartUsage */],
    // 247
    [SysMLv2Parser.RULE_attributeUsage, "attribute" /* AttributeUsage */],
    // 224
    [SysMLv2Parser.RULE_portUsage, "port" /* PortUsage */],
    // 251
    [SysMLv2Parser.RULE_connectionUsage, "connection" /* ConnectionUsage */],
    // 254
    [SysMLv2Parser.RULE_actionUsage, "action" /* ActionUsage */],
    // 296
    [SysMLv2Parser.RULE_stateUsage, "state" /* StateUsage */],
    // 357
    [SysMLv2Parser.RULE_requirementUsage, "requirement" /* RequirementUsage */],
    // 398
    [SysMLv2Parser.RULE_constraintUsage, "constraint" /* ConstraintUsage */],
    // 381
    [SysMLv2Parser.RULE_itemUsage, "item" /* ItemUsage */],
    // 245
    [SysMLv2Parser.RULE_allocationUsage, "allocation" /* AllocationUsage */],
    // 276
    [SysMLv2Parser.RULE_useCaseUsage, "use case" /* UseCaseUsage */],
    // 419
    [SysMLv2Parser.RULE_includeUseCaseUsage, "include use case" /* IncludeUseCaseUsage */],
    // 420
    [SysMLv2Parser.RULE_actorUsage, "actor" /* ActorUsage */],
    // 395
    [SysMLv2Parser.RULE_subjectUsage, "subject" /* SubjectUsage */],
    // 388
    [SysMLv2Parser.RULE_stakeholderUsage, "stakeholder" /* StakeholderUsage */],
    // 397
    [SysMLv2Parser.RULE_referenceUsage, "ref" /* RefUsage */],
    // 213
    [SysMLv2Parser.RULE_interfaceUsage, "interface" /* InterfaceUsage */],
    // 268
    [SysMLv2Parser.RULE_performActionUsage, "perform action" /* PerformActionUsage */],
    // 298
    [SysMLv2Parser.RULE_exhibitStateUsage, "exhibit state" /* ExhibitStateUsage */],
    // 359
    [SysMLv2Parser.RULE_transitionUsage, "transition" /* TransitionUsage */],
    // 360
    [SysMLv2Parser.RULE_occurrenceDefinition, "occurrence def" /* OccurrenceDef */],
    // 231
    [SysMLv2Parser.RULE_occurrenceUsage, "occurrence" /* OccurrenceUsage */],
    // 235
    [SysMLv2Parser.RULE_renderingDefinition, "rendering def" /* RenderingDef */],
    // 434
    [SysMLv2Parser.RULE_viewUsage, "view" /* ViewUsage */],
    // 426
    [SysMLv2Parser.RULE_viewpointUsage, "viewpoint" /* ViewpointUsage */],
    // 433
    [SysMLv2Parser.RULE_verificationCaseDefinition, "verification case def" /* VerificationCaseDef */],
    // 414
    [SysMLv2Parser.RULE_verificationCaseUsage, "verification case" /* VerificationCaseUsage */],
    // 415
    [SysMLv2Parser.RULE_analysisCaseDefinition, "analysis case def" /* AnalysisCaseDef */],
    // 412
    [SysMLv2Parser.RULE_analysisCaseUsage, "analysis case" /* AnalysisCaseUsage */],
    // 413
    [SysMLv2Parser.RULE_aliasMember, "alias" /* Alias */]
    // 43
  ]);
  var NAME_RULE_INDICES = /* @__PURE__ */ new Set([
    SysMLv2Parser.RULE_identification,
    // 22
    SysMLv2Parser.RULE_name,
    // 20
    SysMLv2Parser.RULE_qualifiedName
    // 44
  ]);
  var PREFIX_EXTENSION_RULE_INDICES = /* @__PURE__ */ new Set([
    SysMLv2Parser.RULE_prefixMetadataAnnotation,
    // 169
    SysMLv2Parser.RULE_prefixMetadataMember,
    // 170
    SysMLv2Parser.RULE_prefixMetadataFeature,
    // 171
    SysMLv2Parser.RULE_prefixMetadataUsage,
    // 437
    SysMLv2Parser.RULE_definitionExtensionKeyword,
    // 190
    SysMLv2Parser.RULE_usageExtensionKeyword,
    // 205
    SysMLv2Parser.RULE_occurrenceDefinitionPrefix,
    // 230
    SysMLv2Parser.RULE_occurrenceUsagePrefix,
    // 234
    SysMLv2Parser.RULE_definitionPrefix,
    // 191
    SysMLv2Parser.RULE_basicDefinitionPrefix,
    // 189
    SysMLv2Parser.RULE_typePrefix,
    // 55
    SysMLv2Parser.RULE_featurePrefix,
    // 88
    SysMLv2Parser.RULE_basicFeaturePrefix,
    // 87
    SysMLv2Parser.RULE_endFeaturePrefix
    // 86
  ]);
  var TYPE_SPECIALIZATION_RULE_INDICES = /* @__PURE__ */ new Set([
    SysMLv2Parser.RULE_specialization,
    // 66
    SysMLv2Parser.RULE_ownedSpecialization,
    // 67
    SysMLv2Parser.RULE_subclassification,
    // 83
    SysMLv2Parser.RULE_ownedSubclassification,
    // 84
    SysMLv2Parser.RULE_subsetting,
    // 111
    SysMLv2Parser.RULE_ownedSubsetting,
    // 112
    SysMLv2Parser.RULE_specializationPart
    // 57
  ]);
  var TYPE_TYPING_RULE_INDICES = /* @__PURE__ */ new Set([
    SysMLv2Parser.RULE_typings,
    // 101
    SysMLv2Parser.RULE_featureTyping,
    // 109
    SysMLv2Parser.RULE_ownedFeatureTyping,
    // 110
    SysMLv2Parser.RULE_conjugation,
    // 70  (see NOTE above)
    SysMLv2Parser.RULE_ownedConjugation,
    // 71  (see NOTE above)
    SysMLv2Parser.RULE_disjoining,
    // 72  (see NOTE above)
    SysMLv2Parser.RULE_ownedDisjoining
    // 73  (see NOTE above)
  ]);
  var TYPE_EXTRACTION_RULE_INDICES = /* @__PURE__ */ new Set([
    ...TYPE_SPECIALIZATION_RULE_INDICES,
    ...TYPE_TYPING_RULE_INDICES
  ]);
  var TYPE_RECURSE_RULE_INDICES = /* @__PURE__ */ new Set([
    SysMLv2Parser.RULE_featureSpecialization,
    // 100
    SysMLv2Parser.RULE_featureSpecializationPart,
    // 98
    SysMLv2Parser.RULE_featureDeclaration,
    // 92
    SysMLv2Parser.RULE_usageCompletion,
    // 210
    SysMLv2Parser.RULE_definition,
    // 192
    SysMLv2Parser.RULE_usage
    // 208
  ]);
  var DOC_RULE_INDICES = /* @__PURE__ */ new Set([
    SysMLv2Parser.RULE_comment,
    // 30
    SysMLv2Parser.RULE_documentation
    // 31
  ]);
  var PREFIX_METADATA_RULE_INDICES = /* @__PURE__ */ new Set([
    SysMLv2Parser.RULE_prefixMetadataMember,
    // 170
    SysMLv2Parser.RULE_prefixMetadataAnnotation
    // 169
  ]);
  var PREFIX_METADATA_RECURSE_RULE_INDICES = /* @__PURE__ */ new Set([
    SysMLv2Parser.RULE_prefixMetadataFeature,
    // 171
    SysMLv2Parser.RULE_prefixMetadataUsage,
    // 437
    SysMLv2Parser.RULE_definitionExtensionKeyword,
    // 190
    SysMLv2Parser.RULE_usageExtensionKeyword,
    // 205
    SysMLv2Parser.RULE_definitionPrefix,
    // 191
    SysMLv2Parser.RULE_basicDefinitionPrefix,
    // 189
    SysMLv2Parser.RULE_definition,
    // 192
    SysMLv2Parser.RULE_usage,
    // 208
    SysMLv2Parser.RULE_occurrenceDefinitionPrefix,
    // 230
    SysMLv2Parser.RULE_occurrenceUsagePrefix,
    // 234
    SysMLv2Parser.RULE_usagePrefix,
    // 207
    SysMLv2Parser.RULE_unextendedUsagePrefix,
    // 206
    SysMLv2Parser.RULE_basicUsagePrefix
    // 203
  ]);
  var RE_KEYWORD_TRUNCATE = /(?<![A-Za-z_])(redefines|subsets|references|connect|bind|first|then|flow|allocate|assign|accept|send|decide|merge|join|fork|via|default)\b.*/i;
  var RE_KEYWORD_TRUNCATE_SPEC = /(?<![A-Za-z_])(redefines|references|connect|bind|first|then|flow|allocate|assign|accept|send|decide|merge|join|fork|via|default)\b.*/i;
  var RE_SPEC = /(?:specializes|:>|:>>)\s*('[^']+'|[A-Za-z_]\w*(?:::\w+)*)(?:\s*,\s*(?:'[^']+'|[A-Za-z_]\w*(?:::\w+)*))*/;
  var RE_SPEC_WITH_SUBSETS = /(?:specializes|subsets|:>|:>>)\s*('[^']+'|[A-Za-z_]\w*(?:::\w+)*)(?:\s*,\s*(?:'[^']+'|[A-Za-z_]\w*(?:::\w+)*))*/;
  var RE_DEFINED_BY = /definedby\s*([A-Za-z_]\w*(?:::\w+)*(?:\s*,\s*[A-Za-z_]\w*(?:::\w+)*)*)/;
  var RE_TYPING = /:(?![:>])\s*('[^']+'|[A-Za-z_]\w*(?:::\w+)*)/;
  var RE_QUOTED_NAME = /'([^']+)'/;
  var RE_IDENT_START = /^([A-Za-z_]\w*(?:::\w+)*)/;
  var SymbolTable = class {
    /** All symbols indexed by qualified name */
    symbols = /* @__PURE__ */ new Map();
    /** All symbols indexed by URI for cross-file lookup */
    symbolsByUri = /* @__PURE__ */ new Map();
    /** All symbols indexed by simple name for O(1) lookup */
    symbolsByName = /* @__PURE__ */ new Map();
    /** Symbols sorted by (line, character) per URI for O(log n) positional lookup */
    symbolsByPosition = /* @__PURE__ */ new Map();
    /** Reverse index: type name → symbols that reference it in typeNames */
    typeNameRefs = /* @__PURE__ */ new Map();
    /** Cached array from getAllSymbols(), invalidated on any mutation */
    allSymbolsCache;
    /** The global scope */
    globalScope;
    constructor() {
      this.globalScope = new Scope("__global__");
    }
    /**
     * Build the symbol table from a parse result.
     */
    build(uri, parseResult) {
      this.clearUri(uri);
      if (!parseResult.tree) {
        return;
      }
      this.walkTree(parseResult.tree, uri, this.globalScope, "");
      this.resolveViewInheritance(uri);
    }
    /**
     * Get a symbol by its qualified name.
     */
    getSymbol(qualifiedName) {
      return this.symbols.get(qualifiedName);
    }
    /**
     * Find a symbol by name (simple name, not qualified).
     */
    findByName(name) {
      return this.symbolsByName.get(name) ?? [];
    }
    /**
     * Find all symbols in a given URI.
     */
    getSymbolsForUri(uri) {
      return this.symbolsByUri.get(uri) ?? [];
    }
    /**
     * Get all symbols in the table.
     * Returns a cached array — invalidated on symbol add/remove.
     */
    getAllSymbols() {
      if (!this.allSymbolsCache) {
        this.allSymbolsCache = Array.from(this.symbols.values());
      }
      return this.allSymbolsCache;
    }
    /**
     * Get the global scope for resolution.
     */
    getGlobalScope() {
      return this.globalScope;
    }
    /**
     * Find the symbol at a given position in a document.
     * Uses a position-sorted index with binary search for O(log n) lookup.
     */
    findSymbolAtPosition(uri, line, character) {
      const sorted = this.symbolsByPosition.get(uri);
      if (!sorted || sorted.length === 0) return void 0;
      let lo = 0;
      let hi = sorted.length - 1;
      while (lo < hi) {
        const mid = lo + hi + 1 >>> 1;
        const r = sorted[mid].selectionRange.start;
        if (r.line < line || r.line === line && r.character <= character) {
          lo = mid;
        } else {
          hi = mid - 1;
        }
      }
      let best;
      let bestSize = Infinity;
      for (let i = lo; i >= 0; i--) {
        const sym = sorted[i];
        const r = sym.selectionRange;
        if (r.start.line < line - 1 && r.end.line < line) break;
        if (r.start.line < line && r.end.line < line) continue;
        if (line >= r.start.line && line <= r.end.line && (line > r.start.line || character >= r.start.character) && (line < r.end.line || character <= r.end.character)) {
          const size = (r.end.line - r.start.line) * 1e4 + (r.end.character - r.start.character);
          if (size < bestSize) {
            best = sym;
            bestSize = size;
          }
        }
      }
      return best;
    }
    /**
     * Find all references to a symbol name across all documents.
     * Matches symbols whose name equals the target OR whose typeNames include it.
     * Uses a reverse index for O(1) typeName lookup.
     */
    findReferences(name) {
      const results = [];
      const byName = this.symbolsByName.get(name);
      if (byName) results.push(...byName);
      const refs = this.typeNameRefs.get(name);
      if (refs) {
        for (const sym of refs) {
          if (sym.name !== name) {
            results.push(sym);
          }
        }
      }
      return results;
    }
    /**
     * Count references to a symbol name without allocating a result array.
     */
    countReferences(name) {
      let count = 0;
      const byName = this.symbolsByName.get(name);
      if (byName) count += byName.length;
      const refs = this.typeNameRefs.get(name);
      if (refs) {
        for (const sym of refs) {
          if (sym.name !== name) count++;
        }
      }
      return count;
    }
    // --------------------------------------------------------------------------
    // Private tree-walking
    // --------------------------------------------------------------------------
    /**
     * Remove all symbols for a given URI (public API for document close/eviction).
     */
    removeUri(uri) {
      this.clearUri(uri);
      this.symbolsByUri.delete(uri);
    }
    clearUri(uri) {
      const existing = this.symbolsByUri.get(uri);
      if (existing && existing.length > 0) {
        const affectedNames = /* @__PURE__ */ new Set();
        const affectedTypeNames = /* @__PURE__ */ new Set();
        for (const sym of existing) {
          this.symbols.delete(sym.qualifiedName);
          affectedNames.add(sym.name);
          for (const tn of sym.typeNames) {
            affectedTypeNames.add(tn);
          }
        }
        for (const name of affectedNames) {
          const list = this.symbolsByName.get(name);
          if (list) {
            const filtered = list.filter((s) => s.uri !== uri);
            if (filtered.length === 0) this.symbolsByName.delete(name);
            else this.symbolsByName.set(name, filtered);
          }
        }
        for (const tn of affectedTypeNames) {
          const list = this.typeNameRefs.get(tn);
          if (list) {
            const filtered = list.filter((s) => s.uri !== uri);
            if (filtered.length === 0) this.typeNameRefs.delete(tn);
            else this.typeNameRefs.set(tn, filtered);
          }
        }
        this.allSymbolsCache = void 0;
      }
      this.symbolsByUri.set(uri, []);
      this.symbolsByPosition.set(uri, []);
    }
    /**
     * Resolve view specialization chains to inherit filters, rendering,
     * and expose targets from parent view definitions.
     *
     * For example, if `view x : PartsTreeView` and `PartsTreeView :> TreeView`,
     * and TreeView has `render asTreeDiagram`, then x inherits that rendering.
     */
    resolveViewInheritance(uri) {
      const symbols = this.symbolsByUri.get(uri) ?? [];
      const viewSymbols = symbols.filter(
        (s) => s.kind === "view" /* ViewUsage */ || s.kind === "view def" /* ViewDef */
      );
      if (viewSymbols.length === 0) return;
      const viewDefsByName = /* @__PURE__ */ new Map();
      for (const s of this.getAllSymbols()) {
        if (s.kind === "view def" /* ViewDef */) {
          viewDefsByName.set(s.name, s);
        }
      }
      for (const view of viewSymbols) {
        const visited = /* @__PURE__ */ new Set();
        let current = view;
        for (let depth = 0; depth < 5 && current; depth++) {
          if (visited.has(current.name)) break;
          visited.add(current.name);
          const parentName = current.typeNames[0] ?? current.typeName;
          if (!parentName) break;
          const parent = viewDefsByName.get(parentName);
          if (!parent) break;
          if (parent.viewFilters && parent.viewFilters.length > 0) {
            if (!view.viewFilters) {
              view.viewFilters = [...parent.viewFilters];
            } else {
              for (const f of parent.viewFilters) {
                if (!view.viewFilters.includes(f)) {
                  view.viewFilters.push(f);
                }
              }
            }
          }
          if (parent.viewRendering && !view.viewRendering) {
            view.viewRendering = parent.viewRendering;
          }
          if (parent.exposeTargets && parent.exposeTargets.length > 0 && (!view.exposeTargets || view.exposeTargets.length === 0)) {
            view.exposeTargets = [...parent.exposeTargets];
          }
          current = parent;
        }
      }
    }
    /**
     * Recursively walk the parse tree, extracting SysML element declarations.
     *
     * This is a generic tree walker that inspects rule names to identify
     * SysML elements. It works by pattern-matching on the ANTLR rule
     * context class names from the generated parser.
     */
    walkTree(ctx, uri, currentScope, parentQualifiedName) {
      const ruleName = this.getRuleName(ctx);
      const symbol = this.tryExtractSymbol(ctx, uri, ruleName, parentQualifiedName);
      let childScope = currentScope;
      if (symbol) {
        this.registerSymbol(symbol, uri, currentScope);
        childScope = new Scope(symbol.qualifiedName, currentScope);
      } else {
        this.registerAnonymousTypeRefs(ctx, uri, parentQualifiedName);
      }
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (child instanceof ParserRuleContext) {
          this.walkTree(
            child,
            uri,
            childScope,
            symbol?.qualifiedName ?? parentQualifiedName
          );
        }
      }
    }
    registerSymbol(symbol, uri, scope) {
      this.symbols.set(symbol.qualifiedName, symbol);
      this.allSymbolsCache = void 0;
      const uriSymbols = this.symbolsByUri.get(uri) ?? [];
      uriSymbols.push(symbol);
      this.symbolsByUri.set(uri, uriSymbols);
      const nameList = this.symbolsByName.get(symbol.name) ?? [];
      nameList.push(symbol);
      this.symbolsByName.set(symbol.name, nameList);
      const posList = this.symbolsByPosition.get(uri) ?? [];
      const startLine = symbol.selectionRange.start.line;
      const startChar = symbol.selectionRange.start.character;
      if (posList.length === 0 || startLine > posList[posList.length - 1].selectionRange.start.line || startLine === posList[posList.length - 1].selectionRange.start.line && startChar >= posList[posList.length - 1].selectionRange.start.character) {
        posList.push(symbol);
      } else {
        let lo = 0, hi = posList.length;
        while (lo < hi) {
          const mid = lo + hi >>> 1;
          const mr = posList[mid].selectionRange.start;
          if (mr.line < startLine || mr.line === startLine && mr.character < startChar) {
            lo = mid + 1;
          } else {
            hi = mid;
          }
        }
        posList.splice(lo, 0, symbol);
      }
      this.symbolsByPosition.set(uri, posList);
      for (const tn of symbol.typeNames) {
        const refList = this.typeNameRefs.get(tn) ?? [];
        refList.push(symbol);
        this.typeNameRefs.set(tn, refList);
      }
      scope.define(symbol);
    }
    /**
     * For anonymous elements (elements with a recognized kind but no name),
     * extract type names and register them in the reverse index so that
     * "Go to References" on a type definition still finds anonymous usages
     * like `interface : PwrHeaterIface connect ...`.
     */
    registerAnonymousTypeRefs(ctx, uri, parentQualifiedName) {
      const kind = RULE_INDEX_TO_KIND.get(ctx.ruleIndex);
      if (kind === void 0) return;
      const typeNames = this.extractTypeNames(ctx);
      if (typeNames.length === 0) return;
      const range = contextToRange(ctx);
      const anonName = `<anonymous ${kind}>`;
      const qualifiedName = parentQualifiedName ? `${parentQualifiedName}::${anonName}#${range.start.line}` : `${anonName}#${range.start.line}`;
      const anonSymbol = {
        name: anonName,
        kind,
        qualifiedName,
        range,
        selectionRange: range,
        uri,
        typeName: typeNames[0],
        typeNames,
        specializationNames: [],
        parentQualifiedName: parentQualifiedName || void 0,
        children: []
      };
      for (const tn of typeNames) {
        const refList = this.typeNameRefs.get(tn) ?? [];
        refList.push(anonSymbol);
        this.typeNameRefs.set(tn, refList);
      }
      const uriSymbols = this.symbolsByUri.get(uri) ?? [];
      uriSymbols.push(anonSymbol);
      this.symbolsByUri.set(uri, uriSymbols);
      const posList = this.symbolsByPosition.get(uri) ?? [];
      const startLine = range.start.line;
      const startChar = range.start.character;
      if (posList.length === 0 || startLine > posList[posList.length - 1].selectionRange.start.line || startLine === posList[posList.length - 1].selectionRange.start.line && startChar >= posList[posList.length - 1].selectionRange.start.character) {
        posList.push(anonSymbol);
      } else {
        let lo = 0, hi = posList.length;
        while (lo < hi) {
          const mid = lo + hi >>> 1;
          const mr = posList[mid].selectionRange.start;
          if (mr.line < startLine || mr.line === startLine && mr.character < startChar) {
            lo = mid + 1;
          } else {
            hi = mid;
          }
        }
        posList.splice(lo, 0, anonSymbol);
      }
      this.symbolsByPosition.set(uri, posList);
    }
    /**
     * Get the parser rule name from a context (e.g., "packageDeclaration").
     */
    getRuleName(ctx) {
      const idx = ctx.ruleIndex;
      if (idx >= 0 && idx < SysMLv2Parser.ruleNames.length) {
        return SysMLv2Parser.ruleNames[idx];
      }
      const ctorName = ctx.constructor.name;
      if (ctorName.endsWith("Context")) {
        return ctorName.slice(0, -"Context".length);
      }
      return ctorName;
    }
    /**
     * Try to extract a SysMLSymbol from a parse tree context.
     * Returns undefined if this context doesn't represent a named declaration.
     */
    tryExtractSymbol(ctx, uri, ruleName, parentQualifiedName) {
      const kind = this.inferKind(ruleName, ctx);
      if (kind === void 0) {
        return void 0;
      }
      const name = this.extractName(ctx);
      if (!name) {
        return void 0;
      }
      const qualifiedName = parentQualifiedName ? `${parentQualifiedName}::${name}` : name;
      const range = contextToRange(ctx);
      const selectionRange = this.extractNameRange(ctx) ?? range;
      const typeNames = this.extractTypeNames(ctx);
      const specializationNames = this.extractSpecializationNames(ctx);
      const typeName = typeNames[0];
      const documentation = this.extractDocumentation(ctx);
      const { multiplicity, multiplicityRange } = isUsage(kind) ? this.extractMultiplicity(ctx) : {};
      const metadataAnnotations = this.extractPrefixMetadataAnnotations(ctx);
      const isView = kind === "view" /* ViewUsage */ || kind === "view def" /* ViewDef */;
      const isPackage = kind === "package" /* Package */;
      const exposeTargets = isView ? this.extractExposeTargets(ctx) : void 0;
      const viewFilters = isView || isPackage ? this.extractViewFilters(ctx) : void 0;
      const viewRendering = isView ? this.extractViewRendering(ctx) : void 0;
      return {
        name,
        kind,
        qualifiedName,
        range,
        selectionRange,
        uri,
        typeName,
        typeNames,
        specializationNames,
        documentation,
        parentQualifiedName: parentQualifiedName || void 0,
        children: [],
        multiplicity,
        multiplicityRange,
        metadataAnnotations: metadataAnnotations.length > 0 ? metadataAnnotations : void 0,
        exposeTargets: exposeTargets && exposeTargets.length > 0 ? exposeTargets : void 0,
        viewFilters: viewFilters && viewFilters.length > 0 ? viewFilters : void 0,
        viewRendering: viewRendering || void 0
      };
    }
    /**
     * Infer the SysML element kind from the ANTLR rule index.
     * Uses a pre-built Map for O(1) lookup — no string allocation.
     */
    inferKind(_ruleName, ctx) {
      return RULE_INDEX_TO_KIND.get(ctx.ruleIndex);
    }
    /**
     * Extract the declared name from a parse tree context.
     * Looks for an IDENT token or a name/identification sub-rule.
     */
    extractName(ctx) {
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (child instanceof TerminalNode) {
          const token = child.symbol;
          if (this.isIdentifierToken(token)) {
            return this.unquoteName(token.text ?? "");
          }
        }
        if (child instanceof ParserRuleContext) {
          if (NAME_RULE_INDICES.has(child.ruleIndex)) {
            const name = this.extractTextFromSubtree(child);
            if (name) return name;
          }
        }
      }
      for (let i = 0; i < Math.min(ctx.getChildCount(), 5); i++) {
        const child = ctx.getChild(i);
        if (child instanceof ParserRuleContext) {
          if (this.isPrefixOrExtensionContext(child)) continue;
          const name = this.extractName(child);
          if (name) return name;
        }
      }
      return void 0;
    }
    /**
     * Extract the range of just the name token.
     */
    extractNameRange(ctx) {
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (child instanceof TerminalNode && this.isIdentifierToken(child.symbol)) {
          return tokenToRange(child.symbol);
        }
        if (child instanceof ParserRuleContext) {
          if (this.isPrefixOrExtensionContext(child)) continue;
          const result = this.extractNameRange(child);
          if (result) return result;
        }
      }
      return void 0;
    }
    /**
     * Extract a type name from specialization syntax (": TypeName" or ":> TypeName").
     */
    /**
     * Extract all type names from a context.
     * Handles both usage typing (`:` / `defined by`) and definition
     * specialization (`specializes` / `:>`).
     *
     * Examples:
     *   part x : A, B          → ['A', 'B']
     *   part x defined by A, B → ['A', 'B']
     *   part def X specializes A, B → ['A', 'B']
     *   part def X :> A, B     → ['A', 'B']
     */
    extractTypeNames(ctx) {
      const names = [];
      this.collectTypeNamesFromTree(ctx, names, 0);
      if (names.length > 0) return names;
      const fullText = ctx.getText();
      const braceIdx = fullText.indexOf("{");
      let text = braceIdx >= 0 ? fullText.substring(0, braceIdx) : fullText;
      text = text.replace(RE_KEYWORD_TRUNCATE, "");
      const specMatch = text.match(RE_SPEC);
      if (specMatch) {
        const specStr = text.substring(text.indexOf(specMatch[0]) + specMatch[0].indexOf(specMatch[1]));
        for (const part of specStr.split(",")) {
          const qm = part.match(RE_QUOTED_NAME);
          if (qm) {
            names.push(qm[1]);
            continue;
          }
          const m2 = part.trim().match(RE_IDENT_START);
          if (m2) names.push(m2[1]);
        }
        return names;
      }
      const defByMatch = text.match(RE_DEFINED_BY);
      if (defByMatch) {
        for (const part of defByMatch[1].split(",")) {
          const m2 = part.trim().match(RE_IDENT_START);
          if (m2) names.push(m2[1]);
        }
        return names;
      }
      const typingMatch = text.match(RE_TYPING);
      if (typingMatch) {
        const fullMatchIdx = text.indexOf(typingMatch[0]);
        const afterColon = text.substring(fullMatchIdx + 1).trim();
        for (const part of afterColon.split(",")) {
          const qm = part.match(RE_QUOTED_NAME);
          if (qm) {
            names.push(qm[1]);
            continue;
          }
          const m2 = part.trim().match(RE_IDENT_START);
          if (m2) names.push(m2[1]);
        }
        return names;
      }
      return names;
    }
    /**
     * Extract only the specialization names (:> / specializes / subsets) from a context.
     * Uses the same tree-walk as extractTypeNames but restricted to
     * TYPE_SPECIALIZATION_RULE_INDICES so that : typing names are excluded.
     * Falls back to a regex path that covers :> / :>> / specializes / subsets.
     */
    extractSpecializationNames(ctx) {
      const names = [];
      this.collectNamesFromTree(ctx, names, 0, TYPE_SPECIALIZATION_RULE_INDICES);
      if (names.length > 0) return names;
      const fullText = ctx.getText();
      const braceIdx = fullText.indexOf("{");
      let text = braceIdx >= 0 ? fullText.substring(0, braceIdx) : fullText;
      text = text.replace(RE_KEYWORD_TRUNCATE_SPEC, "");
      const specMatch = text.match(RE_SPEC_WITH_SUBSETS);
      if (specMatch) {
        const specStr = text.substring(text.indexOf(specMatch[0]) + specMatch[0].indexOf(specMatch[1]));
        for (const part of specStr.split(",")) {
          const qm = part.match(RE_QUOTED_NAME);
          if (qm) {
            names.push(qm[1]);
            continue;
          }
          const m2 = part.trim().match(RE_IDENT_START);
          if (m2) names.push(m2[1]);
        }
      }
      return names;
    }
    /**
     * Recursively walk the parse tree to find typing / specialization rules.
     * Recurses into declaration wrappers (up to maxDepth) so that
     * `interfaceUsage → interfaceUsageDeclaration → usageDeclaration →
     *  featureSpecializationPart → featureSpecialization → typings` is found.
     */
    collectTypeNamesFromTree(ctx, names, depth) {
      this.collectNamesFromTree(ctx, names, depth, TYPE_EXTRACTION_RULE_INDICES);
    }
    /**
     * Core recursive tree walker used by both collectTypeNamesFromTree and
     * extractSpecializationNames — parameterised on which extraction rule set to use.
     */
    collectNamesFromTree(ctx, names, depth, extractionRules) {
      if (depth > 6) return;
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (!(child instanceof ParserRuleContext)) continue;
        const ri = child.ruleIndex;
        if (extractionRules.has(ri)) {
          const childText = child.getText();
          const stripped = childText.replace(/^(specializes|:>>|:>|:|definedby|subsets|redefines|references|conjugates|disjoints)/i, "");
          for (const part of stripped.split(",")) {
            const qm = part.match(/'([^']+)'/);
            if (qm) {
              names.push(qm[1]);
            } else {
              const m2 = part.match(/([A-Za-z_]\w*(?:::\w+)*)/);
              if (m2) names.push(m2[1]);
            }
          }
        } else if (
          // Recurse into declaration / part / body wrappers that may
          // contain nested typing rules (but NOT into body rules that
          // contain children — to avoid collecting types from members).
          TYPE_RECURSE_RULE_INDICES.has(ri) || // Also recurse into any rule whose name contains 'declaration'
          // (covers e.g. interfaceUsageDeclaration, usageDeclaration, etc.)
          SysMLv2Parser.ruleNames[ri]?.includes("eclaration")
        ) {
          this.collectNamesFromTree(child, names, depth + 1, extractionRules);
        }
      }
    }
    /**
     * Extract documentation from a comment or doc child.
     */
    extractDocumentation(ctx) {
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (child instanceof ParserRuleContext) {
          if (DOC_RULE_INDICES.has(child.ruleIndex)) {
            const raw = child.getText();
            if (raw) {
              let text = raw;
              if (text.startsWith("doc")) text = text.slice(3);
              if (text.startsWith("comment")) text = text.slice(7);
              text = text.replace(/^\/\*\s*/, "").replace(/\s*\*\/$/, "");
              text = text.replace(/^\/\/\s*/, "");
              return text.trim() || raw;
            }
            return raw ?? void 0;
          }
          const nested = this.extractDocumentation(child);
          if (nested) return nested;
        }
      }
      return void 0;
    }
    /**
     * Extract multiplicity from a context.
     * Looks for MultiplicityBoundsContext in the subtree.
     * Returns { multiplicity: "1..5", multiplicityRange: { lower: 1, upper: 5 } }
     */
    extractMultiplicity(ctx) {
      const multCtx = this.findMultiplicityBounds(ctx);
      if (!multCtx) {
        return {};
      }
      const members = multCtx.multiplicityExpressionMember();
      if (!members || members.length === 0) {
        return {};
      }
      const values = [];
      for (const member of members) {
        const rawText = member.getText()?.trim();
        if (rawText) {
          values.push(rawText);
        }
      }
      if (values.length === 0) {
        return {};
      }
      let lower;
      let upper;
      let multiplicity;
      if (values.length === 1) {
        multiplicity = values[0];
        if (values[0] === "*") {
          lower = 0;
          upper = "*";
        } else {
          const num = parseInt(values[0], 10);
          if (isNaN(num)) {
            return { multiplicity };
          }
          lower = num;
          upper = num;
        }
      } else {
        multiplicity = `${values[0]}..${values[1]}`;
        lower = parseInt(values[0], 10);
        if (isNaN(lower)) {
          return { multiplicity };
        }
        if (values[1] === "*") {
          upper = "*";
        } else {
          upper = parseInt(values[1], 10);
          if (isNaN(upper)) {
            return { multiplicity };
          }
        }
      }
      return {
        multiplicity,
        multiplicityRange: { lower, upper }
      };
    }
    /**
     * Recursively search for a MultiplicityBoundsContext in the subtree.
     */
    findMultiplicityBounds(ctx) {
      if (ctx.ruleIndex === SysMLv2Parser.RULE_multiplicityBounds) {
        return ctx;
      }
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (child instanceof ParserRuleContext) {
          const result = this.findMultiplicityBounds(child);
          if (result) {
            return result;
          }
        }
      }
      return void 0;
    }
    /**
     * Whether a context is a prefix metadata or definition/usage prefix rule.
     * These contain annotation identifiers (e.g. from `#product`) that should
     * not be mistaken for the element's own declared name.
     */
    isPrefixOrExtensionContext(ctx) {
      return PREFIX_EXTENSION_RULE_INDICES.has(ctx.ruleIndex);
    }
    /**
     * Extract prefix metadata annotation names from a context.
     * Looks for `#name` patterns in prefixMetadataMember / prefixMetadataAnnotation children.
     */
    extractPrefixMetadataAnnotations(ctx) {
      const annotations = [];
      this.collectPrefixMetadata(ctx, annotations, 0);
      return annotations;
    }
    collectPrefixMetadata(ctx, annotations, depth) {
      if (depth > 4) return;
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (!(child instanceof ParserRuleContext)) continue;
        const ri = child.ruleIndex;
        if (PREFIX_METADATA_RULE_INDICES.has(ri)) {
          const name = this.extractTextFromSubtree(child);
          if (name) annotations.push(name);
        } else if (PREFIX_METADATA_RECURSE_RULE_INDICES.has(ri)) {
          this.collectPrefixMetadata(child, annotations, depth + 1);
        }
      }
    }
    /**
     * Check if a token is an identifier (not a keyword or punctuation).
     * Also accepts SysML quoted names ('single quoted strings').
     */
    isIdentifierToken(token) {
      const text = token.text;
      if (!text) return false;
      if (this.isQuotedName(text)) return true;
      return /^[a-zA-Z_]/.test(text) && !this.isKeyword(text);
    }
    /**
     * Check if text is a SysML quoted name (single-quoted string).
     */
    isQuotedName(text) {
      return text.length >= 3 && text.startsWith("'") && text.endsWith("'");
    }
    /**
     * Strip quotes from a SysML quoted name, returning the inner text.
     * Returns the text unchanged if not quoted.
     */
    unquoteName(text) {
      if (this.isQuotedName(text)) {
        return text.slice(1, -1);
      }
      return text;
    }
    /**
     * Check if a text is a SysML keyword.
     * Uses the shared keyword set derived from the generated lexer.
     */
    isKeyword(text) {
      return SYSML_KEYWORDS.has(text);
    }
    /**
     * Extract expose target qualified names from a view body.
     * Walks viewBody/viewDefinitionBody children to find expose rules,
     * then extracts the qualified name from membershipExpose or namespaceExpose.
     */
    extractExposeTargets(ctx) {
      const targets = [];
      this.collectExposeTargets(ctx, targets, 0);
      return targets;
    }
    collectExposeTargets(ctx, targets, depth) {
      if (depth > 6) return;
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (!(child instanceof ParserRuleContext)) continue;
        const ri = child.ruleIndex;
        if (ri === SysMLv2Parser.RULE_expose) {
          const target = this.extractExposeQualifiedName(child);
          if (target) targets.push(target);
        } else if (ri === SysMLv2Parser.RULE_viewBody || ri === SysMLv2Parser.RULE_viewBodyItem || ri === SysMLv2Parser.RULE_viewDefinitionBody || ri === SysMLv2Parser.RULE_viewDefinitionBodyItem) {
          this.collectExposeTargets(child, targets, depth + 1);
        }
      }
    }
    /**
     * Extract the qualified name from an expose rule.
     * Handles both membershipExpose (single name, optionally ::**)
     * and namespaceExpose (name::* or name::**).
     */
    extractExposeQualifiedName(exposeCtx) {
      for (let i = 0; i < exposeCtx.getChildCount(); i++) {
        const child = exposeCtx.getChild(i);
        if (!(child instanceof ParserRuleContext)) continue;
        const ri = child.ruleIndex;
        if (ri === SysMLv2Parser.RULE_membershipExpose || ri === SysMLv2Parser.RULE_namespaceExpose) {
          return this.extractFullExposeText(child);
        }
      }
      return void 0;
    }
    /**
     * Extract the full text of an expose target including :: and wildcard tokens.
     * Returns e.g. "Vehicle::engine", "Pkg::*", "Pkg::**"
     */
    extractFullExposeText(ctx) {
      const parts = [];
      this.collectExposeText(ctx, parts);
      return parts.length > 0 ? parts.join("") : void 0;
    }
    collectExposeText(ctx, parts) {
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (child instanceof TerminalNode) {
          const text = child.symbol.text;
          if (text) parts.push(text);
        } else if (child instanceof ParserRuleContext) {
          this.collectExposeText(child, parts);
        }
      }
    }
    /**
     * Extract element filter expressions from a view body.
     * Looks for elementFilterMember rules containing `filter @ QualifiedName`.
     */
    extractViewFilters(ctx) {
      const filters = [];
      this.collectViewFilters(ctx, filters, 0);
      return filters;
    }
    collectViewFilters(ctx, filters, depth) {
      if (depth > 6) return;
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (!(child instanceof ParserRuleContext)) continue;
        const ri = child.ruleIndex;
        if (ri === SysMLv2Parser.RULE_elementFilterMember) {
          const text = this.extractFullExposeText(child);
          if (text) {
            const cleaned = text.replace(/^filter/i, "").replace(/;$/g, "").trim();
            if (cleaned) filters.push(cleaned);
          }
        } else if (ri === SysMLv2Parser.RULE_viewBody || ri === SysMLv2Parser.RULE_viewBodyItem || ri === SysMLv2Parser.RULE_viewDefinitionBody || ri === SysMLv2Parser.RULE_viewDefinitionBodyItem || ri === SysMLv2Parser.RULE_packageBody || ri === SysMLv2Parser.RULE_packageBodyElement) {
          this.collectViewFilters(child, filters, depth + 1);
        }
      }
    }
    /**
     * Extract the view rendering reference from a view body.
     * Looks for viewRenderingMember rules containing `render QualifiedName`.
     */
    extractViewRendering(ctx) {
      return this.findViewRendering(ctx, 0);
    }
    findViewRendering(ctx, depth) {
      if (depth > 6) return void 0;
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (!(child instanceof ParserRuleContext)) continue;
        const ri = child.ruleIndex;
        if (ri === SysMLv2Parser.RULE_viewRenderingMember) {
          const text = this.extractFullExposeText(child);
          if (text) {
            const cleaned = text.replace(/^render/i, "").replace(/[;{}]/g, "").trim();
            if (cleaned) return cleaned;
          }
        } else if (ri === SysMLv2Parser.RULE_viewBody || ri === SysMLv2Parser.RULE_viewBodyItem || ri === SysMLv2Parser.RULE_viewDefinitionBody || ri === SysMLv2Parser.RULE_viewDefinitionBodyItem) {
          const found = this.findViewRendering(child, depth + 1);
          if (found) return found;
        }
      }
      return void 0;
    }
    /**
     * Extract all text content from a subtree (concatenate terminal nodes).
     */
    extractTextFromSubtree(ctx) {
      const parts = [];
      for (let i = 0; i < ctx.getChildCount(); i++) {
        const child = ctx.getChild(i);
        if (child instanceof TerminalNode) {
          const text = child.symbol.text;
          if (text && this.isIdentifierToken(child.symbol)) {
            parts.push(this.unquoteName(text));
          }
        } else if (child instanceof ParserRuleContext) {
          const sub = this.extractTextFromSubtree(child);
          if (sub) parts.push(sub);
        }
      }
      return parts.length > 0 ? parts.join("::") : void 0;
    }
  };

  // server/src/utils/identUtils.ts
  function isIdentStart(c) {
    return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
  }
  function isIdentPart(c) {
    return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95;
  }
  function extractQualifiedNameAt(lineText, character) {
    const len = lineText.length;
    let i = 0;
    while (i < len) {
      if (!isIdentStart(lineText.charCodeAt(i))) {
        i++;
        continue;
      }
      const wordStart = i;
      while (i < len) {
        while (i < len && isIdentPart(lineText.charCodeAt(i))) i++;
        if (i + 2 <= len && lineText[i] === ":" && lineText[i + 1] === ":" && i + 2 < len && isIdentStart(lineText.charCodeAt(i + 2))) {
          i += 2;
        } else {
          break;
        }
      }
      const wordEnd = i;
      if (character >= wordStart && character <= wordEnd) {
        return lineText.substring(wordStart, wordEnd);
      }
    }
    return void 0;
  }
  function stripComments(text) {
    return text.replace(/\/\*[\s\S]*?\*\//g, (m2) => m2.replace(/[^\n]/g, " ")).replace(/\/\/[^\n]*/g, (m2) => " ".repeat(m2.length));
  }

  // server/src/documentManager.ts
  var DocumentManager = class {
    cache = /* @__PURE__ */ new Map();
    /** Shared workspace-wide symbol table — rebuilt incrementally. */
    wsSymbolTable = new SymbolTable();
    /** Tracks per-URI versions that were last built into the workspace table. */
    wsBuiltVersions = /* @__PURE__ */ new Map();
    /**
     * Parse a document and cache the result.
     * Returns the cached result if the content hasn't changed.
     */
    parse(document) {
      const uri = document.uri;
      const version = document.version;
      const cached = this.cache.get(uri);
      if (cached && cached.version === version && !cached.needsParse) {
        return cached.result;
      }
      const text = document.getText();
      const result = parseDocument(text);
      this.cache.set(uri, {
        version,
        text,
        result,
        needsParse: false
      });
      return result;
    }
    /**
     * Parse a document using the batch-optimised path (reuses lexer/parser
     * instances across calls).  Use this for workspace scanning where many
     * files are parsed sequentially and the per-file constructor overhead
     * matters.
     */
    parseBatch(uri, version, text) {
      const cached = this.cache.get(uri);
      if (cached && cached.version === version && !cached.needsParse) {
        return cached.result;
      }
      const result = parseDocumentBatch(text);
      this.cache.set(uri, {
        version,
        text,
        result,
        needsParse: false
      });
      return result;
    }
    /**
     * Cache the document text and version without parsing.
     * The actual ANTLR parse is deferred until a provider needs the
     * symbol table (via `getSymbolTable` / `getWorkspaceSymbolTable`).
     * This avoids the double-parse penalty when a parse worker has
     * already produced diagnostics for this version.
     */
    cacheTextOnly(uri, version, text) {
      const cached = this.cache.get(uri);
      if (cached && cached.version === version && !cached.needsParse) {
        return;
      }
      this.cache.set(uri, {
        version,
        text,
        // Stub result — will be replaced by real parse when needed
        result: {
          tree: null,
          tokenStream: null,
          parser: null,
          lexer: null,
          errors: [],
          timing: { lexMs: 0, parseMs: 0 }
        },
        needsParse: true
      });
    }
    /**
     * Ensure the cached entry for a URI has been fully parsed.
     * Called lazily by symbol table accessors.
     */
    ensureParsed(uri) {
      const cached = this.cache.get(uri);
      if (!cached || !cached.needsParse) return;
      const result = parseDocument(cached.text);
      cached.result = result;
      cached.needsParse = false;
      cached.symbolTable = void 0;
    }
    /**
     * Get the cached parse result for a URI, or undefined if not cached.
     * Triggers a lazy parse if the entry was created via cacheTextOnly.
     */
    get(uri) {
      this.ensureParsed(uri);
      return this.cache.get(uri)?.result;
    }
    /**
     * Get the cached text for a URI.
     */
    getText(uri) {
      return this.cache.get(uri)?.text;
    }
    /**
     * Get the cached document version for a URI.
     */
    getVersion(uri) {
      return this.cache.get(uri)?.version ?? -1;
    }
    /**
     * Get the text with comments stripped (cached per version).
     * Avoids running the 2-pass regex on the same text multiple times.
     */
    getStrippedText(uri) {
      const cached = this.cache.get(uri);
      if (!cached) return void 0;
      if (cached.strippedText === void 0) {
        cached.strippedText = stripComments(cached.text);
      }
      return cached.strippedText;
    }
    /**
     * Get the parse time in milliseconds for a URI.
     */
    getParseTimeMs(uri) {
      const cached = this.cache.get(uri);
      if (!cached) return 0;
      const t = cached.result.timing;
      return t.lexMs + t.parseMs;
    }
    /**
     * Get detailed timing breakdown for a URI.
     */
    getTimingBreakdown(uri) {
      const cached = this.cache.get(uri);
      if (!cached) return { lexMs: 0, parseMs: 0 };
      return { lexMs: cached.result.timing.lexMs, parseMs: cached.result.timing.parseMs };
    }
    /**
     * Get a cached symbol table for a URI, building it if necessary.
     * The symbol table is cached alongside the parse result and only
     * rebuilt when the document version changes.
     */
    getSymbolTable(uri) {
      this.ensureParsed(uri);
      const cached = this.cache.get(uri);
      if (!cached) return void 0;
      if (!cached.symbolTable) {
        const st = new SymbolTable();
        st.build(uri, cached.result);
        cached.symbolTable = st;
      }
      return cached.symbolTable;
    }
    /**
     * Get a workspace-wide symbol table covering all cached documents.
     *
     * Incrementally maintained — only re-builds URIs whose document
     * version has changed since the last call.  All 6+ providers that
     * previously built their own private tables should use this instead.
     */
    getWorkspaceSymbolTable() {
      for (const [uri, cached] of this.cache) {
        if (cached.needsParse) {
          this.ensureParsed(uri);
        }
        const builtVersion = this.wsBuiltVersions.get(uri);
        if (builtVersion === cached.version) continue;
        this.wsSymbolTable.build(uri, cached.result);
        this.wsBuiltVersions.set(uri, cached.version);
      }
      return this.wsSymbolTable;
    }
    /**
     * Cache semantic diagnostics for the current document version.
     */
    setSemanticDiagnostics(uri, diagnostics) {
      const cached = this.cache.get(uri);
      if (!cached) return;
      cached.semanticDiagnostics = {
        version: cached.version,
        diagnostics
      };
    }
    /**
     * Return cached semantic diagnostics if they match the current document version.
     */
    getSemanticDiagnostics(uri) {
      const cached = this.cache.get(uri);
      if (!cached?.semanticDiagnostics) return void 0;
      if (cached.semanticDiagnostics.version !== cached.version) return void 0;
      return cached.semanticDiagnostics.diagnostics;
    }
    /**
     * Remove a document from the cache (called on document close).
     */
    remove(uri) {
      this.cache.delete(uri);
      this.wsSymbolTable.removeUri(uri);
      this.wsBuiltVersions.delete(uri);
    }
    /**
     * Get all cached URIs.
     */
    getUris() {
      return Array.from(this.cache.keys());
    }
  };

  // server/src/library/bundledLibrary.generated.ts
  var BUNDLED_LIBRARY = { "Domain Libraries/Analysis/AnalysisTooling.sysml": "standard library package AnalysisTooling {\n	doc\n	/*\n	 * This package contains definitions for metadata annotations related\n	 * to analysis tool integration.\n	 */\n\n	private import ScalarValues::*;\n	\n	metadata def ToolExecution {\n		doc\n		/*\n		 * ToolExecution metadata identifies an external analysis tool to be\n		 * used to implement the annotated action.\n		 */\n	\n		attribute toolName : String;\n		attribute uri : String;\n	}\n	\n	metadata def ToolVariable {\n		doc\n		/*\n		 * ToolVariable metadata is used in the context of an action that has\n		 * been annotated with ToolExecution metadata. It is used to annotate\n		 * a parameter or other feature of the action with the name of the\n		 * variable in the tool that is to correspond to the annotated\n		 * feature.\n		 */\n	\n		attribute name : String;\n	}\n	\n}", "Domain Libraries/Analysis/SampledFunctions.sysml": "standard library package SampledFunctions {\n	doc\n	/*\n	 * This package provides a library model of discretely sampled mathematical functions.\n	 */\n\n	private import Base::Anything;\n	private import ScalarValues::Positive;\n	private import Collections::KeyValuePair;\n	private import Collections::OrderedMap;\n	private import SequenceFunctions::size;\n	private import ControlFunctions::forAll;\n	private import ControlFunctions::collect;\n	private import ControlFunctions::select;\n	\n    attribute def SamplePair :> KeyValuePair {\n		doc\n		/*\n		 * SamplePair is a key-value pair of a domain-value and a range-value, used as a sample element in SampledFunction.\n		 */\n	\n        attribute domainValue :>> key;\n        attribute rangeValue :>> val;\n    }\n\n	attribute def SampledFunction :> OrderedMap {\n		doc\n		/*\n	     * SampledFunction is a variable-size, ordered collection of 'SamplePair' elements that represents a generic, discretely sampled, \n	     * uni-variate or multi-variate mathematical function. The function must be montonic, either strictly increasing or strictly\n	     * decreasing.\n	     * \n	     * It maps discrete domain values to discrete range values.\n	     * The domain of the function is represented by the sequence of 'domainValue' of each 'SamplePair' in 'samples', and \n	     * the range of the function is represented by the sequence of 'rangeValue' of each 'SamplePair' in 'samples'.\n	     */\n	\n		attribute samples: SamplePair[0..*] ordered :>> elements;\n		\n		assert constraint {\n			// Note: Assumes the functions '<' and '>' are defined for the domain type.\n			(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) < samples.domainValue#(i+1)) } or  // Strictly increasing\n            (1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) > samples.domainValue#(i+1)) }     // Strictly decreasing\n		}\n	}\n	\n	calc def Domain { \n		doc\n		/* \n		 * Domain returns the sequence of the domainValues of all samples in a SampledFunction.\n		 */\n		 \n		in fn : SampledFunction; \n		return : Anything[0..*] = fn.samples.domainValue;\n	}\n	\n	calc def Range { \n		doc\n		/* \n		 * Range returns the sequence of the rangeValues of all samples in a SampledFunction.\n		 */\n			\n		in fn : SampledFunction; \n		return : Anything[0..*] = fn.samples.rangeValue;\n	}\n	\n	calc def Sample {\n		doc\n		/* \n		 * Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues.\n		 */\n		 \n		in calc calculation { in x; }\n		in attribute domainValues [0..*];\n		return sampling = new SampledFunction (\n			samples = domainValues->collect { in x; new SamplePair(x, calculation(x)) }\n		);\n	}\n	\n	calc def Interpolate {\n		doc\n		/*\n		 * An Interpolate calculation returns an interpolated range value from a given SampledFunction for a given domain value.\n		 * If the input domain value is outside the bounds of the domainValues of the SampleFunction, null is returned.\n		 */\n	\n		in attribute fn : SampledFunction;\n		in attribute value;\n		return attribute result;\n	}\n		\n	calc interpolateLinear : Interpolate {\n		doc\n		/*\n		 * interpolateLinear is an Interpolate calculation assuming a linear functional form between SamplePairs.\n		 */\n	\n		in attribute fn : SampledFunction;\n		in attribute value;\n		\n		private attribute domainValues = Domain(fn);\n		private attribute index : Positive[0..1] =\n			(1..size(domainValues))->select { in i : Positive; domainValues#(i) <= value }#(1);\n			\n		private calc def Linear {\n			in attribute lowerSample : SamplePair;\n			in attribute upperSample : SamplePair;\n			in attribute value;\n			private attribute f = (value - lowerSample.domainValue) / (lowerSample.domainValue - upperSample.domainValue);\n			return result = upperSample.rangeValue + f * (lowerSample.rangeValue - upperSample.rangeValue);				\n		}\n		\n		return result [0..1] =\n			if index == null or index == size(domainValues)? null\n			else if domainValues#(index) < domainValues#(index+1)? Linear(fn.samples#(index), fn.samples#(index+1), value)\n			else Linear(fn.samples#(index+1), fn.samples#(index), value);\n	}\n	\n}", "Domain Libraries/Analysis/StateSpaceRepresentation.sysml": "standard library package StateSpaceRepresentation {\n	doc\n	/*\n	 * This package provides a model of the foundational state-space system representation, \n	 * commonly used in control systems.\n	 */\n\n    private import ISQ::DurationValue;\n    private import Quantities::VectorQuantityValue;\n    private import VectorCalculations::*;\n\n    abstract attribute def StateSpace :> VectorQuantityValue;\n    abstract attribute def Input :> VectorQuantityValue;\n    abstract attribute def Output :> VectorQuantityValue;\n\n    abstract calc def GetNextState { \n    	in input: Input; \n    	in stateSpace: StateSpace; \n    	in timeStep: DurationValue; \n    	return : StateSpace;\n    }\n    abstract calc def GetOutput {\n    	in input: Input; \n    	in stateSpace: StateSpace;\n    	return : Output;\n	}\n	\n     abstract action def StateSpaceEventDef {\n    	doc\n    	/*\n    	 * Events to be received.\n    	 */\n    }\n    action def ZeroCrossingEventDef :> StateSpaceEventDef;\n\n    item def StateSpaceItem {\n    	doc\n    	/*\n    	 * Item for SSR connection\n    	 */\n    }\n\n    abstract action def StateSpaceDynamics {\n	    doc\n	    /*\n	     * StateSpaceDynamics is the simplest form of State Space Representation,\n	     * and nextState directly computes the stateSpace of the next timestep. \n	     */\n    \n        in attribute input: Input;\n\n        abstract calc getNextState: GetNextState;\n        abstract calc getOutput: GetOutput;\n        attribute stateSpace: StateSpace;\n\n        out attribute output: Output = getOutput(input, stateSpace);\n    }\n\n    abstract attribute def StateDerivative :> VectorQuantityValue {\n	    doc\n	    /*\n	     * The definition of the time derivative of StateSpace, which means dx/dt, where x is StateSpace\n	     */\n    \n        ref stateSpace: StateSpace;\n        constraint { stateSpace.order == order }\n    }\n\n    abstract calc def GetDerivative {\n	    doc\n	    /*\n	     * Computes the time derivative of stateSpace, which corresponds dx/dt = f(u, x), where u is input and x is stateSpace.\n	     */\n	    \n    	in input: Input;\n    	in stateSpace: StateSpace;\n    	return : StateDerivative;\n	}\n	\n    abstract calc def Integrate {\n	    doc\n	    /*\n	     * Integrates stateSpace to compute the next stateSpace, which corresponds to x + int dx/dt dt.\n	     * Its actual implementation should be given by a solver. \n	     */\n    \n        in getDerivative: GetDerivative;\n        in input: Input;\n        in initialState: StateSpace;\n        in timeInterval: DurationValue;\n        return result: StateSpace;\n	}\n	\n    abstract action def ContinuousStateSpaceDynamics :> StateSpaceDynamics {\n	    doc\n	    /*\n	     * ContinuousStateSpaceDynamics represents continuous behavior.\n	     * derivative needs to return a time derivative of stateSpace, i.e. dx/dt.\n	     */\n    \n        abstract calc getDerivative: GetDerivative;\n        calc :>> getNextState: GetNextState {\n            /* We compute nextState by Integrate defined above by giving derivative calc. */\n            calc integrate: Integrate {\n                in getDerivative = ContinuousStateSpaceDynamics::getDerivative;\n                in input = GetNextState::input;\n                in initialState = GetNextState::stateSpace;\n                in timeInterval = GetNextState::timeStep;\n           }\n           return result = integrate.result;\n        }\n\n        event occurrence zeroCrossingEvents[0..*] : ZeroCrossingEventDef {\n        	/* ContinuousStateSpaceDynamics may cause zero crossings anomaly. */ \n        }\n    }\n\n    abstract calc def GetDifference {\n    	doc\n	    /*\n	     * Computes difference of stateSpace by one timestep, that is x(k+1) - x(k),\n	     * where k is the timestep number. \n	     */\n    \n    	in input: Input;\n    	in stateSpace: StateSpace;\n    	return : StateSpace;\n	}\n	\n    abstract action def DiscreteStateSpaceDynamics :> StateSpaceDynamics {\n	    doc\n	    /*\n	     * DiscreteStateSpaceDynamics represents discrete behavior.\n	     * differences needs to return difference of the stateSpace for each timestep.\n	     */\n    \n        abstract calc getDifference: GetDifference;\n        calc :>> getNextState: GetNextState {\n            attribute diff: StateSpace = getDifference(input, stateSpace);\n            return result = stateSpace + diff;\n        }\n    }\n}\n", "Domain Libraries/Analysis/TradeStudies.sysml": 'standard library package TradeStudies {\n	doc\n	/*\n	 * This package provides a simple framework for defining trade-off study analysis cases.\n	 */\n\n	private import Base::Anything;\n	private import ScalarValues::*;\n	private import ScalarFunctions::*;\n	private import ControlFunctions::*;\n	\n	abstract calc def EvaluationFunction {\n		doc\n		/*\n		 * An EvaluationFunction is a calculation that evaluates a TradeStudy alternative,\n		 * producing a ScalarValue that can be comparted with the evaluation of other\n		 * alternatives.\n		 */\n	\n		in ref alternative : Anything {\n			doc\n			/*\n			 * The alternative to be evaluated.\n			 */\n		} \n		\n		return attribute result : ScalarValue[1] {\n			doc\n			/*\n			 * A ScalarValue representing the evaluation of the given alternative.\n			 */\n		} \n	}\n	\n	abstract requirement def TradeStudyObjective {\n		doc\n		/*\n		 * A TradeStudyObjective is the base definition for the objective of a TradeStudy.\n		 * The requirement is to choose from a given set of alternatives the selectedAlternative\n		 * for that has the best evaluation according to a given EvaluationFunction. What\n		 * value is considered "best" is not defined in the abstract base definition but must be\n		 * computed in any concrete specialization.\n		 */\n	\n		subject selectedAlternative : Anything {\n			doc\n			/*\n			 * The alternative that should be selected, as evaluated using the given \n			 * ObjectiveFunction.\n			 */\n		}\n		\n		in ref alternatives : Anything[1..*] {\n			doc\n			/*\n			 * The alternatives being considered in the TradeStudy for which this TradeStudyObjective \n			 * is the objective.\n			 */\n		}\n		\n		in calc eval : EvaluationFunction {\n			doc\n			/*\n			 * The EvaluationFunction to be used in evaluating the given alternatives.\n			 */\n		}\n		\n		attribute best : ScalarValue {\n			doc\n			/*\n			 * Out of the evaluation results of all the given alternatives, the one that is considered \n			 * "best", in the sense that it is the value the selectedAlternative should have. This \n			 * value must be computed in any concrete specialization of TradeStudyObjective.\n			 */\n		}\n				\n		require constraint { eval(selectedAlternative) == best }\n	}\n	\n	requirement def MinimizeObjective :> TradeStudyObjective {\n		doc\n		/*\n		 * A MinimizeObjective is a TradeStudyObjective that requires that the \n		 * selectedAlternative have the minimum ObjectiveFunction value of all the\n		 * given alternatives.\n		 */\n		 \n		attribute :>> best = alternatives->minimize {\n			doc\n			/*\n			 * For a MinimizeObjective, the best value is the minimum one.\n			 */\n		\n			in x; eval(x)\n		};\n	}\n	\n	requirement def MaximizeObjective :> TradeStudyObjective {\n		doc\n		/*\n		 * A MaximizeObjective is a TradeStudyObjective that requires that the \n		 * selectedAlternative have the maximum ObjectiveFunction value of all the\n		 * given alternatives.\n		 */\n	\n		attribute :>> best = alternatives->maximize {\n			doc\n			/*\n			 * For a MinimizeObjective, the best value is the maximum one.\n			 */\n		\n			in x; eval(x)\n		};\n	}\n	\n	abstract analysis def TradeStudy {\n		doc\n		/*\n		 * A TradeStudy is an analysis case whose subject is a set of alternatives\n		 * (at least one) and whose result is a selection of one of those alternatives.\n		 * The alternatives are evaluated based on a given ObjectiveFunction and the\n		 * selection is made such that it satisfies the objective of the TradeStudy\n		 * (which must be a TradeStudyObjective).\n		 */\n	\n		subject studyAlternatives : Anything[1..*] {\n			doc\n			/*\n			 * The set of alternatives being considered in this TradeStudy. \n			 * \n			 * In a TradeStudy usage, bind this feature to the actual collection of\n			 * alternatives to be considered.\n			 */\n		}\n		\n		abstract calc evaluationFunction : EvaluationFunction {\n			doc\n			/*\n			 * The EvaluationFunction to be used to evaluate the alternatives.\n			 * \n			 * In a TradeStudy usage, redefine this feature to provide the desired\n			 * calculation (or bind it to a calculation usage that does so).\n			 */\n		}\n		\n		objective tradeStudyObjective : TradeStudyObjective {\n			doc\n			/*\n			 * The objective of this TradeStudy.\n			 * \n			 * Redefine this feature to give it a definition that is a concrete\n			 * specialization of TradeStudyObjective. That can either be one of the\n			 * specializations provided in this package, or a more specific user-\n			 * defined one.\n			 */\n		\n            subject :>> selectedAlternative;\n			in ref :>> alternatives = studyAlternatives;\n			in calc :>> eval = evaluationFunction;\n		}\n		\n		return selectedAlternative : Anything = studyAlternatives->selectOne {in ref a {\n			doc\n			/*\n			 * The alternative selected by this TradeStudy, which is the one that meets the\n			 * requirement of the tradeStudyObjective.\n			 */\n		} tradeStudyObjective(selectedAlternative = a)};\n	}\n	\n}', "Domain Libraries/Cause and Effect/CausationConnections.sysml": "standard library package CausationConnections {	\n	doc \n	/* \n	 * This package provides a library model modeling causes, effects, and causation connections \n	 * between them.\n	 */\n\n	private import SequenceFunctions::isEmpty;\n	private import SequenceFunctions::size;\n	private import SequenceFunctions::intersection;\n		 \n	abstract occurrence causes[*] {\n		doc /* Occurrences that are causes. */\n	}\n	\n	abstract occurrence effects[*]  {\n		doc /* Occurrences that are effects. */\n	}\n	\n	abstract connection def Multicausation {\n		doc\n		/*\n		 * A Multicausation connection models the situation in which one set of\n		 * occurrences causes another.\n		 * \n		 * To create a Multicausation connection, specialize this connection definition\n		 * adding specific end features of the relavent types. Ends representing causes\n		 * should subset 'causes', while ends representing effects should subset 'effects'.\n		 * There must be at least one cause and at least one effect.\n		 */\n		 \n		abstract constant ref occurrence causes[1..*] :>> causes :> participant {\n			doc \n			/* \n			 * The causing occurrences. (Constant for each Multicausation instance.)\n			 */\n		}\n		abstract constant ref occurrence effects[1..*] :>> effects :> participant {\n			doc \n			/* \n			 * The effect occurrences caused by the causing occurrences. \n			 * (Constant for each Multicausation instance.)\n			 */\n		}\n		\n		private assert constraint disjointCauseEffect {\n			doc /* causes must be disjoint from effects. */\n			isEmpty(intersection(causes, effects))\n		}\n		\n		private succession causalOrdering first [nCauses] causes.startShot then [nEffects] effects {\n			doc /* All causes must exist before all effects. */\n			attribute nCauses = size(causes);\n			attribute nEffects = size(effects);\n		}\n	}\n	\n	abstract connection multicausations : Multicausation[*] {\n		doc /* multicausations is the base feature for Multicausation ConnectionUsages. */\n	}\n	\n	connection def Causation :> Multicausation {\n		doc\n		/*\n		 * A Causation is a binary Multicausation in which a single cause occurrence\n		 * causes a single effect occurrence. (However, a single cause can separately\n		 * have multiple effects, and a single effect can have separate Causation\n		 * connections with multiple causes.)\n		 */\n		\n		end theCauses [*] occurrence theCause :> causes :>> source {\n		    doc /* The single causing occurrence. */\n		}\n		\n		end theEffects [*] occurrence theEffect :> effects :>> target {\n			doc /* The single effect occurrence resulting from the cause. */\n		}\n	}\n	\n	abstract connection causations : Causation[*] :> multicausations {\n		doc /* causations is the base feature for Causation ConnectionUsages. */\n	}\n}", "Domain Libraries/Cause and Effect/CauseAndEffect.sysml": "standard library package CauseAndEffect {\n	doc /* This package provides language-extension metadata for cause-effect modeling. */\n	\n	public import CausationConnections::*;\n	private import ScalarValues::*;\n	private import Metaobjects::SemanticMetadata;\n\n	metadata def <cause> CauseMetadata :> SemanticMetadata {\n		doc\n		/*\n		 * CauseMetadata identifies a usage as being a cause occurrence.\n		 * It is intended to be used to tag the cause ends of a Multicausation.\n		 */\n		 \n		ref :>> annotatedElement : SysML::Usage;\n		ref :>> baseType = causes as SysML::Usage;\n	}\n	\n	metadata def <effect> EffectMetadata :> SemanticMetadata {\n		doc\n		/*\n		 * EffectMetadata identifies a usage as being an effect occurrence.\n		 * It is intended to be used to tag the effect ends of a Multicausation.\n		 */\n		 \n		ref :>> annotatedElement : SysML::Usage;\n		ref :>> baseType = effects as SysML::Usage;\n	}\n	\n	metadata def CausationMetadata {\n		doc\n		/*\n		 * CausationMetadata allows for the specification of additional metadata about\n		 * a cause-effect connection definition or usage.\n		 */\n		 \n		ref :> annotatedElement : SysML::ConnectionDefinition;\n		ref :> annotatedElement : SysML::ConnectionUsage;\n		\n		attribute isNecessary : Boolean default false {\n			doc \n			/* \n			 * Whether all the causes are necessary for all the effects to occur.\n			 * If this is false (the default), then some or all of the effects may \n			 * still have occurred even if some of the causes did not.\n			 */\n		}\n		\n		attribute isSufficient : Boolean default false {\n			doc\n			/*\n			 * Whether the causes were sufficient for all the effects to occur.\n			 * If this is false (the default), then it may be the case that some\n			 * other occurrences were also necessary for some or all of the effects\n			 * to have occurred.\n			 */\n		}\n		\n		attribute probability : Real[0..1] {\n			doc /* The probability that the causes will actually result in effects occurring. */\n		}	\n	}\n	\n	metadata def <multicausation> MulticausationSemanticMetadata :> CausationMetadata, SemanticMetadata {\n		doc\n		/*\n		 * MulticausationMetadata is SemanticMetadata for a Multicausation connection.\n		 */\n		 \n		ref :>> baseType = multicausations meta SysML::Usage;\n	}\n	\n	metadata def <causation> CausationSemanticMetadadata :> CausationMetadata, SemanticMetadata {\n		doc\n		/*\n		 * CausationMetadata is SemanticMetadata for a Causation connection.\n		 */\n		 \n		ref :>> baseType = causations meta SysML::Usage;\n	}\n}\n", "Domain Libraries/Geometry/ShapeItems.sysml": "standard library package ShapeItems {\n	doc\n	/*\n	 * This package provides a model of items that represent basic geometric shapes. \n	 */\n\n	private import ScalarValues::Boolean;\n	private import ScalarValues::Positive;\n	private import ISQSpaceTime::*;\n	private import ISQBase::*;\n	private import SI::m;\n	private import Occurrences::MatesWith;\n	private import Objects::*;\n	private import Items::Item;\n	private import SequenceFunctions::equals;\n	private import SequenceFunctions::isEmpty;\n	private import SequenceFunctions::notEmpty;\n	private import SequenceFunctions::size;\n	private import SequenceFunctions::includes;\n	private import ControlFunctions::'if';\n	private import ControlFunctions::forAll;\n	private import ControlFunctions::exists;\n	private import Quantities::scalarQuantities;\n\n	item def PlanarCurve :> Curve {\n		doc\n		/*\n		 * A PlanarCurve is a Curve with a given length embeddable in a plane.\n		 */\n	\n		attribute :>> length [1];\n\n		attribute :>> outerSpaceDimension;\n		assert constraint { notEmpty(outerSpaceDimension) &  outerSpaceDimension <= 2 }\n	}\n\n	item def PlanarSurface :> Surface {\n		doc\n		/*\n		 * A PlanarSurface is a flat Surface with a given area.\n		 */\n	\n		attribute :>> area [1];\n		attribute :>> outerSpaceDimension = 2;\n\n		item :>> shape : PlanarCurve;\n	}\n\n	item def Line :> PlanarCurve {\n		doc\n		/*\n		 * A Line is a Curve that is a straight line of a given length.\n		 */\n	\n		attribute :>> length [1];\n		attribute :>> outerSpaceDimension = 1;\n	}\n\n	abstract item def Path :> StructuredSpaceObject::StructuredCurve {\n		doc\n		/*\n		 * Path is the most general structured Curve.\n		 */\n        \n		item :>> faces [0];\n		item :>> edges [1..*] {\n			item :>> vertices [0..2];\n		}\n		item :>> vertices [*] = edges.vertices;\n\n		assert constraint { isClosed == vertices->forAll{in p1 : Point;\n					vertices->exists{p2 : Point; p1 != p2 and\n							 includes(p1.matingOccurrences, p2) } } }\n	}\n\n	attribute semiMajorAxis : LengthValue [0..*] :> scalarQuantities;\n	attribute semiMinorAxis : LengthValue [0..*] :> scalarQuantities;\n	attribute xoffset : LengthValue [0..*] :> scalarQuantities default 0 [m];\n	attribute yoffset : LengthValue [0..*] :> scalarQuantities default 0 [m];\n	attribute baseLength : LengthValue [0..*] :> scalarQuantities;\n	attribute baseWidth : LengthValue [0..*] :> scalarQuantities;\n\n	item def ConicSection :> Path, PlanarCurve {\n		doc\n		/*\n		 * A ConicSection is a closed PlanarCurve, possibly disconnected, see Hyperbola.\n		 */\n	\n\n		item :>> edges [1..2];\n\n		item :>> vertices [0];\n	}\n\n	item def Ellipse :> ConicSection {\n		doc\n		/*\n		 * An Ellipse is a ConicSection in the shape of an ellipse of a given semiaxes.\n		 */\n	\n		attribute :>> semiMajorAxis [1];\n		attribute :>> semiMinorAxis [1];\n\n		item :>> edges [1];\n	}\n\n	item def Circle :> Ellipse {\n		doc\n		/*\n		 * A Circle is an Ellipse with semiaxes equal to its radius.\n		 */\n	\n		attribute :>> radius [1];\n		attribute :>> semiMajorAxis [1] = radius;\n		attribute :>> semiMinorAxis [1] = radius;\n\n		item :>> edges {\n			attribute length [1] = Circle::radius * TrigFunctions::pi * 2;\n		}\n	}\n\n	item def Parabola :> ConicSection {\n		doc\n		/*\n		 * A Parabola is a ConicSection in the shape of a parabola of a given focal length.\n		 */\n	\n		attribute focalDistance : LengthValue [1] :> scalarQuantities;\n\n		item :>> edges [1];\n	}\n\n	item def Hyperbola :> ConicSection {\n		doc\n		/*\n		 * A Hyperbola is a ConicSection in the shape of a hyperbola with given axes.\n		 */\n	\n		attribute tranverseAxis : LengthValue [1] :> scalarQuantities;\n		attribute conjugateAxis : LengthValue [1] :> scalarQuantities;\n	}\n\n	item def Polygon :> Path, PlanarCurve {\n		doc\n		/*\n		 * A Polygon is a closed planar Path with straight edges.\n		 */\n	\n		item :>> edges : Line { item :>> vertices [2]; }\n\n		attribute :>> isClosed = true;\n\n		assert constraint { (1..size(edges))->forAll {in i;\n					edges#(i).vertices->equals((vertices#((2*i)-1), vertices#(2*i))) and  \n					includes((edges#(i).vertices#(2) as Item).matingOccurrences,\n						 edges#(if i==size(edges) ? 1 else i+1).vertices#(1)) } }\n	}\n\n	item def Triangle :> Polygon {\n		doc\n		/*\n		 * A Triangle is three-sided Polygon  with given length (base), width (perpendicular distance\n		 * from base to apex), and offset of this perpendicular at the base from the center of the base.\n		 */\n	\n		attribute :>> length [1];\n		attribute :>> width [1];\n		attribute :>> xoffset [1];\n\n		item :>> edges [3] = (base, e2, e3);\n		item base [1] { length = Triangle::length; }\n		item e2 [1];\n		item e3 [1];\n\n		item :>> vertices [6];\n		item v12  [2] ordered = (vertices#(2), vertices#(3));\n		item apex [2] ordered = (vertices#(4), vertices#(5));\n		item v31  [2] ordered = (vertices#(6), vertices#(1));\n	}\n\n	item def RightTriangle :> Triangle {\n		doc\n		/*\n		 * A RightTriangle is a Triangle with sides opposite the hypotenuse at right angles.\n		 */\n	\n		attribute :>> xoffset = length / 2;\n\n		item :>> e2 { attribute :>> length = Triangle::width; }\n\n		item hypotenuse :>> e3 {\n			attribute :>> length = ( Triangle::length^2 + Triangle::width^2 );\n		}\n	}\n\n	item def Quadrilateral :> Polygon {\n		doc\n		/*\n		 * A Quadrilateral is a four-sided Polygon.\n		 */\n	\n		item :>> edges [4] = (e1, e2, e3, e4);\n		item e1 [1];\n		item e2 [1];\n		item e3 [1];\n		item e4 [1];\n\n		item :>> vertices [8];\n		item v12 [2] ordered = (vertices#(2), vertices#(3));\n		item v23 [2] ordered = (vertices#(4), vertices#(5));\n		item v34 [2] ordered = (vertices#(6), vertices#(7));\n		item v41 [2] ordered = (vertices#(6), vertices#(1));\n	}\n\n	item def Rectangle :> Quadrilateral {\n		doc\n		/*\n		 * A Rectangle is a Quadrilateral four right angles and given length and width.\n		 */\n	\n		attribute :>> length [1];\n		attribute :>> width [1];\n\n		item :>> e1 { attribute :>> length = Rectangle::length; }\n		item :>> e2 { attribute :>> length = Rectangle::width; }\n		item :>> e3 { attribute :>> length = e1.length; }\n		item :>> e4 { attribute :>> length = e2.length; }\n	}\n\n	abstract item def Shell :> StructuredSpaceObject::StructuredSurface {\n		doc\n		/*\n		 * Shell is the most general structured Surface.\n		 */\n	}\n\n	item def Disc :> Shell, PlanarSurface {\n		doc\n		/*\n		 * A Disc is a Shell bound by an Ellipse.\n		 */\n	\n		attribute :>> semiMajorAxis [1];\n		attribute :>> semiMinorAxis [1];\n\n		item :>> shape : Ellipse [1] {\n			attribute :>> semiMajorAxis = Disc::semiMajorAxis;\n			attribute :>> semiMinorAxis = Disc::semiMinorAxis;\n		}\n\n		item :>> faces : PlanarSurface [1] {\n			item :>> edges [1];\n		}\n		item :>> edges : Ellipse [1] = shape {\n            attribute :>> Shell::edges::innerSpaceDimension, Ellipse::innerSpaceDimension;\n            ref item :>> Shell::edges::vertices, Ellipse::vertices;\n		}\n		item :>> vertices [0];\n	}\n\n	item def CircularDisc :> Disc {\n		doc\n		/*\n		 * A CircularDisc is a Disc bound by a Circle.\n		 */\n	\n		attribute :>> radius [1];\n		attribute :>> semiMajorAxis [1] = radius;\n		attribute :>> semiMinorAxis [1] = radius;\n\n		item :>> shape : Circle {\n            attribute :>> Disc::shape::semiMajorAxis, Circle::semiMajorAxis;\n            attribute :>> Disc::shape::semiMinorAxis, Circle::semiMinorAxis;\n        }\n		item :>> edges : Circle;\n	}\n\n	item def ConicSurface :> Shell {\n		doc\n		/*\n		 * A ConicSurface is a Surface that has ConicSection cross-sections.\n		 */\n	\n		item :>> faces [1..2];\n		item :>> edges [0];\n		item :>> vertices [0];\n\n		attribute :>> genus = 0;\n	}\n\n	item def Ellipsoid :> ConicSurface {\n		doc\n		/*\n		 * An Ellipsoid is a ConicSurface with only elliptical cross-sections.\n		 */\n	\n		attribute semiAxis1 : LengthValue [1] :> scalarQuantities; \n		attribute semiAxis2 : LengthValue [1] :> scalarQuantities;\n		attribute semiAxis3 : LengthValue [1] :> scalarQuantities;\n\n		item :>> faces [1];\n	}\n\n	item def Sphere :> Ellipsoid {\n		doc\n		/*\n		 * A Sphere is an Ellipsoid with all the same semiaxes.\n		 */	\n\n		attribute :>> radius [1];\n		attribute :>> semiAxis1 [1] = radius;\n		attribute :>> semiAxis2 [1] = radius;\n		attribute :>> semiAxis3 [1] = radius;\n	}\n\n	item def Paraboloid :> ConicSurface {\n		doc\n		/*\n		 * A Paraboloid is a ConicSurface with only parabolic cross-sections.\n		 */\n	\n		attribute focalDistance : LengthValue [1] :> scalarQuantities;\n\n		item :>> faces [1];\n	}\n\n	item def Hyperboloid :> ConicSurface {\n		doc\n		/*\n		 * A Hyperboloid is a ConicSurface with only hyperbolic cross-sections.\n		 */\n	\n		attribute transverseAxis : LengthValue [1] :> scalarQuantities;\n		attribute conjugateAxis : LengthValue [1] :> scalarQuantities;\n	}\n\n	item def Toroid :> Shell {\n		doc\n		/*\n		 * A Toroid is a surface generated from revolving a planar closed curve about an line coplanar\n		 * with the curve. It is single sided with one hole.\n		 */	\n\n		attribute revolutionRadius : LengthValue [1] :> scalarQuantities;\n\n		item revolvedCurve : PlanarCurve [1] { attribute :>> isClosed = true; }\n\n		item :>> faces [1];\n		item :>> edges [0];\n		item :>> vertices [0];\n\n		attribute :>> genus = 1;\n	}\n\n	item def Torus :> Toroid {\n		doc\n		/*\n		 * A Torus is a revolution of a Circle.\n		 */	\n\n		attribute majorRadius :>> revolutionRadius;\n		attribute minorRadius : LengthValue [1] :> scalarQuantities;\n\n		item :>> revolvedCurve: Circle [1] { attribute :>> radius = minorRadius; }\n	}\n\n\n	item def RectangularToroid :> Toroid {\n		doc\n		/*\n		 * A RectangularToroid is a revolution of a Rectangle.\n		 */	\n\n		attribute rectangleLength : LengthValue [1] :> scalarQuantities;\n		attribute rectangleWidth  : LengthValue [1] :> scalarQuantities;\n\n		item :>> revolvedCurve: Rectangle [1] {\n			attribute :>> length = rectangleLength;\n			attribute :>> width  = rectangleWidth;\n			attribute :>> revolvedCurve::isClosed, Rectangle::isClosed;\n		}\n	}\n\n	item def ConeOrCylinder :> Shell {\n		doc\n		/*\n		 * A ConeOrCylinder is Shell that a Cone or a Cylinder with a given elliptical base,\n		 * height, width (perpendicular distance from the base to the center of the top side or vertex),\n		 * and offsets of this perpendicular at the base from the center of the base.\n		 */\n	\n		attribute :>> semiMajorAxis [1];\n		attribute :>> semiMinorAxis [1];\n		attribute :>> height [1];\n\n		attribute :>> xoffset [1];\n		attribute :>> yoffset [1];\n\n		item :>> faces [2..3];\n		item base : Disc [1] :> faces {        \n            attribute :>> Disc::innerSpaceDimension, faces::innerSpaceDimension;\n            ref :>> Disc::edges, ConeOrCylinder::faces::edges {\n                attribute :>> Disc::edges::innerSpaceDimension, ConeOrCylinder::faces::edges::innerSpaceDimension;\n            }\n            ref :>> Disc::vertices, ConeOrCylinder::faces::vertices;		    \n		}\n		item af : Disc [0..1] :> faces {        \n            attribute :>> Disc::innerSpaceDimension, faces::innerSpaceDimension;\n            ref :>> Disc::edges, ConeOrCylinder::faces::edges {\n                attribute :>> Disc::edges::innerSpaceDimension, ConeOrCylinder::faces::edges::innerSpaceDimension;\n            }\n            ref :>> Disc::vertices, ConeOrCylinder::faces::vertices;            \n        }\n		item cf : Surface [1] :> faces;\n\n		item :>> edges [2..4] = faces.edges;\n		item be [2] :> edges { \n			attribute :>> semiMajorAxis = ConeOrCylinder::semiMajorAxis;\n			attribute :>> semiMinorAxis = ConeOrCylinder::semiMinorAxis;\n		}\n		item ae [0..2] :> edges {\n			attribute :>> semiMajorAxis = be.semiMajorAxis;\n			attribute :>> semiMinorAxis = be.semiMinorAxis;\n		}\n		assert constraint { size(ae) == (if isEmpty(af) ? 0 else 2) and\n				            size(edges) == (if isEmpty(af) ? 2 else 4)  }\n\n		item :>> vertices [0..1] = faces.vertices;\n		assert constraint { isEmpty(af) == notEmpty(vertices) }\n\n		/* Bind face edges to specific edges */\n		binding [1] bind [0..*] base.edges = [0..*] be;\n		binding [1] bind [0..*] cf.edges = [0..*] be;\n\n		/* Meeting edges */\n		connection :MatesWith connect [1] be to [1] be;\n\n		attribute :>> genus = 0;\n	}\n\n	item def Cone :> ConeOrCylinder {\n		doc\n		/*\n		 * A Cone has one elliptical sides joined to a point by a curved side.\n		 */	\n\n		item :>> faces [2];\n\n		item apex :>> vertices;\n\n		/* Bind face vertices to specific vertices */\n		binding [1] bind [0..*] cf.vertices = [0..*] apex;\n	}\n\n	item def EccentricCone :> Cone {\n		doc\n		/*\n		 * An EccentricCone is a Cone with least one positive offset.\n		 */\n	\n		assert constraint { xoffset > 0 or yoffset > 0 }\n	}\n\n	item def CircularCone :> Cone {\n		doc\n		/*\n		 * A CircularCone is a Cone with a circular base.\n		 */	\n\n		attribute :>> radius [1];\n		attribute :>> semiMajorAxis [1] = radius;\n		attribute :>> semiMinorAxis [1] = radius;\n\n		item :>> base : CircularDisc {\n		    ref :>> base::edges, CircularDisc::edges;\n		}\n	}\n\n	item def RightCircularCone :> CircularCone {\n		doc\n		/*\n		 * A RightCircularCone is a CircularCone with zero offsets.\n		 */\n	\n		attribute :>> xoffset { attribute :>> num = 0; }\n		attribute :>> yoffset { attribute :>> num = 0; }\n	}\n\n	item def Cylinder :> ConeOrCylinder {\n		doc\n		/*\n		 * A Cylinder has two elliptical sides joined by a curved side.\n		 */\n	\n		item :>> af [1];\n\n		binding [1] bind [0..*] cf.edges = [0..*] ae;\n\n		connection :MatesWith connect [1] ae to [1] ae {\n			doc /* Meeting edges */\n		}\n	}\n\n	item def EccentricCylinder :> Cylinder {\n	doc\n	/*\n	 * An EccentricCylinder is a Cylinder with least one positive offset.\n	 */\n	\n		assert constraint { xoffset > 0 or yoffset > 0 }\n	}\n\n	item def CircularCylinder :> Cylinder {\n		doc\n		/*\n		 * A CircularCylinder is a Cylinder with two circular sides.\n		 */\n	\n		attribute :>> radius [1];\n		attribute :>> semiMajorAxis [1] = radius;\n		attribute :>> semiMinorAxis [1] = radius;\n\n		item :>> base : CircularDisc {\n            ref :>> base::edges, CircularDisc::edges;\n        }\n		item :>> af : CircularDisc {\n            ref :>> af::edges, CircularDisc::edges;\n        }\n	}\n\n	item def RightCircularCylinder :> CircularCylinder {\n		doc\n		/*\n		 * A RightCircularCylinder is a CircularCylinder with zero offsets.\n		 */\n	\n		attribute :>> xoffset { attribute :>> num = 0; }\n		attribute :>> yoffset { attribute :>> num = 0; }\n	}\n\n	item def Polyhedron :> Shell {\n		doc\n		/*\n		 * A Polyhedron is a closed Shell with polygonal sides.\n		 */	\n\n		attribute :>> isClosed = true;\n\n		item :>> faces : Polygon [2..*] {        \n            attribute :>> Polygon::innerSpaceDimension, faces::innerSpaceDimension;\n            ref :>> Polygon::edges, ConeOrCylinder::faces::edges;\n            ref :>> Polygon::vertices, ConeOrCylinder::faces::vertices;            \n        }\n		\n		item :>> edges = faces.edges;\n		\n		attribute :>> outerSpaceDimension = if size(faces) > 2 ? 3 else 2;\n\n		attribute :>> genus = 0;\n	}\n\n	item def CuboidOrTriangularPrism :> Polyhedron {\n		doc\n		/*\n		 * A CuboidOrTriangularPrism is a Polyhedron that is either a Cuboid or TriangularPrism.\n		 */\n\n		item :>> faces [5..6];\n		item tf	 : Quadrilateral [1] :> faces {        \n            ref :>> Quadrilateral::edges, ConeOrCylinder::faces::edges;\n            ref :>> Quadrilateral::vertices, ConeOrCylinder::faces::vertices;            \n        }\n		item bf	 : Quadrilateral [1] :> faces {        \n            ref :>> Quadrilateral::edges, ConeOrCylinder::faces::edges;\n            ref :>> Quadrilateral::vertices, ConeOrCylinder::faces::vertices;            \n        }\n		item ff	 : Polygon [1] :> faces { item :>> Polygon::edges, faces::edges [3..4]; }\n		item rf	 : Polygon [1] :> faces { item :>> Polygon::edges, faces::edges [3..4]; }\n		item slf : Quadrilateral [1] :> faces {        \n            ref :>> Quadrilateral::edges, ConeOrCylinder::faces::edges;\n            ref :>> Quadrilateral::vertices, ConeOrCylinder::faces::vertices;            \n        }\n		item srf : Quadrilateral [0..1] :> faces {        \n            ref :>> Quadrilateral::edges, ConeOrCylinder::faces::edges;\n            ref :>> Quadrilateral::vertices, ConeOrCylinder::faces::vertices;            \n        }\n\n		item :>> edges;\n		assert constraint { size(edges) == 18 or size(edges) == 24 }\n		\n		item tfe  [2]	 :> edges;\n		item tre  [2]	 :> edges;\n		item tsle [2]	 :> edges;\n		item tsre [0..2] :> edges;\n		item bfe  [2]	 :> edges;\n		item bre  [2]	 :> edges;\n		item bsle [2]	 :> edges;\n		item bsre [2]	 :> edges;\n		item ufle [2]	 :> edges;\n		item ufre [0..2] :> edges;\n		item urle [2]	 :> edges;\n		item urre [0..2] :> edges;\n\n		assert constraint { ( isEmpty(srf) implies isEmpty(tsre) ) and\n				    ( isEmpty(tsre) == isEmpty(ufre) ) and\n				    ( isEmpty(ufre) == isEmpty(urre) ) }\n\n		item :>> vertices;\n		assert constraint { size(vertices) == size(edges) }\n\n		item tflv [3]	 :> vertices;\n		item tfrv [0..3] :> vertices;\n		item trlv [3]	 :> vertices;\n		item trrv [0..3] :> vertices;\n		item bflv [3]	 :> vertices;\n		item bfrv [3]	 :> vertices;\n		item brlv [3]	 :> vertices;\n		item brrv [3]	 :> vertices;\n		\n		assert constraint { ( isEmpty(tfrv) == isEmpty(trrv) ) }\n\n		/* Bind face edges to specific edges */\n		binding [1] bind [0..1] tf.edges = [0..1] tfe;\n		binding [1] bind [0..1] tf.edges = [0..1] tre;\n		binding [1] bind [0..1] tf.edges = [0..1] tsle;\n		binding [1] bind [0..1] bf.edges = [0..1] bfe;\n		binding [1] bind [0..1] bf.edges = [0..1] bre;\n		binding [1] bind [0..1] bf.edges = [0..1] bsle;\n		binding [1] bind [0..1] bf.edges = [0..1] bsre;\n\n		binding [1] bind [0..1] ff.edges = [0..1] tfe;\n		binding [1] bind [0..1] ff.edges = [0..1] bfe;\n		binding [1] bind [0..1] ff.edges = [0..1] ufle;\n\n		binding [1] bind [0..1] rf.edges = [0..1] tre;\n		binding [1] bind [0..1] rf.edges = [0..1] bre;\n		binding [1] bind [0..1] rf.edges = [0..1] urle;\n\n		/* Bind edge vertices to specific vertices */\n		binding [1] bind [0..1] tfe.vertices = [0..1] tflv;\n		binding [1] bind [0..1] tre.vertices = [0..1] trlv;\n		binding [1] bind [0..1] tsle.vertices = [0..1] tflv;\n		binding [1] bind [0..1] tsle.vertices = [0..1] trlv;\n\n		binding [1] bind [0..1] bfe.vertices = [0..1] bflv;\n		binding [1] bind [0..1] bfe.vertices = [0..1] bfrv;\n		binding [1] bind [0..1] bre.vertices = [0..1] brlv;\n		binding [1] bind [0..1] bre.vertices = [0..1] brrv;\n		binding [1] bind [0..1] bsle.vertices = [0..1] bflv;\n		binding [1] bind [0..1] bsle.vertices = [0..1] brlv;\n		binding [1] bind [0..1] bsre.vertices = [0..1] bfrv;\n		binding [1] bind [0..1] bsre.vertices = [0..1] brrv;\n\n		binding [1] bind [0..1] ufle.vertices = [0..1] tflv;\n		binding [1] bind [0..1] ufle.vertices = [0..1] bflv;\n		binding [1] bind [0..1] urle.vertices = [0..1] trlv;\n		binding [1] bind [0..1] urle.vertices = [0..1] brlv;\n\n		/* Meeting edges */\n		connection :MatesWith connect [1] tfe to [1] tfe;\n		connection :MatesWith connect [1] tre to [1] tre;\n		connection :MatesWith connect [1] tsle to [1] tsle;\n		connection :MatesWith connect [1] bfe to [1] bfe;\n		connection :MatesWith connect [1] bre to [1] bre;\n		connection :MatesWith connect [1] bsle to [1] bsle;\n		connection :MatesWith connect [1] bsre to [1] bsre;\n		connection :MatesWith connect [1] ufle to [1] ufle;\n		connection :MatesWith connect [1] urle to [1] urle;\n		connection :MatesWith connect [1] bsre to [1] bsre;\n\n		/* Meeting vertices  */\n		connection :MatesWith connect [2] tflv to [2] tflv;\n		connection :MatesWith connect [2] trlv to [2] trlv;\n		connection :MatesWith connect [2] bflv to [2] bflv;\n		connection :MatesWith connect [2] bfrv to [2] bfrv;\n		connection :MatesWith connect [2] brlv to [2] brlv;\n		connection :MatesWith connect [2] brrv to [2] brrv;\n	}\n\n	item def TriangularPrism :> CuboidOrTriangularPrism {\n		doc\n		/*\n		 * A TriangularPrism is a Polyhedron with five sides, two triangular and\n		 * the others quadrilateral.\n		 */\n	\n\n		item :>> faces [5];\n		item :>> ff : Triangle {        \n            ref :>> Triangle::edges, ConeOrCylinder::faces::edges;\n            ref :>> Triangle::vertices, ConeOrCylinder::faces::vertices;            \n        }\n		item :>> rf : Triangle {        \n            ref :>> Triangle::edges, ConeOrCylinder::faces::edges;\n            ref :>> Triangle::vertices, ConeOrCylinder::faces::vertices;            \n        }\n\n		item :>> edges [18];\n\n		item :>> vertices;\n\n		/* Bind face edges to specific edges */\n		binding [1] bind [0..1] tf.edges = [0..1] bsre;\n\n		/* Bind edge vertices to specific vertices */\n		binding [1] bind [0..1] tfe.vertices = [0..1] bfrv;\n		binding [1] bind [0..1] tre.vertices = [0..1] bfrv;\n	}\n\n	item def RightTriangularPrism :> TriangularPrism {\n		doc\n		/*\n		 * A RightTriangularPrism  a TriangularPrism with two right triangluar sides,\n		 * with given length, width, and height.\n		 */\n	 \n		attribute :>> length [1];\n		attribute :>> width [1];\n		attribute :>> height [1];\n\n		item :>> tf  : Rectangle;\n		item :>> bf  : Rectangle;\n		item :>> ff : RightTriangle {\n			attribute :>> length = RightTriangularPrism::length;\n			attribute :>> width = RightTriangularPrism::width;\n		}\n		item :>> rf : RightTriangle {\n			attribute :>> length = ff.length;\n			attribute :>> width = rf.width;\n		}\n		item :>> slf : Rectangle;\n		item :>> srf : Rectangle;\n\n		item :>> tfe  { attribute :>> length = ff.hypotenuse.length; }\n		item :>> tre  { attribute :>> length = tfe.length; }\n		item :>> tsle { attribute :>> length = height; }\n		item :>> bfe  { attribute :>> length = RightTriangularPrism::length; }\n		item :>> bre  { attribute :>> length = RightTriangularPrism::length; }\n		item :>> bsle { attribute :>> length = height; }\n		item :>> bsre { attribute :>> length = height; }\n		item :>> ufle { attribute :>> length = width;  } \n		item :>> urle { attribute :>> length = width; }\n	}\n	alias Wedge for RightTriangularPrism;\n\n	item def Cuboid :> CuboidOrTriangularPrism {\n		doc\n		/*\n		 * A Cuboid is a Polyhedron with six sides, all quadrilateral.\n		 */	\n\n		item :>> faces [6];\n		item :>> ff : Quadrilateral {        \n            ref :>> Quadrilateral::edges, ConeOrCylinder::faces::edges;\n            ref :>> Quadrilateral::vertices, ConeOrCylinder::faces::vertices;            \n        }\n		item :>> rf : Quadrilateral {        \n            ref :>> Quadrilateral::edges, ConeOrCylinder::faces::edges;\n            ref :>> Quadrilateral::vertices, ConeOrCylinder::faces::vertices;            \n        }\n\n		item :>> edges [24];\n\n		item :>> vertices;\n\n		/* Bind face edges to specific edges */\n		binding [1] bind [0..1] tf.edges = [0..1] tsre;\n		binding [1] bind [0..1] ff.edges = [0..1] ufre;\n		binding [1] bind [0..1] rf.edges = [0..1] urre;\n\n		binding [1] bind [0..1] srf.edges = [0..1] tsre;\n		binding [1] bind [0..1] srf.edges = [0..1] bsre;\n		binding [1] bind [0..1] srf.edges = [0..1] ufre;\n		binding [1] bind [0..1] srf.edges = [0..1] urre;\n\n		/* Bind edge vertices to specific vertices */\n		binding [1] bind [0..1] tfe.vertices = [0..1] tfrv;\n		binding [1] bind [0..1] tre.vertices = [0..1] trrv;\n		binding [1] bind [0..1] tsre.vertices = [0..1] tfrv;\n		binding [1] bind [0..1] tsre.vertices = [0..1] trrv;\n\n		binding [1] bind [0..1] ufre.vertices = [0..1] tfrv;\n		binding [1] bind [0..1] ufre.vertices = [0..1] bfrv;\n		binding [1] bind [0..1] urre.vertices = [0..1] trrv;\n		binding [1] bind [0..1] urre.vertices = [0..1] brrv;\n\n		/* Meeting edges */\n		connection :MatesWith connect [1] tsre to [1] tsre;\n		connection :MatesWith connect [1] ufre to [1] ufre;\n		connection :MatesWith connect [1] urre to [1] urre;\n		connection :MatesWith connect [1] bsre to [1] bsre;\n\n		/* Meeting vertices  */\n		connection :MatesWith connect [2] tfrv to [2] tfrv;\n		connection :MatesWith connect [2] trrv to [2] trrv;\n	}\n\n	item def RectangularCuboid :> Cuboid {\n		doc\n		/*\n		 * A RectangularCuboid is a Cuboid with all Rectangular sides.\n		 */\n	\n		attribute :>> length [1];\n		attribute :>> width [1];\n		attribute :>> height [1];\n	\n		item :>> tf  : Rectangle { attribute :>> length = RectangularCuboid::length;\n								   attribute :>> width	= RectangularCuboid::height; }\n		item :>> bf  : Rectangle { attribute :>> length = RectangularCuboid::length;\n								   attribute :>> width	= RectangularCuboid::height; }\n		item :>> ff  : Rectangle { attribute :>> length = RectangularCuboid::length;\n								   attribute :>> width	= RectangularCuboid::width; }\n		item :>> rf  : Rectangle { attribute :>> length = RectangularCuboid::length;\n								   attribute :>> width	= RectangularCuboid::width; }\n		item :>> slf : Rectangle { attribute :>> length = RectangularCuboid::height;\n								   attribute :>> width	= RectangularCuboid::width; }\n		item :>> srf : Rectangle { attribute :>> length = RectangularCuboid::height;\n								   attribute :>> width	= RectangularCuboid::width; }\n	}\n	alias Box for RectangularCuboid;\n\n	item def Pyramid :> Polyhedron {\n		doc\n		/*\n		 * A Pyramid is a Polyhedron with the sides of a polygon (base) forming the bases of triangles\n		 * that join at an apex point.	Its height is the perpendicular distance from the base to the apex,\n		 * and its offsets are between this perpendicular at the base and the center of the base.\n		 */	 \n\n		attribute :>> height [1];\n		attribute :>> xoffset;\n		attribute :>> yoffset;\n\n		item :>> faces;\n		item base [1] :> faces;\n		item wall : Triangle :> faces {        \n            ref :>> Triangle::edges, ConeOrCylinder::faces::edges;\n            ref :>> Triangle::vertices, ConeOrCylinder::faces::vertices;            \n        }\n		attribute wallNumber : Positive = size(wall);\n\n		assert constraint { size(faces) == wallNumber + 1 }\n		assert constraint { size(wall) == size(base.edges) }\n\n		item :>> edges;\n\n		assert constraint { size(edges) == wallNumber * 4 }\n\n		item :>> vertices;\n		item apex :> vertices = wall.apex;\n\n		assert constraint { size(apex) == wallNumber }\n\n		/* Base to wall and wall to wall edge mating. */\n		assert constraint { (1..wallNumber)->forAll {in i;\n					includes(wall#(i).base.matingOccurrences,\n							 Pyramid::base.edges#(i)) and\n					includes((wall#(i).edges#(3) as Item).matingOccurrences,\n							 wall#(if i==wallNumber ? 1 else i+1).edges#(2)) } }\n\n		/* Meeting apices. */\n		connection :MatesWith connect [wallNumber] apex to [wallNumber] apex;\n	}\n\n	item def Tetrahedron :> Pyramid {\n		doc\n		/*\n		 * A Tetrahedron is Pyramid with a triangular base.\n		 */\n	\n		attribute :>> baseLength [1];\n		attribute :>> baseWidth [1];\n\n		item :>> base : Triangle {\n            ref :>> Triangle::edges, ConeOrCylinder::faces::edges;\n            ref :>> Triangle::vertices, ConeOrCylinder::faces::vertices;            \n			attribute :>> length = Tetrahedron::baseLength;\n			attribute :>> width  = Tetrahedron::baseWidth;\n		}\n	}\n\n	item def RectangularPyramid :> Pyramid {\n		doc\n		/*\n		 * A RectangularPyramid is Pyramid with a rectangular base.\n		 */	\n\n		attribute :>> baseLength [1];\n		attribute :>> baseWidth [1];\n\n		item :>> base : Rectangle {\n            ref :>> Rectangle::edges, ConeOrCylinder::faces::edges;\n            ref :>> Rectangle::vertices, ConeOrCylinder::faces::vertices;            \n			attribute :>> length = RectangularPyramid::baseLength;\n			attribute :>> width = RectangularPyramid::baseWidth;\n		}\n	}\n}", "Domain Libraries/Geometry/SpatialItems.sysml": "standard library package SpatialItems {\n	doc\n	/*\n	 * This package models physical items that have a spatial extent and act as a spatial frame of reference\n	 * for obtaining position and displacement vectors of points within them.\n	 */\n\n	private import Objects::Point;\n	private import SpatialFrames::SpatialFrame;\n	private import Quantities::VectorQuantityValue;\n	private import MeasurementReferences::ThreeDCoordinateFrame;\n	private import MeasurementReferences::nullTransformation;\n	private import Time::Clock;\n	private import Time::TimeInstantValue;\n	private import ScalarValues::Natural;\n	private import ISQ::universalCartesianSpatial3dCoordinateFrame;\n	private import ISQ::Position3dVector;\n	private import ISQ::Displacement3dVector;\n	private import VectorFunctions::isZeroVector;\n	private import SequenceFunctions::isEmpty;\n	private import ControlFunctions::forAll;\n	\n	item def SpatialItem :> SpatialFrame {\n		doc\n		/*\n		 * A SpatialItem is an Item with a three-dimensional spatial extent that also acts as a SpatialFrame of reference.\n		 */\n	\n		ref item :>> localClock : Clock[1] default Time::universalClock {\n			doc\n			/*\n			 * A local Clock to be used as the corresponding time reference within this SpatialItem. \n			 * By default this is the singleton universalClock.\n			 */\n		}\n		\n		attribute coordinateFrame : ThreeDCoordinateFrame[1] default universalCartesianSpatial3dCoordinateFrame {\n            doc\n            /*\n             * The three-dimensional CoordinateFrame to be used as the measurement reference for position \n             * and displacement vector values relative to this SpatialItem.\n             * By default this is the singleton universalCartesianSpatial3dCoordinateFrame.\n             */\n        }\n        		\n		item originPoint : Point[1] :> spaceShots {\n			doc\n			/*\n			 * The Point at the origin of the coordinateFrame of this SpatialItem.\n			 */\n		}\n		\n		assert constraint originPointConstraint {\n			doc\n			/*\n			 * The CurrentPositionOf the originPoint must always be a zero vector.\n			 */\n		\n			isZeroVector(CurrentPositionOf(originPoint, that))\n		}\n\n        item subSpatialItems : SpatialItem[1..*] :> subitems {\n            ref item :>> SpatialItem::localClock, subitems::localClock;\n        }\n        \n        part subSpatialParts : SpatialItem[1..*] :> subSpatialItems, subparts {\n            ref item :>> SpatialItem::localClock, subSpatialItems::localClock, subparts::localClock;\n        }\n\n		item componentItems : SpatialItem[1..*] :> subSpatialItems {\n			doc\n			/*\n			 * A SpatialItem with componentItems is entirely made up of those items (the SpatialItem occurs only\n			 * as a collection of its componentItems).  By default they have the same localClock and equivalent\n			 * coordinate frame as the SpatialItem they make up.  A SpatialItem without componentItems occurs\n			 * on its own, separately from its subitems.\n			 */		\n			ref item :>> SpatialItem::localClock, subSpatialItems::localClock default (that as SpatialItem).localClock;\n			attribute :>> coordinateFrame {\n				attribute :>> mRefs default (that.that as SpatialItem).coordinateFrame.mRefs;\n				attribute :>> transformation[1] default nullTransformation {\n					attribute :>> source default (that.that.that as SpatialItem).coordinateFrame;\n				}\n			}\n		}\n\n		private attribute cunionNum: Natural [1] = if isEmpty(componentItems) ? 0 else 1;\n		private attribute componentUnion[cunionNum] :> unionsOf {\n			doc\n			/*\n			 * A SpatialItem with componentItems is is a spatial union of them.\n			 */\n		\n			item :>> elements : SpatialItem [1..*] = componentItems;\n		}\n		\n		part componentParts : SpatialItem[1..*] :> componentItems, subSpatialParts {\n		    ref item :>> SpatialItem::localClock, componentItems::localClock, subSpatialParts::localClock, subparts::localClock;\n		}\n	}\n\n	calc def PositionOf :> SpatialFrames::PositionOf {\n		doc\n		/*\n		 * The PositionOf a Point relative to a SpatialItem, at a specific TimeInstantValue relative to a given Clock,\n		 * is a positionVector that is a VectorQuantityValue in the coordinateFrame of the SpatialItem.\n		 * The default Clock is the localClock of the SpatialItem.\n		 */\n	\n		in point : Point[1];\n		in timeInstant : TimeInstantValue[1];\n		in enclosingItem :>> 'frame' : SpatialItem[1];\n		in clock : Clock[1] default enclosingItem.localClock;\n		return positionVector : Position3dVector[1] {\n			attribute :>> mRef = enclosingItem.coordinateFrame;\n		}\n	}\n\n	calc def CurrentPositionOf :> SpatialFrames::CurrentPositionOf {\n		doc\n		/*\n		 * The CurrentPositionOf a Point relative to a SpatialItem and a Clock is the PositionOf\n		 * the Point relative to the SpatialItem at the currentTime of the Clock.\n		 */\n	\n		in point : Point[1];\n		in enclosingItem :>> 'frame' : SpatialItem[1];\n		in clock : Clock[1] default enclosingItem.localClock;\n		return positionVector : Position3dVector[1] {\n			attribute :>> mRef = enclosingItem.coordinateFrame;\n		}\n	}\n\n	calc def DisplacementOf :> SpatialFrames::DisplacementOf {\n		doc\n		/*\n		 * The DisplacementOf two Points relative to a SpatialItem, at a specific TimeInstantValue relative to a\n		 * given Clock, is the displacementVector computed as the difference between the PositionOf the \n		 * first Point and PositionOf the second Point, relative to that SpatialItem, at that timeInstant.\n		 */\n	\n		in point1 : Point[1];\n		in point2 : Point[1];\n		in timeInstant : TimeInstantValue[1];\n		in spatialItem :>> 'frame' : SpatialItem[1];\n		in clock : Clock[1] default spatialItem.localClock;\n		return displacementVector : Displacement3dVector[1] {\n			attribute :>> mRef = spatialItem.coordinateFrame;\n		}\n	}\n\n	calc def CurrentDisplacementOf :> SpatialFrames::CurrentDisplacementOf {\n		doc\n		/*\n		 * The CurrentDisplacementOf two Points relative to a SpatialItem and a Clock is the DisplacementOf\n		 * the Points relative to the SpatialItem, at the currentTime of the Clock.\n		 */\n	\n		in point1 : Point[1];\n		in point2 : Point[1];\n		in spatialItem :>> 'frame' : SpatialItem[1];\n		in clock : Clock[1] default spatialItem.localClock;\n		return displacementVector : Displacement3dVector[1] {\n			attribute :>> mRef = spatialItem.coordinateFrame;\n		}\n	}\n\n}", "Domain Libraries/Metadata/ImageMetadata.sysml": 'standard library package ImageMetadata {\n	doc\n	/*\n	 * This package provides attributive data and metadata to allow a model element to be\n	 * annotated with an image to be used in its graphical rendering or as a marker to\n	 * adorn graphical or textual renderings.\n	 */\n	 \n	private import ScalarValues::String;\n	\n	attribute def Image {\n		doc\n		/*\n		 * Image provides the data necessary for the physical definition of \n		 * a graphical image.\n		 */\n		 \n		attribute content : String[0..1] {\n			doc\n			/*\n			 * Binary data for the image according to the given MIME type, \n			 * encoded as given by the encoding.\n			 */\n		}\n		\n		attribute encoding : String[0..1] {\n			doc\n			/*\n			 * Describes how characters in the content are to be decoded into \n			 * binary data. At least "base64", "hex", "identify", and "JSONescape"\n			 * shall be supported.\n			 */\n		}\n		\n		attribute type : String[0..1] {\n			doc\n			/*\n			 * The MIME type according to which the content should be interpreted.\n			 */\n		}\n		\n		attribute location : String[0..1] {\n			doc\n			/*\n			 * A URI for the location of a resource containing the image content,\n			 * as an alternative for embedding it in the content attribute.\n			 */\n		}\n	}\n	\n	metadata def Icon {\n		doc\n		/*\n		 * Icon metadata can be used to annotate a model element with an image to be used\n		 * to show render the element on a diagram and/or a small image to be used as an\n		 * adornment on a graphical or textual rendering. Alternatively, another metadata\n		 * definition can be annotated with an Icon to indicate that any model element \n		 * annotated by the containing metadata can be rendered according to the Icon.\n		 */\n		 \n		attribute fullImage : Image[0..1] {\n			doc\n			/*\n			 * A full-sized image that can be used to render the annotated element on a\n			 * graphical view, potentially as an alternative to its standard rendering.\n			 */\n		}\n		\n		attribute smallImage : Image[0..1] {\n			doc\n			/*\n			 * A smaller image that can be used as an adornment on the graphical rendering\n			 * of the annotated element or as a marker in a textual rendering.\n			 */\n		}\n	}\n	\n}', "Domain Libraries/Metadata/ModelingMetadata.sysml": "standard library package ModelingMetadata {\n	doc\n	/*\n	 * This package contains definitions of metadata generally useful for annotating models.\n	 */\n\n	private import Base::Anything;\n	private import ScalarValues::String;\n	private import RiskMetadata::Risk;\n	\n	enum def StatusKind {\n		doc\n		/*\n		 * StatusKind enumerates the possible statuses of work on a model element.\n		 */\n	\n		open {\n			doc\n			/*\n			 * Status is open.\n			 */\n		}\n		\n		tbd {\n			doc\n			/*\n			 * Status is to be determined.\n			 */\n		}\n		\n		tbr {\n			doc\n			/*\n			 * Status is to be resolved.\n			 */\n		}\n		\n		tbc {\n			doc\n			/*\n			 * Status is to be confirmed.\n			 */\n		}\n		\n		done {\n			doc\n			/*\n			 * Status is done.\n			 */\n		}\n		\n		closed {\n			doc\n			/*\n			 * Status is closed.\n			 */\n		}\n	}\n	\n	metadata def StatusInfo {\n		doc\n		/*\n		 * StatusInfo is used to annotate a model element with status information.\n		 */\n	\n		attribute originator : String [0..1] {\n			doc\n			/*\n			 * The originator of the annotated element.\n			 */\n		}\n		\n		attribute owner : String [0..1] {\n			doc\n			/*\n			 * The current owner of the annotated element.\n			 */\n		}\n		\n		attribute status : StatusKind {\n			doc\n			/*\n			 * The current status of work on the annotated element (required).\n			 */\n		}\n		\n		item risk : Risk [0..1] {\n			doc\n			/*\n			 * An assessment of risk for the annotated element.\n			 */\n		}\n	}\n	\n	metadata def Rationale {\n		doc\n		/*\n		 * Rationale is used to explain a choice or other decision made related to the\n		 * annotated element.\n		 */\n	\n		attribute text : String {\n			doc\n			/*\n			 * A textual description of the rationale (required).\n			 */\n		}\n		\n		ref explanation : Anything [0..1] {\n			doc\n			/*\n			 * A reference to a feature that provides a formal explanation of the rationale.\n			 * (For example, a trade study whose result explains the choice of a certain alternative).\n			 */\n		}\n	}\n	\n	metadata def Issue {\n		doc\n		/*\n		 * Issue is used to record some issue concerning the annotated element.\n		 */\n	\n		attribute text : String {\n		doc\n		/*\n		 * A textual description of the issue.\n		 */\n		}\n	}\n	\n	metadata def <refinement> Refinement {\n		doc\n		/*\n		 * Refinement is used to identify a dependency as modeling a refinement relationship.\n		 * In such a relationship, the source elements of the relationship provide a more precise and/or \n		 * accurate representation than the target elements.\n		 */\n	\n		:>> annotatedElement : SysML::Dependency;\n	}\n	\n}", "Domain Libraries/Metadata/ParametersOfInterestMetadata.sysml": "standard library package ParametersOfInterestMetadata {\n	doc\n	/*\n	 * This package contains definitions of metadata to identify key parameters of interest,\n	 * including measures of effectiveness (MOE) and other key measures of performance (MOP).\n	 */\n	 \n	 private import Metaobjects::SemanticMetadata;\n	 \n	 attribute measuresOfEffectiveness[*] nonunique {\n	 	doc /* Base feature for attributes that are measures of effectiveness. */\n	 }\n	 \n	 attribute measuresOfPerformance[*] nonunique {\n	 	doc /* Base feature for attributes that are measures of performance. */\n	 }\n	 \n	 metadata def <moe> MeasureOfEffectiveness :> SemanticMetadata {\n	 	doc \n	 	/*\n	 	 * MeasureOfEffectiveness is semantic metadata for identifying an attribute as a\n	 	 * measure of effectiveness.\n	 	 */\n	 	\n	 	:>> annotatedElement : SysML::Usage;\n	 	:>> baseType = measuresOfEffectiveness meta SysML::Usage;\n	 }\n	 \n	 metadata def <mop> MeasureOfPerformance :> SemanticMetadata {\n	 	doc \n	 	/*\n	 	 * MeasureOfPerformance is semantic metadata for identifying an attribute as a\n	 	 * measure of performance.\n	 	 */\n	 	\n	 	:>> annotatedElement : SysML::Usage;\n	 	:>> baseType = measuresOfPerformance meta SysML::Usage;\n	 }\n}", "Domain Libraries/Metadata/RiskMetadata.sysml": "standard library package RiskMetadata {\n	doc\n	/*\n	 * This package defines metadata for annotating model elements with assessments of risk.\n	 */\n\n	private import ScalarValues::Real;\n	\n	attribute def Level :> Real {\n		doc\n		/*\n		 * A Level is a Real number in the interval 0.0 to 1.0, inclusive.\n		 */\n	\n		assert constraint { that >= 0.0 and that <= 1.0 }\n	}\n	\n	enum def LevelEnum :> Level {\n		doc\n		/*\n		 * LevelEnum provides standard probability Levels for low, medium and high risks.\n		 */\n	\n		low = 0.25;\n		medium = 0.50;\n		high = 0.75;\n	}\n\n	attribute def RiskLevel {\n		doc\n		/*\n		 * RiskLevel gives the probability of a risk occurring and, optionally, the impact\n		 * if the risk occurs.\n		 */\n	\n		attribute probability : Level {\n			doc\n			/*\n			 * The probability that a risk will occur.\n			 */\n		}\n		\n		attribute impact : Level [0..1] {\n			doc\n			/*\n			 * The impact of the risk if it occurs (with 0.0 being no impact and 1.0 being \n			 * the most severe impact).\n			 */\n		}\n	}\n	\n	enum def RiskLevelEnum :> RiskLevel {\n		doc\n		/*\n		 * RiskLevelEnum enumerates standard RiskLevels for low, medium and high risks\n		 * (without including impact).\n		 */\n\n		low = new RiskLevel(probability = LevelEnum::low);\n		medium = new RiskLevel(probability = LevelEnum::medium);\n		high = new RiskLevel(probability = LevelEnum::high);\n	}\n	\n	metadata def Risk {\n		doc\n		/*\n		 * Risk is used to annotate a model element with an assessment of the risk related to it\n		 * in some typical risk areas.\n		 */\n	\n		attribute totalRisk : RiskLevel [0..1] {\n			doc\n			/*\n			 * The total risk associated with the annotated element.\n			 */\n		}\n		\n		attribute technicalRisk : RiskLevel [0..1] {\n			doc\n			/*\n			 * The risk of unresolved technical issues regarding the annotated element.\n			 */\n		}\n		\n		attribute scheduleRisk : RiskLevel [0..1] {\n			doc\n			/*\n			 * The risk that work on the annotated element will not be completed on schedule.\n			 */\n		}\n		\n		attribute costRisk : RiskLevel [0..1] {\n			doc\n			/*\n			 * The risk that work on the annotated element will exceed its planned cost.\n			 */\n		}\n	}\n	\n}", "Domain Libraries/Quantities and Units/ISQ.sysml": `standard library package ISQ {
    doc
    /*
     * International system of quantities (ISQ), as defined in ISO/IEC 80000
     */

	private import ScalarValues::Real;
	private import Quantities::*;
	private import MeasurementReferences::*;

	public import ISQBase::*;                  // ISO/IEC 80000 base quantities and general concepts
    public import ISQSpaceTime::*;             // ISO 80000-3 "Space and Time"
    public import ISQMechanics::*;             // ISO 80000-4 "Mechanics"
    public import ISQThermodynamics::*;        // ISO 80000-5 "Thermodynamics"
    public import ISQElectromagnetism::*;      // IEC 80000-6 "Electromagnetism"
    public import ISQLight::*;                 // ISO 80000-7 "Light"
    public import ISQAcoustics::*;             // ISO 80000-8 "Acoustics"
    public import ISQChemistryMolecular::*;    // ISO 80000-9 "Physical chemistry and molecular physics"
    public import ISQAtomicNuclear::*;         // ISO 80000-10 "Atomic and nuclear physics"
    public import ISQCharacteristicNumbers::*; // ISO 80000-11 "Characteristic numbers"
    public import ISQCondensedMatter::*;       // ISO 80000-12 "Condensed matter physics"
    public import ISQInformation::*;           // IEC 80000-13 "Information science and technology"

    /* Additional quantity declarations */

    attribute def TemperatureDifferenceValue :> ScalarQuantityValue {
        doc
        /*
         * temperature difference
         * A separate temperature difference quantity and unit are needed in order to support \xB0C, \xB0F and centrigrade temperature differences
         */
        attribute :>> num: Real;
        attribute :>> mRef: TemperatureDifferenceUnit[1];
    }
    
    attribute temperatureDifference: TemperatureDifferenceValue [*] nonunique :> scalarQuantities;

    attribute def TemperatureDifferenceUnit :> SimpleUnit {    
        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = 1; }
        attribute :>> quantityDimension { :>> quantityPowerFactors = thermodynamicTemperaturePF; }
    }
}
`, "Domain Libraries/Quantities and Units/ISQAcoustics.sysml": 'standard library package ISQAcoustics {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-8:2020 "Acoustics"\n     * see also https://www.iso.org/standard/64978.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n    private import ISQMechanics::PowerValue;\n    private import ISQMechanics::PressureValue;\n    private import ISQSpaceTime::CartesianSpatial3dCoordinateFrame;\n    private import ISQSpaceTime::SpeedValue;\n    private import ISQSpaceTime::CartesianVelocity3dCoordinateFrame;\n    private import ISQSpaceTime::AccelerationValue;\n    private import ISQSpaceTime::CartesianAcceleration3dCoordinateFrame;\n    private import ISQThermodynamics::EnergyValue;\n\n    /* ISO-80000-8 item 8-1 logarithmic frequency range */\n    attribute def LogarithmicFrequencyRangeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-1 logarithmic frequency range\n         * symbol(s): `G`\n         * application domain: generic\n         * name: LogarithmicFrequencyRange\n         * quantity dimension: 1\n         * measurement unit(s): oct, dec\n         * tensor order: 0\n         * definition: quantity given by: `G = log_2(f_2/f_1) "[oct]" = log_10(f_2/f_1) "[dec]"`, where `f_1` and `f_2` are two frequencies (ISO 80000-3)\n         * remarks: One octave (oct) is the logarithmic frequency range between `f_1` and `f_2` when `f_2/f_1 = 2`. Similarly, one decade (dec) is the logarithmic frequency range between `f_1` and `f_2` when `f_2/f_1 = 10`; thus `1 "[dec]" = log_2(10) "[oct]" \u2248 3.322 "[oct]"`. ISO 266 specifies preferred frequencies for acoustics separated by logarithmic frequency ranges equal to one tenth of a decade (`0.1 "[dec]"`). Each `0.1 "[dec]"` logarithmic frequency range is referred to in ISO 266 as a "one-third-octave interval" because `0.1 "[dec]"` is approximately equal to `1/3 "[oct]"`. Similarly, a logarithmic frequency range of `0.3 "[dec]"` is referred to as a "one-octave interval" because `0.3 "[dec]"` is approximately equal to `1 "[oct]"`. A logarithmic frequency range equal to one tenth of a decade can be referred to as a decidecade.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LogarithmicFrequencyRangeUnit[1];\n    }\n\n    attribute logarithmicFrequencyRange: LogarithmicFrequencyRangeValue[*] nonunique :> scalarQuantities;\n\n    attribute def LogarithmicFrequencyRangeUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-8 item 8-2.1 static pressure */\n    attribute staticPressure: PressureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 8-2.1 static pressure\n         * symbol(s): `p_s`\n         * application domain: generic\n         * name: StaticPressure (specializes Pressure)\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: pressure (ISO 80000-4) in a medium when no sound wave is present\n         * remarks: This definition applies to a medium with zero flow.\n         */\n    }\n\n    /* ISO-80000-8 item 8-2.2 sound pressure */\n    attribute soundPressure: PressureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 8-2.2 sound pressure\n         * symbol(s): `p`\n         * application domain: generic\n         * name: SoundPressure (specializes Pressure)\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: difference between instantaneous total pressure and static pressure (item 8-2.1)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-8 item 8-3 sound particle displacement */\n    attribute def CartesianSoundParticleDisplacement3dVector :> \'3dVectorQuantityValue\' {\n        doc\n        /*\n         * source: item 8-3 sound particle displacement\n         * symbol(s): `vec(\u03B4)`\n         * application domain: generic\n         * name: SoundParticleDisplacement (specializes Displacement)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity giving the instantaneous displacement (ISO 80000-3) of a particle in a medium from what would be its position in the absence of sound waves\n         * remarks: None.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianSpatial3dCoordinateFrame[1];\n    }\n\n    attribute cartesianSoundParticleDisplacement3dVector: CartesianSoundParticleDisplacement3dVector :> vectorQuantities;\n\n    /* ISO-80000-8 item 8-4 sound particle velocity */\n    attribute def CartesianSoundParticleVelocity3dVector :> \'3dVectorQuantityValue\' {\n        doc\n        /*\n         * source: item 8-4 sound particle velocity\n         * symbol(s): `vec(u)`, `(vec(v))`\n         * application domain: generic\n         * name: SoundParticleVelocity (specializes Velocity)\n         * quantity dimension: L^1*T^-1\n         * measurement unit(s): m*s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity given by: `vec(u) = del(vec(\u03B4))/del(t)`, where `vec(\u03B4)` is sound particle displacement (item 8-3) and `t` is time (ISO 80000-3)\n         * remarks: The definition is limited to small-amplitude acoustic disturbances such that the magnitude of `vec(u)` is small relative to the phase speed (ISO 80000-3) of sound.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianVelocity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianSoundParticleVelocity3dVector: CartesianSoundParticleVelocity3dVector :> vectorQuantities;\n\n    /* ISO-80000-8 item 8-5 sound particle acceleration */\n    attribute def CartesianSoundParticleAcceleration3dVector :> \'3dVectorQuantityValue\' {\n        doc\n        /*\n         * source: item 8-5 sound particle acceleration\n         * symbol(s): `vec(a)`\n         * application domain: generic\n         * name: SoundParticleAcceleration (specializes Acceleration)\n         * quantity dimension: L^1*T^-2\n         * measurement unit(s): m*s^-2\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity given by: `vec(a) = (del(vec(u)))/(del(t))`, where `vec(u)` is sound particle velocity (item 8-4) and `t` is time\n         * remarks: The definition is limited to small-amplitude acoustic disturbances such that the magnitude of `vec(u)` is small relative to the phase speed (ISO 80000-3) of sound.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianAcceleration3dCoordinateFrame[1];\n    }\n\n    attribute cartesianSoundParticleAcceleration3dVector: CartesianSoundParticleAcceleration3dVector :> vectorQuantities;\n\n    /* ISO-80000-8 item 8-6 volume velocity, volume flow rate */\n    attribute volumeVelocity: SpeedValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 8-6 volume velocity, volume flow rate\n         * symbol(s): `q`, `q_v`\n         * application domain: generic\n         * name: VolumeVelocity (specializes Speed)\n         * quantity dimension: L^3*T^-1\n         * measurement unit(s): m^3*s^-1\n         * tensor order: 0\n         * definition: surface integral of the normal component of the sound particle velocity (item 8-4) over a defined surface\n         * remarks: None.\n         */\n    }\n\n    alias volumeFlowRate for volumeVelocity;\n\n    /* ISO-80000-8 item 8-7 sound energy density */\n    attribute def SoundEnergyDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-7 sound energy density\n         * symbol(s): `w`\n         * application domain: generic\n         * name: SoundEnergyDensity\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): J/m^3, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: quantity given by: `w = 1/2 \u03C1_m u^2 + 1/2 p^2/(\u03C1_m c^2)`, where `\u03C1_m` is mean density (ISO 80000-4), `u` is the magnitude of the sound particle velocity (item 8-4), `p` is sound pressure (item 8-2.2), and `c` is the phase speed (ISO 80000-3) of sound\n         * remarks: In formula form: `E = int_(t_1)^(t_2) p^2 dt`, where `t_1` and `t_2` are the starting and ending times for the integral and `p` is sound pressure (item 8-2.2). In airborne acoustics, the sound pressure is frequency-weighted and frequency-band-limited. If frequency weightings as specified in IEC 61672-1 are applied, this should be indicated by appropriate subscripts to the symbol `E`. In underwater acoustics, the term ""sound exposure"" indicates an unweighted quantity unless indicated otherwise.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SoundEnergyDensityUnit[1];\n    }\n\n    attribute soundEnergyDensity: SoundEnergyDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def SoundEnergyDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-8 item 8-8 sound energy */\n    attribute soundEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 8-8 sound energy\n         * symbol(s): `Q`\n         * application domain: generic\n         * name: SoundEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: integral of sound energy density (item 8-7) over a specified volume\n         * remarks: The sound energy in region `R` can be expressed by: `Q = oint_R w(x) d^3x`, where `d^3x` is an element of volume.\n         */\n    }\n\n    /* ISO-80000-8 item 8-9 sound power */\n    attribute soundPower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 8-9 sound power\n         * symbol(s): `P`, `W`\n         * application domain: generic\n         * name: SoundPower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W, kg*m^2*s^-3\n         * tensor order: 0\n         * definition: integral over a surface of the product of sound pressure, `p` (item 8-2.2), and the component `u_n` of the particle velocity (item 8-4) in the direction normal to the surface, at a point on the surface\n         * remarks: This definition holds for waves in the volume of homogenous fluids or gases. This definition can become inapplicable in situations with a high mean fluid flow. Sound power is for example used to indicate the rate at which energy is radiated by a sound source. Sound power is an oscillatory quantity that can be positive or negative. A positive sound power indicates that the sound power is radiated out of the surface. A negative sound power indicates that the sound power is absorbed into the surface.\n         */\n    }\n\n    /* ISO-80000-8 item 8-10 sound intensity */\n    attribute def SoundIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-10 sound intensity (magnitude)\n         * symbol(s): `I`\n         * application domain: generic\n         * name: SoundIntensity\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/m^2, kg*s^-3\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity given by: `vec(I) = p vec(u)`, where `p` is sound pressure (item 8-2.2) and `vec(u)` is sound particle velocity (item 8-4)\n         * remarks: This definition can become inapplicable in situations with a high mean fluid flow.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SoundIntensityUnit[1];\n    }\n\n    attribute soundIntensity: SoundIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def SoundIntensityUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    attribute def CartesianSoundIntensity3dVector :> \'3dVectorQuantityValue\' {\n        doc\n        /*\n         * source: item 8-10 sound intensity (vector)\n         * symbol(s): `vec(I)`\n         * application domain: generic\n         * name: SoundIntensity\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/m^2, kg*s^-3\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity given by: `vec(I) = p vec(u)`, where `p` is sound pressure (item 8-2.2) and `vec(u)` is sound particle velocity (item 8-4)\n         * remarks: This definition can become inapplicable in situations with a high mean fluid flow.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianSoundIntensity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianSoundIntensity3dVector: CartesianSoundIntensity3dVector :> vectorQuantities;\n\n    attribute def CartesianSoundIntensity3dCoordinateFrame :> \'3dCoordinateFrame\' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: SoundIntensityUnit[3];\n    }\n\n    /* ISO-80000-8 item 8-11 sound exposure */\n    attribute def SoundExposureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-11 sound exposure\n         * symbol(s): `E`\n         * application domain: generic\n         * name: SoundExposure\n         * quantity dimension: L^-2*M^2*T^-3\n         * measurement unit(s): Pa^2*s, kg^2*m^-2*s^-3\n         * tensor order: 0\n         * definition: time-integrated squared sound pressure (item 8-2.2)\n         * remarks: In formula form: `E = int_(t_1)^(t_2) p^2 dt`, where `t_1` and `t_2` are the starting and ending times for the integral and `p` is sound pressure (item 8-2.2). In airborne acoustics, the sound pressure is frequency-weighted and frequency-band-limited. If frequency weightings as specified in IEC 61672-1 are applied, this should be indicated by appropriate subscripts to the symbol `E`. In underwater acoustics, the term "sound exposure" indicates an unweighted quantity unless indicated otherwise.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SoundExposureUnit[1];\n    }\n\n    attribute soundExposure: SoundExposureValue[*] nonunique :> scalarQuantities;\n\n    attribute def SoundExposureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-8 item 8-12 characteristic impedance of a medium for longitudinal waves */\n    attribute def CharacteristicImpedanceOfAMediumForLongitudinalWavesValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-12 characteristic impedance of a medium for longitudinal waves\n         * symbol(s): `Z_c`\n         * application domain: generic\n         * name: CharacteristicImpedanceOfAMediumForLongitudinalWaves\n         * quantity dimension: L^-2*M^1*T^-1\n         * measurement unit(s): Pa*s/m, kg*m^-2*s^-1\n         * tensor order: 0\n         * definition: quotient of sound pressure (item 8-2.2) and the component of the sound particle velocity (item 8-4) in the direction of the wave propagation\n         * remarks: The definition is limited to a progressive plane wave in a non-dissipative homogenous gas or fluid. Characteristic impedance is a property of the medium and is equal to `\u03C1 c` where `\u03C1` is the time-averaged density (ISO 80000-4) of the medium and `c` the phase speed of sound (ISO 80000-3). Longitudinal waves are waves in which the displacement of the medium is in the same direction as, or the opposite direction to, the direction of propagation of the wave.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CharacteristicImpedanceOfAMediumForLongitudinalWavesUnit[1];\n    }\n\n    attribute characteristicImpedanceOfAMediumForLongitudinalWaves: CharacteristicImpedanceOfAMediumForLongitudinalWavesValue[*] nonunique :> scalarQuantities;\n\n    attribute def CharacteristicImpedanceOfAMediumForLongitudinalWavesUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-8 item 8-13 acoustic impedance */\n    attribute def AcousticImpedanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-13 acoustic impedance\n         * symbol(s): `Z_a`\n         * application domain: generic\n         * name: AcousticImpedance\n         * quantity dimension: L^-4*M^1*T^-1\n         * measurement unit(s): Pa*s/m^3, kg*m^-4*s^-1\n         * tensor order: 0\n         * definition: at a surface, quotient of the average sound pressure (item 8-2.2) over that surface and the sound volume flow rate (item 8-6) through that surface\n         * remarks: This definition applies to a sound pressure that is in phase with the volume flow rate. In this situation, the acoustic impedance is real. Both the sound pressure, `p`, and sound volume flow rate, `q`, are real quantities that fluctuate with time. If the fluctuations are in phase (phase difference equal to zero), the quotient `p/q` is a constant. If they are out of phase (phase difference not equal to zero), they can be represented by complex quantities in the frequency domain, the quotient of which is also complex.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AcousticImpedanceUnit[1];\n    }\n\n    attribute acousticImpedance: AcousticImpedanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def AcousticImpedanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -4; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-8 item 8-14 sound pressure level */\n    attribute def SoundPressureLevelValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-14 sound pressure level\n         * symbol(s): `L_p`\n         * application domain: generic\n         * name: SoundPressureLevel\n         * quantity dimension: 1\n         * measurement unit(s): dB\n         * tensor order: 0\n         * definition: quantity given by: `L_p = 10 log_10((p_"RMS"^2)/p_0^2) "[dB]"`, where `p_"RMS"` is the root-mean-square sound pressure in the time domain and `p_0` is the reference value of sound pressure\n         * remarks: For sound in air and other gases, the reference value of sound pressure is given by `p_0 = 20 "[\u03BCPa]"`. For sound in water and other liquids, the reference value of sound pressure is given by `p_0 = 1 "[\u03BCPa]"`. When stating a value of sound pressure level, the reference value shall be specified. The value of sound pressure level depends on the selected frequency range and time duration. When stating a value of sound pressure level, the frequency range and time duration shall be specified. In accordance with ISO 80000-1, any attachment to the unit symbol as a means of giving information about the special nature of the quantity or context of measurement under consideration is not permitted. If specific frequency and time weightings as specified in IEC 61672-1 or specific frequency bands or time duration are applied, this should be indicated by appropriate subscripts to the quantity symbol. In some applications the level of the peak sound pressure is required. This is obtained by replacing the root-mean-square sound pressure, with the instantaneous sound pressure having the greatest absolute value during a stated time interval, in the definition of sound pressure level.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SoundPressureLevelUnit[1];\n    }\n\n    attribute soundPressureLevel: SoundPressureLevelValue[*] nonunique :> scalarQuantities;\n\n    attribute def SoundPressureLevelUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-8 item 8-15 sound power level */\n    attribute def SoundPowerLevelValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-15 sound power level\n         * symbol(s): `L_P`, `L_W`\n         * application domain: generic\n         * name: SoundPowerLevel\n         * quantity dimension: 1\n         * measurement unit(s): dB\n         * tensor order: 0\n         * definition: quantity given by: `L_P = 10 log_10 ((P_m)/P_0) "[dB]"`, where `P_m` is the magnitude of the time-averaged sound power (item 8-9) and `P_0` is the reference value of sound power\n         * remarks: The reference value of sound power is given by `P_0 = 1 "[pW]"`. When stating a value of sound power level, the reference value shall be specified. The value of sound power level depends on the selected frequency range and time duration. When stating a value of sound power level, the frequency range and time duration shall be specified. In accordance with ISO 80000-1, any attachment to the unit symbol as a means of giving information about the special nature of the quantity or context of measurement under consideration is not permitted. If specific frequency and time weightings as specified in IEC 61672-1 or specific frequency bands or time duration are applied, this should be indicated by appropriate subscripts to the quantity symbol.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SoundPowerLevelUnit[1];\n    }\n\n    attribute soundPowerLevel: SoundPowerLevelValue[*] nonunique :> scalarQuantities;\n\n    attribute def SoundPowerLevelUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-8 item 8-16 sound exposure level */\n    attribute def SoundExposureLevelValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 8-16 sound exposure level\n         * symbol(s): `L_E`\n         * application domain: generic\n         * name: SoundExposureLevel\n         * quantity dimension: 1\n         * measurement unit(s): dB\n         * tensor order: 0\n         * definition: quantity given by: `L_E = 10 log_10(E/E_0) "[dB]"`, where `E` is sound exposure (item 8-11) and `E_0` is the reference value of sound exposure\n         * remarks: For sound in air and other gases, the reference value of sound exposure is given by `E_0 = 400 "@"["\u03BCPa"^2*"s"]`. For sound in water and other liquids, the reference value of sound exposure is given by `E_0 = 1"@"["\u03BCPa"^2*"s"]`. When stating a value of sound exposure level, the reference value shall be specified. The value of sound exposure level depends on the selected frequency range and time duration. When stating a value of sound exposure level, the frequency range and time duration shall be specified. In accordance with ISO 80000-1, any attachment to the unit symbol as a means of giving information about the special nature of the quantity or context of measurement under consideration is not permitted. If specific frequency and time weightings as specified in IEC 61672-1 or specific frequency bands or time duration are applied, this should be indicated by appropriate subscripts to the quantity symbol.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SoundExposureLevelUnit[1];\n    }\n\n    attribute soundExposureLevel: SoundExposureLevelValue[*] nonunique :> scalarQuantities;\n\n    attribute def SoundExposureLevelUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-8 item 8-17 reverberation time */\n    attribute reverberationTime: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 8-17 reverberation time\n         * symbol(s): `T`\n         * application domain: generic\n         * name: ReverberationTime (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: time duration (ISO 80000-3) required for the space-averaged sound energy density (item 8-7) to decrease to `10^(\u22126)` of its initial value (i.e. for its level to decrease by `60 "[dB]"`) after the source emission has stopped\n         * remarks: The reverberation time can be evaluated based on a dynamic range smaller than `60 "[dB]"` and extrapolated to a decay time of `60 "[dB]"`. It is then labelled accordingly `T_n`, where `n` is the dynamic range in `"[dB]"`. See also ISO 3382-1.\n         */\n    }\n\n}\n', "Domain Libraries/Quantities and Units/ISQAtomicNuclear.sysml": 'standard library package ISQAtomicNuclear {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-10:2019 "Atomic and nuclear physics"\n     * see also https://www.iso.org/standard/64980.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n    private import ISQChemistryMolecular::DiffusionCoefficientUnit;\n    private import ISQChemistryMolecular::DiffusionCoefficientValue;\n    private import ISQChemistryMolecular::diffusionCoefficient;    \n    private import ISQElectromagnetism::ElectricChargeValue;\n    private import ISQSpaceTime::AngularFrequencyValue;\n    private import ISQSpaceTime::AreaValue;\n    private import ISQThermodynamics::EnergyValue;\n\n    /* ISO-80000-10 item 10-1.1 atomic number, proton number */\n    attribute atomicNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-1.1 atomic number, proton number\n         * symbol(s): `Z`\n         * application domain: generic\n         * name: AtomicNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of protons in an atomic nucleus\n         * remarks: A nuclide is a species of atom with specified numbers of protons and neutrons. Nuclides with the same value of `Z` but different values of `N` are called isotopes of an element. The ordinal number of an element in the periodic table is equal to the atomic number. The atomic number equals the quotient of the charge (IEC 80000-6) of the nucleus and the elementary charge (ISO 80000-1).\n         */\n    }\n\n    alias protonNumber for atomicNumber;\n\n    /* ISO-80000-10 item 10-1.2 neutron number */\n    attribute neutronNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-1.2 neutron number\n         * symbol(s): `N`\n         * application domain: generic\n         * name: NeutronNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of neutrons in an atomic nucleus\n         * remarks: Nuclides with the same value of `N` but different values of `Z` are called isotones. `N - Z` is called the neutron excess number.\n         */\n    }\n\n    /* ISO-80000-10 item 10-1.3 nucleon number, mass number */\n    attribute nucleonNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-1.3 nucleon number, mass number\n         * symbol(s): `A`\n         * application domain: generic\n         * name: NucleonNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of nucleons in an atomic nucleus\n         * remarks: `A` = `Z` + `N` Nuclides with the same value of `A` are called isobars.\n         */\n    }\n\n    alias massNumber for nucleonNumber;\n\n    /* ISO-80000-10 item 10-2 rest mass, proper mass */\n    attribute restMass: MassValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-2 rest mass, proper mass\n         * symbol(s): `m(X)`, `m_X`\n         * application domain: generic\n         * name: RestMass (specializes Mass)\n         * quantity dimension: M^1\n         * measurement unit(s): kg, Da, u\n         * tensor order: 0\n         * definition: for particle X, mass (ISO 80000-4) of that particle at rest in an inertial frame\n         * remarks: EXAMPLE `m(H_2O)` for a water molecule, `m_e` for an electron. Rest mass is often denoted `m_0`. 1 u is equal to 1/12 times the mass of a free carbon 12 atom, at rest and in its ground state. 1 Da = 1 u\n         */\n    }\n\n    alias properMass for restMass;\n\n    /* ISO-80000-10 item 10-3 rest energy */\n    attribute restEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-3 rest energy\n         * symbol(s): `E_0`\n         * application domain: generic\n         * name: RestEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, N*m, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: energy `E_0` (ISO 80000-5) of a particle at rest: `E_0 = m_0 c_0^2` where `m_0` is the rest mass (item 10-2) of that particle, and `c_0` is speed of light in vacuum (ISO 80000-1)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-4.1 atomic mass */\n    attribute atomicMass: MassValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-4.1 atomic mass\n         * symbol(s): `m(X)`, `m_X`\n         * application domain: generic\n         * name: AtomicMass (specializes Mass)\n         * quantity dimension: M^1\n         * measurement unit(s): kg, Da, u\n         * tensor order: 0\n         * definition: rest mass (item 10-2) of an atom X in the ground state\n         * remarks: `m(X)/m_u` is called the relative atomic mass. 1 u is equal to 1/12 times the mass of a free carbon 12 atom, at rest and in its ground state. 1 Da = 1 u\n         */\n    }\n\n    /* ISO-80000-10 item 10-4.2 nuclidic mass */\n    attribute nuclidicMass: MassValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-4.2 nuclidic mass\n         * symbol(s): `m(X)`, `m_X`\n         * application domain: generic\n         * name: NuclidicMass (specializes Mass)\n         * quantity dimension: M^1\n         * measurement unit(s): kg, Da, u\n         * tensor order: 0\n         * definition: rest mass (item 10-2) of a nuclide X in the ground state\n         * remarks: 1 u is equal to 1/12 times the mass of a free carbon 12 atom, at rest and in its ground state. 1 Da = 1 u\n         */\n    }\n\n    /* ISO-80000-10 item 10-4.3 unified atomic mass constant */\n    attribute unifiedAtomicMassConstant: MassValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-4.3 unified atomic mass constant\n         * symbol(s): `m_u`\n         * application domain: generic\n         * name: UnifiedAtomicMassConstant (specializes Mass)\n         * quantity dimension: M^1\n         * measurement unit(s): kg, Da, u\n         * tensor order: 0\n         * definition: 1/12 of the mass (ISO 80000-4) of an atom of the nuclide ^(12)C in the ground state at rest\n         * remarks: 1 u is equal to 1/12 times the mass of a free carbon 12 atom, at rest and in its ground state. 1 Da = 1 u\n         */\n    }\n\n    /* ISO-80000-10 item 10-5.1 elementary charge */\n    attribute elementaryCharge: ElectricChargeValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-5.1 elementary charge\n         * symbol(s): `e`\n         * application domain: generic\n         * name: ElementaryCharge (specializes ElectricCharge)\n         * quantity dimension: T^1*I^1\n         * measurement unit(s): C, s*A\n         * tensor order: 0\n         * definition: one of the fundamental constants in the SI system (ISO 80000-1), equal to the charge of the proton and opposite to the charge of the electron\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-5.2 charge number, ionization number */\n    attribute def ChargeNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-5.2 charge number, ionization number\n         * symbol(s): `c`\n         * application domain: generic\n         * name: ChargeNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for a particle, quotient of the electric charge (IEC 80000-6) and the elementary charge (ISO 80000-1)\n         * remarks: A particle is said to be electrically neutral if its charge number is equal to zero. The charge number of a particle can be positive, negative, or zero. The state of charge of a particle may be presented as a superscript to the symbol of that particle, e.g. `H^+, He^(++), Al^(3+), Cl^-, S^(--), N^(3-)`.\n         */\n    }\n    attribute chargeNumber: ChargeNumberValue :> scalarQuantities;\n\n    alias ionizationNumber for chargeNumber;\n\n    /* ISO-80000-10 item 10-6 Bohr radius */\n    attribute bohrRadius: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-6 Bohr radius\n         * symbol(s): `a_0`\n         * application domain: generic\n         * name: BohrRadius (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m, \xC5\n         * tensor order: 0\n         * definition: radius (ISO 80000-3) of the electron orbital in the hydrogen atom in its ground state in the Bohr model of the atom: `a_0 = (4 \u03C0 \u03B5_0 \u210F^2)/(m_e e^2)` where `\u03B5_0` is the electric constant (IEC 80000-6), `\u210F` is the reduced Planck constant (ISO 80000-1), `m_e` is the rest mass (item 10-2) of electron, and `e` is the elementary charge (ISO 80000-1)\n         * remarks: The radius of the electron orbital in the H atom in its ground state is `a_0` in the Bohr model of the atom. \xE5ngstr\xF6m (\xC5), `1 \xC5 := 10^-10 m`.\n         */\n    }\n\n    /* ISO-80000-10 item 10-7 Rydberg constant */\n    attribute def RydbergConstantValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-7 Rydberg constant\n         * symbol(s): `R_\u221E`\n         * application domain: generic\n         * name: RydbergConstant\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: spectroscopic constant that determines the wave numbers of the lines in the spectrum of hydrogen: `R_(oo) = e^2/(8 \u03C0 \u03B5_0 a_0 h c_0)` where `e` is the elementary charge (ISO 80000-1), `\u03B5_0` is the electric constant (IEC 80000-6), `a_0` is the Bohr radius (item 10-6), `h` is the Planck constant (ISO 80000-1), and `c_0` is the speed of light in vacuum (ISO 80000-1)\n         * remarks: The quantity `R_y = R_\u221E h c_0` is called the Rydberg energy.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RydbergConstantUnit[1];\n    }\n\n    attribute rydbergConstant: RydbergConstantValue[*] nonunique :> scalarQuantities;\n\n    attribute def RydbergConstantUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-10 item 10-8 Hartree energy */\n    attribute def HartreeEnergyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-8 Hartree energy\n         * symbol(s): `E_H`, `E_h`\n         * application domain: generic\n         * name: HartreeEnergy\n         * quantity dimension: L^6*M^3*T^-6\n         * measurement unit(s): eV*J*kg*m^2*s^-2\n         * tensor order: 0\n         * definition: energy (ISO 80000-5) of the electron in a hydrogen atom in its ground state: `E_H = e^2/(4 \u03C0 \u03B5_0 a_0)` where `e` is the elementary charge (ISO 80000-1), `\u03B5_0` is the electric constant (IEC 80000-6), and `a_0` is the Bohr radius (item 10-6)\n         * remarks: The energy of the electron in an H atom in its ground state is `E_H`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: HartreeEnergyUnit[1];\n    }\n\n    attribute hartreeEnergy: HartreeEnergyValue[*] nonunique :> scalarQuantities;\n\n    attribute def HartreeEnergyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 6; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -6; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-9.1 magnetic dipole moment */\n    attribute def MagneticDipoleMomentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-9.1 magnetic dipole moment (magnitude)\n         * symbol(s): `\u03BC`\n         * application domain: atomic physics\n         * name: MagneticDipoleMoment\n         * quantity dimension: L^2*I^1\n         * measurement unit(s): m^2*A\n         * tensor order: 0\n         * definition: for a particle, vector (ISO 80000-2) quantity causing a change to its energy (ISO 80000-5) `\u0394W` in an external magnetic field of field flux density `vec(B)` (IEC 80000-6): `\u0394W` = -`vec(\u03BC)` \xB7 `vec(B)`\n         * remarks: For an atom or nucleus, this energy is quantized and can be written as: `W` = `g \u03BC_x M B` where `g` is the appropriate `g` factor (item 10-14.1 or item 10-14.2), `\u03BC_x` is mostly the Bohr magneton or nuclear magneton (item 10-9.2 or item 10-9.3), `M` is magnetic quantum number (item 10-13.4), and `B` is magnitude of the magnetic flux density. See also IEC 80000-6.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticDipoleMomentUnit[1];\n    }\n\n    attribute magneticDipoleMoment: MagneticDipoleMomentValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticDipoleMomentUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianMagneticDipoleMoment3dVector :> \'3dVectorQuantityValue\' {\n        doc\n        /*\n         * source: item 10-9.1 magnetic dipole moment (vector)\n         * symbol(s): `vec(\u03BC)`\n         * application domain: atomic physics\n         * name: MagneticDipoleMoment\n         * quantity dimension: L^2*I^1\n         * measurement unit(s): m^2*A\n         * tensor order: 1\n         * definition: for a particle, vector (ISO 80000-2) quantity causing a change to its energy (ISO 80000-5) `\u0394W` in an external magnetic field of field flux density `vec(B)` (IEC 80000-6): `\u0394W` = -`vec(\u03BC)` \xB7 `vec(B)`\n         * remarks: For an atom or nucleus, this energy is quantized and can be written as: `W` = `g \u03BC_x M B` where `g` is the appropriate `g` factor (item 10-14.1 or item 10-14.2), `\u03BC_x` is mostly the Bohr magneton or nuclear magneton (item 10-9.2 or item 10-9.3), `M` is magnetic quantum number (item 10-13.4), and `B` is magnitude of the magnetic flux density. See also IEC 80000-6.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMagneticDipoleMoment3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMagneticDipoleMoment3dVector: CartesianMagneticDipoleMoment3dVector :> vectorQuantities;\n\n    attribute def CartesianMagneticDipoleMoment3dCoordinateFrame :> \'3dCoordinateFrame\' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MagneticDipoleMomentUnit[3];\n    }\n\n    /* ISO-80000-10 item 10-9.2 Bohr magneton */\n    attribute bohrMagneton: MagneticDipoleMomentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-9.2 Bohr magneton\n         * symbol(s): `\u03BC_B`\n         * application domain: generic\n         * name: BohrMagneton (specializes MagneticDipoleMoment)\n         * quantity dimension: L^2*I^1\n         * measurement unit(s): m^2*A\n         * tensor order: 0\n         * definition: magnitude of the magnetic moment of an electron in a state with orbital angular momentum quantum number `l`=1 (item 10-13.3) due to its orbital motion: `\u03BC_B = (e \u210F)/(2 m_e)` where `e` is the elementary charge (ISO 80000-1), `\u210F` is the reduced Planck constant (ISO 80000-1), and `m_e` is the rest mass (item 10-2) of electron\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-9.3 nuclear magneton */\n    attribute nuclearMagneton: MagneticDipoleMomentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-9.3 nuclear magneton\n         * symbol(s): `\u03BC_N`\n         * application domain: generic\n         * name: NuclearMagneton (specializes MagneticDipoleMoment)\n         * quantity dimension: L^2*I^1\n         * measurement unit(s): m^2*A\n         * tensor order: 0\n         * definition: absolute value of the magnetic moment of a nucleus: `\u03BC_N = (e \u210F)/(2 m_p)` where `e` is the elementary charge (ISO 80000-1), `\u210F` is the reduced Planck constant (ISO 80000-1), and `m_p` is the rest mass (item 10-2) of proton\n         * remarks: Subscript N stands for nucleus. For the neutron magnetic moment, subscript n is used. The magnetic moments of protons and neutrons differ from this quantity by their specific `g` factors (item 10-14.2).\n         */\n    }\n\n    /* ISO-80000-10 item 10-10 spin */\n    attribute def SpinValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-10 spin (magnitude)\n         * symbol(s): `s`\n         * application domain: generic\n         * name: Spin\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): kg*m^2*s^-1\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity expressing the internal angular momentum (ISO 80000-4) of a particle or a particle system\n         * remarks: Spin is an additive vector quantity.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpinUnit[1];\n    }\n\n    attribute spin: SpinValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpinUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianSpin3dVector :> \'3dVectorQuantityValue\' {\n        doc\n        /*\n         * source: item 10-10 spin (vector)\n         * symbol(s): `vec(s)`\n         * application domain: generic\n         * name: Spin\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): kg*m^2*s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity expressing the internal angular momentum (ISO 80000-4) of a particle or a particle system\n         * remarks: Spin is an additive vector quantity.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianSpin3dCoordinateFrame[1];\n    }\n\n    attribute cartesianSpin3dVector: CartesianSpin3dVector :> vectorQuantities;\n\n    attribute def CartesianSpin3dCoordinateFrame :> \'3dCoordinateFrame\' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: SpinUnit[3];\n    }\n\n    /* ISO-80000-10 item 10-11 total angular momentum */\n    attribute def TotalAngularMomentumValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-11 total angular momentum (magnitude)\n         * symbol(s): `J`\n         * application domain: generic\n         * name: TotalAngularMomentum\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): J*s*eV*s, kg*m^2*s^-1\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity in a quantum system composed of the vectorial sum of angular momentum `vec(L)` (ISO 80000-4) and spin `vec(s)` (item 10-10)\n         * remarks: In atomic and nuclear physics, orbital angular momentum is usually denoted by `vec(l)` or `vec(L)`. The magnitude of `vec(J)` is quantized so that: `J^2 = \u210F^2 j (j+1)` where `j` is the total angular momentum quantum number (item 10-13.6). Total angular momentum and magnetic dipole moment have the same direction. `j` is not the magnitude of the total angular momentum `vec(J)` but its projection onto the quantization axis, divided by `\u210F`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TotalAngularMomentumUnit[1];\n    }\n\n    attribute totalAngularMomentum: TotalAngularMomentumValue[*] nonunique :> scalarQuantities;\n\n    attribute def TotalAngularMomentumUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianTotalAngularMomentum3dVector :> \'3dVectorQuantityValue\' {\n        doc\n        /*\n         * source: item 10-11 total angular momentum (vector)\n         * symbol(s): `vec(J)`\n         * application domain: generic\n         * name: TotalAngularMomentum\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): J*s*eV*s, kg*m^2*s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity in a quantum system composed of the vectorial sum of angular momentum `vec(L)` (ISO 80000-4) and spin `vec(s)` (item 10-10)\n         * remarks: In atomic and nuclear physics, orbital angular momentum is usually denoted by `vec(l)` or `vec(L)`. The magnitude of `vec(J)` is quantized so that: `J^2 = \u210F^2 j (j+1)` where `j` is the total angular momentum quantum number (item 10-13.6). Total angular momentum and magnetic dipole moment have the same direction. `j` is not the magnitude of the total angular momentum `vec(J)` but its projection onto the quantization axis, divided by `\u210F`.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianTotalAngularMomentum3dCoordinateFrame[1];\n    }\n\n    attribute cartesianTotalAngularMomentum3dVector: CartesianTotalAngularMomentum3dVector :> vectorQuantities;\n\n    attribute def CartesianTotalAngularMomentum3dCoordinateFrame :> \'3dCoordinateFrame\' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: TotalAngularMomentumUnit[3];\n    }\n\n    /* ISO-80000-10 item 10-12.1 gyromagnetic ratio, magnetogyric ratio, gyromagnetic coefficient */\n    attribute def GyromagneticRatioValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-12.1 gyromagnetic ratio, magnetogyric ratio, gyromagnetic coefficient\n         * symbol(s): `\u03B3`\n         * application domain: generic\n         * name: GyromagneticRatio\n         * quantity dimension: M^-1*T^1*I^1\n         * measurement unit(s): A*m^2*J^-1*s^-1, A*s/kg, kg^-1*s*A\n         * tensor order: 0\n         * definition: proportionality constant between the magnetic dipole moment and the angular momentum: `vec(\u03BC)` = `\u03B3` `vec(J)` where `vec(\u03BC)` is the magnetic dipole moment (item 10-9.1), and `vec(J)` is the total angular momentum (item 10-11)\n         * remarks: 1 A\xB7m^2/(J\xB7s) = 1 A\xB7s/kg = 1 T^-1\xB7s^-1 The systematic name is "gyromagnetic coefficient", but "gyromagnetic ratio" is more usual. The gyromagnetic ratio of the proton is denoted by `\u03B3_p`. The gyromagnetic ratio of the neutron is denoted by `\u03B3_n`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: GyromagneticRatioUnit[1];\n    }\n\n    attribute gyromagneticRatio: GyromagneticRatioValue[*] nonunique :> scalarQuantities;\n\n    attribute def GyromagneticRatioUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, electricCurrentPF); }\n    }\n\n    alias MagnetogyricRatioUnit for GyromagneticRatioUnit;\n    alias MagnetogyricRatioValue for GyromagneticRatioValue;\n    alias magnetogyricRatio for gyromagneticRatio;\n\n    alias GyromagneticCoefficientUnit for GyromagneticRatioUnit;\n    alias GyromagneticCoefficientValue for GyromagneticRatioValue;\n    alias gyromagneticCoefficient for gyromagneticRatio;\n\n    /* ISO-80000-10 item 10-12.2 gyromagnetic ratio of the electron, magnetogyric ratio of the electron, gyromagnetic coefficient of the electron */\n    attribute def GyromagneticRatioOfTheElectronValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-12.2 gyromagnetic ratio of the electron, magnetogyric ratio of the electron, gyromagnetic coefficient of the electron\n         * symbol(s): `\u03B3_e`\n         * application domain: generic\n         * name: GyromagneticRatioOfTheElectron\n         * quantity dimension: M^-1*T^1*I^1\n         * measurement unit(s): A*m^2*J^-1*s^-1, A*s/kg, kg^-1*s*A\n         * tensor order: 0\n         * definition: proportionality constant between the magnetic dipole moment and the angular momentum of the electron `vec(\u03BC)` = `\u03B3_e` `vec(J)` where `vec(\u03BC)` is the magnetic dipole moment (item 10-9.1), and `vec(J)` is the total angular momentum (item 10-11)\n         * remarks: 1 A\xB7m^2/(J\xB7s) = 1 A\xB7s/kg = 1 T^-1\xB7s^-1\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: GyromagneticRatioOfTheElectronUnit[1];\n    }\n\n    attribute gyromagneticRatioOfTheElectron: GyromagneticRatioOfTheElectronValue[*] nonunique :> scalarQuantities;\n\n    attribute def GyromagneticRatioOfTheElectronUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, electricCurrentPF); }\n    }\n\n    alias MagnetogyricRatioOfTheElectronUnit for GyromagneticRatioOfTheElectronUnit;\n    alias MagnetogyricRatioOfTheElectronValue for GyromagneticRatioOfTheElectronValue;\n    alias magnetogyricRatioOfTheElectron for gyromagneticRatioOfTheElectron;\n\n    alias GyromagneticCoefficientOfTheElectronUnit for GyromagneticRatioOfTheElectronUnit;\n    alias GyromagneticCoefficientOfTheElectronValue for GyromagneticRatioOfTheElectronValue;\n    alias gyromagneticCoefficientOfTheElectron for gyromagneticRatioOfTheElectron;\n\n    /* ISO-80000-10 item 10-13.1 quantum number */\n    attribute def QuantumNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-13.1 quantum number\n         * symbol(s): `N`, `L`, `M`, `j`, `s`, `F`\n         * application domain: generic\n         * name: QuantumNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number describing a particular state of a quantum system\n         * remarks: Electron states determine the binding energy `E = E(n,l,m,j,s,f)` in an atom. Upper case letters `N, L, M, J, S, F` are usually used for the whole system. The spatial probability distribution of an electron is given by `|\u03A8|^2`, where `\u03A8` is its wave function. For an electron in an H atom in a non-relativistic approximation, the wave function can be presented as: `\u03A8(r,\u03B8,\u03C6) = R_(nl)(r)*Y_l^m(\u03B8,\u03C6)`, where `r,\u03B8,\u03C6` are spherical coordinates (ISO 80000-2) with respect to the nucleus and to a given (quantization) axis, `R_(nl)(r)` is the radial distribution function, and `Y_l^m(\u03B8,\u03C6)` are spherical harmonics. In the Bohr model of one-electron atoms, `n`, `l`, and `m` define the possible orbits of an electron about the nucleus.\n         */\n    }\n    attribute quantumNumber: QuantumNumberValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-13.2 principal quantum number */\n    attribute principalQuantumNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-13.2 principal quantum number\n         * symbol(s): `n`\n         * application domain: generic\n         * name: PrincipalQuantumNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: atomic quantum number related to the number `n`-1 of radial nodes of one-electron wave functions\n         * remarks: In the Bohr model, `n = 1,2,\u2026,\u221E` is related to the binding energy of an electron and the radius of spherical orbits (principal axis of the elliptic orbits). For an electron in an H atom, the semi-classical radius of its orbit is `r_n = a_0 n^2` and its binding energy is `E_n = E_H/n^2`.\n         */\n    }\n\n    /* ISO-80000-10 item 10-13.3 orbital angular momentum quantum number */\n    attribute orbitalAngularMomentumQuantumNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-13.3 orbital angular momentum quantum number\n         * symbol(s): `l`, `l_i`, `L`\n         * application domain: generic\n         * name: OrbitalAngularMomentumQuantumNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: atomic quantum number related to the orbital angular momentum `l` of a one-electron state\n         * remarks: `abs(l)^2 = \u210F^2 l (l-1)` , `l = 0, 1, \u2026, n-1` where `vec(l)` is the orbital angular momentum and `\u210F` is the reduced Planck constant (ISO 80000-1). If reference is made to a specific particle `i`, the symbol `l_i` is used instead of `l`; if reference is made to the whole system, the symbol `L` is used instead of `l`. An electron in an H atom for `l = 0` appears as a spherical cloud. In the Bohr model, it is related to the form of the orbit.\n         */\n    }\n\n    /* ISO-80000-10 item 10-13.4 magnetic quantum number */\n    attribute magneticQuantumNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-13.4 magnetic quantum number\n         * symbol(s): `m`, `m_i`, `M`\n         * application domain: generic\n         * name: MagneticQuantumNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: atomic quantum number related to the `z` component `l_z`, `j_z` or `s_z`, of the orbital, total, or spin angular momentum\n         * remarks: `l_z = m_l \u210F` , `j_z = m_j \u210F` , and `s_z = m_s \u210F` , with the ranges from `-l` to `l`, from `-j` to `j`, and `\xB11/2`, respectively. `m_i` refers to a specific particle `i`. `M` is used for the whole system. Subscripts `l`, `s`, `j`, etc., as appropriate, indicate the angular momentum involved. `\u210F` is the reduced Planck constant (ISO 80000-1).\n         */\n    }\n\n    /* ISO-80000-10 item 10-13.5 spin quantum number */\n    attribute spinQuantumNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-13.5 spin quantum number\n         * symbol(s): `s`\n         * application domain: generic\n         * name: SpinQuantumNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: characteristic quantum number `s` of a particle, related to its spin (item 10-10), `vec(s)`: `s^2 = \u210F^2 s (s+1)` where `\u210F` is the reduced Planck constant (ISO 80000-1)\n         * remarks: Spin quantum numbers of fermions are odd multiples of 1/2, and those of bosons are integers.\n         */\n    }\n\n    /* ISO-80000-10 item 10-13.6 total angular momentum quantum number */\n    attribute totalAngularMomentumQuantumNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-13.6 total angular momentum quantum number\n         * symbol(s): `j`, `j_i`, `J`\n         * application domain: generic\n         * name: TotalAngularMomentumQuantumNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantum number in an atom describing the magnitude of total angular momentum `vec(J)` (item 10-11)\n         * remarks: `j_i` refers to a specific particle `i`; `J` is used for the whole system. The quantum number `J` and the magnitude of total angular momentum `vec(J)` (item 10-11) are different quantities. The two values of `j` are `l`\xB11/2. (See item 10-13.3.)\n         */\n    }\n\n    /* ISO-80000-10 item 10-13.7 nuclear spin quantum number */\n    attribute nuclearSpinQuantumNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-13.7 nuclear spin quantum number\n         * symbol(s): `I`\n         * application domain: generic\n         * name: NuclearSpinQuantumNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantum number related to the total angular momentum (item 10-11), `vec(J)`, of a nucleus in any specified state, normally called nuclear spin: `vec(J)^2 = \u210F^2 I (I+1)` where `\u210F` is the reduced Planck constant (ISO 80000-1)\n         * remarks: Nuclear spin is composed of spins of the nucleons (protons and neutrons) and their (orbital) motions. In principle there is no upper limit for the nuclear spin quantum number. It has possible values `I` = 0,1,2,\u2026 for even `A` and `I = 1/2, 3/2, \u2026` for odd `A`. In nuclear and particle physics, `vec(J)` is often used.\n         */\n    }\n\n    /* ISO-80000-10 item 10-13.8 hyperfine structure quantum number */\n    attribute hyperfineStructureQuantumNumber: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-13.8 hyperfine structure quantum number\n         * symbol(s): `F`\n         * application domain: generic\n         * name: HyperfineStructureQuantumNumber (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantum number of an atom describing the inclination of the nuclear spin with respect to a quantization axis given by the magnetic field produced by the orbital electrons\n         * remarks: The interval of `F` is \u2502`I`-`J`\u2502, \u2502`I`-`J`\u2502+1, ..., `I`-`J`. This is related to the hyperfine splitting of the atomic energy levels due to the interaction between the electron and nuclear magnetic moments.\n         */\n    }\n\n    /* ISO-80000-10 item 10-14.1 Lande factor, g factor of atom */\n    attribute def LandeFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-14.1 Lande factor, g factor of atom\n         * symbol(s): `g`\n         * application domain: generic\n         * name: LandeFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the magnetic dipole moment of an atom, and the product of the total angular momentum quantum number and the Bohr magneton: `g = \u03BC/(J*\u03BC_B)` where `\u03BC` is magnitude of magnetic dipole moment (item 10-9.1), `J` is total angular momentum quantum number (item 10-13.6), and `\u03BC_B` is the Bohr magneton (item 10-9.2)\n         * remarks: These quantities are also called `g` values. The Land\xE9 factor can be calculated from the expression: `g(L, S, J) = 1 + (g_e -1) xx (J(J+1) + S(S+1) - L(L+1))/(2J(J+1))` where `g_e` is the` g` factor of the electron.\n         */\n    }\n    attribute landeFactor: LandeFactorValue :> scalarQuantities;\n\n    alias gFactorOfAtom for landeFactor;\n\n    /* ISO-80000-10 item 10-14.2 g factor of nucleus or nuclear particle */\n    attribute def GFactorOfNucleusOrNuclearParticleValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-14.2 g factor of nucleus or nuclear particle\n         * symbol(s): `g`\n         * application domain: generic\n         * name: GFactorOfNucleusOrNuclearParticle (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the magnetic dipole moment of an atom, and the product of the nuclear spin quantum number and the nuclear magneton: `g = \u03BC/(I*\u03BC_N)` where `\u03BC` is magnitude of magnetic dipole moment (item 10-9.1), `I` is nuclear spin quantum number (item 10-13.7), and `\u03BC_N` is the nuclear magneton (item 10-9.3)\n         * remarks: The `g` factors for nuclei or nucleons are known from measurements.\n         */\n    }\n    attribute gFactorOfNucleusOrNuclearParticle: GFactorOfNucleusOrNuclearParticleValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-15.1 Larmor angular frequency */\n    attribute larmorAngularFrequency: AngularFrequencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-15.1 Larmor angular frequency\n         * symbol(s): `\u03C9_L`\n         * application domain: generic\n         * name: LarmorAngularFrequency (specializes AngularFrequency)\n         * quantity dimension: T^-1\n         * measurement unit(s): rad*s^-1, s^-1\n         * tensor order: 0\n         * definition: angular frequency (ISO 80000-3) of the electron angular momentum (ISO 80000-4) vector precession about the axis of an external magnetic field: `\u03C9_L = e/(2 m_e) B` where `e` is the elementary charge (ISO 80000-1), `m_e` is the rest mass (item 10-2) of electron, and `B` is magnetic flux density (IEC 80000-6)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-15.2 Larmor frequency */\n    attribute def LarmorFrequencyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-15.2 Larmor frequency\n         * symbol(s): `\u03BD_L`\n         * application domain: generic\n         * name: LarmorFrequency\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: quotient of Larmor angular frequency (ISO 80000-3) and 2\u03C0\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LarmorFrequencyUnit[1];\n    }\n\n    attribute larmorFrequency: LarmorFrequencyValue[*] nonunique :> scalarQuantities;\n\n    attribute def LarmorFrequencyUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-10 item 10-15.3 nuclear precession angular frequency */\n    attribute nuclearPrecessionAngularFrequency: AngularFrequencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-15.3 nuclear precession angular frequency\n         * symbol(s): `\u03C9_N`\n         * application domain: generic\n         * name: NuclearPrecessionAngularFrequency (specializes AngularFrequency)\n         * quantity dimension: T^-1\n         * measurement unit(s): rad*s^-1, s^-1\n         * tensor order: 0\n         * definition: frequency (ISO 80000-3) by which the nucleus angular momentum vector (ISO 80000-4) precesses about the axis of an external magnetic field: `\u03C9_N` = `\u03B3` `B` where `\u03B3` is the gyromagnetic ratio (item 10-12.1), and `B` is magnetic flux density (IEC 80000-6)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-16 cyclotron angular frequency */\n    attribute cyclotronAngularFrequency: AngularFrequencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-16 cyclotron angular frequency\n         * symbol(s): `\u03C9_c`\n         * application domain: generic\n         * name: CyclotronAngularFrequency (specializes AngularFrequency)\n         * quantity dimension: T^-1\n         * measurement unit(s): rad*s^-1, s^-1\n         * tensor order: 0\n         * definition: quotient of the product of the electric charge of a particle and the magnitude of the magnetic flux density of the magnetic field, and the particle mass: `\u03C9_c = abs(q)/m B` where `q` is the electric charge (IEC 80000-6) of the particle, `m` is the mass (ISO 80000-4) of the particle, and `B` is the absolute value of the magnetic flux density (IEC 80000-6)\n         * remarks: The quantity `v_c` = `\u03C9_c`/2\u03C0 is called the cyclotron frequency.\n         */\n    }\n\n    /* ISO-80000-10 item 10-17 gyroradius, Larmor radius */\n    attribute gyroradius: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-17 gyroradius, Larmor radius\n         * symbol(s): `r_g`, `r_L`\n         * application domain: generic\n         * name: Gyroradius (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: radius (ISO 80000-3) of circular movement of a particle with mass (ISO 80000-4), velocity `vec(v)` (ISO 80000-3), and electric charge `q` (IEC 80000-6), moving in a magnetic field with magnetic flux density `vec(B)` (IEC 80000-6): `r_g = (m abs(vec(v) xx vec(B)))/(q B^2)`\n         * remarks: None.\n         */\n    }\n\n    alias larmorRadius for gyroradius;\n\n    /* ISO-80000-10 item 10-18 nuclear quadrupole moment */\n    attribute def NuclearQuadrupoleMomentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-18 nuclear quadrupole moment\n         * symbol(s): `Q`\n         * application domain: generic\n         * name: NuclearQuadrupoleMoment\n         * quantity dimension: L^2\n         * measurement unit(s): m^2\n         * tensor order: 0\n         * definition: `z` component of the diagonalized tensor of nuclear quadrupole moment: `Q = (1/e) int (3z^2 - r^2) \u03C1(x, y, z) dV` in the quantum state with the nuclear spin in the field direction (`z`), where `e` is the elementary charge (ISO 80000-1), `r^2 = x^2 + y^2 + z^2`, `\u03C1(x,y,z)` is the nuclear electric charge density (IEC 80000-6), and `dV` is the volume element `dx dy dz`\n         * remarks: The electric nuclear quadrupole moment is `eQ`. This value is equal to the `z` component of the diagonalized tensor of quadrupole moment.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: NuclearQuadrupoleMomentUnit[1];\n    }\n\n    attribute nuclearQuadrupoleMoment: NuclearQuadrupoleMomentValue[*] nonunique :> scalarQuantities;\n\n    attribute def NuclearQuadrupoleMomentUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-10 item 10-19.1 nuclear radius */\n    attribute nuclearRadius: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-19.1 nuclear radius\n         * symbol(s): `R`\n         * application domain: generic\n         * name: NuclearRadius (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: conventional radius (ISO 80000-3) of sphere in which the nuclear matter is included\n         * remarks: This quantity is not exactly defined. It is given approximately for nuclei in their ground state by: `R = r_0 A^(1//3)` where `r_0 ~~ 1.2 * 10^-15` m, and `A` is the nucleon number (item 10-1.3). Nuclear radius is usually expressed in femtometres, 1 fm = 10^(-15) m.\n         */\n    }\n\n    /* ISO-80000-10 item 10-19.2 electron radius */\n    attribute electronRadius: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-19.2 electron radius\n         * symbol(s): `r_e`\n         * application domain: generic\n         * name: ElectronRadius (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: radius of a sphere such that the relativistic electron energy is distributed uniformly: `r_e = e^2/(4 \u03C0 \u03B5_0 m_e c_0^2)` where `e` is the elementary charge (ISO 80000-1), `\u03B5_0` is the electric constant (IEC 80000-6), `m_e` is the rest mass (item 10-2) of electron, and `c_0` is the speed of light in vacuum (ISO 80000-1)\n         * remarks: This quantity corresponds to the electrostatic energy `E` of a charge distributed inside a sphere of radius `r_e` as if all the rest energy (item 10-3) of the electron were attributed to the energy of electromagnetic origin, using the relation `E = m_e c_0^2`.\n         */\n    }\n\n    /* ISO-80000-10 item 10-20 Compton wavelength */\n    attribute comptonWavelength: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-20 Compton wavelength\n         * symbol(s): `\u03BB_C`\n         * application domain: generic\n         * name: ComptonWavelength (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: quotient of the Planck constant and the product of the mass of the particle and the speed of light in vacuum: `\u03BB_C = h / (m c_0)` where `h` is the Planck constant (ISO 80000-1), `m` is the rest mass (item 10-2) of a particle, and `c_0` is the speed of light in vacuum (ISO 80000-1)\n         * remarks: The wavelength of electromagnetic radiation scattered from free electrons (Compton scattering) is larger than that of the incident radiation by a maximum of 2`\u03BB_C`.\n         */\n    }\n\n    /* ISO-80000-10 item 10-21.1 mass excess */\n    attribute massExcess: MassValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-21.1 mass excess\n         * symbol(s): `\u0394`\n         * application domain: generic\n         * name: MassExcess (specializes Mass)\n         * quantity dimension: M^1\n         * measurement unit(s): kg, Da, u\n         * tensor order: 0\n         * definition: difference between the mass of an atom, and the product of its mass number and the unified mass constant: `\u0394 = m_a - A*m_u`, where `m_a` is the rest mass (item 10-2) of the atom, `A` is its nucleon number (item 10-1.3), and `m_u` is the unified atomic mass constant (item 10-4.3)\n         * remarks: The mass excess is usually expressed in daltons, 1 Da = 1 u. See item 10-2.\n         */\n    }\n\n    /* ISO-80000-10 item 10-21.2 mass defect */\n    attribute massDefect: MassValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-21.2 mass defect\n         * symbol(s): `B`\n         * application domain: generic\n         * name: MassDefect (specializes Mass)\n         * quantity dimension: M^1\n         * measurement unit(s): kg, Da, u\n         * tensor order: 0\n         * definition: sum of the product of the proton number and the hydrogen atomic mass, and the neutron rest mass, minus the rest mass of the atom: `B = Z*m(\u2062^1"H") + N*m_n - m_a` where `Z` is the proton number (item 10-1.1) of the atom, `m(\u2062^1"H")` is atomic mass (item 10-4.1) of `\u2062^1"H"`, `N` is neutron number (item 10-1.2), `m_n` is the rest mass (item 10-2) of the neutron, and `m_a` is the rest mass (item 10-2) of the atom\n         * remarks: The mass excess is usually expressed in daltons, 1 Da = 1 u. If the binding energy of the orbital electrons is neglected, `B c_0^2` is equal to the binding energy of the nucleus.\n         */\n    }\n\n    /* ISO-80000-10 item 10-22.1 relative mass excess */\n    attribute def RelativeMassExcessValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-22.1 relative mass excess\n         * symbol(s): `\u0394_r`\n         * application domain: generic\n         * name: RelativeMassExcess (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mass excess and the unified atomic mass constant: `\u0394_r = \u0394/m_u` where `\u0394` is mass excess (item 10-21.1), and `m_u` is the unified atomic mass constant (item 10-4.3)\n         * remarks: None.\n         */\n    }\n    attribute relativeMassExcess: RelativeMassExcessValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-22.2 relative mass defect */\n    attribute def RelativeMassDefectValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-22.2 relative mass defect\n         * symbol(s): `B_r`\n         * application domain: generic\n         * name: RelativeMassDefect (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mass defect and the unified atomic mass constant: `B_r = B/m_u` where `B` is mass defect (item 10-21.2), and `m_u` is the unified atomic mass constant (item 10-4.3)\n         * remarks: None.\n         */\n    }\n    attribute relativeMassDefect: RelativeMassDefectValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-23.1 packing fraction */\n    attribute def PackingFractionValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-23.1 packing fraction\n         * symbol(s): `f`\n         * application domain: generic\n         * name: PackingFraction (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of relative mass excess and the nucleon number: `f` = \u0394_r/A` where `\u0394_r` is relative mass excess (item 10-22.1), and `A` is the nucleon number (item 10-1.3)\n         * remarks: None.\n         */\n    }\n    attribute packingFraction: PackingFractionValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-23.2 binding fraction */\n    attribute def BindingFractionValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-23.2 binding fraction\n         * symbol(s): `b`\n         * application domain: generic\n         * name: BindingFraction (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of relative mass defect and the nucleon number: `b = B_r/A` where `B_r` is relative mass defect (item 10-22.2), and `A` is the nucleon number (item 10-1.3)\n         * remarks: None.\n         */\n    }\n    attribute bindingFraction: BindingFractionValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-24 decay constant, disintegration constant */\n    attribute def DecayConstantValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-24 decay constant, disintegration constant\n         * symbol(s): `\u03BB`\n         * application domain: generic\n         * name: DecayConstant\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: quotient of `(-dN)/N` and `dt`, where `(dN)/N` is the mean fractional change in the number of nuclei in a particular energy state due to spontaneous transformations in a time interval of duration (ISO 80000-3) `dt`: `\u03BB = -1/N (dN)/(dt)`\n         * remarks: For exponential decay, this quantity is constant. For more than one decay channel, `\u03BB = sum \u03BB_a` where `\u03BB_a` denotes the decay constant for a specified final state and the sum is taken over all final states.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DecayConstantUnit[1];\n    }\n\n    attribute decayConstant: DecayConstantValue[*] nonunique :> scalarQuantities;\n\n    attribute def DecayConstantUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    alias DisintegrationConstantUnit for DecayConstantUnit;\n    alias DisintegrationConstantValue for DecayConstantValue;\n    alias disintegrationConstant for decayConstant;\n\n    /* ISO-80000-10 item 10-25 mean duration of life, mean life time */\n    attribute meanDurationOfLife: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-25 mean duration of life, mean life time\n         * symbol(s): `\u03C4`\n         * application domain: atomic and nuclear physics\n         * name: MeanDurationOfLife (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: reciprocal of the decay constant `\u03BB` (item 10-24): `\u03C4 = 1/\u03BB`\n         * remarks: Mean duration of life is the expected value of the duration of life of an unstable particle or an excited state of a particle when the number of decay events in a short time interval follows a Poisson distribution.\n         */\n    }\n\n    alias meanLifeTime for meanDurationOfLife;\n\n    /* ISO-80000-10 item 10-26 level width */\n    attribute levelWidth: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-26 level width\n         * symbol(s): `\u0393`\n         * application domain: generic\n         * name: LevelWidth (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: quotient of the reduced Planck constant and the mean life: `\u0393 = \u210F/\u03C4` where `\u210F` is the reduced Planck constant (ISO 80000-1), and `\u03C4` is mean duration of life (item 10-25)\n         * remarks: Level width is the uncertainty of the energy of an unstable particle or an excited state of a system due to the Heisenberg principle. The term energy level refers to the configuration of the distribution function of the density of states. Energy levels may be considered as discrete, like those in an atom, or may have a finite width, like e.g. this item or like e.g. the valence or conduction band in solid state physics. Energy levels are applicable to both real and virtual particles, e.g. electrons and phonons, respectively.\n         */\n    }\n\n    /* ISO-80000-10 item 10-27 nuclear activity */\n    attribute def NuclearActivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-27 nuclear activity\n         * symbol(s): `A`\n         * application domain: generic\n         * name: NuclearActivity\n         * quantity dimension: T^-1\n         * measurement unit(s): Bq, s^-1\n         * tensor order: 0\n         * definition: differential quotient of `N` with respect to time, where `N` is the mean change in the number of nuclei in a particular energy state due to spontaneous nuclear transformations in a time interval of duration (ISO 80000-3) `dt`: `A = -(dN)/(dt)`\n         * remarks: For exponential decay, `A = \u03BBN`, where `\u03BB` is the decay constant (item 10-24). The becquerel (Bq) is a special name for second to the power minus one, to be used as the coherent SI unit of activity. In report 85a of the ICRU a definition with an equivalent meaning is given as: The activity, `A`, of an amount of a radionuclide in a particular energy state at a given time is the quotient of `-dN` by `dt`, where `dN` is the mean change in the number of nuclei in that energy state due to spontaneous nuclear transformations in the time interval `dt`: `A = -(dN)/(dt)`. See also section 0.3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: NuclearActivityUnit[1];\n    }\n\n    attribute nuclearActivity: NuclearActivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def NuclearActivityUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-10 item 10-28 specific activity, massic activity */\n    attribute def SpecificActivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-28 specific activity, massic activity\n         * symbol(s): `a`\n         * application domain: generic\n         * name: SpecificActivity\n         * quantity dimension: M^-1*T^-1\n         * measurement unit(s): Bq/kg, kg^-1*s^-1\n         * tensor order: 0\n         * definition: quotient of the activity `A` (item 10-27) of a sample and the mass `m` (ISO 80000-4) of that sample: `a = A/m`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificActivityUnit[1];\n    }\n\n    attribute specificActivity: SpecificActivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificActivityUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    alias MassicActivityUnit for SpecificActivityUnit;\n    alias MassicActivityValue for SpecificActivityValue;\n    alias massicActivity for specificActivity;\n\n    /* ISO-80000-10 item 10-29 activity density, volumic activity, activity concentration */\n    attribute def ActivityDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-29 activity density, volumic activity, activity concentration\n         * symbol(s): `c_A`\n         * application domain: generic\n         * name: ActivityDensity\n         * quantity dimension: L^-3*T^-1\n         * measurement unit(s): Bq/m^3, m^-3*s^-1\n         * tensor order: 0\n         * definition: quotient of the activity `A` (item 10-27) of a sample and the mass `m` (ISO 80000-4) of that sample: `a = A/m`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ActivityDensityUnit[1];\n    }\n\n    attribute activityDensity: ActivityDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ActivityDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    alias VolumicActivityUnit for ActivityDensityUnit;\n    alias VolumicActivityValue for ActivityDensityValue;\n    alias volumicActivity for activityDensity;\n\n    alias ActivityConcentrationUnit for ActivityDensityUnit;\n    alias ActivityConcentrationValue for ActivityDensityValue;\n    alias activityConcentration for activityDensity;\n\n    /* ISO-80000-10 item 10-30 surface-activity density */\n    attribute def SurfaceActivityDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-30 surface-activity density\n         * symbol(s): `a_S`\n         * application domain: generic\n         * name: SurfaceActivityDensity\n         * quantity dimension: L^-2*T^-1\n         * measurement unit(s): Bq/m^2, m^-2*s^-1\n         * tensor order: 0\n         * definition: quotient of the activity `A` (item 10-27) of a sample and the total area `S` (ISO 80000-3) of the surface of that sample: `a_S` = `A`/`S`\n         * remarks: This value is usually defined for flat sources, where `S` corresponds to the total area of surface of one side of the source.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SurfaceActivityDensityUnit[1];\n    }\n\n    attribute surfaceActivityDensity: SurfaceActivityDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def SurfaceActivityDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-31 half life */\n    attribute halfLife: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-31 half life\n         * symbol(s): `T_(1/2)`\n         * application domain: generic\n         * name: HalfLife (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: mean duration (ISO 80000-3) required for the decay of one half of the atoms or nuclei\n         * remarks: For exponential decay, `T_(1/2) = (ln2)/\u03BB`, where `\u03BB` is the decay constant (item 10-24).\n         */\n    }\n\n    /* ISO-80000-10 item 10-32 alpha disintegration energy */\n    attribute alphaDisintegrationEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-32 alpha disintegration energy\n         * symbol(s): `Q_\u03B1`\n         * application domain: generic\n         * name: AlphaDisintegrationEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: sum of the kinetic energy (ISO 80000-4) of the \u03B1-particle produced in the disintegration process and the recoil energy (ISO 80000-5) of the product atom in a reference frame in which the emitting nucleus is at rest before its disintegration\n         * remarks: The ground-state alpha disintegration energy, `Q_(\u03B1,0)`, also includes the energy of any nuclear transitions that take place in the daughter produced.\n         */\n    }\n\n    /* ISO-80000-10 item 10-33 maximum beta-particle energy */\n    attribute maximumBetaParticleEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-33 maximum beta-particle energy\n         * symbol(s): `E_\u03B2`\n         * application domain: generic\n         * name: MaximumBetaParticleEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: maximum kinetic energy (ISO 80000-4) of the emitted beta particle produced in the nuclear disintegration process\n         * remarks: The maximum kinetic energy corresponds to the highest energy of the beta spectrum.\n         */\n    }\n\n    /* ISO-80000-10 item 10-34 beta disintegration energy */\n    attribute betaDisintegrationEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-34 beta disintegration energy\n         * symbol(s): `Q_\u03B2`\n         * application domain: generic\n         * name: BetaDisintegrationEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: sum of the maximum beta-particle kinetic energy (item 10-33) and the recoil energy (ISO 80000-5) of the atom produced in a reference frame in which the emitting nucleus is at rest before its disintegration\n         * remarks: For positron emitters, the energy for the production of the annihilation radiation created in the combination of an electron with the positron is part of the beta disintegration energy. The ground-state beta disintegration energy, `Q_(\u03B2,0)`, also includes the energy of any nuclear transitions that take place in the daughter product.\n         */\n    }\n\n    /* ISO-80000-10 item 10-35 internal conversion factor */\n    attribute def InternalConversionFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-35 internal conversion factor\n         * symbol(s): `\u03B1`\n         * application domain: generic\n         * name: InternalConversionFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the number of internal conversion electrons and the number of gamma quanta emitted by the radioactive atom in a given transition, where a conversion electron represents an orbital electron emitted through the radioactive decay\n         * remarks: The quantity `\u03B1/(\u03B1+1)` is also used and called the internal-conversion fraction. Partial conversion fractions referring to the various electron shells `K, L, ...` are indicated by `\u03B1_K`, `\u03B1_L`, ... `\u03B1_K/\u03B1_L` is called the K-to-L internal conversion ratio.\n         */\n    }\n    attribute internalConversionFactor: InternalConversionFactorValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-36 particle emission rate */\n    attribute def ParticleEmissionRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-36 particle emission rate\n         * symbol(s): `dot(N)`\n         * application domain: generic\n         * name: ParticleEmissionRate\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: differential quotient of `N` with respect to time, where `N` is the number of particles being emitted from an infinitesimally small volume element in the time interval of duration `dt` (ISO 80000-3), and `dt`: `dot(N) = (dN)/(dt)`\n         * remarks: Usually the kind of particles is specified, e.g. neutron emission rate or alpha particle emission rate.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ParticleEmissionRateUnit[1];\n    }\n\n    attribute particleEmissionRate: ParticleEmissionRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def ParticleEmissionRateUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-10 item 10-37.1 reaction energy */\n    attribute reactionEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-37.1 reaction energy\n         * symbol(s): `Q`\n         * application domain: generic\n         * name: ReactionEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: in a nuclear reaction, sum of the kinetic energies (ISO 80000-4) and photon energies (ISO 80000-5) of the reaction products minus the sum of the kinetic and photon energies of the reactants\n         * remarks: For exothermic nuclear reactions, `Q>0`. For endothermic nuclear reactions, `Q<0`.\n         */\n    }\n\n    /* ISO-80000-10 item 10-37.2 resonance energy */\n    attribute resonanceEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-37.2 resonance energy\n         * symbol(s): `E_r`, `E_"res"`\n         * application domain: generic\n         * name: ResonanceEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: kinetic energy (ISO 80000-4) of an incident particle, in the reference frame of the target, corresponding to a resonance in a nuclear reaction\n         * remarks: The energy of the resonance corresponds to the difference of the energy levels involved of the nucleus.\n         */\n    }\n\n    /* ISO-80000-10 item 10-38.1 cross section */\n    attribute crossSection: AreaValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-38.1 cross section\n         * symbol(s): `\u03C3`\n         * application domain: atomic physics\n         * name: CrossSection (specializes Area)\n         * quantity dimension: L^2\n         * measurement unit(s): m^2, b\n         * tensor order: 0\n         * definition: for a specified target entity and for a specified reaction or process produced by incident charged or uncharged particles of a given type and energy, the quotient of the mean number of such reactions or processes and the incident-particle fluence (item 10-43)\n         * remarks: The type of process is indicated by subscripts, e.g. absorption cross section `\u03C3_a`, scattering cross section `\u03C3_s`, fission cross section `\u03C3_f`. `1 "barn" ("b") = 10^(-28) "m"^2`.\n         */\n    }\n\n    /* ISO-80000-10 item 10-38.2 total cross section */\n    attribute totalCrossSection: AreaValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-38.2 total cross section\n         * symbol(s): `\u03C3_"tot"`, `\u03C3_"T"`\n         * application domain: atomic physics\n         * name: TotalCrossSection (specializes Area)\n         * quantity dimension: L^2\n         * measurement unit(s): m^2, b\n         * tensor order: 0\n         * definition: sum of all cross sections (item 10-38.1) corresponding to the various reactions or processes between an incident particle of specified type and energy (ISO 80000-5) and a target entity\n         * remarks: In the case of a narrow unidirectional beam of incident particles, this is the effective cross section for the removal of an incident particle from the beam. See the Remarks for item 10-52. `1 "barn" ("b") = 10^(-28) "m"^2`.\n         */\n    }\n\n    /* ISO-80000-10 item 10-39 direction distribution of cross section */\n    attribute def DirectionDistributionOfCrossSectionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-39 direction distribution of cross section\n         * symbol(s): `\u03C3_\u03A9`\n         * application domain: atomic physics\n         * name: DirectionDistributionOfCrossSection\n         * quantity dimension: L^2\n         * measurement unit(s): m^2*sr^-1, m^2\n         * tensor order: 0\n         * definition: differential quotient of `\u03C3` with respect to `\u03A9`, where `\u03C3` is the cross section (item 10-38.1) for ejecting or scattering a particle into a specified direction, and `\u03A9` is the solid angle (ISO 80000-3) around that direction: `\u03C3_\u03A9 = (d\u03C3)/(d\u03A9)`\n         * remarks: Quantities listed under items 10-39, 10-40 and 10-41 are sometimes called differential cross sections. The type of interaction needs to be specified.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DirectionDistributionOfCrossSectionUnit[1];\n    }\n\n    attribute directionDistributionOfCrossSection: DirectionDistributionOfCrossSectionValue[*] nonunique :> scalarQuantities;\n\n    attribute def DirectionDistributionOfCrossSectionUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-10 item 10-40 energy distribution of cross section */\n    attribute def EnergyDistributionOfCrossSectionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-40 energy distribution of cross section\n         * symbol(s): `\u03C3_E`\n         * application domain: atomic physics\n         * name: EnergyDistributionOfCrossSection\n         * quantity dimension: M^-1*T^2\n         * measurement unit(s): m^2/J, kg^-1*s^2\n         * tensor order: 0\n         * definition: differential quotient of `\u03C3` with respect to energy, where `\u03C3` is the cross section (item 10-38.1) for a process in which the energy `E` (ISO 80000-5) of the ejected or scattered particle is between `E` and `E + dE`: `\u03C3_E = (d\u03C3)/(dE)`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EnergyDistributionOfCrossSectionUnit[1];\n    }\n\n    attribute energyDistributionOfCrossSection: EnergyDistributionOfCrossSectionValue[*] nonunique :> scalarQuantities;\n\n    attribute def EnergyDistributionOfCrossSectionUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-41 direction and energy distribution of cross section */\n    attribute def DirectionAndEnergyDistributionOfCrossSectionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-41 direction and energy distribution of cross section\n         * symbol(s): `\u03C3_(\u03A9,E)`\n         * application domain: atomic physics\n         * name: DirectionAndEnergyDistributionOfCrossSection\n         * quantity dimension: M^-1*T^2\n         * measurement unit(s): m^2/(J*sr), kg^-1*s^2\n         * tensor order: 0\n         * definition: partial differential quotient of `\u03C3` with respect to solid angle and energy, where `\u03C3` is the cross section (item 10-38.1) for ejecting or scattering a particle into a solid angle `d\u03A9` around a specified direction and with an energy between `E` and `E+dE`: `\u03C3_(\u03A9,E) = (del^2 \u03C3) / (del \u03A9 del E)`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DirectionAndEnergyDistributionOfCrossSectionUnit[1];\n    }\n\n    attribute directionAndEnergyDistributionOfCrossSection: DirectionAndEnergyDistributionOfCrossSectionValue[*] nonunique :> scalarQuantities;\n\n    attribute def DirectionAndEnergyDistributionOfCrossSectionUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-42.1 volumic cross section, macroscopic cross section */\n    attribute def VolumicCrossSectionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-42.1 volumic cross section, macroscopic cross section\n         * symbol(s): `\u03A3`\n         * application domain: atomic physics\n         * name: VolumicCrossSection\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: product of the number density `n_a` of the atoms and of the cross section (item 10-38.1) `\u03C3_a` for a given type of atoms: `\u03A3 = n_a \u03C3_a`\n         * remarks: When the target particles of the medium are at rest, `\u03A3 = 1/l`, where `l` is the mean free path (item 10-71).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: VolumicCrossSectionUnit[1];\n    }\n\n    attribute volumicCrossSection: VolumicCrossSectionValue[*] nonunique :> scalarQuantities;\n\n    attribute def VolumicCrossSectionUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    alias MacroscopicCrossSectionUnit for VolumicCrossSectionUnit;\n    alias MacroscopicCrossSectionValue for VolumicCrossSectionValue;\n    alias macroscopicCrossSection for volumicCrossSection;\n\n    /* ISO-80000-10 item 10-42.2 volumic total cross section, macroscopic total cross section */\n    attribute def VolumicTotalCrossSectionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-42.2 volumic total cross section, macroscopic total cross section\n         * symbol(s): `\u03A3_"tot"`, `\u03A3_"T"`\n         * application domain: atomic physics\n         * name: VolumicTotalCrossSection\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: product of the number density `n_a` of the atoms and the cross section (item 10-38.1) `\u03C3_"tot"` for a given type of atoms: `\u03A3_"tot" = n_a*\u03C3_"tot"`\n         * remarks: See the Remarks for item 10-49.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: VolumicTotalCrossSectionUnit[1];\n    }\n\n    attribute volumicTotalCrossSection: VolumicTotalCrossSectionValue[*] nonunique :> scalarQuantities;\n\n    attribute def VolumicTotalCrossSectionUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    alias MacroscopicTotalCrossSectionUnit for VolumicTotalCrossSectionUnit;\n    alias MacroscopicTotalCrossSectionValue for VolumicTotalCrossSectionValue;\n    alias macroscopicTotalCrossSection for volumicTotalCrossSection;\n\n    /* ISO-80000-10 item 10-43 particle fluence */\n    attribute def ParticleFluenceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-43 particle fluence\n         * symbol(s): `\u03A6`\n         * application domain: generic\n         * name: ParticleFluence\n         * quantity dimension: L^-2\n         * measurement unit(s): m^-2\n         * tensor order: 0\n         * definition: differential quotient of `N` with respect to `a`, where `N` is the number of particles incident on a sphere of cross-sectional area `a` (item 10-38.1): `\u03A6 = (dN)/(da)`\n         * remarks: The word "particle" is usually replaced by the name of a specific particle, for example `proton` fluence. If a flat area of size `dA` is passed perpendicularly by a number of `dN` particles, the corresponding particle fluence is: `\u03A6 = (dN)/(dA)`. A plane area of size `dA` crossed at an angle `\u03B1` with respect to the surface normal by a number of `dN` particles results in the particle fluence: `\u03A6 = (dN)/(cos(\u03B1) dA)` In report 85a of the ICRU a definition with an equivalent meaning is given as: The fluence, `\u03A6` , is the quotient of `dN` and `da`, where `dN` is the number of particles incident on a sphere of cross-sectional area `da`: `\u03A6 = (dN)/(dA)`. See also section 0.3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ParticleFluenceUnit[1];\n    }\n\n    attribute particleFluence: ParticleFluenceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ParticleFluenceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-10 item 10-44 particle fluence rate */\n    attribute def ParticleFluenceRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-44 particle fluence rate\n         * symbol(s): `dot(\u03A6)`\n         * application domain: generic\n         * name: ParticleFluenceRate\n         * quantity dimension: L^-2*T^-1\n         * measurement unit(s): m^-2*s^-1\n         * tensor order: 0\n         * definition: differential quotient of fluence `\u03A6` (item 10-43) with respect to time (ISO 80000-3): `dot(\u03A6) = (d\u03A6)/(dA)`\n         * remarks: The word "particle" is usually replaced by the name of a specific particle, for example proton fluence rate. The distribution function expressed in terms of speed and energy, `dot(\u03A6)_v` and `dot(\u03A6)_E` , are related to by: `dot(\u03A6) = int dot(\u03A6)_v dv = int dot(\u03A6)_E dE`. This quantity has also been termed particle flux density. Because the word "density" has several connotations, the term "fluence rate" is preferred. For a radiation field composed of particles of velocity `v`, the fluence rate is equal to `n`\xB7`v` where `n` is the particle number density. See Remarks for item 10-43. In report 85a of the ICRU a definition with an equivalent meaning is given as: The fluence rate, `dot(\u03A6)` , is the quotient of `d \u03A6` and `dt`, where `d \u03A6` is the increment of the fluence in the time interval `dt`: `dot(\u03A6) = (d\u03A6)/(dt)`. See also section 0.3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ParticleFluenceRateUnit[1];\n    }\n\n    attribute particleFluenceRate: ParticleFluenceRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def ParticleFluenceRateUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-45 radiant energy */\n    attribute radiantEnergyForIonizingRadiation: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-45 radiant energy\n         * symbol(s): `R`\n         * application domain: ionizing radiation\n         * name: RadiantEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: mean energy (ISO 80000-5), excluding rest energy (item 10-3), of the particles that are emitted, transferred, or received\n         * remarks: For particles of energy `E` (excluding rest energy), the radiant energy, `R`, is equal to the product `N\xB7E` where `N` is the number of the particles that are emitted, transferred, or received The distributions, `N_E` and `R_E`, of the particle number and the radiant energy with respect to energy are given by `N_E` = `dN`/d`E` and `R_E` = `dR`/d`E`, respectively, where `dN` is the number of particles with energy between `E` and `E`+d`E`, and `dR` is their radiant energy. The two distributions are related by `R_E` = `E`\xB7`N_E`.\n         */\n    }\n\n    /* ISO-80000-10 item 10-46 energy fluence */\n    attribute def EnergyFluenceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-46 energy fluence\n         * symbol(s): `\u03A8`\n         * application domain: generic\n         * name: EnergyFluence\n         * quantity dimension: M^1*T^-2\n         * measurement unit(s): eV/m^2, J/m^2, kg*s^-2\n         * tensor order: 0\n         * definition: differential quotient of radiant energy `R` (item 10-45) incident on a sphere of cross-sectional area (item 10-38.1) `a` with respect to that area: `\u03A8 = (dR)/(da)`\n         * remarks: In report 85a of the ICRU a definition with an equivalent meaning is given as: The energy fluence, `\u03A8` is the quotient of `dR` and `da`, where `dR` is the radiant energy incident on a sphere of cross-sectional area `da`: `\u03A8 = (dR)/(da)`. See also section 0.3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EnergyFluenceUnit[1];\n    }\n\n    attribute energyFluence: EnergyFluenceValue[*] nonunique :> scalarQuantities;\n\n    attribute def EnergyFluenceUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-47 energy fluence rate */\n    attribute def EnergyFluenceRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-47 energy fluence rate\n         * symbol(s): `dot(\u03A8)`\n         * application domain: generic\n         * name: EnergyFluenceRate\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/m^2, kg*s^-3\n         * tensor order: 0\n         * definition: differential quotient of the energy fluence `\u03A8` (item 10-46) with respect to time (ISO 80000-3): `dot(\u03A8) = (d \u03A8)/(dt)`\n         * remarks: In report 85a of the ICRU a definition with an equivalent meaning is given as: The energy-fluence rate, `dot(\u03A8)` , is the quotient of `d \u03A8` by `dt`, where `d \u03A8` is the increment of the energy fluence in the time interval `dt`: `dot(\u03A8) = (d \u03A8)/(dt)`. See also section 0.3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EnergyFluenceRateUnit[1];\n    }\n\n    attribute energyFluenceRate: EnergyFluenceRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def EnergyFluenceRateUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-48 particle current density */\n    attribute def ParticleCurrentDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-48 particle current density (magnitude)\n         * symbol(s): `J`, `S`\n         * application domain: generic\n         * name: ParticleCurrentDensity\n         * quantity dimension: L^-2*T^-1\n         * measurement unit(s): m^-2*s^-1\n         * tensor order: 0\n         * definition: vector whose component in direction of an area normal is given by: `vec(J_n) = int \u03A6_\u03A9(\u03B8, \u03B1) cos(\u03B8) d\u03A9` where `\u03A6_\u03A9(\u03B8, \u03B1)` is the directional distribution of the particle fluence rate (item 10-44), and ` \u03B8` and `\u03B1` are polar and azimuthal angles, respectively\n         * remarks: Usually the word "particle" is replaced by the name of a specific particle, for example proton current. Symbol `vec(S)` is recommended when there is a possibility of confusion with the symbol `vec(J)` for electric current density. For neutron current, the symbol `vec(J)` is generally used. The distribution functions expressed in terms of speed and energy, `vec(J_v)` and `vec(J_E)`, are related to `vec(J)` by: `vec(J) = int vec(J_v) dv = int vec(J_E) dE`. The directional distribution of the particle fluence rate is also denoted as particle radiance.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ParticleCurrentDensityUnit[1];\n    }\n\n    attribute particleCurrentDensity: ParticleCurrentDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ParticleCurrentDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    attribute def CartesianParticleCurrentDensity3dVector :> \'3dVectorQuantityValue\' {\n        doc\n        /*\n         * source: item 10-48 particle current density (vector)\n         * symbol(s): `vec(J)`, `vec(S)`\n         * application domain: generic\n         * name: ParticleCurrentDensity\n         * quantity dimension: L^-2*T^-1\n         * measurement unit(s): m^-2*s^-1\n         * tensor order: 1\n         * definition: vector whose component in direction of an area normal is given by: `vec(J_n) = int \u03A6_\u03A9(\u03B8, \u03B1) cos(\u03B8) d\u03A9` where `\u03A6_\u03A9(\u03B8, \u03B1)` is the directional distribution of the particle fluence rate (item 10-44), and ` \u03B8` and `\u03B1` are polar and azimuthal angles, respectively\n         * remarks: Usually the word "particle" is replaced by the name of a specific particle, for example proton current. Symbol `vec(S)` is recommended when there is a possibility of confusion with the symbol `vec(J)` for electric current density. For neutron current, the symbol `vec(J)` is generally used. The distribution functions expressed in terms of speed and energy, `vec(J_v)` and `vec(J_E)`, are related to `vec(J)` by: `vec(J) = int vec(J_v) dv = int vec(J_E) dE`. The directional distribution of the particle fluence rate is also denoted as particle radiance.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianParticleCurrentDensity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianParticleCurrentDensity3dVector: CartesianParticleCurrentDensity3dVector :> vectorQuantities;\n\n    attribute def CartesianParticleCurrentDensity3dCoordinateFrame :> \'3dCoordinateFrame\' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: ParticleCurrentDensityUnit[3];\n    }\n\n    /* ISO-80000-10 item 10-49 linear attenuation coefficient */\n    attribute def LinearAttenuationCoefficientForIonizingRadiationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-49 linear attenuation coefficient\n         * symbol(s): `\u03BC`, `\u03BC_l`\n         * application domain: ionizing radiation\n         * name: LinearAttenuationCoefficient\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: for uncharged particles of a given type and energy the differential quotient `n` with respect to `l,` where `n` is the fraction of `N` incoming particles that experience interactions in traversing a distance (ISO 80000-3) `l` in a given material: `\u03BC = (dn)/(dl) = 1/N (dN)/(dl)` where `dN` is the number of particles that experience interactions in traversing `dl`\n         * remarks: `\u03BC` is equal to the macroscopic total cross section `\u03A3_"tot"` for the removal of particles from the beam. Using the relation `\u03BC_m = \u03BC/\u03C1` between the linear attenuation coefficient `\u03BC`, the mass attenuation coefficient `\u03BC_m` (item 10-50) and the density `\u03C1`, the definition given for the mass attenuation coefficient in report 85a of the ICRU can be applied to the linear attenuation coefficient resulting in: The linear attenuation coefficient, `\u03BC`, of a material, for uncharged particles of a given type and energy, is the quotient of `(dN)/N` by `dl`, where `(dN)/N` is the mean fraction of the particles that experience interactions in traversing a distance `dl` in the material: `\u03BC = 1/(dl) (dN)/(N)`. This definition has an equivalent meaning as the one given in column 4 of this item. See also section 0.3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearAttenuationCoefficientForIonizingRadiationUnit[1];\n    }\n\n    attribute linearAttenuationCoefficientForIonizingRadiation: LinearAttenuationCoefficientForIonizingRadiationValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearAttenuationCoefficientForIonizingRadiationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-10 item 10-50 mass attenuation coefficient */\n    attribute def MassAttenuationCoefficientForIonizingRadiationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-50 mass attenuation coefficient\n         * symbol(s): `\u03BC_m`\n         * application domain: ionizing radiation\n         * name: MassAttenuationCoefficient\n         * quantity dimension: L^2*M^-1\n         * measurement unit(s): kg^-1*m^2\n         * tensor order: 0\n         * definition: quotient of the linear attenuation coefficient `\xB5` (item 10-49) and the mass density `\u03C1` (ISO 80000-4) of the medium: `\u03BC_m = \u03BC/\u03C1`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassAttenuationCoefficientForIonizingRadiationUnit[1];\n    }\n\n    attribute massAttenuationCoefficientForIonizingRadiation: MassAttenuationCoefficientForIonizingRadiationValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassAttenuationCoefficientForIonizingRadiationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-10 item 10-51 molar attenuation coefficient */\n    attribute def MolarAttenuationCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-51 molar attenuation coefficient\n         * symbol(s): `\u03BC_c`\n         * application domain: generic\n         * name: MolarAttenuationCoefficient\n         * quantity dimension: L^2*N^-1\n         * measurement unit(s): m^2*mol^-1\n         * tensor order: 0\n         * definition: quotient of linear attenuation coefficient `\xB5` (item 10-49) and the amount c (ISO 80000-9) of the medium: `\u03BC_c = \u03BC/c`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarAttenuationCoefficientUnit[1];\n    }\n\n    attribute molarAttenuationCoefficient: MolarAttenuationCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarAttenuationCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-10 item 10-52 atomic attenuation coefficient */\n    attribute def AtomicAttenuationCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-52 atomic attenuation coefficient\n         * symbol(s): `\u03BC_a`\n         * application domain: generic\n         * name: AtomicAttenuationCoefficient\n         * quantity dimension: L^2\n         * measurement unit(s): m^2\n         * tensor order: 0\n         * definition: quotient of the linear attenuation coefficient `\xB5` (item 10-49) and the number density (item 10-62.1), `n`, of atoms in the substance: `\u03BC_a = \u03BC/n`\n         * remarks: `\u03BC` is equal to the total cross section `\u03C3_"tot"` for the removal of particles from the beam. See also item 10-38.2.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AtomicAttenuationCoefficientUnit[1];\n    }\n\n    attribute atomicAttenuationCoefficient: AtomicAttenuationCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def AtomicAttenuationCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-10 item 10-53 half-value thickness */\n    attribute halfValueThickness: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-53 half-value thickness\n         * symbol(s): `d_(1//2)`\n         * application domain: generic\n         * name: HalfValueThickness (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: thickness (ISO 80000-3) of the attenuating layer that reduces the quantity of interest of a unidirectional beam of infinitesimal width to half of its initial value\n         * remarks: For exponential attenuation, `d_(1/2) = ln(2)/\u03BC`. The quantity of interest is often the air kerma or exposure.\n         */\n    }\n\n    /* ISO-80000-10 item 10-54 total linear stopping power, linear stopping power */\n    attribute def TotalLinearStoppingPowerValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-54 total linear stopping power, linear stopping power\n         * symbol(s): `S`, `S_l`\n         * application domain: generic\n         * name: TotalLinearStoppingPower\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): eV/m, J/m, kg*m*s^-2\n         * tensor order: 0\n         * definition: for charged particles of a given type and energy `E_0` the differential quotient of `E` with respect to `x,` where `E` is the mean energy (ISO 80000-4) lost by the charged particles in traversing a distance (ISO 80000-3) `x` in the given material: `S = -(dE)/(dx)`\n         * remarks: The total linear stopping power is sometimes also called stopping power. Both electronic losses and radiative losses are included. The quotient of the total linear stopping power of a substance and that of a reference substance is called the relative linear stopping power. See also item 10-85. Using the relation `S_m = S/\u03C1` between the total mass stopping power `S_m` (item 10-55), the total linear stopping power `S`, and the density `\u03C1`, the definition given for the mass stopping in report 85a of the ICRU can be applied to that of the total linear stopping power resulting in: The linear stopping power, `S`, of a material, for charged particles of a given type and energy, is the quotient of `dE` by `dl`, where `dE` is the mean energy lost by the charged particles in traversing a distance `dl` in the material: `S = -(dE)/(dx)`. This definition has an equivalent meaning as the one given in column 4 of this item. See also section 0.3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TotalLinearStoppingPowerUnit[1];\n    }\n\n    attribute totalLinearStoppingPower: TotalLinearStoppingPowerValue[*] nonunique :> scalarQuantities;\n\n    attribute def TotalLinearStoppingPowerUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    alias LinearStoppingPowerUnit for TotalLinearStoppingPowerUnit;\n    alias LinearStoppingPowerValue for TotalLinearStoppingPowerValue;\n    alias linearStoppingPower for totalLinearStoppingPower;\n\n    /* ISO-80000-10 item 10-55 total mass stopping power, mass stopping power */\n    attribute def TotalMassStoppingPowerValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-55 total mass stopping power, mass stopping power\n         * symbol(s): `S_m`\n         * application domain: generic\n         * name: TotalMassStoppingPower\n         * quantity dimension: L^4*T^-2\n         * measurement unit(s): eV*m^-2/kg, J*m^2/kg, m^4*s^-2\n         * tensor order: 0\n         * definition: quotient of the total linear stopping power `S` (item 10-54) and the mass density `\u03C1` (ISO 80000-4) of the material: `S_m = S/\u03C1`\n         * remarks: The quotient of total mass stopping power of a material and that of a reference material is called relative mass stopping power.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TotalMassStoppingPowerUnit[1];\n    }\n\n    attribute totalMassStoppingPower: TotalMassStoppingPowerValue[*] nonunique :> scalarQuantities;\n\n    attribute def TotalMassStoppingPowerUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 4; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    alias MassStoppingPowerUnit for TotalMassStoppingPowerUnit;\n    alias MassStoppingPowerValue for TotalMassStoppingPowerValue;\n    alias massStoppingPower for totalMassStoppingPower;\n\n    /* ISO-80000-10 item 10-56 mean linear range */\n    attribute meanLinearRange: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-56 mean linear range\n         * symbol(s): `R`, `R_l`\n         * application domain: generic\n         * name: MeanLinearRange (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: mean total rectified path length (ISO 80000-3) travelled by a particle in the course of slowing down to rest in a given material averaged over a group of particles having the same initial energy (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-57 mean mass range */\n    attribute def MeanMassRangeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-57 mean mass range\n         * symbol(s): `R_\u03C1`, `R_m`\n         * application domain: generic\n         * name: MeanMassRange\n         * quantity dimension: L^-2*M^1\n         * measurement unit(s): kg*m^-2\n         * tensor order: 0\n         * definition: product of the mean linear range (item 10-56) `R` and the mass density `\u03C1` (ISO 80000-4) of the material: `R_\u03C1 = R*\u03C1`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MeanMassRangeUnit[1];\n    }\n\n    attribute meanMassRange: MeanMassRangeValue[*] nonunique :> scalarQuantities;\n\n    attribute def MeanMassRangeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-10 item 10-58 linear ionization */\n    attribute def LinearIonizationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-58 linear ionization\n         * symbol(s): `N_{i_l}`\n         * application domain: generic\n         * name: LinearIonization\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: differential quotient of `q` with respect to `l`, where `q` is the average total charge (IEC 80000-6) of all positive ions produced by an ionizing charged particle over a path `l` (ISO 80000-3), divided by the elementary charge, `e` (ISO 80000-1): `N_{i_l} = 1/e*(dq)/(dl)`\n         * remarks: Ionization due to secondary ionizing particles is included.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearIonizationUnit[1];\n    }\n\n    attribute linearIonization: LinearIonizationValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearIonizationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-10 item 10-59 total ionization */\n    attribute def TotalIonizationValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-59 total ionization\n         * symbol(s): `N_i`\n         * application domain: generic\n         * name: TotalIonization (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the total mean charge of all positive ions produced by an ionizing charged particle along its entire path and along the paths of any secondary charged particles, and the elementary charge, `e` (ISO 80000-1)\n         * remarks: `N_i = int N_(il) dl` See item 10-58.\n         */\n    }\n    attribute totalIonization: TotalIonizationValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-60 average energy loss per elementary charge produced */\n    attribute def AverageEnergyLossPerElementaryChargeProducedValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-60 average energy loss per elementary charge produced\n         * symbol(s): `W_i`\n         * application domain: generic\n         * name: AverageEnergyLossPerElementaryChargeProduced\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: quotient of the initial kinetic energy `E_k` (ISO 80000-4) of an ionizing charged particle and the total ionization `N_i` (item 10-59) produced by that particle: `W_i = E_k/N_i`\n         * remarks: The name "average energy loss per ion pair formed" is usually used, although it is ambiguous. In the practical dosimetry of ionizing radiation the term `W`/`e`, the quotient of `W`, the average energy deposited in dry air per ion pair formed, and `e`, the elementary charge, is used as the factor which, when multiplied with the electric charge of one sign carried by all ion pairs formed in dry air of given mass, gives the energy deposited in this amount of dry air in the form of excitations and ionizations. In ICRU Report 85a, the mean energy expended in a gas per ion pair formed, `W`, is the quotient of `E` by `N,` where `N` is the mean total liberated charge of either sign, divided by the elementary charge when the initial kinetic energy `E` of a charged particle introduced into the gas is completely dissipated in the gas. Thus, `W` = `E`/`N`. It follows from the definition of `W` that the ions produced by bremsstrahlung or other secondary radiation emitted by the initial and secondary charged particles are included in `N`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AverageEnergyLossPerElementaryChargeProducedUnit[1];\n    }\n\n    attribute averageEnergyLossPerElementaryChargeProduced: AverageEnergyLossPerElementaryChargeProducedValue[*] nonunique :> scalarQuantities;\n\n    attribute def AverageEnergyLossPerElementaryChargeProducedUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-61 mobility */\n    attribute def MobilityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-61 mobility\n         * symbol(s): `\u03BC`, `\u03BC_m`\n         * application domain: generic\n         * name: Mobility\n         * quantity dimension: M^-1*T^2*I^1\n         * measurement unit(s): m^2/(V*s), kg^-1*s^2*A\n         * tensor order: 0\n         * definition: quotient of average drift speed (ISO 80000-3) imparted to a charged particle in a medium by an electric field, and the electric field strength (IEC 80000-6)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MobilityUnit[1];\n    }\n\n    attribute mobility: MobilityValue[*] nonunique :> scalarQuantities;\n\n    attribute def MobilityUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* ISO-80000-10 item 10-62.1 particle number density */\n    attribute def ParticleNumberDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-62.1 particle number density\n         * symbol(s): `n`\n         * application domain: generic\n         * name: ParticleNumberDensity\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: quotient of the mean number `N` of particles in the volume (ISO 80000-3) `V` and volume: `n = N/V`\n         * remarks: `n` is the general symbol for the number density of particles. The distribution functions expressed in terms of speed and energy, `n_v` and `n_E`, are related to `n` by: `n = int n_v dv = int n_E dE`. The word "particle" is usually replaced by the name of a specific particle, for example `neutron` number density.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ParticleNumberDensityUnit[1];\n    }\n\n    attribute particleNumberDensity: ParticleNumberDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ParticleNumberDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-10 item 10-62.2 ion number density, ion density */\n    attribute def IonNumberDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-62.2 ion number density, ion density\n         * symbol(s): `n^"+"`, `n^"-"`\n         * application domain: generic\n         * name: IonNumberDensity\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: quotient of the number of positive and negative ions, `N^"+"` and `N^"-"`, respectively, in the volume `V` (ISO 80000-3), and that volume: `n^"+" = N^"+" / V`, `n^"-" = N^"-" / V`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: IonNumberDensityUnit[1];\n    }\n\n    attribute ionNumberDensity: IonNumberDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def IonNumberDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    alias IonDensityUnit for IonNumberDensityUnit;\n    alias IonDensityValue for IonNumberDensityValue;\n    alias ionDensity for ionNumberDensity;\n\n    /* ISO-80000-10 item 10-63 Recombination coefficient */\n    attribute def RecombinationCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-63 Recombination coefficient\n         * symbol(s): `\u03B1`\n         * application domain: generic\n         * name: RecombinationCoefficient\n         * quantity dimension: L^3*T^-1\n         * measurement unit(s): m^3*s^-1\n         * tensor order: 0\n         * definition: coefficient in the law of recombination: `-(dn^"+")/(dt) = -(dn^"-")/(dt) = \u03B1*n^"+"*n^"-"`, where `n^"+"` and `n^"-"` are the ion number densities (item 10-62.2) of positive and negative ions, respectively, recombined during a time interval of duration `dt` (ISO 80000-3)\n         * remarks: The widely used term "recombination factor" is not correct because "factor" should only be used for quantities with dimension 1. The terms `(dn^"+")/(dt)` , `(dn^"-")/(dt)` are differential quotients.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RecombinationCoefficientUnit[1];\n    }\n\n    attribute recombinationCoefficient: RecombinationCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def RecombinationCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-64 diffusion coefficient, diffusion coefficient for particle number density */\n    /* Refer to declaration for DiffusionCoefficient in ISQChemistryMolecular item 9-39 diffusion coefficient */\n\n    alias DiffusionCoefficientForParticleNumberDensityUnit for DiffusionCoefficientUnit;\n    alias DiffusionCoefficientForParticleNumberDensityValue for DiffusionCoefficientValue;\n    alias diffusionCoefficientForParticleNumberDensity for diffusionCoefficient;\n\n    /* ISO-80000-10 item 10-65 diffusion coefficient for fluence rate */\n    attribute diffusionCoefficientForFluenceRate: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-65 diffusion coefficient for fluence rate\n         * symbol(s): `D_\u03D5`, `D`\n         * application domain: generic\n         * name: DiffusionCoefficientForFluenceRate (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: proportionality constant between the particle current density `vec(J )`(item 10-48) and the gradient of the particle fluence rate `dot(\u03A6)` (item 10-44): `vec(J) = -vec(D) * nabla \u03A6`\n         * remarks: For a particle of a given speed `v`: `D_\u03A8(v) = -J_{v,x}/(partial \u03A8 // partial x)` and `vec(v) * vec(D_\u03A8)(v) = -vec(D_n)(v)`\n         */\n    }\n\n    /* ISO-80000-10 item 10-66 particle source density */\n    attribute def ParticleSourceDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-66 particle source density\n         * symbol(s): `S`\n         * application domain: generic\n         * name: ParticleSourceDensity\n         * quantity dimension: L^-3*T^-1\n         * measurement unit(s): m^-3*s^-1\n         * tensor order: 0\n         * definition: quotient of the mean rate of production of particles in a volume, and that volume (ISO 80000-3)\n         * remarks: The word "particle" is usually replaced by the name of a specific particle, for example `proton` source density. The distribution functions expressed in terms of speed and energy, `S_v` and `S_E`, are related to `S` by: `S = int S_v dv = int S_E dE`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ParticleSourceDensityUnit[1];\n    }\n\n    attribute particleSourceDensity: ParticleSourceDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ParticleSourceDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-67 slowing-down density */\n    attribute def SlowingDownDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-67 slowing-down density\n         * symbol(s): `q`\n         * application domain: generic\n         * name: SlowingDownDensity\n         * quantity dimension: L^-3*T^-1\n         * measurement unit(s): m^-3*s^-1\n         * tensor order: 0\n         * definition: differential quotient of `n` with respect to time, where `n` is the number density of particles that are slowed down in a time interval of duration (ISO 80000-3) `t`: `q = -(dn)/(dt)`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SlowingDownDensityUnit[1];\n    }\n\n    attribute slowingDownDensity: SlowingDownDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def SlowingDownDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-68 resonance escape probability */\n    attribute def ResonanceEscapeProbabilityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-68 resonance escape probability\n         * symbol(s): `p`\n         * application domain: generic\n         * name: ResonanceEscapeProbability (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: in an infinite medium, the probability that a neutron slowing down will traverse all or some specified portion of the range of resonance energies (item 10-37.2) without being absorbed\n         * remarks: None.\n         */\n    }\n    attribute resonanceEscapeProbability: ResonanceEscapeProbabilityValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-69 lethargy */\n    attribute def LethargyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-69 lethargy\n         * symbol(s): `u`\n         * application domain: generic\n         * name: Lethargy (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for a neutron of kinetic energy `E` (ISO 80000-4) : `u = ln(E_0/E)`, where `E_0` is a reference energy\n         * remarks: Lethargy is also referred to as logarithmic energy decrement.\n         */\n    }\n    attribute lethargy: LethargyValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-70 average logarithmic energy decrement */\n    attribute def AverageLogarithmicEnergyDecrementValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 10-70 average logarithmic energy decrement\n         * symbol(s): `\u03B6`\n         * application domain: generic\n         * name: AverageLogarithmicEnergyDecrement (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: average value of the increase in lethargy (item 10-69) in elastic collisions between neutrons and nuclei whose kinetic energy (ISO 80000-4) is negligible compared with that of the neutrons\n         * remarks: None.\n         */\n    }\n    attribute averageLogarithmicEnergyDecrement: AverageLogarithmicEnergyDecrementValue :> scalarQuantities;\n\n    /* ISO-80000-10 item 10-71 mean free path */\n    attribute meanFreePathForAtomicPhysics: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-71 mean free path\n         * symbol(s): `l`, `\u03BB`\n         * application domain: atomic physics\n         * name: MeanFreePath (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: average distance (ISO 80000-3) that particles travel between two successive specified reactions or processes\n         * remarks: See the Remarks for item 10-42.1.\n         */\n    }\n\n    /* ISO-80000-10 item 10-72.1 slowing-down area */\n    attribute slowingDownArea: AreaValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-72.1 slowing-down area\n         * symbol(s): `L_s^2`, `L_"sl"^2`\n         * application domain: generic\n         * name: SlowingDownArea (specializes Area)\n         * quantity dimension: L^2\n         * measurement unit(s): m^2\n         * tensor order: 0\n         * definition: in an infinite homogenous medium, one-sixth of the mean square of the distance (ISO 80000-3) between the neutron source and the point where a neutron reaches a given energy (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-72.2 diffusion area */\n    attribute diffusionArea: AreaValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-72.2 diffusion area\n         * symbol(s): `L^2`\n         * application domain: generic\n         * name: DiffusionArea (specializes Area)\n         * quantity dimension: L^2\n         * measurement unit(s): m^2\n         * tensor order: 0\n         * definition: in an infinite homogenous medium, one-sixth of the mean square distance (ISO 80000-3) between the point where a neutron enters a specified class and the point where it leaves this class\n         * remarks: The class of neutrons must be specified, e.g. thermal.\n         */\n    }\n\n    /* ISO-80000-10 item 10-72.3 migration area */\n    attribute migrationArea: AreaValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-72.3 migration area\n         * symbol(s): `M^2`\n         * application domain: generic\n         * name: MigrationArea (specializes Area)\n         * quantity dimension: L^2\n         * measurement unit(s): m^2\n         * tensor order: 0\n         * definition: sum of the slowing-down area (item 10-72.1) from fission energy to thermal energy (ISO 80000-5) and the diffusion area (item 10-72.2) for thermal neutrons\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-73.1 slowing-down length */\n    attribute slowingDownLength: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-73.1 slowing-down length\n         * symbol(s): `L_s`, `L_"sl"`\n         * application domain: generic\n         * name: SlowingDownLength (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: square root of the slowing down area `L_s^2` (item 10-72.1): `L_s = sqrt(L_s^2)`\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-73.2 diffusion length */\n    attribute diffusionLength: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-73.2 diffusion length\n         * symbol(s): `L`\n         * application domain: atomic physics\n         * name: DiffusionLength (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: square root of the diffusion area `L^2` (item 10-72.2): `L = sqrt(L^2)`\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-73.3 migration length */\n    attribute migrationLength: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-73.3 migration length\n         * symbol(s): `M`\n         * application domain: generic\n         * name: MigrationLength (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: square root of the migration area `M^2` (item 10-72.3): `M = sqrt(M^2)`\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-74.1 neutron yield per fission */\n    attribute neutronYieldPerFission: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-74.1 neutron yield per fission\n         * symbol(s): `\u03BD`\n         * application domain: generic\n         * name: NeutronYieldPerFission (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: average number of fission neutrons, both prompt and delayed, emitted per fission event\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-10 item 10-74.2 neutron yield per absorption */\n    attribute neutronYieldPerAbsorption: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-74.2 neutron yield per absorption\n         * symbol(s): `\u03B7`\n         * application domain: generic\n         * name: NeutronYieldPerAbsorption (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: average number of fission neutrons, both prompt and delayed, emitted per neutron absorbed in a fissionable nuclide or in a nuclear fuel, as specified\n         * remarks: `\u03BD/\u03B7` is equal to the quotient of the macroscopic cross section for fission and that for absorption, both for neutrons in the fuel material.\n         */\n    }\n\n    /* ISO-80000-10 item 10-75 fast fission factor */\n    attribute def FastFissionFactorValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-75 fast fission factor\n         * symbol(s): `\u03C6`\n         * application domain: generic\n         * name: FastFissionFactor\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: in an infinite medium, the quotient of the mean number of neutrons produced by fission due to neutrons of all energies (ISO 80000-5) and the mean number of neutrons produced by fissions due to thermal neutrons only\n         * remarks: The class of neutrons must be specified, e.g. thermal.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: FastFissionFactorUnit[1];\n    }\n\n    attribute fastFissionFactor: FastFissionFactorValue[*] nonunique :> scalarQuantities;\n\n    attribute def FastFissionFactorUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-10 item 10-76 thermal utilization factor */\n    attribute def ThermalUtilizationFactorValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-76 thermal utilization factor\n         * symbol(s): `f`\n         * application domain: generic\n         * name: ThermalUtilizationFactor\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: in an infinite medium, the quotient of the number of thermal neutrons absorbed in a fissionable nuclide or in a nuclear fuel, as specified, and the total number of thermal neutrons absorbed\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThermalUtilizationFactorUnit[1];\n    }\n\n    attribute thermalUtilizationFactor: ThermalUtilizationFactorValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThermalUtilizationFactorUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-10 item 10-77 non-leakage probability */\n    attribute def NonLeakageProbabilityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-77 non-leakage probability\n         * symbol(s): `\u039B`\n         * application domain: generic\n         * name: NonLeakageProbability\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: probability that a neutron will not escape from the reactor during the slowing-down process or while it diffuses as a thermal neutron\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: NonLeakageProbabilityUnit[1];\n    }\n\n    attribute nonLeakageProbability: NonLeakageProbabilityValue[*] nonunique :> scalarQuantities;\n\n    attribute def NonLeakageProbabilityUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-10 item 10-78.1 multiplication factor */\n    attribute def MultiplicationFactorValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-78.1 multiplication factor\n         * symbol(s): `k`\n         * application domain: generic\n         * name: MultiplicationFactor\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the total number of fission or fission-dependent neutrons produced in the duration of a time interval and the total number of neutrons lost by absorption and leakage in that duration\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MultiplicationFactorUnit[1];\n    }\n\n    attribute multiplicationFactor: MultiplicationFactorValue[*] nonunique :> scalarQuantities;\n\n    attribute def MultiplicationFactorUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-10 item 10-78.2 infinite multiplication factor */\n    attribute def InfiniteMultiplicationFactorValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-78.2 infinite multiplication factor\n         * symbol(s): `k_\u221E`\n         * application domain: generic\n         * name: InfiniteMultiplicationFactor\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: multiplication factor (item 10-78.1) for an infinite medium or for an infinite repeating lattice\n         * remarks: For a thermal reactor, `k_\u221E = \u03B7*\u03B5*p*f`\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: InfiniteMultiplicationFactorUnit[1];\n    }\n\n    attribute infiniteMultiplicationFactor: InfiniteMultiplicationFactorValue[*] nonunique :> scalarQuantities;\n\n    attribute def InfiniteMultiplicationFactorUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-10 item 10-79 reactor time constant */\n    attribute reactorTimeConstant: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-79 reactor time constant\n         * symbol(s): `T`\n         * application domain: generic\n         * name: ReactorTimeConstant (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: duration (ISO 80000-3) required for the neutron fluence rate (item 10-44) in a reactor to change by the factor e when the fluence rate is rising or falling exponentially\n         * remarks: Also called reactor period.\n         */\n    }\n\n    /* ISO-80000-10 item 10-80.1 energy imparted */\n    attribute energyImparted: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-80.1 energy imparted\n         * symbol(s): `\u03B5`\n         * application domain: generic\n         * name: EnergyImparted (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: sum of all energy deposits in a given volume: `\u03B5 = sum_i \u03B5_i` where the summation is performed over all energy (ISO 80000-5) deposits `\u03B5_i` of interaction `i` in that volume\n         * remarks: Energy imparted is a stochastic quantity. `\u03B5_i` is given by: `\u03B5_i = \u03B5_(i n) - \u03B5_"out" + Q` where `\u03B5_(i n)` is the energy (ISO 80000-5) of the incident ionizing particle, excluding rest energy (item 10-3), `\u03B5_"out"` is the sum of the energies (ISO 80000-5) of all ionizing particles leaving the interaction, excluding rest energy (item 10-3), and `Q` is the change in the rest energies (item 10-3) of the nucleus and of all particles involved in the interaction. `Q > 0` means decrease of rest energy; `Q < 0` means increase of rest energy. Stochastic quantities such as the energy imparted and the specific energy imparted (item 10-81.2) and their probability distributions have been introduced as they describe the discontinuous nature of the ionizing radiations as a determinant of radiochemical and radiobiological effects. In radiation applications involving large numbers of ionizing particles, e.g. in medicine, radiation protection and materials testing and processing, these fluctuations are adequately represented by the expectation values of the probability distributions. Non-stochastic quantities such as particle fluence (item 10-43), absorbed dose (item 10-81.1) and kerma (item 10-86.1) are based on these expectation values.\n         */\n    }\n\n    /* ISO-80000-10 item 10-80.2 mean energy imparted */\n    attribute meanEnergyImparted: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-80.2 mean energy imparted\n         * symbol(s): `bar(\u03B5)`\n         * application domain: generic\n         * name: MeanEnergyImparted (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): eV, J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: expectation value of the energy imparted (item 10-80.1): `bar(\u03B5) = R_"in" - R_"out" + sum Q` where `R_"in"` is the radiant energy (item 10-45) of all those charged and uncharged ionizing particles that enter the volume, `R_"out"` is the radiant energy of all those charged and uncharged ionizing particles that leave the volume, and `sum Q` is the sum of all changes of the rest energy (item 10-3) of nuclei and elementary particles that occur in that volume\n         * remarks: Sometimes, it has been called the integral absorbed dose. `Q > 0` means decrease of rest energy; `Q < 0` means increase of rest energy.\n         */\n    }\n\n    /* ISO-80000-10 item 10-81.1 absorbed dose */\n    attribute def AbsorbedDoseValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-81.1 absorbed dose\n         * symbol(s): `D`\n         * application domain: generic\n         * name: AbsorbedDose\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): Gy, J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: differential quotient of `bar(\u03B5)` with respect to `m`, where `bar(\u03B5)` is the mean energy (ISO 80000-5) imparted by ionizing radiation to matter of mass (ISO 80000-4) `m`: `D = (d bar(\u03B5))/(dm)`\n         * remarks: The gray is a special name for joule per kilogram, to be used as the coherent SI unit for absorbed dose. `1 "Gy" = 1 "J"/"kg"`. `bar(\u03B5) = int D dm` where `dm` is the element of mass of the irradiated matter. In the limit of a small domain, the mean specific energy `bar(z) = (\u0394 bar(\u03B5))/(\u0394 m)` is equal to the absorbed dose `D`. The absorbed dose can also be expressed in terms of the volume of the mass element by: `D = (d bar(\u03B5))/(dm) = (d bar(\u03B5))/(\u03C1 dV)` where `\u03C1` is the mass density of the mass element. In report 85a of the ICRU a definition with an equivalent meaning is given as: The absorbed dose, `D`, is the quotient of `d bar(\u03B5)` by dm, where `d bar(\u03B5)` is the mean energy imparted by ionizing radiation to matter of mass `dm`: `D = (d bar(\u03B5))/(dm)`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AbsorbedDoseUnit[1];\n    }\n\n    attribute absorbedDose: AbsorbedDoseValue[*] nonunique :> scalarQuantities;\n\n    attribute def AbsorbedDoseUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-81.2 specific energy imparted */\n    attribute specificEnergyImparted: AbsorbedDoseValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-81.2 specific energy imparted\n         * symbol(s): `z`\n         * application domain: generic\n         * name: SpecificEnergyImparted (specializes AbsorbedDose)\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): Gy, J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: quotient of the energy imparted `\u03B5` (item 10-80.1) and the mass `m` (ISO 80000-4) of the matter in a given volume element: `z = \u03B5 / m`\n         * remarks: `z` is a stochastic quantity. In the limit of a small domain, the mean specific energy `bar(z)` is equal to the absorbed dose `D`. The specific energy imparted can be due to one or more (energy-deposition) events.\n         */\n    }\n\n    /* ISO-80000-10 item 10-82 quality factor */\n    attribute def QualityFactorForIonizingRadiationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-82 quality factor\n         * symbol(s): `Q`\n         * application domain: ionizing radiation\n         * name: QualityFactor\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: factor in the calculation and measurement of dose equivalent (item 10-83.1), by which the absorbed dose (item 10-81.1) is to be weighted in order to account for different biological effectiveness of radiations, for radiation protection purposes\n         * remarks: `Q` is determined by the linear energy transfer (item 10-85) for `\u0394 -> \u221E` , `L_\u221E` (often denoted as `L` or LET), of charged particles passing through a small volume element at this point (the value of `L_\u221E` refers to water, not to tissue; the difference, however, is small). The relationship between `L` and `Q` is given in ICRP Publication 103 (ICRP, 2007).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: QualityFactorForIonizingRadiationUnit[1];\n    }\n\n    attribute qualityFactorForIonizingRadiation: QualityFactorForIonizingRadiationValue[*] nonunique :> scalarQuantities;\n\n    attribute def QualityFactorForIonizingRadiationUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-10 item 10-83.1 dose equivalent */\n    attribute def DoseEquivalentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-83.1 dose equivalent\n         * symbol(s): `H`\n         * application domain: generic\n         * name: DoseEquivalent\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): Sv, J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: product of the absorbed dose `D` (item 10-81.1) to tissue at the point of interest and the quality factor `Q` (item 10-82) at that point: `H = DQ`\n         * remarks: The sievert (Sv) is a special name for joule per kilogram, and is the coherent SI unit for dose equivalent. `1 "Sv" = 1 "J/kg"`. The dose equivalent at a point in tissue is given by: `H = int_0^\u221E Q(L) D_L dL` where `D_L = (dD)/(dL)` is the distribution of `D` in `L` at the point of interest. See ICRP Publication 103 (ICRP, 2007). The quantities measured with radiation protection dosimeters are based on the definition `H = Q*D`. If various radiation qualities `i` have to be simultaneously accounted for, the definition is: `H = sum_i Q_i*D_i`. In ICRU 51 this quantity is denoted as "dose equivalent". In order to quantify the radiation exposition of the human body and to specify dose limits, use is made of a quantity defined in ICRP 103, the "equivalent dose to a tissue or organ": `H_T = w_T*sum_R w_R*D_{T,R}`. The weighting factors `w_T` for various tissues and organs `T` and `w_R` for various radiation qualities `R` have been numerically laid down in ICRP 103. `D_{T,R}` is the mean absorbed dose to tissue within a tissue or organ `T`, imparted by radiation with radiation quality `R`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DoseEquivalentUnit[1];\n    }\n\n    attribute doseEquivalent: DoseEquivalentValue[*] nonunique :> scalarQuantities;\n\n    attribute def DoseEquivalentUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-83.2 dose equivalent rate */\n    attribute doseEquivalentRate: DoseEquivalentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 10-83.2 dose equivalent rate\n         * symbol(s): `dot(H)`\n         * application domain: generic\n         * name: DoseEquivalentRate (specializes DoseEquivalent)\n         * quantity dimension: L^2*T^-3\n         * measurement unit(s): Sv/s, W/kg, m^2*s^-3\n         * tensor order: 0\n         * definition: differential quotient of dose equivalent `H` (item 10-83.1) with respect to time (ISO 80000-3): `dot(H) = (dH)/(dt)`\n         * remarks: `1 "Sv/s" = 1 "W/kg"`. See the remarks for item 10-83.1.\n         */\n    }\n\n    /* ISO-80000-10 item 10-84 absorbed-dose rate */\n    attribute def AbsorbedDoseRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-84 absorbed-dose rate\n         * symbol(s): `dot(D)`\n         * application domain: generic\n         * name: AbsorbedDoseRate\n         * quantity dimension: L^2*T^-3\n         * measurement unit(s): Gy/s, W/kg, m^2*s^-3\n         * tensor order: 0\n         * definition: differential quotient of the absorbed dose `D` (item 10-81.1) with respect to time (ISO 80000-3): `dot(D) = (dD)/(dt)`\n         * remarks: `1 "Gy/s"  = 1 "W/kg"` See the remarks for item 10-81.1. In report 85a of the ICRU a definition with an equivalent meaning is given as: The absorbed-does rate, `dot(D)` , is the quotient of `dD` by `dt`, where `dD` is the increment of absorbed does in the time interval `dt`: `dot(D) = (dD)/(dt)`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AbsorbedDoseRateUnit[1];\n    }\n\n    attribute absorbedDoseRate: AbsorbedDoseRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def AbsorbedDoseRateUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-85 linear energy transfer */\n    attribute def LinearEnergyTransferValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-85 linear energy transfer\n         * symbol(s): `L_\u0394`\n         * application domain: generic\n         * name: LinearEnergyTransfer\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): eV/m, J/m, kg*m*s^-2\n         * tensor order: 0\n         * definition: quotient of the mean energy (ISO 80000-4) `dE_\u0394` lost by the charged particles due to electronic interactions in traversing a distance (ISO 80000-3) `dl`, minus the mean sum of the kinetic energies in excess of `\u0394` of all the electrons released by the charged particles and `dl`: `L_\u0394 = (dE_\u0394)/(dl)`\n         * remarks: This quantity is not completely defined unless `\u0394` is specified, i.e. the maximum kinetic energy of secondary electrons whose energy is considered to be "locally deposited". `\u0394` may be expressed in `"eV"`. Note that the abbreviation LET specifically refers to the quantity `L_\u221E` mentioned in the remark to 10-82.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearEnergyTransferUnit[1];\n    }\n\n    attribute linearEnergyTransfer: LinearEnergyTransferValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearEnergyTransferUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-86.1 kerma */\n    attribute def KermaValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-86.1 kerma\n         * symbol(s): `K`\n         * application domain: generic\n         * name: Kerma\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): Gy, J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: for uncharged ionizing radiation, differential quotient of `E_(`tr) with respect to `m`, where `E_(`tr) is the mean sum of the initial kinetic energies (ISO 80000-4) of all the charged ionizing particles liberated in a mass (ISO 80000-4) `m` of a material: `K = (dE_tr)/(dm)`\n         * remarks: `1 "Gy" = 1 "J/kg"` See the remarks for item 10-81.1. The name "kerma" is derived from Kinetic Energy Released in MAtter (or MAss or MAterial). The quantity `dE_(tr)` includes also the kinetic energy of the charged particles emitted in the decay of excited atoms, molecules, or nuclei. When the mass element `dm` consists of air the term air kerma is used. It can be convenient to refer to a value of air kerma in free space or at a point inside a material different from air, e.g. to the air kerma at a point inside a water phantom. In report 85a of the ICRU a definition with an equivalent meaning is given as: The kerma, `K`, for ionizing uncharged particles, is the quotient of `dE_(tr)` by `dm`, where `dE_(tr)` is the mean sum of the initial kinetic energies of all the charged particles liberated in a mass `dm` of a material by the uncharged particles incident on `dm`: `K = (dE_(tr))/(dm)`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: KermaUnit[1];\n    }\n\n    attribute kerma: KermaValue[*] nonunique :> scalarQuantities;\n\n    attribute def KermaUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-86.2 kerma rate */\n    attribute def KermaRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-86.2 kerma rate\n         * symbol(s): `dot(K)`\n         * application domain: generic\n         * name: KermaRate\n         * quantity dimension: L^2*T^-3\n         * measurement unit(s): Gy/s, W/kg, m^2*s^-3\n         * tensor order: 0\n         * definition: differential quotient of kerma (item 10-86.1) with respect to time (ISO 80000-3): `dot(K) = (dK)/(dt)`\n         * remarks: `1 "Gy/s" = 1 "W/kg"`. See the Remarks for item 10-81.1. In report 85a of the ICRU a definition with an equivalent meaning is given as: The kerma rate, `dot(K)` , is the quotient of `dK` by `dt`, where `dK` is the increment of kerma in the time interval `dt`: `dot(K) = (dK)/(dt)`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: KermaRateUnit[1];\n    }\n\n    attribute kermaRate: KermaRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def KermaRateUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-10 item 10-87 mass energy-transfer coefficient */\n    attribute def MassEnergyTransferCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-87 mass energy-transfer coefficient\n         * symbol(s): `\u03BC_"tr"/\u03C1`\n         * application domain: generic\n         * name: MassEnergyTransferCoefficient\n         * quantity dimension: L^2*M^-1\n         * measurement unit(s): kg^-1*m^2\n         * tensor order: 0\n         * definition: for ionizing uncharged particles of a given type and energy, the differential quotient of `R_"tr"` with respect to `l`: `m_"tr"/\u03C1 = 1/\u03C1 1/R (dR_"tr")/(dl)` where `R_"tr"` is the mean energy (ISO 80000-5) that is transferred to kinetic energy (ISO 80000-4) of charged particles by interactions of the uncharged particles of incident radiant energy `R` (item 10-45) in traversing a distance (ISO 80000-3) `l` in the material of density (ISO 80000-4) `\u03C1`, divided by `\u03C1` and `R`\n         * remarks: `m_(tr)/\u03C1 = (dot(K))/\u03C8` , where `dot(K)` is kerma rate (item 10-86.2) and `\u03C8` is energy fluence rate (item 10-47). The quantity: `\u03BC_(en)/\u03C1 = \u03BC_(tr)/\u03C1(1-g)` where `g` is mean fraction of the kinetic energy of the liberated charged particles that is lost in radiative processes in the material, is called mass energy-absorption coefficient. The mass energy-absorption coefficient of a compound material depends on the stopping power of the material. Thus, its evaluation cannot, in principle, be reduced to a simple summation of the mass energy-absorption coefficient of the atomic constituents. Such a summation can provide an adequate approximation when the value of `g` is sufficiently small. In report 85a of the ICRU a definition with an equivalent meaning is given as: The mass energy-transfer coefficient, `\u03BC_(tr)/\u03C1` , of a material, for uncharged particles of a given type and energy, is the quotient of `(dR_(tr))/R` by `\u03C1 dl`, where `dR_(tr)` is the mean energy that is transferred to kinetic energy of charged particles by interactions of the uncharged particles of incident radiant energy `R` in traversing a distance `dl` in the material of density `\u03C1` : `\u03BC_(tr)/\u03C1 = 1/(\u03C1 dl) (d R_(tr))/R`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassEnergyTransferCoefficientUnit[1];\n    }\n\n    attribute massEnergyTransferCoefficient: MassEnergyTransferCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassEnergyTransferCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-10 item 10-88 exposure */\n    attribute def ExposureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-88 exposure\n         * symbol(s): `X`\n         * application domain: ionizing radiation\n         * name: Exposure\n         * quantity dimension: M^-1*T^1*I^1\n         * measurement unit(s): C/kg, kg^-1*s*A\n         * tensor order: 0\n         * definition: for X- or gamma radiation the differential quotient of `q` with respect to `m`, where `q` is the absolute value of the mean total electric charge of the ions of one sign produced when all the electrons and positrons liberated or created by photons incident on an element of dry air with mass `m` (ISO 80000-4) are completely stopped in dry air: `X = (dq)/(dm)`\n         * remarks: The ionization produced by electrons emitted in atomic or molecular relaxation is included in `dq`. The ionization due to photons emitted by radiative processes (i.e. bremsstrahlung and fluorescence photons) is not included in `dq`. This quantity should not be confused with the quantity photon exposure (ISO 80000-7), radiation exposure (ISO 80000-7), or the quantity luminous exposure (ISO 80000-7). It can be convenient to refer to a value of exposure in free space or at a point inside a material different from air, e.g. to the exposure at a point inside a water phantom. The exposure is related to the air kerma, `K_a`, (see item 10-86.1) by: `X = (e (1-g))/W K_a` , where `e` is the elementary charge (ISO 80000-1), `W` the average energy loss per elementary charge produced (item 10-60), and `g` is the fraction of the kinetic energy of liberated charged particles that is lost in radiative processes. In report 85a of the ICRU a definition with an equivalent meaning is given as: The exposure, `X`, is the quotient of `dq` by `dm`, where `dq` is the absolute value of the mean total charge of the ions of one sign produced when all the electrons and positrons liberated or created by photons incident on a mass `dm` of dry air are completely stopped in dry air: `X = (dq)/(dm)`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ExposureUnit[1];\n    }\n\n    attribute exposure: ExposureValue[*] nonunique :> scalarQuantities;\n\n    attribute def ExposureUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* ISO-80000-10 item 10-89 exposure rate */\n    attribute def ExposureRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 10-89 exposure rate\n         * symbol(s): `dot(X)`\n         * application domain: generic\n         * name: ExposureRate\n         * quantity dimension: M^-1*I^1\n         * measurement unit(s): C/(kg*s), kg^-1*A\n         * tensor order: 0\n         * definition: differential quotient of the exposure `X` (item 10-88) with respect to time (ISO 80000-3): `dot(X) = (dX)/(dt)`\n         * remarks: `1 "C/(kg s)" = 1 "A/kg"`. In report 85a of the ICRU a definition with an equivalent meaning is given as: The exposure rate, `dot(X)` , is the quotient of `dX` by `dt`, where `dX` is the increment of exposure in the time interval `dt`: `dot(X) = (dX)/(dt)`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ExposureRateUnit[1];\n    }\n\n    attribute exposureRate: ExposureRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def ExposureRateUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, electricCurrentPF); }\n    }\n\n}\n', "Domain Libraries/Quantities and Units/ISQBase.sysml": 'standard library package ISQBase {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO/IEC 80000\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n\n    /* ISO-80000-3 item 3-1.1 length */\n    attribute def LengthValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-1.1 length\n         * symbol(s): `l`, `L`\n         * application domain: generic\n         * name: Length\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: linear extent in space between any two points\n         * remarks: Length does not need to be measured along a straight line. Length is one of the seven base quantities in the International System of Units (ISO 80000-1).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LengthUnit[1];\n    }\n\n    attribute length: LengthValue[*] nonunique :> scalarQuantities;\n\n    attribute def LengthUnit :> SimpleUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-3 item 3-9 duration, time */\n    attribute def DurationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-9 duration, time\n         * symbol(s): `t`\n         * application domain: generic\n         * name: Duration\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: measure of the time difference between two events\n         * remarks: Duration is often just called time. Time is one of the seven base quantities in the International System of Quantities, ISQ (see ISO 80000-1). Duration is a measure of a time interval.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DurationUnit[1];\n    }\n\n    attribute duration: DurationValue[*] nonunique :> scalarQuantities;\n\n    attribute def DurationUnit :> SimpleUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-4 item 4-1 mass */\n    attribute def MassValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-1 mass\n         * symbol(s): `m`\n         * application domain: generic\n         * name: Mass\n         * quantity dimension: M^1\n         * measurement unit(s): kg\n         * tensor order: 0\n         * definition: property of a body which expresses itself in terms of inertia with regard to changes in its state of motion as well as its gravitational attraction to other bodies\n         * remarks: The kilogram (kg) is one of the seven base units (see ISO 80000-1) of the International System of Units, the SI. See also IEC 60050-113.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassUnit[1];\n    }\n\n    attribute mass: MassValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassUnit :> SimpleUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = massPF; }\n    }\n\n    /* ISO-80000-5 item 5-1 thermodynamic temperature, temperature */\n    attribute def ThermodynamicTemperatureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-1 thermodynamic temperature, temperature\n         * symbol(s): `T`, `\u0398`\n         * application domain: generic\n         * name: ThermodynamicTemperature\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: partial derivative of internal energy with respect to entropy at constant volume and constant number of particles in the system: `T = ((partial U)/(partial S))_(V,N)` where `U` is internal energy (item 5-20.2), `S` is entropy (item 5-18), `V` is volume (ISO 80000-3), and `N` is number of particles\n         * remarks: It is measured with a primary thermometer, examples of which are gas thermometers of different kinds, noise thermometers, or radiation thermometers. The Boltzmann constant (ISO 80000-1) relates energy at the individual particle level with thermodynamic temperature. Differences of thermodynamic temperatures or changes may be expressed either in kelvin, symbol K, or in degrees Celsius, symbol \xB0C (item 5-2). Thermodynamic temperature is one of the seven base quantities in the International System of Quantities, ISQ (see ISO 80000-1). The International Temperature Scale of 1990. For the purpose of practical measurements, the International Temperature Scale of 1990, ITS-90, was adopted by CIPM in 1989, which is a close approximation to the thermodynamic temperature scale. The quantities defined by this scale are denoted `T_90` and `t_90`, respectively (replacing `T_68` and `t_68` defined by the International Practical Temperature Scale of 1968, IPTS-68), where `t_90/(1 \xB0C) = T_90/(1 K) - 273,15`. The units of `T_90` and `t_90` are the kelvin, symbol K, and the degree Celsius, symbol \xB0C (item 5-2), respectively. For further information, see References [5], [6]. For ready conversion between temperatures reported on the International Temperature Scale and thermodynamic temperatures the systematic deviations can be found in Reference [7].\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThermodynamicTemperatureUnit[1];\n    }\n\n    attribute thermodynamicTemperature: ThermodynamicTemperatureValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThermodynamicTemperatureUnit :> SimpleUnit {\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.\'\u0398\'; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = thermodynamicTemperaturePF; }\n    }\n\n    /* IEC-80000-6 item 6-1 electric current */\n    attribute def ElectricCurrentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-1 electric current\n         * symbol(s): `I`, `i`\n         * application domain: generic\n         * name: ElectricCurrent\n         * quantity dimension: I^1\n         * measurement unit(s): A\n         * tensor order: 0\n         * definition: electric current is one of the base quantities in the International System of Quantities, ISQ, on which the International System of Units, SI, is based\n         * remarks: Electric current is the quantity that can often be measured with an ammeter. The electric current through a surface is the quotient of the electric charge (item 6-2) transferred through the surface during a time interval by the duration of that interval. For a more complete definition, see item 6-8 and IEC 60050-121, item 121-11-13.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricCurrentUnit[1];\n    }\n\n    attribute electricCurrent: ElectricCurrentValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricCurrentUnit :> SimpleUnit {\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = electricCurrentPF; }\n    }\n\n    /* ISO-80000-7 item 7-14 luminous intensity */\n    attribute def LuminousIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-14 luminous intensity\n         * symbol(s): `I_v`, `(I)`\n         * application domain: generic\n         * name: LuminousIntensity\n         * quantity dimension: J^1\n         * measurement unit(s): cd\n         * tensor order: 0\n         * definition: density of luminous flux with respect to solid angle in a specified direction, expressed by `I_v = (d\u03A6_v)/(d\u03A9)` where `\u03A6_v` is the luminous flux (item 7-13) emitted in a specified direction, and `\u03A9` is the solid angle (ISO 80000-3) containing that direction\n         * remarks: The definition holds strictly only for a point source. The distribution of the luminous intensities as a function of the direction of emission, e.g. given by the polar angles `(\u03B8,\u03D5)`, is used to determine the luminous flux (item 7-13) within a certain solid angle (ISO 80000-3) `\u03A9` of a source: `\u03A6_v = int int_\u03A9 I_v(\u03B8,\u03C6) sin(\u03B8) d\u03C6 d\u03B8`. Luminous intensity can be derived from the spectral radiant intensity distribution by `I_v = K_m int_0^\u221E I_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB`, where `K_m` is maximum luminous efficacy (item 7-11.3), `I_(e,\u03BB)(\u03BB)` is the spectral radiant intensity (item 7-5.2) at wavelength `\u03BB` (ISO 80000-3), and `V(\u03BB)` is spectral luminous efficiency (item 7-10.2). The corresponding radiometric quantity is "radiant intensity" (item 7-5.1). The corresponding quantity for photons is "photon intensity" (item 7-21).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LuminousIntensityUnit[1];\n    }\n\n    attribute luminousIntensity: LuminousIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def LuminousIntensityUnit :> SimpleUnit {\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = luminousIntensityPF; }\n    }\n\n    /* ISO-80000-9 item 9-2 amount of substance, number of moles */\n    attribute def AmountOfSubstanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-2 amount of substance, number of moles\n         * symbol(s): `n(X)`\n         * application domain: generic\n         * name: AmountOfSubstance\n         * quantity dimension: N^1\n         * measurement unit(s): mol\n         * tensor order: 0\n         * definition: quotient of number `N` of specified elementary entities of kind `X` (item 9-1) in a sample, and the Avogadro constant `N_A` (ISO 80000-1): `n(X) = N(X)/N_A`\n         * remarks: Amount of substance is one of the seven base quantities in the International System of Quantities, ISQ (see ISO 80000-1). Elementary entities, such as molecules, atoms, ions, electrons, holes and other quasi-particles, double bonds can be used. It is necessary to specify precisely the entity involved, e.g. atoms of hydrogen `H` vs. molecules of hydrogen `H_2`, preferably by giving the molecular chemical formula of the material involved. In the name "amount of substance", the words "of substance" could be replaced by words specifying the substance concerned, e.g. "amount of hydrogen chloride, `HCl`", or "amount of benzene, `C_6H_6`". The name "number of moles" is often used for "amount of substance", but this is deprecated because the name of a quantity should be distinguished from the name of the unit.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AmountOfSubstanceUnit[1];\n    }\n\n    attribute amountOfSubstance: AmountOfSubstanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def AmountOfSubstanceUnit :> SimpleUnit {\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = amountOfSubstancePF; }\n    }\n\n    attribute <isq> \'International System of Quantities\': SystemOfQuantities {\n        doc\n        /*\n         * Declaration of the International System of Quantities (ISQ), \n         * including its base quantities and symbols as specified in ISO 80000-1:2009.\n         */\n        attribute :>> baseQuantities = ( L, M, T, I, \'\u0398\', N, J );\n        \n        attribute L: LengthValue[1];\n        attribute M: MassValue[1];\n        attribute T: DurationValue[1];\n        attribute I: ElectricCurrentValue[1];\n        attribute \'\u0398\': ThermodynamicTemperatureValue[1];\n        attribute N: AmountOfSubstanceValue[1];\n        attribute J: LuminousIntensityValue[1];\n    }\n}\n', "Domain Libraries/Quantities and Units/ISQCharacteristicNumbers.sysml": 'standard library package ISQCharacteristicNumbers {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-11:2019 "Characteristic numbers"\n     * see also https://www.iso.org/standard/64982.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* ISO-80000-11 item 11-4.1 Reynolds number */\n    attribute def ReynoldsNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.1 Reynolds number\n         * symbol(s): `Re`\n         * application domain: generic\n         * name: ReynoldsNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of inertial forces and viscous forces in a fluid flow, expressed by `Re = (\u03C1*v*l)/\u03B7 = (v*l)/\u03BD`, where `\u03C1` is mass density (ISO 80000-4), `v` is speed (ISO 80000-3), `l` is characteristic length (ISO 80000-3), `\u03B7` is dynamic viscosity (ISO 80000-4), and `\u03BD` is kinematic viscosity (ISO 80000-4)\n         * remarks: The value of the Reynolds number gives an estimate on the flow state: laminar flow or turbulent flow. In rotating movement, the speed `v = \u03C9*l`, where `l` is the distance from the rotation axis and `\u03C9` is the angular velocity.\n         */\n    }\n    attribute reynoldsNumber: ReynoldsNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.2 Euler number */\n    attribute def EulerNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.2 Euler number\n         * symbol(s): `Eu`\n         * application domain: generic\n         * name: EulerNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relationship between pressure drop in a flow and the kinetic energy per volume for flow of fluids in a pipe, expressed by `Eu = (\u0394p)/(\u03C1*v^2)`, where `\u0394p` is drop of pressure (ISO 80000-4), `\u03C1` is mass density (ISO 80000-4), and `v` is speed (ISO 80000-3)\n         * remarks: The Euler number is used to characterize losses in the flow. A modification of the Euler number is considering the dimensions of the containment (pipe): `Eu^"\'" = d/l*Eu`, where `d` is inner diameter (ISO 80000-3) of the pipe, and `l` is length (ISO 80000-3).\n         */\n    }\n    attribute eulerNumber: EulerNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.3 Froude number */\n    attribute def FroudeNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.3 Froude number\n         * symbol(s): `Fr`\n         * application domain: generic\n         * name: FroudeNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of a body\u2019s inertial forces and its gravitational forces for flow of fluids, expressed by `Fr = v/sqrt(l*g)`, where `v` is speed (ISO 80000-3) of flow, `l` is characteristic length (ISO 80000-3), and `g` is acceleration of free fall (ISO 80000-3)\n         * remarks: The Froude number can be modified by buoyancy. Sometimes the square and sometimes the inverse of the Froude number as defined here is wrongly used.\n         */\n    }\n    attribute froudeNumber: FroudeNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.4 Grashof number */\n    attribute def GrashofNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.4 Grashof number\n         * symbol(s): `Gr`\n         * application domain: generic\n         * name: GrashofNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of buoyancy forces due to thermal expansion which results in a change of mass density and viscous forces for free convection due to temperature differences, expressed by `Gr = l^3*g*\u03B1_V*(\u0394T)/\u03BD^2`, where `l` is characteristic length (ISO 80000-3), `g` is acceleration of free fall (ISO 80000-3), `\u03B1_V` is thermal cubic expansion coefficient (ISO 80000-5), `\u0394T` is difference of thermodynamic temperature `T` (ISO 80000-5) between surface of the body and the fluid far away from the body, and `\u03BD` is kinematic viscosity (ISO 80000-4)\n         * remarks: Heating can occur near hot vertical walls, in pipes, or by a bluff body. The characteristic length can be the vertical height of a hot plate, the diameter of a pipe, or the effective length of a body. See also Rayleigh number (item 11-5.3).\n         */\n    }\n    attribute grashofNumber: GrashofNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.5 Weber number */\n    attribute def WeberNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.5 Weber number\n         * symbol(s): `We`\n         * application domain: generic\n         * name: WeberNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between inertial forces and capillary forces due to surface tension at the interface between two different fluids, expressed by `We = (\u03C1*v^2*l)/\u03B3`, where `\u03C1` is mass density (ISO 80000-4), `v` is speed (ISO 80000-3), `l` is characteristic length (ISO 80000-3), and `\u03B3` is surface tension (ISO 80000-4)\n         * remarks: The fluids can be gases or liquids. The different fluids often are drops moving in a gas or bubbles in a liquid. The characteristic length is commonly the diameter of bubbles or drops. The square root of the Weber number is called Rayleigh number. Sometimes the square root of the Weber number as defined here is called the Weber number. That definition is deprecated. Interfaces only exist between two fluids which are not miscible.\n         */\n    }\n    attribute weberNumber: WeberNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.6 Mach number */\n    attribute def MachNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.6 Mach number\n         * symbol(s): `Ma`\n         * application domain: generic\n         * name: MachNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the speed of flow and the speed of sound, expressed by `Ma = v/c`, where `v` is speed (ISO 80000-3) of the body, and `c` is speed of sound (ISO 80000-8) in the fluid\n         * remarks: The Mach number represents the relationship of inertial forces compared to compression forces. For an ideal gas `c = sqrt(\u03B3 p/rho) = sqrt(\u03B3 (RT)/M) = sqrt(\u03B3 (kT)/m)`, where `\u03B3` is ratio of the specific heat capacity (ISO 80000-5).\n         */\n    }\n    attribute machNumber: MachNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.7 Knudsen number */\n    attribute def KnudsenNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.7 Knudsen number\n         * symbol(s): `Kn`\n         * application domain: generic\n         * name: KnudsenNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of free path length of a particle and a characteristic length, expressed by `Kn = \u03BB/l`, where `\u03BB` is mean free path (ISO 80000-9), and `l` is characteristic length (ISO 80000-3)\n         * remarks: The Knudsen number is a measure to estimate whether the gas in flow behaves like a continuum. The characteristic length, `l`, can be a characteristic size of the gas flow region like a pipe diameter.\n         */\n    }\n    attribute knudsenNumber: KnudsenNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.8 Strouhal number, Thomson number */\n    attribute def StrouhalNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.8 Strouhal number, Thomson number\n         * symbol(s): `Sr`, `Sh`\n         * application domain: generic\n         * name: StrouhalNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between a characteristic frequency and a characteristic speed for unsteady flow with periodic behaviour, expressed by `Sr = f*l/v`, where `f` is frequency (ISO 80000-3) of vortex shedding, `l` is characteristic length (ISO 80000-3), and `v` is speed (ISO 80000-3) of flow\n         * remarks: The characteristic length, `l`, can be the diameter of an obstacle in the flow which can cause vortex shedding, or the length of it.\n         */\n    }\n    attribute strouhalNumber: StrouhalNumberValue :> scalarQuantities;\n\n    alias thomsonNumber for strouhalNumber;\n\n    /* ISO-80000-11 item 11-4.9 drag coefficient */\n    /* Refer to declaration for DragCoefficient in ISQMechanics item 4-23.4 drag coefficient */\n\n    /* ISO-80000-11 item 11-4.10 Bagnold number */\n    attribute def BagnoldNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.10 Bagnold number\n         * symbol(s): `Bg`\n         * application domain: generic\n         * name: BagnoldNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of drag force and gravitational force for a body moving in a fluid, expressed by `Bg = (c_D*\u03C1*v^2)/(l*g*\u03C1_b)`, where `c_D` is drag coefficient (item 11-4.9) of the body, `\u03C1` is mass density (ISO 80000-4) of the fluid, `v` is speed (ISO 80000-3) of the body, `l` is characteristic length (ISO 80000-3), `g` is acceleration of free fall (ISO 80000-3), and `\u03C1_b` is mass density (ISO 80000-4) of the body\n         * remarks: The characteristic length, `l`, is the body\u2019s volume divided by its cross-sectional area.\n         */\n    }\n    attribute bagnoldNumber: BagnoldNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.11 Bagnold number */\n    attribute def BagnoldNumberForSolidParticlesValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.11 Bagnold number\n         * symbol(s): `Ba_2`\n         * application domain: solid particles\n         * name: BagnoldNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of drag force and viscous force in a fluid transferring solid particles, expressed by `Ba_2 = (\u03C1_s*d^2*dot(\u03B3))/\u03B7*sqrt(1/(f_s^(1/2) - 1))`, where `\u03C1_s` is mass density (ISO 80000-4) of particles, `d` is diameter (ISO 80000-3) of particles, `dot(\u03B3) = v/d` is shear rate time-derivative of shear strain (ISO 80000-4), `\u03B7` is dynamic viscosity (ISO 80000-4) of fluid, and `f_s` is volumic fraction of solid particles\n         * remarks: None.\n         */\n    }\n    attribute bagnoldNumberForSolidParticles: BagnoldNumberForSolidParticlesValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.12 lift coefficient */\n    attribute def LiftCoefficientValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.12 lift coefficient\n         * symbol(s): `c_l`, `c_A`\n         * application domain: generic\n         * name: LiftCoefficient (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the lift force available from a wing at a given angle and the inertial force for a wing shaped body moving in a fluid, expressed by `c_l = ( 2*F_l)/(\u03C1*v^2*S) = F_l/(q*S)`, where `F_l` is lift force (ISO 80000-4) on the wing, `\u03C1` is mass density (ISO 80000-4) of the fluid, `v` is speed (ISO 80000-3) of the body, `S = A*cos(\u03B1)` is effective area (ISO 80000-3) when `\u03B1` is the angle of attack and `A` is area of the wing, and `q = 1/2*\u03C1*v^2` is dynamic pressure\n         * remarks: The lift coefficient is dependant on the shape of the wing.\n         */\n    }\n    attribute liftCoefficient: LiftCoefficientValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.13 thrust coefficient */\n    attribute def ThrustCoefficientValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.13 thrust coefficient\n         * symbol(s): `c_t`\n         * application domain: generic\n         * name: ThrustCoefficient (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the effective thrust force available from a propeller and the inertial force in a fluid, expressed by `c_t = F_T/(\u03C1*n^2*d^4)`, where `F_T` is thrust force (ISO 80000-4) of the propeller, `\u03C1` is mass density (ISO 80000-4) of the fluid, `n` is rotational frequency (ISO 80000-3), and `d` is tip diameter (ISO 80000-3) of the propeller\n         * remarks: The thrust coefficient is dependant on the shape of the propeller.\n         */\n    }\n    attribute thrustCoefficient: ThrustCoefficientValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.14 Dean number */\n    attribute def DeanNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.14 Dean number\n         * symbol(s): `Dn`\n         * application domain: generic\n         * name: DeanNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between centrifugal force and inertial force, for flows of fluids in curved pipes, expressed by `Dn = (2*v*r)/\u03BD*sqrt(r/R)`, where `v` is (axial) speed (ISO 80000-3), `r` is radius (ISO 80000-3) of the pipe, `\u03BD` is kinematic viscosity (ISO 80000-4) of the fluid, and `R` is radius of curvature (ISO 80000-3) of the path of the pipe\n         * remarks: None.\n         */\n    }\n    attribute deanNumber: DeanNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.15 Bejan number */\n    attribute def BejanNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.15 Bejan number\n         * symbol(s): `Be`\n         * application domain: generic\n         * name: BejanNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mechanical work and frictional energy loss in fluid dynamics in a pipe, expressed by `Be = (\u0394p*\u03C1*l^2)/(\u03B7*\u03BD)`, where `p` is drop of pressure (ISO 80000-4) along the pipe, `l` is characteristic length (ISO 80000-3), `\u03B7` is dynamic viscosity (ISO 80000-4), `\u03BD` is kinematic viscosity (ISO 80000-4), and `\u03C1` is mass density (ISO 80000-4)\n         * remarks: A similar number exists for heat transfer (item 11-5.9). The kinematic viscosity is also called momentum diffusivity.\n         */\n    }\n    attribute bejanNumber: BejanNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.16 Lagrange number */\n    attribute def LagrangeNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.16 Lagrange number\n         * symbol(s): `Lg`\n         * application domain: generic\n         * name: LagrangeNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mechanical work and frictional energy loss in fluid dynamics in a pipe, expressed by `Lg = (l*\u0394p)/(\u03B7*v)`, where `l` is length (ISO 80000-3) of the pipe, `\u0394p` is drop of pressure (ISO 80000-4) along the pipe, `\u03B7` is dynamic viscosity (ISO 80000-4), and `v` is speed (ISO 80000-3)\n         * remarks: The Lagrange number is also given by `Lg = Re*Eu`, where `Re` is the Reynolds number (item 11-4.1), and `Eu` is the Euler number (item 11-4.2).\n         */\n    }\n    attribute lagrangeNumber: LagrangeNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.17 Bingham number, plasticity number */\n    attribute def BinghamNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.17 Bingham number, plasticity number\n         * symbol(s): `Bm`, `Bn`\n         * application domain: generic\n         * name: BinghamNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of yield stress and viscous stress in a viscous material for flow of viscoplastic material in channels, expressed by `Bm = (\u03C4*d)/(\u03B7*v)`, where `\u03C4` is shear stress (ISO 80000-4), `d` is characteristic diameter (ISO 80000-3), e.g. effective channel width, `\u03B7` is dynamic viscosity (ISO 80000-4), and `v` is speed (ISO 80000-3)\n         * remarks: None.\n         */\n    }\n    attribute binghamNumber: BinghamNumberValue :> scalarQuantities;\n\n    alias plasticityNumber for binghamNumber;\n\n    /* ISO-80000-11 item 11-4.18 Hedstr\xF6m number */\n    attribute def \'Hedstr\xF6mNumberValue\' :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.18 Hedstr\xF6m number\n         * symbol(s): `He`, `Hd`\n         * application domain: generic\n         * name: Hedstr\xF6mNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of yield stress and viscous stress of a viscous material at flow limit for visco-plastic material in a channel, expressed by `He = (\u03C4_0*d^2*\u03C1)/\u03B7^2`, where `\u03C4_0` is shear stress (ISO 80000-4) at flow limit, `d` is characteristic diameter (ISO 80000-3), e.g. effective channel width, `\u03C1` is mass density (ISO 80000-4), and `\u03B7` is dynamic viscosity (ISO 80000-4)\n         * remarks: None.\n         */\n    }\n    attribute \'hedstr\xF6mNumber\': \'Hedstr\xF6mNumberValue\' :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.19 Bodenstein number */\n    attribute def BodensteinNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.19 Bodenstein number\n         * symbol(s): `Bd`\n         * application domain: generic\n         * name: BodensteinNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: mathematical expression of the transfer of matter by convection in reactors with respect to diffusion, `Bd = (v*l)/D`, where `v` is speed (ISO 80000-3), `l` is length (ISO 80000-3) of the reactor, and `D` is diffusion coefficient (ISO 80000-9)\n         * remarks: The Bodenstein number is also given by `Bd = Pe^"*" = Re*Sc`, where `Pe^"*"` is the P\xE9clet number for mass transfer (item 11-6.2), `Re` is the Reynolds number (item 11-4.1), and `Sc = \u03B7/(\u03C1*D) = \u03BD/D` is the Schmidt number (item 11-7.2).\n         */\n    }\n    attribute bodensteinNumber: BodensteinNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.20 Rossby number, Kiebel number */\n    attribute def RossbyNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.20 Rossby number, Kiebel number\n         * symbol(s): `Ro`\n         * application domain: generic\n         * name: RossbyNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of inertial forces and Coriolis forces in the context of transfer of matter in geophysics, expressed by `Ro = v/(2*l*\u03C9_E*sin(\u03C6)`, where `v` is speed (ISO 80000-3) of motion, `l` is characteristic length (ISO 80000-3), the scale of the phenomenon, `\u03C9_E` is angular velocity (ISO 80000-3) of the Earth\'s rotation, and `\u03C6` is angle (ISO 80000-3) of latitude\n         * remarks: The Rossby number represents the effect of Earth\'s rotation on flow in pipes, rivers, ocean currents, tornadoes, etc. The quantity `\u03C9_E*sin(\u03C6)` is called Coriolis frequency.\n         */\n    }\n    attribute rossbyNumber: RossbyNumberValue :> scalarQuantities;\n\n    alias kiebelNumber for rossbyNumber;\n\n    /* ISO-80000-11 item 11-4.21 Ekman number */\n    attribute def EkmanNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.21 Ekman number\n         * symbol(s): `Ek`\n         * application domain: generic\n         * name: EkmanNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of viscous forces and Coriolis forces in the context of transfer of matter for the flow of a rotating fluid, expressed by `Ek = \u03BD/(2*l^2*\u03C9_E*sin(\u03C6))`, where `\u03BD` is kinematic viscosity (ISO 80000-4), `l` is characteristic length (ISO 80000-3), the scale of the phenomenon, `\u03C9_E` is angular frequency (ISO 80000-3) of the Earth\u2019s rotation, and `\u03C6` is angle of latitude\n         * remarks: In plasma physics, the square root of this number is used. The Ekman number is also given by `Ek = (Ro)/(Re)`, where `Ro` is the Rossby number (item 11-4.20), and `Re` is the Reynolds number (item 11-4.1).\n         */\n    }\n    attribute ekmanNumber: EkmanNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.22 elasticity number */\n    attribute def ElasticityNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.22 elasticity number\n         * symbol(s): `El`\n         * application domain: generic\n         * name: ElasticityNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between relaxation time and diffusion time in viscoelastic flows, expressed by `El = (t_r*\u03BD)/r^2`, where `t_r` is relaxation time (ISO 80000-12), `\u03BD` is kinematic viscosity (ISO 80000-4), and `r` is radius (ISO 80000-3) of pipe\n         * remarks: See also Deborah number (item 11-7.8).\n         */\n    }\n    attribute elasticityNumber: ElasticityNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.23 Darcy friction factor, Moody friction factor */\n    attribute def DarcyFrictionFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.23 Darcy friction factor, Moody friction factor\n         * symbol(s): `f_D`\n         * application domain: generic\n         * name: DarcyFrictionFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: representation of pressure loss in a pipe due to friction within a laminar or turbulent flow of a fluid in a pipe, expressed by `f_D = (2*\u0394p)/(\u03C1*v^2)*d/l`, where `\u0394p` is drop of pressure (ISO 80000-4) due to friction, `\u03C1` is mass density (ISO 80000-4) of the fluid, `v` is (average) speed (ISO 80000-3) of the fluid in the pipe, `d` is diameter (ISO 80000-3) of the pipe, and `l` is length (ISO 80000-3) of the pipe\n         * remarks: None.\n         */\n    }\n    attribute darcyFrictionFactor: DarcyFrictionFactorValue :> scalarQuantities;\n\n    alias moodyFrictionFactor for darcyFrictionFactor;\n\n    /* ISO-80000-11 item 11-4.24 Fanning number */\n    attribute def FanningNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.24 Fanning number\n         * symbol(s): `f_n`, `f`\n         * application domain: generic\n         * name: FanningNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between shear stress and dynamic pressure in the flow of a fluid in a containment, expressed by `f_n = (2*\u03C4)/(\u03C1*v^2)`, where `\u03C4` is shear stress (ISO 80000-4) at the wall, `\u03C1` is mass density (ISO 80000-4) of the fluid, and `v` is speed (ISO 80000-3) of the fluid in the pipe\n         * remarks: The Fanning number describes the flow of fluids in a pipe with friction at the walls represented by its shear stress. Symbol `f` may be used where no conflicts are possible.\n         */\n    }\n    attribute fanningNumber: FanningNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.25 Goertler number, Goertler parameter */\n    attribute def GoertlerNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.25 Goertler number, Goertler parameter\n         * symbol(s): `Go`\n         * application domain: generic\n         * name: GoertlerNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: characterization of the stability of laminar boundary layer flows in transfer of matter in a boundary layer on curved surfaces, expressed by `Go = (v*l_b)/\u03BD * sqrt(l_b/r_c)`, where `v` is speed (ISO 80000-3), `l_b` is boundary layer thickness (ISO 80000-3), `\u03BD` is kinematic viscosity (ISO 80000-4), and `r_c` is radius of curvature (ISO 80000-3)\n         * remarks: The Goertler number represents the ratio of centrifugal effects to viscous effects.\n         */\n    }\n    attribute goertlerNumber: GoertlerNumberValue :> scalarQuantities;\n\n    alias goertlerParameter for goertlerNumber;\n\n    /* ISO-80000-11 item 11-4.26 Hagen number */\n    attribute def HagenNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.26 Hagen number\n         * symbol(s): `Hg`, `Ha`\n         * application domain: generic\n         * name: HagenNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: generalization of the Grashof number for forced or free convection in laminar flow, expressed by `Hg = -1/\u03C1*(dp)/(dx)*l^3/\u03BD^2`, where `\u03C1` is mass density (ISO 80000-4) of fluid, `(dp)/(dx)` is gradient of pressure (ISO 80000-4), `l` is characteristic length (ISO 80000-3), and `\u03BD` is kinematic viscosity (ISO 80000-4)\n         * remarks: For free thermal convection with `(dp)/(dx) = \u03C1*g*\u03B1_V*\u0394T`, the Hagen number then coincides with the Grashof number (item 11-4.4). See also the Poiseuille number (item 11-4.28).\n         */\n    }\n    attribute hagenNumber: HagenNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.27 Laval number */\n    attribute def LavalNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.27 Laval number\n         * symbol(s): `La`\n         * application domain: generic\n         * name: LavalNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of speed and the (critical) sound speed at the throat of a nozzle, expressed by `La = v/sqrt((R_s*T*2*\u03B3)/(\u03B3+1))`, where `v` is speed (ISO 80000-3), \xA0`R_s = R/M` is specific gas constant, where `R` is molar gas constant (ISO 80000-9), and `M` is molar mass (ISO 80000-9), `T` is thermodynamic temperature (ISO 80000-5), and `\u03B3` is ratio of the specific heat capacities (ISO 80000-5)\n         * remarks: The Laval number is a specific kind of Mach number (item 11-4.6).\n         */\n    }\n    attribute lavalNumber: LavalNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.28 Poiseuille number */\n    attribute def PoiseuilleNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.28 Poiseuille number\n         * symbol(s): `Poi`\n         * application domain: generic\n         * name: PoiseuilleNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of propulsive force by pressure and viscous force for a flow of fluids in a pipe, expressed by `Poi = -(\u0394p)/l*d^2/(\u03B7*v)`, where `\u0394p` is drop of pressure (ISO 80000-4) along the pipe, `l` is length (ISO 80000-3) of the pipe, `d` is diameter (ISO 80000-3) of the pipe, `\u03B7` is dynamic viscosity (ISO 80000-4) of the fluid, and `v` is characteristic speed (ISO 80000-3) of the fluid\n         * remarks: The Poiseuille number is `Poi=32` for laminar flow in a round pipe. See also the Hagen number (item 11-4.26).\n         */\n    }\n    attribute poiseuilleNumber: PoiseuilleNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.29 power number */\n    attribute def PowerNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.29 power number\n         * symbol(s): `Pn`\n         * application domain: generic\n         * name: PowerNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of power consumption by agitators due to drag and rotational inertial power in fluids, expressed by `Pn = P/(\u03C1*n^3*d^5)`, where `P` is active power (IEC 80000-6) consumed by a stirrer, `\u03C1` is mass density (ISO 80000-4) of fluid, `n` is rotational frequency (ISO 80000-3), and `d` is diameter (ISO 80000-3) of stirrer\n         * remarks: None.\n         */\n    }\n    attribute powerNumber: PowerNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.30 Richardson number */\n    attribute def RichardsonNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.30 Richardson number\n         * symbol(s): `Ri`\n         * application domain: generic\n         * name: RichardsonNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of potential energy and kinetic energy for a falling body, expressed by `Ri = (g*h)/v^2`, where `g` is acceleration of free fall (ISO 80000-3), `h` is characteristic height (ISO 80000-3), and `v` is characteristic speed (ISO 80000-3)\n         * remarks: In geophysics differences of these quantities are of interest.\n         */\n    }\n    attribute richardsonNumber: RichardsonNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.31 Reech number */\n    attribute def ReechNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.31 Reech number\n         * symbol(s): `Ree`\n         * application domain: generic\n         * name: ReechNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between the speed of an object submerged in water relative to the water, and wave propagation speed, expressed by `Ree = (g*l)/v`, where `g` is acceleration of free fall (ISO 80000-3), `l` is characteristic length (ISO 80000-3), and `v` is speed (ISO 80000-3) of the object relative to the water\n         * remarks: The Reech number can be used to determine the resistance of a partially submerged object (e.g. a ship) of length `l` (in direction of the motion) moving through water. A similar quantity is defined as the Boussinesq number `Bs = v/sqrt(2*g*l)` .\n         */\n    }\n    attribute reechNumber: ReechNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.32 Stokes number */\n    attribute def StokesNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.32 Stokes number\n         * symbol(s): `Stk`\n         * application domain: time-related\n         * name: StokesNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of friction and inertia forces for particles in a fluid or in a plasma, expressed by `Stk = t_r/t_a`, where `t_r` is relaxation time (ISO 80000-12) of particles to achieve fluid\u2019s velocity due to friction (viscosity), and `t_a` is time (ISO 80000-3) of fluid to alter its velocity under external influence\n         * remarks: In most cases `t_r = l/v`, where `l` is characteristic length, and `v` is speed of fluid. The characteristic length can be the diameter of an obstacle or hole.\n         */\n    }\n    attribute stokesNumber: StokesNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.33 Stokes number */\n    attribute def StokesNumberForVibratingParticlesValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.33 Stokes number\n         * symbol(s): `Stk_1`\n         * application domain: vibrating particles\n         * name: StokesNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of friction and inertia forces for the special case of particles vibrating in a fluid or plasma, expressed by `Stk_1 = \u03BD/(d^2*f)`, where `\u03BD` is kinematic viscosity (ISO 80000-4) of the fluid or plasma, `d` is diameter (ISO 80000-3) of particle, and `f` is frequency (ISO 80000-3) of particle vibrations\n         * remarks: Sometimes the inverse of this number is wrongly used.\n         */\n    }\n    attribute stokesNumberForVibratingParticles: StokesNumberForVibratingParticlesValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.34 Stokes number, power coefficient */\n    attribute def StokesNumberForRotameterValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.34 Stokes number, power coefficient\n         * symbol(s): `Stk_2`\n         * application domain: rotameter\n         * name: StokesNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: Stokes number for calibration of rotameters metering vertical flows of fluids by means of a floating body, expressed by `Stk_2 = (r^3*g*m*\u03C1)/(\u03B7^2) * (\u03C1_b-\u03C1)/(\u03C1_b) = (r^3*g*m)/\u03BD^2 * (1/\u03C1-1/\u03C1_b)`, where `r` is ratio of pipe and float radii, `g` is acceleration of free fall (ISO 80000-3), `m` is mass (ISO 80000-4) of the body, `\u03C1` is mass density (ISO 80000-4) of the fluid, `\u03B7` is dynamic viscosity (ISO 80000-4) of the fluid, `\u03C1_b` is mass density (ISO 80000-4) of the body, and `\u03BD` is kinematic viscosity (ISO 80000-4) of the fluid\n         * remarks: In general use, this value is multiplied by 1,042. See also the Archimedes number (item 11-6.12).\n         */\n    }\n    attribute stokesNumberForRotameter: StokesNumberForRotameterValue :> scalarQuantities;\n\n    alias powerCoefficient for stokesNumber;\n\n    /* ISO-80000-11 item 11-4.35 Stokes number */\n    attribute def StokesNumberForGravityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.35 Stokes number\n         * symbol(s): `Stk_3`\n         * application domain: gravity\n         * name: StokesNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between viscous forces and gravity forces for particles falling in a fluid, expressed by `Stk_3 = (v*\u03BD)/(g*l^2)`, where `v` is characteristic speed (ISO 80000-3) of particles, `\u03BD` is kinematic viscosity (ISO 80000-4) of the fluid, `g` is acceleration of free fall (ISO 80000-3), and `l` is length (ISO 80000-3) of fall\n         * remarks: None.\n         */\n    }\n    attribute stokesNumberForGravity: StokesNumberForGravityValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.36 Stokes number */\n    attribute def StokesNumberForDragValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.36 Stokes number\n         * symbol(s): `Stk_4`\n         * application domain: drag\n         * name: StokesNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of drag force and internal friction forces for particles dragged in a fluid `Stk_4 = F_D/(\u03B7*v*l)`, where `F_D` is drag force (ISO 80000-4), `\u03B7` is dynamic viscosity (ISO 80000-4), `v` is speed (ISO 80000-3), and `l` is characteristic length (ISO 80000-3)\n         * remarks: None.\n         */\n    }\n    attribute stokesNumberForDrag: StokesNumberForDragValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.37 Laplace number, Suratman number */\n    attribute def LaplaceNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.37 Laplace number, Suratman number\n         * symbol(s): `La`, `Su`\n         * application domain: generic\n         * name: LaplaceNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between capillary forces and viscous forces when characterizing free surface flow, expressed by `La = Su = (\u03B3*\u03C1*l)/\u03B7^2`, where `\u03B3` is surface tension (ISO 80000-4), `\u03C1` is mass density (ISO 80000-4) of the fluid, `l` is characteristic length (ISO 80000-3), and `\u03B7` is dynamic viscosity (ISO 80000-4) of the fluid\n         * remarks: The Laplace number is also the ratio of surface tension to momentum transfer, especially dissipation, inside a fluid. The Laplace number is also given by `La = Su = 1/(Oh)^2 = (Re)^2/(We)`, where `Oh` is the Ohnesorge number (item 11-7.4), `Re` is the Reynolds number (item 11-4.1), and `We` is the Weber number (item 11-4.5).\n         */\n    }\n    attribute laplaceNumber: LaplaceNumberValue :> scalarQuantities;\n\n    alias suratmanNumber for laplaceNumber;\n\n    /* ISO-80000-11 item 11-4.38 Blake number */\n    attribute def BlakeNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.38 Blake number\n         * symbol(s): `Bl`\n         * application domain: generic\n         * name: BlakeNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between inertial forces and viscous forces in a porous material, expressed by `Bl = (v*\u03C1*l)/(\u03B7*(1-\u03B5))`, where `v` is speed (ISO 80000-3) of the fluid, `\u03C1` is mass density (ISO 80000-4) of the fluid, `l` is characteristic length (ISO 80000-3) defined as the volume of a particle divided by its surface area, `\u03B7` is dynamic viscosity (ISO 80000-4) of the fluid, and `\u03B5` is porosity of the material (=void fraction)\n         * remarks: The Blake number can be interpreted as a Reynolds number for flow in porous material.\n         */\n    }\n    attribute blakeNumber: BlakeNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.39 Sommerfeld number */\n    attribute def SommerfeldNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.39 Sommerfeld number\n         * symbol(s): `So`, `Sm`\n         * application domain: generic\n         * name: SommerfeldNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between viscous force and load force in a lubrication boundary, expressed by `So = (\u03B7*n)/p*(r/c)^2`, where `\u03B7` is dynamic viscosity (ISO 80000-4) of the lubricant, `n` is rotational frequency (ISO 80000-3), `p` is mean bearing pressure (ISO 80000-4), `r` is radius (ISO 80000-3) of the shaft, and `c` is radial distance (ISO 80000-3) between rotating shaft and annulus\n         * remarks: Sometimes the inverse of this number is wrongly used.\n         */\n    }\n    attribute sommerfeldNumber: SommerfeldNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.40 Taylor number */\n    attribute def TaylorNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.40 Taylor number\n         * symbol(s): `Ta`\n         * application domain: momentum transfer\n         * name: TaylorNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between centrifugal force and viscous force of a rotating shaft, expressed by `Ta = (4*\u03C9^2*l^4)/\u03BD^2`, where `\u03C9` is angular velocity (ISO 80000-3) of rotation, `l` is length (ISO 80000-3) perpendicular to the rotation axis, and `\u03BD` is kinematic viscosity (ISO 80000-4)\n         * remarks: Sometimes the square root of this quantity is wrongly used. The Taylor number for a rotating shaft relative to an annulus is given by `Ta_a = (\u03C9/nu)^2*r*a^3`, where `\u03C9` is angular velocity (ISO 80000-3) of the shaft, `nu` is kinematic viscosity (ISO 80000-4), `r = (r_2+r_1)/2` is mean radius (ISO 80000-3) of the annulus, and `a = (r_2 - r_1)` is width of the annulus, where `r_1` is inner radius of the annulus, and `r_2` is outer radius of the annulus. Sometimes the square root of this quantity is used; this use is deprecated.\n         */\n    }\n    attribute taylorNumber: TaylorNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.41 Galilei number */\n    attribute def GalileiNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.41 Galilei number\n         * symbol(s): `Ga`\n         * application domain: generic\n         * name: GalileiNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between gravitational force and viscous force in fluid films flowing over walls, expressed by `Ga = (g*l^3)/\u03BD^2`, where `g` is acceleration of free fall (ISO 80000-3), `l` is characteristic length (ISO 80000-3), and `\u03BD` is kinematic viscosity (ISO 80000-4) of the fluid\n         * remarks: The Galilei number is also given by `Ga = Re^2*Ri` or `Ga = {:Re:}^2/{:Fr:}^2`, where `Re` is the Reynolds number (item 11-4.1), `Ri` is the Richardson number (item 11-4.30), and `Fr` is the Froude number (item 11-4.3).\n         */\n    }\n    attribute galileiNumber: GalileiNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-4.42 Womersley number */\n    attribute def WomersleyNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-4.42 Womersley number\n         * symbol(s): `Wo`, `\u03B1`\n         * application domain: generic\n         * name: WomersleyNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between inertial forces and viscous forces in oscillating flows of fluids in pipes, expressed by `Wo = R*sqrt(\u03C9/\u03BD)`, where `R` is (effective) radius (ISO 80000-3) of the pipe, `\u03C9` is angular frequency (ISO 80000-3) of oscillations, and `\u03BD` is kinematic viscosity (ISO 80000-4)\n         * remarks: The Womersley number is used for pulsating flows e.g. in blood flow.\n         */\n    }\n    attribute womersleyNumber: WomersleyNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.1 Fourier number */\n    attribute def FourierNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.1 Fourier number\n         * symbol(s): `Fo`\n         * application domain: heat transfer\n         * name: FourierNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between heat conduction rate and the rate of thermal energy storage in a body for conductive heat transfer into a body, expressed by `Fo = (a*t)/l^2`, where `a` is thermal diffusivity (ISO 80000-5), `t` is time (ISO 80000-3), and `l` is characteristic length (ISO 80000-3)\n         * remarks: The characteristic length `l` of the body is often defined as the quotient of the body\u2019s volume and its heated surface. Sometimes the reciprocal of this number is wrongly used.\n         */\n    }\n    attribute fourierNumber: FourierNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.2 P\xE9clet number */\n    attribute def \'P\xE9cletNumberValue\' :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.2 P\xE9clet number\n         * symbol(s): `Pe`\n         * application domain: heat transfer\n         * name: P\xE9cletNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between convective heat transfer rate and conductive heat transfer rate, expressed by `Pe = (v*l)/a`, where `v` is speed (ISO 80000-3), `l` is length (ISO 80000-3) in the direction of heat transfer, and `a` is thermal diffusivity (ISO 80000-5)\n         * remarks: The thermal P\xE9clet number is also given by `Pe = Re*Pr`, where `Re` is the Reynolds number (item 11-4.1), and `Pr` is the Prandtl number (item 11-7.1). Compare with item 11-6.2, P\xE9clet number for mass transfer.\n         */\n    }\n    attribute \'p\xE9cletNumber\': \'P\xE9cletNumberValue\' :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.3 Rayleigh number */\n    attribute def RayleighNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.3 Rayleigh number\n         * symbol(s): `Ra`\n         * application domain: generic\n         * name: RayleighNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between buoyancy forces due to thermal expansion and viscous forces in free convection in buoyancy driven flow near a heated surface perpendicular to the gravity force, expressed by `Ra = (l^3*g*\u03B1_V*\u0394T)/(\u03BD*a)`, where `l` is distance (ISO 80000-3) from the wall, `g` is acceleration of free fall (ISO 80000-3), `\u03B1_V` is cubic expansion coefficient (ISO 80000-5) of the fluid, `\u0394T` is difference of thermodynamic temperature (ISO 80000-5) between surface of the wall and the fluid far away from the wall, `\u03BD` is kinematic viscosity (ISO 80000-4) of the fluid, and `a` is thermal diffusivity (ISO 80000-5) of the fluid\n         * remarks: The Rayleigh number is also given by `Ra = Gr*Pr`, where `Gr` is the Grashof number (item 11-4.4), and `Pr` is the Prandtl number (item 11-7.1).\n         */\n    }\n    attribute rayleighNumber: RayleighNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.4 Froude number */\n    attribute def FroudeNumberForHeatTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.4 Froude number\n         * symbol(s): `Fr^"*"`\n         * application domain: heat transfer\n         * name: FroudeNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of gravitational forces and thermodiffusion forces for heat transfer in forced convection of fluids, expressed by `Fr^"*" = (g*l^3)/a^2`, where `g` is acceleration of free fall (ISO 80000-3), `l` is characteristic length (ISO 80000-3), and `a` is thermal diffusivity (ISO 80000-5)"\n         * remarks: None.\n         */\n    }\n    attribute froudeNumberForHeatTransfer: FroudeNumberForHeatTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.5 Nusselt number */\n    attribute def NusseltNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.5 Nusselt number\n         * symbol(s): `Nu`\n         * application domain: heat transfer\n         * name: NusseltNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between the internal thermal resistance of a body and its surface thermal resistance in a body transferring heat from a surface into its interior or vice versa, expressed by `Nu = (K*l)/\u03BB = (K*l)/(a*\u03C1*c_p)`, where `K` is coefficient of heat transfer (ISO 80000-5) through the surface, `l` is length (ISO 80000-3) of the body in direction of heat flow, `\u03BB` is thermal conductivity (ISO 80000-5) of the surface, `a` is thermal diffusivity (ISO 80000-5), `\u03C1` is mass density (ISO 80000-4), and `c_p` is specific heat capacity at constant pressure (ISO 80000-5)\n         * remarks: The body under consideration can be a solid body, a fluid, or their combination, and additional heat transfer due to convective motion can occur. In case of merely conductive heat transfer especially in a solid body, the "Biot number for heat transfer" (item 11-5.6) is used.\n         */\n    }\n    attribute nusseltNumber: NusseltNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.6 Biot number */\n    attribute def BiotNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.6 Biot number\n         * symbol(s): `Bi`\n         * application domain: heat transfer\n         * name: BiotNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: special case of the Nusselt number for heat transfer (item 11-5.5) in case of conductive heat transfer in a solid body, expressed by `Bi = (K*l)/\u03BB`, where `K` is coefficient of heat transfer (ISO 80000-5) through the surface, `l` is characteristic length (ISO 80000-3), and `\u03BB` is thermal conductivity (ISO 80000-5) of the body\n         * remarks: The characteristic length is commonly defined as the volume of the body divided by its surface area.\n         */\n    }\n    attribute biotNumber: BiotNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.7 Stanton number */\n    attribute def StantonNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.7 Stanton number\n         * symbol(s): `St`\n         * application domain: heat transfer\n         * name: StantonNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between heat transfer into a fluid from a surface and its heat transfer by convection, expressed by `St = K/(\u03C1*v*c_p)`, where `K` is coefficient of heat transfer (ISO 80000-5) through the surface, `\u03C1` is mass density (ISO 80000-4), `v` is speed (ISO 80000-3), and `c_p` is specific heat capacity at constant pressure (ISO 80000-5) of the fluid\n         * remarks: The Stanton number is also given by `St = (Nu)/(Re*Pr) = (Nu)/(Pe)`, where `Nu` is Nusselt number for heat transfer (item 11-5.5), `Re` is the Reynolds number (item 11-4.1), `Pr` is the Prandtl number (item 11-7.1), and Pe  is the P\xE9clet number (item 11-5.2). Sometimes this quantity is called Margoulis number, symbol `Ms` or `Mg`.\n         */\n    }\n    attribute stantonNumber: StantonNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.8 j-factor, heat transfer factor, Colburn number */\n    attribute def JFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.8 j-factor, heat transfer factor, Colburn number\n         * symbol(s): `j`, `Co`, `Jq`\n         * application domain: heat transfer\n         * name: JFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between heat transfer and mass transfer in a fluid, expressed by `j = K/(c_p*\u03C1*v)*((c_p*\u03B7)/\u03BB)^(2/3)`, where `K` is coefficient of heat transfer (ISO 80000-5), `c_p` is specific heat capacity at constant pressure (ISO 80000-5), `\u03C1` is mass density (ISO 80000-4), `v` is speed (ISO 80000-3), `\u03B7` is dynamic viscosity (ISO 80000-4), and `\u03BB` is thermal conductivity (ISO 80000-5)\n         * remarks: The heat transfer factor is also given by `j = St*Pr^(2/3)`, where `St` is the Stanton number for heat transfer (item 11-5.7), and `Pr` is the Prandtl number (item 11-7.1). See also mass transfer factor (item 11-6.7).\n         */\n    }\n    attribute jFactor: JFactorValue :> scalarQuantities;\n\n    alias heatTransferFactor for jFactor;\n\n    alias colburnNumber for jFactor;\n\n    /* ISO-80000-11 item 11-5.9 Bejan number */\n    attribute def BejanNumberForHeatTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.9 Bejan number\n         * symbol(s): `Be_1`\n         * application domain: heat transfer\n         * name: BejanNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mechanical work and frictional and thermal diffusion energy losses for a forced flow, expressed by `Be_1 = (\u0394p*l^2)/(\u03B7*a)`, where `\u0394p` is drop of pressure (ISO 80000-4) along a pipe, `l` is length (ISO 80000-3) of the pipe, `\u03B7` is dynamic viscosity (ISO 80000-4), and `a` is thermal diffusivity (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n    attribute bejanNumberForHeatTransfer: BejanNumberForHeatTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.10 Bejan number */\n    attribute def BejanNumberForEntropyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.10 Bejan number\n         * symbol(s): `Be_S`\n         * application domain: entropy\n         * name: BejanNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: efficiency of heat transfer by a fluid, expressed by `Be_S = (S(\u0394T))/(S(\u0394T)+S(\u0394p))`, where `S(\u0394T)` is entropy generation contributed by heat transfer, and `S(\u0394p)` is entropy generation contributed by fluid friction\n         * remarks: None.\n         */\n    }\n    attribute bejanNumberForEntropy: BejanNumberForEntropyValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.11 Stefan number */\n    attribute def StefanNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.11 Stefan number\n         * symbol(s): `Ste`, `Stf`\n         * application domain: phase transition\n         * name: StefanNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between heat content and latent heat content in a binary mixture undergoing a phase transition, expressed by `Ste = (c_p*\u0394T)/Q`, where `c_p` is specific heat capacity at constant pressure (ISO 80000-5), `\u0394T` is difference of thermodynamic temperature T (ISO 80000-5) between the phases, and `Q` is quotient of latent heat of phase transition (ISO 80000-5) and mass (ISO 80000-4)\n         * remarks: None.\n         */\n    }\n    attribute stefanNumber: StefanNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.12 Brinkman number */\n    attribute def BrinkmanNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.12 Brinkman number\n         * symbol(s): `Br`, `N_(Br)`\n         * application domain: generic\n         * name: BrinkmanNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between heat produced by viscosity and heat conducted from a wall adjacent to a fluid moving relative to it, expressed by `Br = (\u03B7*v^2)/(\u03BB*\u0394T)`, where `\u03B7` is dynamic viscosity (ISO 80000-4), `v` is characteristic speed (ISO 80000-3), `\u03BB` is thermal conductivity (ISO 80000-5), and `\u0394T = T_W - T_0` is difference of thermodynamic temperature `T` (ISO 80000-5), where `T_0` is bulk fluid temperature, and `T_W` is wall temperature\n         * remarks: None.\n         */\n    }\n    attribute brinkmanNumber: BrinkmanNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.13 Clausius number */\n    attribute def ClausiusNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.13 Clausius number\n         * symbol(s): `Cl`\n         * application domain: generic\n         * name: ClausiusNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between energy transfer associated with fluid momentum and energy transfer by thermal conduction in forced heating, expressed by `Cl = (v^3*l*\u03C1)/(\u03BB*\u0394T)`, where `v` is speed (ISO 80000-3), `l` is length (ISO 80000-3) of the path of energy transfer, `\u03C1` is mass density (ISO 80000-4), `\u03BB` is thermal conductivity (ISO 80000-5), and `\u0394T` is difference of thermodynamic temperature `T` (ISO 80000-5) along length `l`\n         * remarks: None.\n         */\n    }\n    attribute clausiusNumber: ClausiusNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.14 Carnot number */\n    attribute def CarnotNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.14 Carnot number\n         * symbol(s): `Ca`\n         * application domain: generic\n         * name: CarnotNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: theoretical maximum efficiency (ISO 80000-5) of a Carnot cycle operating between temperature reservoirs `Ca = (T_2 - T_1)/T_2`, where `T` is thermodynamic temperature (ISO 80000-5), and `T_2`, `T_1` are the thermodynamic temperatures of a heat source and a heat sink, respectively\n         * remarks: None.\n         */\n    }\n    attribute carnotNumber: CarnotNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.15 Eckert number, Dulong number */\n    attribute def EckertNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.15 Eckert number, Dulong number\n         * symbol(s): `Ec`\n         * application domain: generic\n         * name: EckertNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between the kinetic energy of a flow and its enthalpy change in fluid dynamics exhibiting dissipation, expressed by `Ec = v^2/(c_p*\u0394T)`, where `v` is characteristic speed (ISO 80000-3), `c_p` is specific heat capacity at constant pressure (ISO 80000-5) of the flow, and `\u0394T` is difference of thermodynamic temperature `T` (ISO 80000-5) due to dissipation (by friction)\n         * remarks: None.\n         */\n    }\n    attribute eckertNumber: EckertNumberValue :> scalarQuantities;\n\n    alias dulongNumber for eckertNumber;\n\n    /* ISO-80000-11 item 11-5.16 Graetz number */\n    attribute def GraetzNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.16 Graetz number\n         * symbol(s): `Gz`\n         * application domain: heat transfer\n         * name: GraetzNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between heat transferred by convection and heat transferred by conduction in a laminar flow in a pipe, expressed by `Gz = (v*d^2)/(a*l)`, where `v` is speed (ISO 80000-3) of the fluid, `d` is diameter (ISO 80000-3) of the pipe, `a` is thermal diffusivity (ISO 80000-5) of the fluid, and `l` is length (ISO 80000-3) of the pipe\n         * remarks: None.\n         */\n    }\n    attribute graetzNumber: GraetzNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.17 heat transfer number */\n    attribute def HeatTransferNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.17 heat transfer number\n         * symbol(s): `K_Q`\n         * application domain: generic\n         * name: HeatTransferNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between heat transferred by a flow and its kinetic energy, expressed by `K_Q = \u03A6/(v^3*l^2*\u03C1)`, where `\u03A6` is heat flow rate (ISO 80000-5), `v` is characteristic speed (ISO 80000-3), `l` is characteristic length (ISO 80000-3), and `\u03C1` is mass density (ISO 80000-4)\n         * remarks: None.\n         */\n    }\n    attribute heatTransferNumber: HeatTransferNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.18 Pomerantsev number */\n    attribute def PomerantsevNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.18 Pomerantsev number\n         * symbol(s): `Po`, `Pov`\n         * application domain: heat transfer\n         * name: PomerantsevNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between heat generated in a body and conducted heat in the body, expressed by `Po = (Q_m*l^2)/(\u03BB*\u0394T)`, where `Q_m` is (constant) volumic heat generation rate, `l` is characteristic length (ISO 80000-3), `\u03BB` is thermal conductivity (ISO 80000-5), and `\u0394T = T_m - T_0` is difference of thermodynamic temperature (ISO 80000-5) between that of the medium (T_m) and the initial temperature of the body (T_0)\n         * remarks: Similar numbers are known for areic, lineic and point sources of heat, each with decreasing power of length `l` respectively.\n         */\n    }\n    attribute pomerantsevNumber: PomerantsevNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.19 Boltzmann number */\n    attribute def BoltzmannNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.19 Boltzmann number\n         * symbol(s): `Bz`, `Bol`, `Bo`\n         * application domain: generic\n         * name: BoltzmannNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between convective heat and radiant heat for a fluid in a channel, expressed by `Bz = (\u03C1*v*c_p)/(\u03B5*\u03C3*T^3)`, where `\u03C1` is mass density (ISO 80000-4) of the fluid, `v` is characteristic speed (ISO 80000-3) of the fluid, `c_p` is specific heat capacity at constant pressure (ISO 80000-5), `\u03B5` is emissivity (ISO 80000-7), `\u03C3` is the Stefan-Boltzmann constant (ISO 80000-7), and `T` is thermodynamic temperature (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n    attribute boltzmannNumber: BoltzmannNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-5.20 Stark number */\n    attribute def StarkNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-5.20 Stark number\n         * symbol(s): `Sk`\n         * application domain: generic\n         * name: StarkNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between radiant heat and conductive heat multiplied by the relative temperature difference for a body, expressed by `Sk = (\u03B5*\u03C3*T^3*l)/\u03BB`, where `\u03B5` is emissivity (ISO 80000-7) of the surface, `\u03C3` is the Stefan-Boltzmann constant (ISO 80000-7), `T` is thermodynamic temperature (ISO 80000-5), `l` is characteristic length (ISO 80000-3), and `\u03BB` is thermal conductivity (ISO 80000-5)\n         * remarks: The relative temperature difference is defined by `(\u0394T)/T`, where `\u0394T = T_s - T_l` is the difference of the temperature at the surface, `T_s`, and the temperature at a layer at a distance `l` from the surface, `T_l`. Sometimes this characteristic number is wrongly defined without the factor `\u03B5`. Deprecated names are: Stefan number and Biot radiation number.\n         */\n    }\n    attribute starkNumber: StarkNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.1 Fourier number */\n    attribute def FourierNumberForMassTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.1 Fourier number\n         * symbol(s): `Fo^"*"`\n         * application domain: mass transfer\n         * name: FourierNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between diffusive mass transfer within a given duration and mass storage rate in transient mass transfer, expressed by `Fo^"*" = (D*t)/l^2`, where `D` is diffusion coefficient (ISO 80000-9), `t` is duration (ISO 80000-3) of observation, and `l` is length (ISO 80000-3) of transfer"\n         * remarks: The Fourier number for mass transfer is also given by `Fo^*" = (Fo)/(Le)`, where `Fo` is the Fourier number for heat transfer (item 11-5.1), and `Le` is the Lewis number (item 11-7.3). See also the Fourier number for heat transfer (item 11-5.1)."\n         */\n    }\n    attribute fourierNumberForMassTransfer: FourierNumberForMassTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.2 P\xE9clet number */\n    attribute def \'P\xE9cletNumberForMassTransferValue\' :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.2 P\xE9clet number\n         * symbol(s): `Pe^"*"`, `Bd`, `Bod`\n         * application domain: mass transfer\n         * name: P\xE9cletNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between advective mass transfer rate and longitudinal diffusive mass transfer rate for mass transfer in reactors, expressed by `Pe^*" = (v*l)/D`, where `v` is speed (ISO 80000-3), `l` is characteristic length (ISO 80000-3), and `D` is diffusion coefficient (ISO 80000-9)"\n         * remarks: The P\xE9clet number for mass transfer is also given by `Pe^"*" = Pe*Le = Re*Sc`, where `Pe` is the P\xE9clet number for heat transfer, `Le` is the Lewis number (item 11-7.3), `Re` is the Reynolds number (item 11-4.1), and `Sc` is the Schmidt number (item 11-7.2). Compare with item 11-5.2, the P\xE9clet number for heat transfer.\n         */\n    }\n    attribute \'p\xE9cletNumberForMassTransfer\': \'P\xE9cletNumberForMassTransferValue\' :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.3 Grashof number */\n    attribute def GrashofNumberForMassTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.3 Grashof number\n         * symbol(s): `Gr^"*"`\n         * application domain: mass transfer\n         * name: GrashofNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between buoyancy forces and viscous forces in natural convection of fluids, expressed by `Gr^"*" = (l^3*g*\u03B2*\u0394x)/\u03BD^2`, where `l` is characteristic length (ISO 80000-3), `g` is acceleration of free fall (ISO 80000-3), `\u03B2 = -1/\u03C1*((del \u03C1)/(del x))_(T,p)`, where `\u03C1` is mass density (ISO 80000-4) of the fluid, and `x` is amount-of-substance fraction (ISO 80000-9), `\u0394x` is difference of amount-of-substance fraction (ISO 80000-9) along length `l`, and `\u03BD` is kinematic viscosity (ISO 80000-4)"\n         * remarks: Instead of "amount-of-substance fraction" the "amount-of-substance concentration" (ISO 80000-9) is used also. Compare with item 11-4.4, the Grashof number.\n         */\n    }\n    attribute grashofNumberForMassTransfer: GrashofNumberForMassTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.4 Nusselt number */\n    attribute def NusseltNumberForMassTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.4 Nusselt number\n         * symbol(s): `Nu^"*"`\n         * application domain: mass transfer\n         * name: NusseltNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between mass flux at an interface and specific flux by pure molecular diffusion in a layer of thickness `l` for mass transfer at the boundary of a fluid, expressed by `Nu^"*" = (k\u2019*l)/(\u03C1*D)`, where `k\u2019` is mass flux density `q_m/A` through the surface, where `q_m` is mass flow rate (ISO 80000-4), and `A` is area (ISO 80000-3), `l` is thickness (ISO 80000-3), `\u03C1` is mass density (ISO 80000-4) of the fluid, and `D` is diffusion coefficient (ISO 80000-9)"\n         * remarks: Sometimes this quantity is called the Sherwood number, `Sh`. Compare with item 11-5.5, Nusselt number for heat transfer.\n         */\n    }\n    attribute nusseltNumberForMassTransfer: NusseltNumberForMassTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.5 Stanton number */\n    attribute def StantonNumberForMassTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.5 Stanton number\n         * symbol(s): `St^"*"`\n         * application domain: mass transfer\n         * name: StantonNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between mass transfer perpendicular to the surface of a fluid flow and mass transfer parallel to the surface in a free surface flow, expressed by `St^"*" = k^"*"\n         * remarks: The Stanton number for mass transfer is also given by `St^*" = (Nu^"*")/(Pe^"*"*)`, where `Nu^"*"` is the Nusselt number for mass transfer (item 11-6.4), and `Pe^"*"` is the P\xE9clet number for mass transfer (item 11-6.2). Compare with item 11-5.7, the Stanton number for heat transfer."\n         */\n    }\n    attribute stantonNumberForMassTransfer: StantonNumberForMassTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.6 Graetz number */\n    attribute def GraetzNumberForMassTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.6 Graetz number\n         * symbol(s): `Gz^"*"`\n         * application domain: mass transfer\n         * name: GraetzNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of advective mass transfer rate and radial diffusive mass transfer rate for mass transfer in pipes, expressed by `Gz^"*" = (v*d)/D = d/l*Pe^"*"`, where `v` is characteristic speed (ISO 80000-3) of the fluid, `d` is hydraulic diameter (ISO 80000-3) of the pipe, `D` is diffusion coefficient (ISO 80000-9), `l` is length (ISO 80000-3) of the pipe, and `Pe^"*"` is the P\xE9clet number for mass transfer (item 11-6.2)"\n         * remarks: None.\n         */\n    }\n    attribute graetzNumberForMassTransfer: GraetzNumberForMassTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.7 mass transfer factor */\n    attribute def MassTransferFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.7 mass transfer factor\n         * symbol(s): `j^"*"`\n         * application domain: mass transfer\n         * name: MassTransferFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between mass transfer perpendicular to the surface of a fluid and mass transfer parallel to the surface in an open flow of fluids, expressed by `j^*" = k/v * (\u03BD/D)^(2/3)`, where `k` is the mass transfer coefficient through the surface, `k = k^\'/\u03C1`, where `\u03C1` is mass density (ISO 80000-4), `k^\'` is mass flux density `q_m/A` through the surface, where `q_m` is mass flow rate (ISO 80000-4), and `A` is area (ISO 80000-3), `v` is speed (ISO 80000-3), `\u03BD` is kinematic viscosity (ISO 80000-4), and `D` is diffusion coefficient (ISO 80000-9)"\n         * remarks: The mass transfer factor is also given by `j_m = j^*" = St^"*" * (Sc)^(2/3)` where `St^"*"` is the Stanton number for mass transfer (item 11-6.5), and `Sc` is the Schmidt number (item 11-7.2). See also heat transfer factor (item 11-5.17)."\n         */\n    }\n    attribute massTransferFactor: MassTransferFactorValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.8 Atwood number */\n    attribute def AtwoodNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.8 Atwood number\n         * symbol(s): `At`\n         * application domain: generic\n         * name: AtwoodNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: scaled density difference of heavier and lighter fluids, expressed by `At = (\u03C1_1 - \u03C1_2)/(\u03C1_1 + \u03C1_2)`, where `\u03C1_1` is density of heavier fluid, and `\u03C1_2` is density of lighter fluid\n         * remarks: The Atwood number is used in the study of hydrodynamic instabilities in density stratified flows.\n         */\n    }\n    attribute atwoodNumber: AtwoodNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.9 Biot number */\n    attribute def BiotNumberForMassTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.9 Biot number\n         * symbol(s): `Bi^"*"`\n         * application domain: mass transfer\n         * name: BiotNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between mass transfer rate at the interface and mass transfer rate in the interior of a body, expressed by `Bi^*" = (k*l)/D_"int"`, where `k` is the mass transfer coefficient through the surface, `k = k^\'/\u03C1`, where `\u03C1` is mass density (ISO 80000-4), `k^\'` is mass flux density `q_m/A` through the surface, where `q_m` is mass flow rate (ISO 80000-4), and `A` is area (ISO 80000-3), `l` is thickness (ISO 80000-3) of layer, and `D_"int"` is diffusion coefficient (ISO 80000-9) at the interface"\n         * remarks: None.\n         */\n    }\n    attribute biotNumberForMassTransfer: BiotNumberForMassTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.10 Morton number */\n    attribute def MortonNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.10 Morton number\n         * symbol(s): `Mo`\n         * application domain: generic\n         * name: MortonNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of gravitational forces and viscous forces for gas bubbles in a liquid, or liquid drops in a gas, expressed by `Mo = (g*\u03B7^4)/(\u03C1*\u03B3^3)*(\u03C1_b/\u03C1 - 1)`, where `g` is acceleration of free fall (ISO 80000-3), `\u03B7` is dynamic viscosity (ISO 80000-4) of the surrounding fluid, `\u03C1` is mass density (ISO 80000-4) of the surrounding fluid, `\u03B3` is surface tension (ISO 80000-4) of the interface, and `\u03C1_b` is mass density (ISO 80000-4) of the bubble or drop\n         * remarks: The Morton number is used to determine the shape of bubbles or drops. The Morton number is also given by `Mo = We^3*Fr^-2*Re^-4`, where `We` is the Weber number (item 11-4.5), `Fr` is the Froude number (item 11-4.3), and `Re` is the Reynolds number (item 11-4.1). \n         */\n    }\n    attribute mortonNumber: MortonNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.11 Bond number, E\xF6tv\xF6s number */\n    attribute def BondNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.11 Bond number, E\xF6tv\xF6s number\n         * symbol(s): `Bo`, `Eo`\n         * application domain: generic\n         * name: BondNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of inertial force and capillary force for gas bubbles or liquid drops in a fluid, expressed by `Bo = a/\u03B3 * \u03C1*l^2*(\u03C1_b/\u03C1 - 1)`, where `a` is the acceleration of the body (ISO 80000-3), mostly acceleration of free fall, `g` (ISO 80000-3), `\u03B3` is surface tension (ISO 80000-4) of the interface, `\u03C1` is density (ISO 80000-4) of the medium, `l` is characteristic length (ISO 80000-3) (radius of a drop or radius of a capillary tube), and `\u03C1_b` is mass density (ISO 80000-4) of the drop or bubble\n         * remarks: In the case of gravity `a = g` acceleration of free fall (ISO 80000-3), the name E\xF6tv\xF6s number is mostly used. The Bond number is also given by `Bo = (We)/(Fr)`, where `We` is the Weber number (item 11-4.5), and `Fr` is the Froude number (item11-4.3). The Bond number is also used for capillary action driven by buoyancy.\n         */\n    }\n    attribute bondNumber: BondNumberValue :> scalarQuantities;\n\n    alias \'e\xF6tv\xF6sNumber\' for bondNumber;\n\n    /* ISO-80000-11 item 11-6.12 Archimedes number */\n    attribute def ArchimedesNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.12 Archimedes number\n         * symbol(s): `Ar`\n         * application domain: generic\n         * name: ArchimedesNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of buoyancy forces and viscous forces in fluids motion due to density differences for a body in a fluid, expressed by `Ar = (g*l^3)/v^2*(\u03C1_b/\u03C1 - 1)`, where `g` is acceleration of free fall (ISO 80000-3), `l` is characteristic length (ISO 80000-3) of the body, `\u03BD` is kinematic viscosity (ISO 80000-4) of the fluid, `\u03C1_b` is mass density (ISO 80000-4) of the body, and `\u03C1` is mass density (ISO 80000-4) of the fluid\n         * remarks: In this definition, the body can be replaced by an immiscible fluid. See also Stokes number <rotameter> (item 11-4.34).\n         */\n    }\n    attribute archimedesNumber: ArchimedesNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.13 expansion number */\n    attribute def ExpansionNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.13 expansion number\n         * symbol(s): `Ex`\n         * application domain: generic\n         * name: ExpansionNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of buoyancy force and inertial force in moving fluids due to density differences for gas bubbles rising in a liquid, expressed by `Ex = (g*d)/v^2*(1-\u03C1_b/\u03C1)`, where `g` is acceleration of free fall (ISO 80000-3), `d` is diameter (ISO 80000-3) of bubbles, `v` is speed (ISO 80000-3) of bubbles, `\u03C1_b` is mass density (ISO 80000-4) of bubbles, and `\u03C1` is mass density (ISO 80000-4) of the liquid\n         * remarks: None.\n         */\n    }\n    attribute expansionNumber: ExpansionNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.14 Marangoni number */\n    attribute def MarangoniNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.14 Marangoni number\n         * symbol(s): `Mg`, `Mar`\n         * application domain: generic\n         * name: MarangoniNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of heat transferred by Marangoni convection and heat transferred by thermal diffusivity in thermo-capillary convection of liquid films on a free surface, expressed by `Mg = l*\u0394T/(\u03B7*a)*((d\u03B3)/(dT))`, where `l` is characteristic thickness (ISO 80000-3) of the film, `\u0394T` is difference of thermodynamic temperature `T` (ISO 80000-5) between surface and outer surface of the film, `\u03B7` is dynamic viscosity (ISO 80000-4) of the liquid, `a` is thermal diffusivity (ISO 80000-5) of the liquid, and `\u03B3` is surface tension (ISO 80000-4) of the film\n         * remarks: The Marangoni convection is free surface flow due to different surface tensions caused by a temperature gradient. This quantity is sometimes called Thompson number.\n         */\n    }\n    attribute marangoniNumber: MarangoniNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.15 Lockhart-Martinelli parameter */\n    attribute def LockhartMartinelliParameterValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.15 Lockhart-Martinelli parameter\n         * symbol(s): `Lp`\n         * application domain: generic\n         * name: LockhartMartinelliParameter (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mass flow rates multiplied by the square root of density in a two-phase flow, expressed by `Lp = dot(m)_l/dot(m)_g*sqrt(\u03C1_m/\u03C1_l)`, where `dot(m)_l = q_m` is liquid phase mass flow rate (ISO 80000-4), `dot(m)_g` is gas phase mass flow rate, `\u03C1_g` is gas density (ISO 80000-4), and `\u03C1_l` is liquid density\n         * remarks: The Lockhart-Martinelli parameter is used, for example, in boiling or condensing.\n         */\n    }\n    attribute lockhartMartinelliParameter: LockhartMartinelliParameterValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.16 Bejan number */\n    attribute def BejanNumberForMassTransferValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.16 Bejan number\n         * symbol(s): `Be^"*"`, `Be_2`\n         * application domain: mass transfer\n         * name: BejanNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mechanical work and frictional and diffusion energy loss in viscous flow of fluids in pipes, expressed by `Be^*" = (\u0394p*l^2)/(\u03B7*D)`, where `\u0394p` is drop of pressure (ISO 80000-4) along a pipe or channel, `l` is length (ISO 80000-3) of channel, `\u03B7` is dynamic viscosity (ISO 80000-4) of the fluid, and `D` is diffusion coefficient (ISO 80000-9), mass diffusivity"\n         * remarks: A similar quantity exists for heat transfer (item 11-5.9).\n         */\n    }\n    attribute bejanNumberForMassTransfer: BejanNumberForMassTransferValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.17 cavitation number */\n    attribute def CavitationNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.17 cavitation number\n         * symbol(s): `Ca`, `Cn`\n         * application domain: generic\n         * name: CavitationNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the excess of local static head over vapour pressure head and velocity head for fast flow in liquids, expressed by `Ca = (p-p_v)/(1/2*\u03C1*v^2)`, where `p` is local static pressure (ISO 80000-4), `p_v` is vapour pressure (ISO 80000-4) of the fluid, `\u03C1` is mass density (ISO 80000-4) of the fluid, and `v` is characteristic speed (ISO 80000-3) of the flow\n         * remarks: The cavitation number represents the ratio of the excess of local static head over vapour pressure head to velocity head.\n         */\n    }\n    attribute cavitationNumber: CavitationNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.18 absorption number */\n    attribute def AbsorptionNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.18 absorption number\n         * symbol(s): `Ab`\n         * application domain: generic\n         * name: AbsorptionNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between mass flow rate and surface area for gas absorption at wetted walls, expressed by `Ab = k*sqrt((l*d)/(D*q_V))`, where `k` is the mass transfer coefficient through the surface, `k = k^\'/\u03C1`, where `\u03C1` is mass density (ISO 80000-4), and `k^\'` is mass flux density through the surface, `k^\' = q_m/A`, where `q_m` is mass flow rate (ISO 80000-4), and `A` is area (ISO 80000-3), `l` is length (ISO 80000-3) of wetted surface, `d` is thickness (ISO 80000-3) of liquid film, `D` is diffusion coefficient (ISO 80000-9), and `q_V` is volume flow rate (ISO 80000-4) per wetted perimeter\n         * remarks: None.\n         */\n    }\n    attribute absorptionNumber: AbsorptionNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.19 capillary number */\n    attribute def CapillaryNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.19 capillary number\n         * symbol(s): `Ca`\n         * application domain: generic\n         * name: CapillaryNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of gravitational forces and capillary forces for fluids in narrow pipes, expressed by `Ca = (d^2*\u03C1*g)/\u03B3`, where `d` is diameter (ISO 80000-3) of the pipe, `\u03C1` is mass density (ISO 80000-4) of the fluid, `g` is acceleration of free fall (ISO 80000-3), and `\u03B3` is surface tension (ISO 80000-4) of the fluid\n         * remarks: None.\n         */\n    }\n    attribute capillaryNumber: CapillaryNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-6.20 dynamic capillary number */\n    attribute def DynamicCapillaryNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-6.20 dynamic capillary number\n         * symbol(s): `Ca^"*"`, `Cn`\n         * application domain: generic\n         * name: DynamicCapillaryNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of viscous force and capillary force acting across an interface between a liquid and a gas, or between two immiscible liquids for a flow of fluid influenced by interfacial tension, expressed by `Ca^*" = (\u03B7*v)/\u03B3`, where `\u03B7` is dynamic viscosity (ISO 80000-4) of the fluid, `v` is characteristic speed (ISO 80000-3), and `\u03B3` is surface or interfacial tension (ISO 80000-4)"\n         * remarks: The dynamic capillary number is also given by the quotient of the Weber number and the Reynolds number.\n         */\n    }\n    attribute dynamicCapillaryNumber: DynamicCapillaryNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.1 Prandtl number */\n    attribute def PrandtlNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.1 Prandtl number\n         * symbol(s): `Pr`\n         * application domain: generic\n         * name: PrandtlNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of kinematic viscosity and thermal diffusivity for a fluid, expressed by `Pr = \u03BD/a`, where `\u03BD` is kinematic viscosity (ISO 80000-4), and `a` is thermal diffusivity (ISO 80000-5)\n         * remarks: The Prandtl number also represents the quotient of heat produced by viscosity and heat transferred by thermal diffusivity. The mass transfer analogue of the Prandtl number is the Schmidt number (item 11-7.2). The Prandtl number is also given by `Pr = (Pe)/(Re)`; where `Pe` is the P\xE9clet number (item 11-5.2), and `Re` is the Reynolds number (item 11-4.1). \n         */\n    }\n    attribute prandtlNumber: PrandtlNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.2 Schmidt number */\n    attribute def SchmidtNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.2 Schmidt number\n         * symbol(s): `Sc`\n         * application domain: generic\n         * name: SchmidtNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of kinematic viscosity and diffusion coefficient for a fluid, expressed by `Sc = \u03BD/D`, where `\u03BD` is kinematic viscosity (ISO 80000-4), and `D` is diffusion coefficient (ISO 80000-9)\n         * remarks: The heat transfer analogue of the Schmidt number is the Prandtl number (item 11-7.1). A deprecated name is Colburn number.\n         */\n    }\n    attribute schmidtNumber: SchmidtNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.3 Lewis number */\n    attribute def LewisNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.3 Lewis number\n         * symbol(s): `Le`\n         * application domain: generic\n         * name: LewisNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of thermal diffusivity and diffusion coefficient for heat transfer in a fluid, expressed by `Le = a/D`, where `a` is thermal diffusivity (ISO 80000-5), and `D` is diffusion coefficient (ISO 80000-9)\n         * remarks: The Lewis number is also given by `Le = (Sc)/(Pr)`, where `Sc` is the Schmidt number (item 11-7.2), and `Pr` is the Prandtl number (item 11-7.1). Compare with item 11-5.2. The Lewis number is sometimes defined as reciprocal of this quantity. \n         */\n    }\n    attribute lewisNumber: LewisNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.4 Ohnesorge number */\n    attribute def OhnesorgeNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.4 Ohnesorge number\n         * symbol(s): `Oh`\n         * application domain: generic\n         * name: OhnesorgeNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between viscous force and the square root of the product of inertia force and capillary force for atomization of liquids, expressed by `Oh = \u03B7/sqrt(\u03B3*\u03C1*l)`, where `\u03B7` is dynamic viscosity (ISO 80000-4), `\u03B3` is surface tension (ISO 80000-4), `\u03C1` is mass density (ISO 80000-4), and `l` is characteristic length (ISO 80000-3)\n         * remarks: The Ohnesorge number is also given by `Oh = sqrt(We)/(Re)` where `We` is the Weber number (item 11-4.5), and `Re` is the Reynolds number (item 11-4.1). See also Laplace number (item 11-4.37). The characteristic length typically is the drop diameter.\n         */\n    }\n    attribute ohnesorgeNumber: OhnesorgeNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.5 Cauchy number, aeroelasticity parameter */\n    attribute def CauchyNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.5 Cauchy number, aeroelasticity parameter\n         * symbol(s): `Cy`\n         * application domain: generic\n         * name: CauchyNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between inertia forces and compression forces in compressible fluids, expressed by `Cy = `, where `\u03C1` is mass density (ISO 80000-4), `v` is speed (ISO 80000-3), and `K` is modulus of compression, bulk modulus (ISO 80000-4)\n         * remarks: None.\n         */\n    }\n    attribute cauchyNumber: CauchyNumberValue :> scalarQuantities;\n\n    alias aeroelasticityParameter for cauchyNumber;\n\n    /* ISO-80000-11 item 11-7.6 Hooke number */\n    attribute def HookeNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.6 Hooke number\n         * symbol(s): `Ho_2`\n         * application domain: generic\n         * name: HookeNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between inertia forces and linear stress forces in elastic fluids, expressed by `Ho_2 = (\u03C1*v^2)/E`, where `\u03C1` is mass density (ISO 80000-4), `v` is speed (ISO 80000-3), and `E` is modulus of elasticity (ISO 80000-4)\n         * remarks: None.\n         */\n    }\n    attribute hookeNumber: HookeNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.7 Weissenberg number */\n    attribute def WeissenbergNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.7 Weissenberg number\n         * symbol(s): `Wi`\n         * application domain: generic\n         * name: WeissenbergNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: product of time derivative of shear rate and relaxation time in viscoelastic flows, expressed by `Wi = dot(\u03B3)*t_r`, where `dot(\u03B3)` is time derivative of shear strain (ISO 80000-4), and `t_r` is relaxation time (ISO 80000-12)\n         * remarks: The Weissenberg number represents the relative importance of viscous forces when compared to elastic forces. The time derivative of shear strain is sometimes called the shear rate.\n         */\n    }\n    attribute weissenbergNumber: WeissenbergNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.8 Deborah number */\n    attribute def DeborahNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.8 Deborah number\n         * symbol(s): `De`\n         * application domain: generic\n         * name: DeborahNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of relaxation time of viscoelastic fluids and observation duration in rheology of viscoelastic fluids, expressed by `De = t_c/t_p`, where `t_c` is stress relaxation time, and `t_p` is observation duration (ISO 80000-3)\n         * remarks: The stress relaxation time is sometimes called the Maxwell relaxation time.\n         */\n    }\n    attribute deborahNumber: DeborahNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.9 Lorentz number */\n    attribute def LorentzNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.9 Lorentz number\n         * symbol(s): `Lo`\n         * application domain: generic\n         * name: LorentzNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of electrical conductivity and thermal conductivity, expressed by `Lo = (\u03C3*(\u0394U)^2)/(\u03BB*\u0394T)`, where `\u03C3` is electrical conductivity (IEC 80000-6), `\u0394U` is difference of voltage `U` (ISO 80000-6) between two reference points, `\u03BB` is thermal conductivity (ISO 80000-5), and `\u0394T` is difference in thermodynamic temperature `T` (ISO 80000-5) between the reference points\n         * remarks: None.\n         */\n    }\n    attribute lorentzNumber: LorentzNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-7.10 compressibility number */\n    attribute def CompressibilityNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-7.10 compressibility number\n         * symbol(s): `Z`\n         * application domain: generic\n         * name: CompressibilityNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of isothermal compressibility (ISO 80000-5) of a gas and that of an ideal gas, expressed by `Z = p/(\u03C1*R_s*T)`, where `p` is pressure (ISO 80000-4), `\u03C1` is mass density (ISO 80000-4), `R_s` is specific gas constant (ISO 80000-5), and `T` is thermodynamic temperature (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n    attribute compressibilityNumber: CompressibilityNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.1 Reynolds magnetic number */\n    attribute def ReynoldsMagneticNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.1 Reynolds magnetic number\n         * symbol(s): `Rm`\n         * application domain: generic\n         * name: ReynoldsMagneticNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between inertial force and magneto-dynamic viscous force in an electrically conducting fluid, expressed by `Rm = v*l*\u03BC*\u03C3 = (v*l)/\u03BD_m`, where `v` is speed (ISO 80000-3) of the fluid, `l` is characteristic length (ISO 80000-3), `\u03BC` is magnetic permeability (IEC 80000-6), `\u03C3` is electrical conductivity (IEC 80000-6), and `\u03BD_m = 1/(\u03BC*\u03C3)` is magnetic viscosity (magnetic diffusivity)\n         * remarks: This number is also called magnetic Reynolds number. The Reynolds magnetic number is also given by `Rm = Re*Pr_m`, where `Re` is the Reynolds number (item 11-4.1), and `Pr_m` is the Prandtl magnetic number (item 11-8.10).\n         */\n    }\n    attribute reynoldsMagneticNumber: ReynoldsMagneticNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.2 Batchelor number */\n    attribute def BatchelorNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.2 Batchelor number\n         * symbol(s): `Bt`\n         * application domain: generic\n         * name: BatchelorNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between inertia and magneto-dynamic diffusion in an electrically conducting liquid, expressed by `Bt = (v*l*\u03C3*\u03BC)/(\u03B5_r*\u03BC_r)`, where `v` is speed (ISO 80000-3), `l` is characteristic length (ISO 80000-3), `\u03C3` is electrical conductivity (IEC 80000-6), `\u03BC` is magnetic permeability (IEC 80000-6), `\u03B5_r` is relative permittivity (IEC 80000-6), and `\u03BC_r` is relative permeability (IEC 80000-6)\n         * remarks: None.\n         */\n    }\n    attribute batchelorNumber: BatchelorNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.3 Nusselt electric number */\n    attribute def NusseltElectricNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.3 Nusselt electric number\n         * symbol(s): `Ne`\n         * application domain: generic\n         * name: NusseltElectricNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between convective current and diffusive current of ions in electrochemistry, expressed by `Ne = (v*l)/D^*"`, where `v` is speed (ISO 80000-3), `l` is characteristic length (ISO 80000-3), and `D^"*" = D^"+" + D^"-"`, where `D^"+"`, `D^"-"` are diffusion coefficients (ISO 80000-9) of positive or negative ions respectively"\n         * remarks: This number is also called electric Nusselt number. Sometimes this quantity is called the Reynolds electric number.\n         */\n    }\n    attribute nusseltElectricNumber: NusseltElectricNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.4 Alfv\xE9n number, Mach magnetic number, K\xE1rman number */\n    attribute def \'Alfv\xE9nNumberValue\' :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.4 Alfv\xE9n number, Mach magnetic number, K\xE1rman number\n         * symbol(s): `Al`\n         * application domain: generic\n         * name: Alfv\xE9nNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between speed of a plasma and the Alfv\xE9n wave speed, expressed by `Al = v/(B/sqrt(\u03C1*\u03BC))`, where `v` is speed (ISO 80000-3), `B` is magnetic flux density (IEC 80000-6), `\u03C1` is mass density (ISO 80000-4), and `\u03BC` is magnetic permeability (IEC 80000-6)\n         * remarks: Often, the inverse of this number is wrongly used. The name "Alfv\xE9n Mach number" is used in investigations on the solar wind. The quantity `v_A = B/sqrt(\u03C1*\u03BC)` is called Alfv\xE9n wave speed, where `B` is magnetic flux density (IEC 80000-6), `\u03C1` is mass density (ISO 80000-4), and `\u03BC` is magnetic permeability (IEC 80000-6).\n         */\n    }\n    attribute \'alfv\xE9nNumber\': \'Alfv\xE9nNumberValue\' :> scalarQuantities;\n\n    alias machMagneticNumber for \'alfv\xE9nNumber\';\n\n    alias \'k\xE1rmanNumber\' for \'alfv\xE9nNumber\';\n\n    /* ISO-80000-11 item 11-8.5 Hartmann number */\n    attribute def HartmannNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.5 Hartmann number\n         * symbol(s): `Ha`\n         * application domain: generic\n         * name: HartmannNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between magnetically induced stress and hydrodynamic shear stress in an electrically conducting fluid, expressed by `Ha = B*l*sqrt(\u03C3/\u03B7)`, where `B` is magnetic flux density (IEC 80000-6), `l` is characteristic length (ISO 80000-3), `\u03C3` is electrical conductivity (IEC 80000-6), and `\u03B7` is dynamic viscosity (ISO 80000-4)\n         * remarks: The Hartmann number represents also the ratio of magnetic force to viscous force.\n         */\n    }\n    attribute hartmannNumber: HartmannNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.6 Cowling number, Euler magnetic number */\n    attribute def CowlingNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.6 Cowling number, Euler magnetic number\n         * symbol(s): `Co`\n         * application domain: magnetism\n         * name: CowlingNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of magnetic and kinematic energy density in a plasma, expressed by `Co = B^2/(\u03BC*\u03C1*v^2)`, where `B` is magnetic flux density (IEC 80000-6), `\u03BC` is magnetic permeability (IEC 80000-6), `\u03C1` is mass density (ISO 80000-4), and `v` is speed (ISO 80000-3)\n         * remarks: The Cowling number also represents the ratio of magnetic to dynamic pressure. This quantity is equal to the square of the inverse of the Alfv\xE9n number. This quantity is often called the second Cowling number, `Co_2`. The first Cowling number is then defined as `Co_1 = Co*Rm`, where `Rm` is the Reynolds magnetic number (item 11-8.1).\n         */\n    }\n    attribute cowlingNumber: CowlingNumberValue :> scalarQuantities;\n\n    alias eulerMagneticNumber for cowlingNumber;\n\n    /* ISO-80000-11 item 11-8.7 Stuart electrical number */\n    attribute def StuartElectricalNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.7 Stuart electrical number\n         * symbol(s): `Se`\n         * application domain: generic\n         * name: StuartElectricalNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of electric energy density and kinematic energy density in a plasma, expressed by `Se = (\u03B5*E^2)/(\u03C1*v^2)`, where `\u03B5` is electric permittivity (IEC 80000-6), E is electric field strength (IEC 80000-6), \u03C1 is mass density (ISO 80000-4), and `v` is speed (ISO 80000-3)\n         * remarks: The Stuart electrical number is the electrical counterpart of the Cowling number (item 11-8.6).\n         */\n    }\n    attribute stuartElectricalNumber: StuartElectricalNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.8 magnetic pressure number */\n    attribute def MagneticPressureNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.8 magnetic pressure number\n         * symbol(s): `N_(mp)`\n         * application domain: generic\n         * name: MagneticPressureNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of gas pressure and magnetic pressure in a gas or plasma, expressed by `N_(mp) = p*(2*\u03BC)/B^2`, where `p` is pressure (ISO 80000-4), `\u03BC` is magnetic permeability (IEC 80000-6), and `B` is magnetic flux density (IEC 80000-6)\n         * remarks: The quantity `p_m = B^2/(2*\u03BC)` is called magnetic pressure, where `B` is magnetic flux density (IEC 80000-6), and `\u03BC` is magnetic permeability (IEC 80000-6).\n         */\n    }\n    attribute magneticPressureNumber: MagneticPressureNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.9 Chandrasekhar number */\n    attribute def ChandrasekharNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.9 Chandrasekhar number\n         * symbol(s): `Q`, `Ch`\n         * application domain: generic\n         * name: ChandrasekharNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of Lorentz force and viscous force in magnetic convection in a fluid, expressed by `Q = ((B*l)^2*\u03C3)/(\u03C1*\u03BD)`, where `B` is magnetic flux density (IEC 80000-6), `l` is characteristic length (ISO 80000-3), a length scale of the system, `\u03C3` is electrical conductivity (IEC 80000-6), `\u03C1` is mass density (ISO 80000-4), and `\u03BD` is kinematic viscosity (ISO 80000-4)\n         * remarks: The Chandrasekhar number is also given by `Q = Ha^2` where `Ha` is the Hartmann number (item 11-8.5).\n         */\n    }\n    attribute chandrasekharNumber: ChandrasekharNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.10 Prandtl magnetic number */\n    attribute def PrandtlMagneticNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.10 Prandtl magnetic number\n         * symbol(s): `Pr_m`\n         * application domain: generic\n         * name: PrandtlMagneticNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of kinematic viscosity and magnetic viscosity in an electrically conducting liquid, expressed by `Pr_m = \u03BD*\u03C3*\u03BC`, where `\u03BD` is kinematic viscosity (ISO 80000-4), `\u03C3` is electrical conductivity (IEC 80000-6), and `\u03BC` is magnetic permeability (IEC 80000-6)\n         * remarks: The quantity `\u03BD_m = 1/(\u03BC*\u03C3)` is called magnetic viscosity or magnetic diffusivity. See item 11-8.11. The Prandtl magnetic number is also given by `Pr_m = (Rm)/(Re)`, where `Rm` is the Reynolds magnetic number (item 11-8.1), and `Re` is the Reynolds number (item 11-4.1). This number is also called magnetic Prandtl number.\n         */\n    }\n    attribute prandtlMagneticNumber: PrandtlMagneticNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.11 Roberts number */\n    attribute def RobertsNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.11 Roberts number\n         * symbol(s): `Ro`\n         * application domain: generic\n         * name: RobertsNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of thermal diffusivity and magnetic viscosity in an electrically conducting liquid, expressed by `Ro = a*\u03C3*\u03BC`, where `a` is thermal diffusivity (ISO 80000-5), `\u03C3` is electrical conductivity (IEC 80000-6), and `\u03BC` is magnetic permeability (IEC 80000-6)\n         * remarks: The quantity `\u03BD_m = 1/(\u03BC*\u03C3)` is called magnetic viscosity or magnetic diffusivity; where `\u03BC` is magnetic permeability (IEC 80000-6), and `\u03C3` is electrical conductivity (IEC 80000-6).\n         */\n    }\n    attribute robertsNumber: RobertsNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.12 Stuart number */\n    attribute def StuartNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.12 Stuart number\n         * symbol(s): `Stw`\n         * application domain: generic\n         * name: StuartNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of magnetic forces and inertia forces in an electrically conducting liquid, expressed by `Stw = (B^2*l*\u03C3)/(v*\u03C1)`, where `B` is magnetic flux density (IEC 80000-6), `l` is characteristic length (ISO 80000-3), `\u03C3` is electrical conductivity (IEC 80000-6), `v` is characteristic speed (ISO 80000-3), and `\u03C1` is mass density (ISO 80000-4)\n         * remarks: The Stuart number sometimes is called magnetic force parameter. Sometimes the square root is wrongly used. The Stuart number is also given by `Stw = (Ha^2)/(Re)`, where `Ha` is the Hartmann number, and `Re` is the Reynolds number. \n         */\n    }\n    attribute stuartNumber: StuartNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.13 magnetic number */\n    attribute def MagneticNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.13 magnetic number\n         * symbol(s): `N_(mg)`\n         * application domain: generic\n         * name: MagneticNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of magnetic forces and viscous forces in an electrically conducting fluid, expressed by `N_(mg) = B*sqrt((l*\u03C3)/(\u03B7*v))`, where `B` is magnetic flux density (IEC 80000-6), `l` is characteristic length (ISO 80000-3), `\u03C3` is electrical conductivity (IEC 80000-6), `\u03B7` is dynamic viscosity (ISO 80000-4), and `v` is speed (ISO 80000-3)\n         * remarks: None.\n         */\n    }\n    attribute magneticNumber: MagneticNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.14 electric field parameter */\n    attribute def ElectricFieldParameterValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.14 electric field parameter\n         * symbol(s): `Ef`\n         * application domain: generic\n         * name: ElectricFieldParameter (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of Coulomb force and Lorentz force on moving electrically charged material or particles, expressed by `Ef = E/(v*B)`, where `E` is electric field strength (IEC 80000-6), `v` is speed (ISO 80000-3), and `B` is magnetic flux density (IEC 80000-6)\n         * remarks: None.\n         */\n    }\n    attribute electricFieldParameter: ElectricFieldParameterValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.15 Hall number */\n    attribute def HallNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.15 Hall number\n         * symbol(s): `Hc`, `CH`\n         * application domain: generic\n         * name: HallNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of gyro frequency and collision frequency in a plasma, expressed by `H_c = (\u03C9_c*\u03BB)/(2*\u03C0*v)`, where `\u03C9_c` is cyclotron angular frequency (ISO 80000-10), `\u03BB` is mean free path (ISO 80000-9), and `v` is average speed (ISO 80000-3)\n         * remarks: Sometimes the inverse of this number is wrongly used. `2*\u03C0` times this quantity is called the Hall parameter.\n         */\n    }\n    attribute hallNumber: HallNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.16 Lundquist number */\n    attribute def LundquistNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.16 Lundquist number\n         * symbol(s): `Lu`\n         * application domain: generic\n         * name: LundquistNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of Alfv\xE9n speed and magneto-dynamic speed in a plasma, expressed by `Lu = B*l*\u03C3*sqrt(\u03BC/\u03C1)`, where `B` is magnetic flux density (IEC 80000-6), `l` is characteristic length (ISO 80000-3), `\u03C3` is electrical conductivity (IEC 80000-6), `\u03BC` is magnetic permeability (IEC 80000-6), and `\u03C1` is mass density (ISO 80000-4)\n         * remarks: The quantity `v_A = B/sqrt(\u03C1*\u03BC)` is called Alfv\xE9n wave speed. See item 11-8.4. The quantity `v_m = 1/(l*\u03C3*\u03BC)` is called magneto dynamic speed, where `l` is characteristic length (ISO 80000-3), `\u03C3` is electrical conductivity (IEC 80000-6), and `\u03BC` is magnetic permeability (IEC 80000-6). The Lundquist number is also given by `Lu = (Rm)/(Al)`, where `Rm` is the Reynolds magnetic number (item 11-8.1), and `Al` is the Alfv\xE9n number (item 11-8.4). See also Hartmann number (item 11-8.5).\n         */\n    }\n    attribute lundquistNumber: LundquistNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.17 Joule magnetic number */\n    attribute def JouleMagneticNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.17 Joule magnetic number\n         * symbol(s): `Jo_m`\n         * application domain: generic\n         * name: JouleMagneticNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of Joule heating energy and magnetic field energy in a plasma, expressed by `Jo_m = (2*\u03C1*\u03BC*c_p*\u0394T)/B^2`, where `\u03C1` is mass density (ISO 80000-4), `\u03BC` is magnetic permeability (IEC 80000-6), `c_p` is specific heat capacity at constant pressure (ISO 80000-5), `T` is thermodynamic temperature (ISO 80000-5), and `B` is magnetic flux density (IEC 80000-6)\n         * remarks: This number is also called magnetic Joule number.\n         */\n    }\n    attribute jouleMagneticNumber: JouleMagneticNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.18 Grashof magnetic number */\n    attribute def GrashofMagneticNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.18 Grashof magnetic number\n         * symbol(s): `Gr_m`\n         * application domain: generic\n         * name: GrashofMagneticNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: mathematical expression for the heat transfer by free thermo-magnetic convection of a paramagnetic fluid under gravity, `Gr_m = (4*\u03C0*\u03C3_e*\u03BC_e*g*\u03B1_V*\u0394T*l^3)/\u03BD`, where `\u03C3_e` is electrical conductivity (IEC 80000-6), `\u03BC_e` is magnetic permeability (IEC 80000-6), `g` is acceleration of free fall (ISO 80000-3), `\u03B1_V` is cubic expansion coefficient (ISO 80000-5), `\u0394T = T_S - T_\u221E` is difference of thermodynamic temperature `T` (ISO 80000-5), where `T_S` is surface temperature and `T_\u221E` is bulk temperature, `l` is characteristic length (ISO 80000-3), and `\u03BD` is kinematic viscosity (ISO 80000-4)\n         * remarks: This number is also called magnetic Grashof number. See also Grashof number (item 11-4.4).\n         */\n    }\n    attribute grashofMagneticNumber: GrashofMagneticNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.19 Naze number */\n    attribute def NazeNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.19 Naze number\n         * symbol(s): `Na`\n         * application domain: generic\n         * name: NazeNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of velocity of Alfv\xE9n waves and velocity of sound in a plasma, expressed by `Na = B/(c*sqrt(\u03C1*\u03BC))`, where `B` is magnetic flux density (IEC 80000-6), `c` is speed of sound (ISO 80000-8), `\u03C1` is mass density (ISO 80000-4), and `\u03BC` is magnetic permeability (IEC 80000-6)\n         * remarks: The quantity `v_A = B/sqrt(\u03C1*\u03BC)` is called Alfv\xE9n wave speed. See item 11-8.4.\n         */\n    }\n    attribute nazeNumber: NazeNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.20 Reynolds electric number */\n    attribute def ReynoldsElectricNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.20 Reynolds electric number\n         * symbol(s): `Re_e`\n         * application domain: generic\n         * name: ReynoldsElectricNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of speed of a fluid and average drift speed of the charged particles in an electrically conducting fluid, expressed by `Re_e = (v*\u03B5_e)/(\u03C1_e*l*\u03BC)`, where `v` is characteristic speed (ISO 80000-3) of the fluid, `\u03B5_e` is electric permittivity (IEC 80000-6), `\u03C1_e` is electric charge density (IEC 80000-6), `l` is characteristic length (ISO 80000-3), and `\u03BC` is mobility (ISO 80000-10) of charge carriers\n         * remarks: This number is also called electrical Reynolds number. The drift speed of the charged particles in an electric field is given by `v_d = 1/(\u03BC*E)`, where `E` is electric field strength (IEC 80000-6), and `\u03BC` is mobility (ISO 80000-10) of charge carriers.\n         */\n    }\n    attribute reynoldsElectricNumber: ReynoldsElectricNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-8.21 Amp\xE8re number */\n    attribute def \'Amp\xE8reNumberValue\' :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-8.21 Amp\xE8re number\n         * symbol(s): `Am`\n         * application domain: generic\n         * name: Amp\xE8reNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: relation between electric surface current and magnetic field strength in an electrically conducting liquid, expressed by `Am = I_A/(l*H)`, where `I_A` is electric surface current, `l` is characteristic length (ISO 80000-3), and `H` is magnetic field strength (IEC 80000-6)\n         * remarks: This number is also called magnetic field number. The electric surface current is given by `I_A = \u03C1_A*l*\xB5*E`, where `\u03C1_A` is surface density of electric charge (IEC 80000-6), `l` is characteristic length (ISO 80000-3), `\xB5` is mobility (ISO 80000-10) of charge carriers, and `E` is electric field strength (IEC 80000-6).\n         */\n    }\n    attribute \'amp\xE8reNumber\': \'Amp\xE8reNumberValue\' :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-9.1 Arrhenius number */\n    attribute def ArrheniusNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-9.1 Arrhenius number\n         * symbol(s): `\u03B1`\n         * application domain: generic\n         * name: ArrheniusNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of chemical activation energy and thermal energy; in a chemical reaction it is the exponential factor of the reaction rate constant, `k`, expressed by `k ~ exp(\u03B1)`, with `\u03B1 = E_0/(R*T)`, where `E_0` is activation energy (ISO 80000-5), `R` is molar gas constant (ISO 80000-9), and `T` is thermodynamic temperature (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n    attribute arrheniusNumber: ArrheniusNumberValue :> scalarQuantities;\n\n    /* ISO-80000-11 item 11-9.2 Landau-Ginzburg number */\n    attribute def LandauGinzburgNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 11-9.2 Landau-Ginzburg number\n         * symbol(s): `\u03BA`\n         * application domain: generic\n         * name: LandauGinzburgNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of penetration depth of a magnetic field into a superconductor and the coherence length of thermodynamic fluctuations within a superconducting phase in a material at zero thermodynamic temperature, expressed by `\u03BA = \u03BB_L/(\u03BE*sqrt(2))`, where `\u03BB_L` is London penetration depth (ISO 80000-12), and `\u03BE` is coherence length (ISO 80000-12)\n         * remarks: None.\n         */\n    }\n    attribute landauGinzburgNumber: LandauGinzburgNumberValue :> scalarQuantities;\n\n}\n', "Domain Libraries/Quantities and Units/ISQChemistryMolecular.sysml": 'standard library package ISQChemistryMolecular {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-9:2019 "Physical chemistry and molecular physics"\n     * see also https://www.iso.org/standard/64979.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n    private import ISQSpaceTime::AngularMeasureValue;\n    private import ISQThermodynamics::EnergyValue;\n\n    /* ISO-80000-9 item 9-1 number of entities */\n    attribute numberOfEntities: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-1 number of entities\n         * symbol(s): `N(X)`, `N_X`\n         * application domain: generic\n         * name: NumberOfEntities (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of elementary entities of kind `X` in a system\n         * remarks: The elementary entities must be specified and can be atoms, molecules, ions, electrons, other particle, or a specified group of such particles. It is important to always give a precise specification of the entity involved; this should preferably be done by the empirical chemical formula of the material involved.\n         */\n    }\n\n    /* ISO-80000-9 item 9-2 amount of substance, number of moles */\n    /* See package ISQBase for the declarations of AmountOfSubstanceValue and AmountOfSubstanceUnit */\n\n    alias NumberOfMolesUnit for AmountOfSubstanceUnit;\n    alias NumberOfMolesValue for AmountOfSubstanceValue;\n    alias numberOfMoles for amountOfSubstance;\n\n    /* ISO-80000-9 item 9-3 relative atomic mass */\n    attribute def RelativeAtomicMassValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-3 relative atomic mass\n         * symbol(s): `A_r(X)`\n         * application domain: generic\n         * name: RelativeAtomicMass (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the average mass (ISO 80000-4) of atom `X` and the unified atomic mass (ISO 80000-10)\n         * remarks: A similar quantity "relative molecular mass" can be defined for molecules. EXAMPLE `A_r(Cl) ~~ 35.453` `A_r(CO_2) ~~ 44` The relative atomic or relative molecular mass depends on the nuclidic composition. The International Union of Pure and Applied Chemistry (IUPAC) accepts the use of the special names "atomic weight" and "molecular weight" for the quantities "relative atomic mass" and "relative molecular mass", respectively. The use of these traditional names is deprecated.\n         */\n    }\n    attribute relativeAtomicMass: RelativeAtomicMassValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-4 molar mass */\n    attribute def MolarMassValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-4 molar mass\n         * symbol(s): `M(X)`\n         * application domain: generic\n         * name: MolarMass\n         * quantity dimension: M^1*N^-1\n         * measurement unit(s): g/mol, kg*mol^-1\n         * tensor order: 0\n         * definition: for a pure substance `X`, quotient of mass `m(X)` (ISO 80000-4) and amount `n` of substance (item 9-2): `M = m/n`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarMassUnit[1];\n    }\n\n    attribute molarMass: MolarMassValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarMassUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-5 molar volume */\n    attribute def MolarVolumeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-5 molar volume\n         * symbol(s): `V_m`\n         * application domain: generic\n         * name: MolarVolume\n         * quantity dimension: L^3*N^-1\n         * measurement unit(s): m^3*mol^-1\n         * tensor order: 0\n         * definition: for a pure substance, quotient of its volume `V` (ISO 80000-3) and amount `n` of substance (item 9-2): `V_m = V/n`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarVolumeUnit[1];\n    }\n\n    attribute molarVolume: MolarVolumeValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarVolumeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-6.1 molar internal energy */\n    attribute def MolarInternalEnergyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-6.1 molar internal energy\n         * symbol(s): `U_m`\n         * application domain: generic\n         * name: MolarInternalEnergy\n         * quantity dimension: L^2*M^1*T^-2*N^-1\n         * measurement unit(s): J/mol, kg*m^2*s^-2*mol^-1\n         * tensor order: 0\n         * definition: quotient of internal energy `U` (ISO 80000-5) and amount `n` of substance (item 9-2): `U_m = U/n`\n         * remarks: Molar quantities are normally only used with reference to pure substances.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarInternalEnergyUnit[1];\n    }\n\n    attribute molarInternalEnergy: MolarInternalEnergyValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarInternalEnergyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-6.2 molar enthalpy */\n    attribute def MolarEnthalpyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-6.2 molar enthalpy\n         * symbol(s): `H_m`\n         * application domain: generic\n         * name: MolarEnthalpy\n         * quantity dimension: L^2*M^1*T^-2*N^-1\n         * measurement unit(s): J/mol, kg*m^2*s^-2*mol^-1\n         * tensor order: 0\n         * definition: quotient of enthalpy `H` (ISO 80000-5) and amount `n` of substance (item 9-2): `H_m = H/n`\n         * remarks: Molar quantities are normally only used with reference to pure substances.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarEnthalpyUnit[1];\n    }\n\n    attribute molarEnthalpy: MolarEnthalpyValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarEnthalpyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-6.3 molar Helmholtz energy */\n    attribute def MolarHelmholtzEnergyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-6.3 molar Helmholtz energy\n         * symbol(s): `F_m`\n         * application domain: generic\n         * name: MolarHelmholtzEnergy\n         * quantity dimension: L^2*M^1*T^-2*N^-1\n         * measurement unit(s): J/mol, kg*m^2*s^-2*mol^-1\n         * tensor order: 0\n         * definition: quotient of the Helmholtz energy `F` (ISO 80000-5) and amount `n` of substance (item 9-2): `F_m = F/n`\n         * remarks: Molar quantities are normally only used with reference to pure substances.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarHelmholtzEnergyUnit[1];\n    }\n\n    attribute molarHelmholtzEnergy: MolarHelmholtzEnergyValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarHelmholtzEnergyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-6.4 molar Gibbs energy */\n    attribute def MolarGibbsEnergyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-6.4 molar Gibbs energy\n         * symbol(s): `G_m`\n         * application domain: generic\n         * name: MolarGibbsEnergy\n         * quantity dimension: L^2*M^1*T^-2*N^-1\n         * measurement unit(s): J/mol, kg*m^2*s^-2*mol^-1\n         * tensor order: 0\n         * definition: quotient of the Gibbs energy `G` (ISO 80000-5) and amount `n` of substance (item 9-2): `G_m = G/n`\n         * remarks: Molar quantities are normally only used with reference to pure substances.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarGibbsEnergyUnit[1];\n    }\n\n    attribute molarGibbsEnergy: MolarGibbsEnergyValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarGibbsEnergyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-7 molar heat capacity */\n    attribute def MolarHeatCapacityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-7 molar heat capacity\n         * symbol(s): `C_m`\n         * application domain: generic\n         * name: MolarHeatCapacity\n         * quantity dimension: L^2*M^1*T^-2*\u0398^-1*N^-1\n         * measurement unit(s): J/(mol*K), kg*m^2*s^-2*K^-1*mol^-1\n         * tensor order: 0\n         * definition: quotient of heat capacity `C` (ISO 80000-5) and amount of substance `n` (item 9-2): `C_m = C/n`\n         * remarks: Conditions (constant pressure or volume etc.) must be specified.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarHeatCapacityUnit[1];\n    }\n\n    attribute molarHeatCapacity: MolarHeatCapacityValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarHeatCapacityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.\'\u0398\'; :>> exponent = -1; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-8 molar entropy */\n    attribute def MolarEntropyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-8 molar entropy\n         * symbol(s): `S_m`\n         * application domain: generic\n         * name: MolarEntropy\n         * quantity dimension: L^2*M^1*T^-2*\u0398^-1*N^-1\n         * measurement unit(s): J/(mol*K), kg*m^2*s^-2*K^-1*mol^-1\n         * tensor order: 0\n         * definition: quotient of entropy `S` (ISO 80000-5) and amount `n` of substance (item 9-2): `S_m = S/n`\n         * remarks: Conditions (constant pressure or volume etc.) must be specified.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarEntropyUnit[1];\n    }\n\n    attribute molarEntropy: MolarEntropyValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarEntropyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.\'\u0398\'; :>> exponent = -1; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-9.1 particle concentration */\n    attribute def ParticleConcentrationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-9.1 particle concentration\n         * symbol(s): `n`, `(C)`\n         * application domain: generic\n         * name: ParticleConcentration\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: quotient of number `N` of particles (item 9-1) and volume `V `(ISO 80000-3): `n = N/V`\n         * remarks: The term "number density" is also used.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ParticleConcentrationUnit[1];\n    }\n\n    attribute particleConcentration: ParticleConcentrationValue[*] nonunique :> scalarQuantities;\n\n    attribute def ParticleConcentrationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-9 item 9-9.2 molecular concentration */\n    attribute molecularConcentration: ParticleConcentrationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-9.2 molecular concentration\n         * symbol(s): `C(X)`, `C_X`\n         * application domain: generic\n         * name: MolecularConcentration (specializes ParticleConcentration)\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: for substance `X` in a mixture, quotient of number `N_X` of molecules of substance `X` and volume `V` (ISO 80000-3) of the mixture: `C_X = N_X/V`\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-9 item 9-10 mass concentration */\n    attribute def MassConcentrationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-10 mass concentration\n         * symbol(s): `\u03B3_X`, `(\u03C1_X)`\n         * application domain: generic\n         * name: MassConcentration\n         * quantity dimension: L^-3*M^1\n         * measurement unit(s): g/l, kg*m^-3\n         * tensor order: 0\n         * definition: for substance `X` in a mixture, quotient of mass `m_X` (ISO 80000-4) of substance `X` and volume `V` (ISO 80000-3) of the mixture: `\u03B3_X = m_X/V`\n         * remarks: Decided by the 16th CGPM (1979), both "l" and "L" are allowed for the symbols for the litre.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassConcentrationUnit[1];\n    }\n\n    attribute massConcentration: MassConcentrationValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassConcentrationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-9 item 9-11 mass fraction */\n    attribute def MassFractionValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-11 mass fraction\n         * symbol(s): `w_X`\n         * application domain: generic\n         * name: MassFraction (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for substance `X` in a mixture, quotient of mass `m_X` (ISO 80000-4) of substance `X` and total mass `m` of the mixture: `w_X = m_X/m`\n         * remarks: None.\n         */\n    }\n    attribute massFraction: MassFractionValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-12.1 amount-of-substance concentration */\n    attribute def AmountOfSubstanceConcentrationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-12.1 amount-of-substance concentration\n         * symbol(s): `c_X`\n         * application domain: generic\n         * name: AmountOfSubstanceConcentration\n         * quantity dimension: L^-3*N^1\n         * measurement unit(s): mol/l, mol*m^-3\n         * tensor order: 0\n         * definition: for substance `X` in a mixture, quotient of amount `n_X` of substance (item 9-2) of `X` and volume `V` (ISO 80000-3) of the mixture: `c_X = n_X/V`\n         * remarks: In chemistry, the name "amount-of-substance concentration" is generally abbreviated to the single word "concentration", it being assumed that the adjective "amount-of-substance" is intended. For this reason, however, the word "mass" should never be omitted from the name "mass concentration" in item 9-10. Decided by the 16th CGPM (1979), both "l" and "L" are allowed for the symbols for the litre.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AmountOfSubstanceConcentrationUnit[1];\n    }\n\n    attribute amountOfSubstanceConcentration: AmountOfSubstanceConcentrationValue[*] nonunique :> scalarQuantities;\n\n    attribute def AmountOfSubstanceConcentrationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-12.2 standard amount-of-substance concentration */\n    attribute standardAmountOfSubstanceConcentration: AmountOfSubstanceConcentrationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-12.2 standard amount-of-substance concentration\n         * symbol(s): `c^!(X)`\n         * application domain: generic\n         * name: StandardAmountOfSubstanceConcentration (specializes AmountOfSubstanceConcentration)\n         * quantity dimension: L^-3*N^1\n         * measurement unit(s): mol/l, mol*m^-3\n         * tensor order: 0\n         * definition: for substance `X`, one mole per litre\n         * remarks: Decided by the 16th CGPM (1979), both "l" and "L" are allowed for the symbols for the litre.\n         */\n    }\n\n    /* ISO-80000-9 item 9-13 amount-of-substance fraction mole fraction */\n    attribute def AmountOfSubstanceFractionMoleFractionValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-13 amount-of-substance fraction mole fraction\n         * symbol(s): `x_X`, `y_X`\n         * application domain: generic\n         * name: AmountOfSubstanceFractionMoleFraction (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for substance `X` in a mixture, quotient of amount of substance `n_X` (item 9-2) of `X` and total amount `n` of substance (item 9-2) in the mixture: `x_X = n_X/n`\n         * remarks: For condensed phases, `x_X` is used, and for gaseous mixtures `y_X` may be used. The unsystematic name "mole fraction" is still used. However, the use of this name is deprecated. For this quantity, the entity used to define the amount of substance should always be a single molecule for every species in the mixture.\n         */\n    }\n    attribute amountOfSubstanceFractionMoleFraction: AmountOfSubstanceFractionMoleFractionValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-14 volume fraction */\n    attribute def VolumeFractionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-14 volume fraction\n         * symbol(s): `\u03C6_X`\n         * application domain: generic\n         * name: VolumeFraction\n         * quantity dimension: 1\n         * measurement unit(s): ml/l, 1\n         * tensor order: 0\n         * definition: for substance `X`, quotient of product of amount of substance fraction `x_X` (item 9-13) of `X` and molar volume `V_(m,X)` (item 9-5) of the pure substance `X` at the same temperature (ISO 80000-5) and pressure (ISO 80000-4), and sum over all substances `i` of products of amount-of-substance fractions `x_i` (item 9-13) of substance `i` and their molar volumes `V_(m,i)` (item 9-5): `\u03C6_X = (x_X V_(m,X))/(sum_i x_i V_(m,i))`\n         * remarks: Generally, the volume fraction is temperature dependent. Decided by the 16th CGPM (1979), both "l" and "L" are allowed for the symbols for the litre.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: VolumeFractionUnit[1];\n    }\n\n    attribute volumeFraction: VolumeFractionValue[*] nonunique :> scalarQuantities;\n\n    attribute def VolumeFractionUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-9 item 9-15 molality */\n    attribute def MolalityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-15 molality\n         * symbol(s): `b_B`, `m_B`\n         * application domain: generic\n         * name: Molality\n         * quantity dimension: M^-1*N^1\n         * measurement unit(s): mol/kg\n         * tensor order: 0\n         * definition: quotient of amount of substance (item 9-2) of solute `B` and mass `m_A` (ISO 80000-4) of the solvent substance `A`: `b_B = n_B/m_A`\n         * remarks: The alternative symbol `m_B` should be avoided in situations where it might be mistaken for the mass of substance B. However, the symbol `m_B` is much more commonly used than the symbol `b_B` for molality, despite the possible confusion with mass.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolalityUnit[1];\n    }\n\n    attribute molality: MolalityValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolalityUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-16 latent heat of phase transition, enthalpy of phase transition */\n    attribute latentHeatOfPhaseTransition: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-16 latent heat of phase transition, enthalpy of phase transition\n         * symbol(s): `C_"pt"`\n         * application domain: generic\n         * name: LatentHeatOfPhaseTransition (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: energy (ISO 80000-5) necessary to be added or subtracted isothermally and isobarically to a system to completely undergo the phase transition\n         * remarks: Mostly, molar or specific quantity is used and phase transition is expressed explicitly, e.g. molar latent heat of evaporation. The subscript "pt" is the qualifier for the phase transition, which may be changed to e.g. "l-g". The term "enthalpy of phase transition" is mainly used in theory.\n         */\n    }\n\n    alias enthalpyOfPhaseTransition for latentHeatOfPhaseTransition;\n\n    /* ISO-80000-9 item 9-17 chemical potential */\n    attribute def ChemicalPotentialValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-17 chemical potential\n         * symbol(s): `\u03BC_X`\n         * application domain: chemistry\n         * name: ChemicalPotential\n         * quantity dimension: L^2*M^1*T^-2*N^-1\n         * measurement unit(s): J/mol, kg*m^2*s^-2*mol^-1\n         * tensor order: 0\n         * definition: partial derivative of the Gibbs energy (ISO 80000-5) with respect to amount `n_X` of substance `X` (item 9-2) at constant temperature `T` (ISO 80000-5) and pressure `p `(ISO 80000-4): `\u03BC_X = ((del G)/(del n_X))_(T,p)`\n         * remarks: For a pure substance, where `G_m` is the molar Gibbs energy. In a mixture, `\u03BC_B` is the partial molar Gibbs energy. In condensed matter physics, the chemical potential of electrons is energy.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ChemicalPotentialUnit[1];\n    }\n\n    attribute chemicalPotential: ChemicalPotentialValue[*] nonunique :> scalarQuantities;\n\n    attribute def ChemicalPotentialUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-18 absolute activity */\n    attribute def AbsoluteActivityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-18 absolute activity\n         * symbol(s): `\u03BB_X`\n         * application domain: generic\n         * name: AbsoluteActivity (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for substance `X`, exponential of quotient of chemical potential `\u03BC_X` of substance `B` (item 9-17), and product of molar gas constant `R` (item 9-37.1) and thermodynamic temperature `T` (ISO 80000-5): `\u03BB_X = exp(\u03BC_X/(RT))`\n         * remarks: None.\n         */\n    }\n    attribute absoluteActivity: AbsoluteActivityValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-19 partial pressure */\n    attribute def PartialPressureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-19 partial pressure\n         * symbol(s): `p_X`\n         * application domain: generic\n         * name: PartialPressure\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: for substance `X` in a gaseous mixture, product of amount-of-substance fraction `y_X` of substance X (item 9-13) and total pressure `p` (ISO 80000-4): `p_X = y_X p`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PartialPressureUnit[1];\n    }\n\n    attribute partialPressure: PartialPressureValue[*] nonunique :> scalarQuantities;\n\n    attribute def PartialPressureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-9 item 9-20 fugacity */\n    attribute def FugacityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-20 fugacity\n         * symbol(s): `tilde(p)_X`\n         * application domain: generic\n         * name: Fugacity\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: for substance `X`, quantity proportional to the absolute activity, `\u03BB_X` (item 9-18), the proportionality factor, which is a function of temperature (ISO 80000-5) only, being determined by the condition that, at constant temperature and composition, `p_X/tilde(p)_X` tends to 1 for an indefinitely dilute gas\n         * remarks: `tilde(p)_X = \u03BB_X * lim_(p->0) (p_X/\u03BB_X)` where `p` is total pressure (ISO 80000-4). The IUPAC preferred symbol for fugacity is `f`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: FugacityUnit[1];\n    }\n\n    attribute fugacity: FugacityValue[*] nonunique :> scalarQuantities;\n\n    attribute def FugacityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-9 item 9-21 standard chemical potential */\n    attribute def StandardChemicalPotentialValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-21 standard chemical potential\n         * symbol(s): `\u03BC_B^!`, `\u03BC^!`\n         * application domain: generic\n         * name: StandardChemicalPotential\n         * quantity dimension: L^2*M^1*T^-2*N^-1\n         * measurement unit(s): J/mol, kg*m^2*s^-2*mol^-1\n         * tensor order: 0\n         * definition: for substance `B`, value of the chemical potential (item 9-17) at specified standard conditions\n         * remarks: `\u03BC_B^! = RT ln(\u03BB^!)` where `\u03BC_B^!` is a function of temperature `T` at the standard pressure `p = p^!` The standard chemical potential depends on the choice of standard state, which must be specified. In a liquid or solid solution, the standard state is referenced to the ideal dilute behaviour of the solute (substance `B`).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: StandardChemicalPotentialUnit[1];\n    }\n\n    attribute standardChemicalPotential: StandardChemicalPotentialValue[*] nonunique :> scalarQuantities;\n\n    attribute def StandardChemicalPotentialUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-22 activity factor */\n    attribute def ActivityFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-22 activity factor\n         * symbol(s): `f_X`\n         * application domain: generic\n         * name: ActivityFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for substance `X` in a liquid or a solid mixture, quotient of absolute activity `\u03BB_X` (item 9-18) of substance `X` and the product of absolute activity `\u03BB_X^"*"` of the pure substance `X` at the same temperature (ISO 80000-5) and pressure (ISO 80000-4) and amount-of-substance fraction `x_X` of substance `X` (item 9-13): `f_X = \u03BB_X/(\u03BB_X^"*" x_X)`\n         * remarks: The systematic name is "activity factor", but the name "activity coefficient" is also commonly used (see item 9-25). Activity factors can also be obtained applying Raoult\u2019s law or Henry\u2019s law.\n         */\n    }\n    attribute activityFactor: ActivityFactorValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-23 standard absolute activity in mixture */\n    attribute def StandardAbsoluteActivityInMixtureValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-23 standard absolute activity in mixture\n         * symbol(s): `\u03BB_X^!`\n         * application domain: in a mixture\n         * name: StandardAbsoluteActivityInMixture (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for substance `X` in a liquid or a solid mixture, absolute activity `\u03BB_X^"*"` (item 9-18) of the pure substance `X` at the same temperature (ISO 80000-5) but at standard pressure (ISO 80000-4) `10^5 ["Pa"]`: `\u03BB_X^! = \u03BB_X"*" (p^!)`\n         * remarks: This quantity is a function of temperature only.\n         */\n    }\n    attribute standardAbsoluteActivityInMixture: StandardAbsoluteActivityInMixtureValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-24 activity of solute, relative activity of solute */\n    attribute def ActivityOfSoluteValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-24 activity of solute, relative activity of solute\n         * symbol(s): `a_X`, `a_(m,X)`\n         * application domain: generic\n         * name: ActivityOfSolute (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for a solute `X` in a solution, quantity proportional to the absolute activity, `\u03BB_X` (item 9-18), the proportionality factor, which is a function of temperature (ISO 80000-5) and pressure (ISO 80000-4) only, being determined by the condition that, at constant temperature and pressure, `a_X` divided by the molality (item 9-15) ratio, `b_X/b^!` tends to 1 at infinite dilution; `b_X` is the molality of solute `X` (item 9-15), and `b^!` is standard molality: `a_X = \u03BB_X * lim_(sum b_X -> 0) (b_X//b^!)/\u03BB_X`\n         * remarks: The quantity `a_(c,X)` , similarly defined in terms of the concentration ratio `c_X/c^!` , is also called the activity or relative activity of solute `X`; `c^!` is a standard amount-of-substance concentration (item 9-12.2): `a_(c,X) = \u03BB_X * lim_(sum c_X -> 0) (c_X//c^!)/\u03BB_X`, where `sum` denotes summation over all the solute substances. This especially applies to a dilute liquid solution.\n         */\n    }\n    attribute activityOfSolute: ActivityOfSoluteValue :> scalarQuantities;\n\n    alias relativeActivityOfSolute for activityOfSolute;\n\n    /* ISO-80000-9 item 9-25 activity coefficient */\n    attribute def ActivityCoefficientValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-25 activity coefficient\n         * symbol(s): `\u03B3_B`\n         * application domain: generic\n         * name: ActivityCoefficient (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for a solute `B` in a solution, quotient of activity `a_B` of solute `B` (item 9-24), and quotient of the molality (item 9-15) `b_B` of substance `B` and standard molality `b^!`: `\u03B3_B = a_B/(b_B//b^!)`\n         * remarks: The name "activity coefficient of solute B" is also used for the quantity `\u03B3_B` defined as: `\u03B3_B = a_(c,B)/(c_B//c^!)` See item 9-22.\n         */\n    }\n    attribute activityCoefficient: ActivityCoefficientValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-26 standard absolute activity in solution */\n    attribute def StandardAbsoluteActivityInSolutionValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-26 standard absolute activity in solution\n         * symbol(s): `\u03BB_B^!`\n         * application domain: in a solution\n         * name: StandardAbsoluteActivityInSolution (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for a solute `B` in a solution: `\u03BB_B^! = lim_(sum b_B -> 0) [\u03BB_B ((p^!)b^!)/b_B]` where \u2211 denotes summation over all solutes, `p^!` is a standard pressure (ISO 80000-4), `b^!` is standard molality, and `b_B` is the molality of substance `B` (item 9-15)\n         * remarks: This quantity is a function of temperature only. It especially applies to a dilute liquid solution. The standard pressure is `10^5 ["Pa"]`.\n         */\n    }\n    attribute standardAbsoluteActivityInSolution: StandardAbsoluteActivityInSolutionValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-27.1 activity of solvent, relative activity of solvent */\n    attribute def ActivityOfSolventValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-27.1 activity of solvent, relative activity of solvent\n         * symbol(s): `a_A`\n         * application domain: generic\n         * name: ActivityOfSolvent (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for the solvent `A` in a solution, quotient of the absolute activity of substance `A`, `\u03BB_A` (item 9-18), and that, `\u03BB_A^"*"` , of the pure solvent at the same temperature (ISO 80000-5) and pressure (ISO 80000-4): `a_A = \u03BB_A/\u03BB_A^"*"`\n         * remarks: None.\n         */\n    }\n    attribute activityOfSolvent: ActivityOfSolventValue :> scalarQuantities;\n\n    alias relativeActivityOfSolvent for activityOfSolvent;\n\n    /* ISO-80000-9 item 9-27.2 osmotic factor of solvent, osmotic coefficient of solvent A */\n    attribute def OsmoticFactorOfSolventValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-27.2 osmotic factor of solvent, osmotic coefficient of solvent A\n         * symbol(s): `\u03C6`\n         * application domain: generic\n         * name: OsmoticFactorOfSolvent (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantity given by: `\u03C6 = -(M_A sum b_B)^-1 ln(a_A)` where `M_A` is the molar mass (item 9-4) of the solvent A, \u2211 denotes summation over all the solutes, `b_B` is the molality of solute B (item 9-15), and `a_A` is the activity of solvent A (item 9-27.1)\n         * remarks: The name "osmotic coefficient" is generally used, although the name "osmotic factor" is more systematic. This concept especially applies to a dilute liquid solution.\n         */\n    }\n    attribute osmoticFactorOfSolvent: OsmoticFactorOfSolventValue :> scalarQuantities;\n\n    alias osmoticCoefficientOfSolventA for osmoticFactorOfSolvent;\n\n    /* ISO-80000-9 item 9-27.3 standard absolute activity of solvent */\n    attribute def StandardAbsoluteActivityOfSolventValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-27.3 standard absolute activity of solvent\n         * symbol(s): `\u03BB_A^!`\n         * application domain: in a dilute solution\n         * name: StandardAbsoluteActivityOfSolvent (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for solvent `A`, standard absolute activity (item 9-23) of the pure substance `A` at the same temperature (ISO 80000-5) and at a standard pressure `p^!` (ISO 80000-4): `\u03BB_A^! = \u03BB_A^"*" p^!`\n         * remarks: None.\n         */\n    }\n    attribute standardAbsoluteActivityOfSolvent: StandardAbsoluteActivityOfSolventValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-28 osmotic pressure */\n    attribute def OsmoticPressureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-28 osmotic pressure\n         * symbol(s): `\u03A0`\n         * application domain: generic\n         * name: OsmoticPressure\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: excess pressure (ISO 80000-4) required to maintain osmotic equilibrium between a solution and the pure solvent separated by a membrane permeable to the solvent only\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: OsmoticPressureUnit[1];\n    }\n\n    attribute osmoticPressure: OsmoticPressureValue[*] nonunique :> scalarQuantities;\n\n    attribute def OsmoticPressureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-9 item 9-29 stoichiometric number of substance */\n    attribute def StoichiometricNumberOfSubstanceValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-29 stoichiometric number of substance\n         * symbol(s): `\u03BD_B`\n         * application domain: generic\n         * name: StoichiometricNumberOfSubstance (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for substance `B`, an integer number or a simple fraction, being negative for a reactant and positive for a product, occurring in the expression for a chemical reaction: `0 = sum \u03BD_B` where the symbol `B` denotes the reactants and products involved in the reaction\n         * remarks: EXAMPLE `(1/2)"N"_2 + (3/2)"H"_2 = "N""H"_3` ; `\u03BD("N"_2) = -1/2`, `\u03BD("H"_2) = -3/2`, `\u03BD("N""H"_3) = +1`.\n         */\n    }\n    attribute stoichiometricNumberOfSubstance: StoichiometricNumberOfSubstanceValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-30 affinity of a chemical reaction */\n    attribute def AffinityOfAChemicalReactionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-30 affinity of a chemical reaction\n         * symbol(s): `A`\n         * application domain: generic\n         * name: AffinityOfAChemicalReaction\n         * quantity dimension: L^2*M^1*T^-2*N^-1\n         * measurement unit(s): J/mol, kg*m^2*s^-2*mol^-1\n         * tensor order: 0\n         * definition: negative of the sum over all substances `B` of products of stoichiometric number `\u03BD_B` of substance `B` (item 9-29) and chemical potential `\u03BC_B` of substance `B` (item 9-17): `A = -sum \u03BD_B \u03BC_B`\n         * remarks: The affinity of a reaction is a measure of the "driving force" of the reaction. When it is positive, the reaction goes spontaneously from reactants to products, and when it is negative, the reaction goes in the opposite direction. Another way to write the definition is: `A = ((del G)/(del \u03BE))_(p,T)` where `G` is Gibbs energy (ISO 80000-5) and `\u03BE` is the extent of the reaction (item 9-31). Note that `\u03BD_B` is negative for reactants and positive for products.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AffinityOfAChemicalReactionUnit[1];\n    }\n\n    attribute affinityOfAChemicalReaction: AffinityOfAChemicalReactionValue[*] nonunique :> scalarQuantities;\n\n    attribute def AffinityOfAChemicalReactionUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-31 extent of reaction */\n    attribute extentOfReaction: AmountOfSubstanceValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-31 extent of reaction\n         * symbol(s): `\u03BE`\n         * application domain: generic\n         * name: ExtentOfReaction (specializes AmountOfSubstance)\n         * quantity dimension: N^1\n         * measurement unit(s): mol\n         * tensor order: 0\n         * definition: difference of initial amount `n_(B "in")` of substance `B` (item 9-2) and equilibrium amount `n_(B "eq")` of substance `B` (item 9-2) divided by stoichiometric number `\u03BD_B` of substance `B` (item 9-29): `\u03BE = (n_(B "eq") - n_(B "in"))/\u03BD_B`\n         * remarks: See remark to item 9-30.\n         */\n    }\n\n    /* ISO-80000-9 item 9-32 standard equilibrium constant, thermodynamic equilibrium constant */\n    attribute def StandardEquilibriumConstantValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-32 standard equilibrium constant, thermodynamic equilibrium constant\n         * symbol(s): `K^!`\n         * application domain: generic\n         * name: StandardEquilibriumConstant (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for a chemical reaction, product for all substances `B` of standard absolute activity `\u03BB_B^!` of substance `B` (item 9-26) in power of minus stoichiometric number `\u03BD_B` of substance `B` (item 9-29): `K^! = prod_B (tilde(a) \u03BB_B^!)^(-\u03BD_B)`\n         * remarks: This quantity is a function of temperature only. Others depend on temperature, pressure, and composition. One can define in an analogous way an equilibrium constant in terms of fugacity, `K_f`, molality, `K_m`, etc.\n         */\n    }\n    attribute standardEquilibriumConstant: StandardEquilibriumConstantValue :> scalarQuantities;\n\n    alias thermodynamicEquilibriumConstant for standardEquilibriumConstant;\n\n    /* ISO-80000-9 item 9-33 equilibrium constant on pressure basis */\n    attribute def EquilibriumConstantOnPressureBasisValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-33 equilibrium constant on pressure basis\n         * symbol(s): `K_p`\n         * application domain: pressure basis\n         * name: EquilibriumConstantOnPressureBasis\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: for gases, product for all substances `B` of partial pressure `p_B` of substance `B` (item 9-19) in power of its stoichiometric number `\u03BD_B` (item 9-29): `K_p = prod_B (p_B)^(\u03BD_B)`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EquilibriumConstantOnPressureBasisUnit[1];\n    }\n\n    attribute equilibriumConstantOnPressureBasis: EquilibriumConstantOnPressureBasisValue[*] nonunique :> scalarQuantities;\n\n    attribute def EquilibriumConstantOnPressureBasisUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-9 item 9-34 equilibrium constant on concentration basis */\n    attribute def EquilibriumConstantOnConcentrationBasisValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-34 equilibrium constant on concentration basis\n         * symbol(s): `K_c`\n         * application domain: concentration basis\n         * name: EquilibriumConstantOnConcentrationBasis\n         * quantity dimension: L^-3*N^1\n         * measurement unit(s): mol/m^3\n         * tensor order: 0\n         * definition: for solutions, product for all substances `B` of concentration `c_B` of substance `B` (item 9-9.1) in power of its stoichiometric number `\u03BD_B` (item 9-29): `K_c = prod_B (c_B)^(\u03BD_B)`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EquilibriumConstantOnConcentrationBasisUnit[1];\n    }\n\n    attribute equilibriumConstantOnConcentrationBasis: EquilibriumConstantOnConcentrationBasisValue[*] nonunique :> scalarQuantities;\n\n    attribute def EquilibriumConstantOnConcentrationBasisUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-35.1 microcanonical partition function */\n    attribute microcanonicalPartitionFunction: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-35.1 microcanonical partition function\n         * symbol(s): `\u03A9`\n         * application domain: generic\n         * name: MicrocanonicalPartitionFunction (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of all quantum states `r` consistent with given energy `E` (ISO 80000-4), volume (ISO 80000-3), and external fields: `\u03A9 = sum_r 1`\n         * remarks: `S = k ln(\u03A9)` where `S` is entropy (ISO 80000-5) and `k` is the Boltzmann constant (ISO 80000-1).\n         */\n    }\n\n    /* ISO-80000-9 item 9-35.2 canonical partition function */\n    attribute def CanonicalPartitionFunctionValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-35.2 canonical partition function\n         * symbol(s): `Z`\n         * application domain: generic\n         * name: CanonicalPartitionFunction (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: sum over quantum states of energy `E_r` (ISO 80000-4), expressed by: `Z = sum_r exp(-E_r/(kT))` where `k` is the Boltzmann constant (ISO 80000-1), and `T` is thermodynamic temperature (ISO 80000-5)\n         * remarks: `A = -kT ln(Z)` where `A` is Helmholtz energy (ISO 80000-5).\n         */\n    }\n    attribute canonicalPartitionFunction: CanonicalPartitionFunctionValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-35.3 grand-canonical partition function, grand partition function */\n    attribute def GrandCanonicalPartitionFunctionValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-35.3 grand-canonical partition function, grand partition function\n         * symbol(s): `\u039E`\n         * application domain: generic\n         * name: GrandCanonicalPartitionFunction (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: sum of canonical partition function `Z(N_A,N_B,\u2026)` for the given number of particles `A,B` multiplied by absolute activities (item 9-18) `\u03BB_A, \u03BB_B, ...` of particles `A, B`: `\u039E = sum_(N_A, N_B, ...) Z(N_A, N_B, \u2026) * \u03BB_A^(N_A) * \u03BB_B^(N_B) * ...`\n         * remarks: `A - sum \u03BC_B n_B = -kT ln(\u039E)` where `A` is Helmholtz energy (ISO 80000-5), `\u03BC_B` is the chemical potential of substance `B`, and `n_B` is the amount of substance `B`.\n         */\n    }\n    attribute grandCanonicalPartitionFunction: GrandCanonicalPartitionFunctionValue :> scalarQuantities;\n\n    alias grandPartitionFunction for grandCanonicalPartitionFunction;\n\n    /* ISO-80000-9 item 9-35.4 molecular partition function, partition function of a molecule */\n    attribute def MolecularPartitionFunctionValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-35.4 molecular partition function, partition function of a molecule\n         * symbol(s): `q`\n         * application domain: generic\n         * name: MolecularPartitionFunction (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantity given by: `q = sum_r exp(-\u03B5_r/(kT))` where `\u03B5_r` is the energy (ISO 80000-5) of the `r`-th level of the molecule consistent with given volume (ISO 80000-3) and external fields, `k` is the Boltzmann constant (ISO 80000-1), and `T` is thermodynamic temperature (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n    attribute molecularPartitionFunction: MolecularPartitionFunctionValue :> scalarQuantities;\n\n    alias partitionFunctionOfAMolecule for molecularPartitionFunction;\n\n    /* ISO-80000-9 item 9-36.1 statistical weight of subsystem */\n    attribute statisticalWeightOfSubsystem: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-36.1 statistical weight of subsystem\n         * symbol(s): `g`\n         * application domain: generic\n         * name: StatisticalWeightOfSubsystem (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of different microstates in a subsystem\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-9 item 9-36.2 degeneracy, multiplicity */\n    attribute def DegeneracyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-36.2 degeneracy, multiplicity\n         * symbol(s): `g`\n         * application domain: generic\n         * name: Degeneracy (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for quantum level, statistical weight of that level\n         * remarks: If `g = 1`, the level is called non-degenerate.\n         */\n    }\n    attribute degeneracy: DegeneracyValue :> scalarQuantities;\n\n    alias multiplicity for degeneracy;\n\n    /* ISO-80000-9 item 9-37.1 molar gas constant */\n    attribute def MolarGasConstantValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-37.1 molar gas constant\n         * symbol(s): `R`\n         * application domain: generic\n         * name: MolarGasConstant\n         * quantity dimension: L^2*M^1*T^-2*\u0398^-1*N^-1\n         * measurement unit(s): J/(mol*K), kg*m^2*s^-2*K^-1*mol^-1\n         * tensor order: 0\n         * definition: product of the Boltzmann constant (ISO 80000-1) and the Avogadro constant (ISO 80000-1)\n         * remarks: For an ideal gas, `pV_m = RT`\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarGasConstantUnit[1];\n    }\n\n    attribute molarGasConstant: MolarGasConstantValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarGasConstantUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.\'\u0398\'; :>> exponent = -1; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-37.2 specific gas constant */\n    /* Refer to declaration for SpecificGasConstant in ISQThermodynamics item 5-26 specific gas constant */\n\n    /* ISO-80000-9 item 9-38 mean free path */\n    attribute meanFreePath: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-38 mean free path\n         * symbol(s): `l`, `\u03BB`\n         * application domain: chemistry\n         * name: MeanFreePath (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: for a particle, the average distance `d` (ISO 80000-3) between two successive collisions with other particles\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-9 item 9-39 diffusion coefficient */\n    attribute def DiffusionCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-39 diffusion coefficient\n         * symbol(s): `D`\n         * application domain: chemistry\n         * name: DiffusionCoefficient\n         * quantity dimension: L^2*T^-1\n         * measurement unit(s): m^2*s^-1\n         * tensor order: 0\n         * definition: proportionality coefficient of local molecular concentration `C_B` (item 9-9.2) of substance `B` in the mixture multiplied by the local average velocity (ISO 80000-3) `v_B` of the molecules of `B`, and minus the gradient of the local molecular concentration `C_B` (item 9-9.2) of substance `B` in the mixture, expressed by: `C_B(v_B) = -D grad C_B`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DiffusionCoefficientUnit[1];\n    }\n\n    attribute diffusionCoefficient: DiffusionCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def DiffusionCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-9 item 9-40.1 thermal diffusion ratio */\n    attribute def ThermalDiffusionRatioValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-40.1 thermal diffusion ratio\n         * symbol(s): `k_T`\n         * application domain: generic\n         * name: ThermalDiffusionRatio (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: in a steady-state of a binary mixture in which thermal diffusion occurs, proportionality factor between gradient of the amount-of-subsstance fraction `x_B` (item 9-13) of the heavier substance `B`, and negative gradient of the local thermodynamic temperature `T` (ISO 80000-5) divided by that temperature (ISO 80000-5): `grad x_B = -(k_T/T) grad T`\n         * remarks: None.\n         */\n    }\n    attribute thermalDiffusionRatio: ThermalDiffusionRatioValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-40.2 thermal diffusion factor */\n    attribute def ThermalDiffusionFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-40.2 thermal diffusion factor\n         * symbol(s): `\u03B1_T`\n         * application domain: generic\n         * name: ThermalDiffusionFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the thermal diffusion ratio `k_T` (item 9-40.1), and the product of the local amount-of-substance fractions `x_A`, `x_B` (item 9-13) of two substances `A` and `B`: `\u03B1_T = k_T//(x_A x_B)`\n         * remarks: None.\n         */\n    }\n    attribute thermalDiffusionFactor: ThermalDiffusionFactorValue :> scalarQuantities;\n\n    /* ISO-80000-9 item 9-41 thermal diffusion coefficient */\n    attribute def ThermalDiffusionCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-41 thermal diffusion coefficient\n         * symbol(s): `D_T`\n         * application domain: generic\n         * name: ThermalDiffusionCoefficient\n         * quantity dimension: L^2*T^-1\n         * measurement unit(s): m^2*s^-1\n         * tensor order: 0\n         * definition: product of the thermal diffusion ratio `k_T` (item 9-40.1) and the diffusion coefficient `D` (item 9-39): `D_T = k_T*D`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThermalDiffusionCoefficientUnit[1];\n    }\n\n    attribute thermalDiffusionCoefficient: ThermalDiffusionCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThermalDiffusionCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-9 item 9-42 ionic strength */\n    attribute def IonicStrengthValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-42 ionic strength\n         * symbol(s): `I`\n         * application domain: generic\n         * name: IonicStrength\n         * quantity dimension: M^-1*N^1\n         * measurement unit(s): mol*kg^-1\n         * tensor order: 0\n         * definition: in a sample, one half of the sum of square of the charge number `z_i` (ISO 80000-10) of `i`-th ion multiplied by its molality `b_i` (item 9-15) over any involved ion: `I = 1/2 sum z_i^2 b_i`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: IonicStrengthUnit[1];\n    }\n\n    attribute ionicStrength: IonicStrengthValue[*] nonunique :> scalarQuantities;\n\n    attribute def IonicStrengthUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-43 degree of dissociation, dissociation fraction */\n    attribute def DegreeOfDissociationValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-43 degree of dissociation, dissociation fraction\n         * symbol(s): `\u03B1`\n         * application domain: generic\n         * name: DegreeOfDissociation (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: in a sample, quotient of the number `n_d` of dissociated molecules and the total number `n` of molecules: `\u03B1 = n_D / n`\n         * remarks: None.\n         */\n    }\n    attribute degreeOfDissociation: DegreeOfDissociationValue :> scalarQuantities;\n\n    alias dissociationFraction for degreeOfDissociation;\n\n    /* ISO-80000-9 item 9-44 electrolytic conductivity */\n    attribute def ElectrolyticConductivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-44 electrolytic conductivity\n         * symbol(s): `\u03BA`\n         * application domain: generic\n         * name: ElectrolyticConductivity\n         * quantity dimension: L^-3*M^-1*T^3*I^2\n         * measurement unit(s): S/m, kg^-1*m^-3*s^3*A^2\n         * tensor order: 0\n         * definition: quotient of the magnitude of electric current density `J` (IEC 80000-6) and the magnitude electric field strength `E` (IEC 80000-6) in an electrolyte: `\u03BA = J/E`\n         * remarks: For anisotropic media, `\u03BA` is a tensor. In IEC 80000-6 the symbols `\u03C3`, `\u03B3` are used.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectrolyticConductivityUnit[1];\n    }\n\n    attribute electrolyticConductivity: ElectrolyticConductivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectrolyticConductivityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* ISO-80000-9 item 9-45 molar conductivity */\n    attribute def MolarConductivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-45 molar conductivity\n         * symbol(s): `\u039B_m`\n         * application domain: generic\n         * name: MolarConductivity\n         * quantity dimension: M^-1*T^3*I^2*N^-1\n         * measurement unit(s): S*m^2/mol, kg^-1*s^3*A^2*mol^-1\n         * tensor order: 0\n         * definition: in an electrolyte, quotient of electrolytic conductivity `\u03BA` (item 9-44) and amount-of-substance concentration `c_B` (item 9-12.1): `\u039B_m = \u03BA/c_B`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarConductivityUnit[1];\n    }\n\n    attribute molarConductivity: MolarConductivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarConductivityUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, electricCurrentPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-46 transport number of the ion B, current fraction of the ion B */\n    attribute def TransportNumberOfTheIonBValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 9-46 transport number of the ion B, current fraction of the ion B\n         * symbol(s): `t_B`\n         * application domain: generic\n         * name: TransportNumberOfTheIonB (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for the ion `B`, quotient of electric current `i_B` (IEC 80000-6) carried by the ion `B` and total electric current `i` (IEC 80000-6) in an electrolyte: `t_B = i_B/i`\n         * remarks: None.\n         */\n    }\n    attribute transportNumberOfTheIonB: TransportNumberOfTheIonBValue :> scalarQuantities;\n\n    alias currentFractionOfTheIonB for transportNumberOfTheIonB;\n\n    /* ISO-80000-9 item 9-47 angle of optical rotation */\n    attribute angleOfOpticalRotation: AngularMeasureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 9-47 angle of optical rotation\n         * symbol(s): `\u03B1`\n         * application domain: generic\n         * name: AngleOfOpticalRotation (specializes AngularMeasure)\n         * quantity dimension: 1\n         * measurement unit(s): rad\n         * tensor order: 0\n         * definition: angle through which plane-polarized light is rotated clockwise, as seen when facing the light source, in passing through an optically active medium\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-9 item 9-48 molar optical rotatory power */\n    attribute def MolarOpticalRotatoryPowerValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-48 molar optical rotatory power\n         * symbol(s): `\u03B1_n`\n         * application domain: generic\n         * name: MolarOpticalRotatoryPower\n         * quantity dimension: L^2*N^-1\n         * measurement unit(s): rad*m^2/mol, m^2*mol^-1\n         * tensor order: 0\n         * definition: angle `\u03B1` of optical rotation (item 9-47), multiplied by the quotient of cross-sectional area `A` (ISO 80000-3) of a linearly polarized light beam and the amount of substance `n` (item 9-2) of the optically active component in the path of the beam: `\u03B1_n = (\u03B1 A)/n`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarOpticalRotatoryPowerUnit[1];\n    }\n\n    attribute molarOpticalRotatoryPower: MolarOpticalRotatoryPowerValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarOpticalRotatoryPowerUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, amountOfSubstancePF); }\n    }\n\n    /* ISO-80000-9 item 9-49 specific optical rotatory power */\n    attribute def SpecificOpticalRotatoryPowerValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 9-49 specific optical rotatory power\n         * symbol(s): `\u03B1_m`\n         * application domain: generic\n         * name: SpecificOpticalRotatoryPower\n         * quantity dimension: L^2*M^-1\n         * measurement unit(s): rad*m^2/kg, kg^-1*m^2\n         * tensor order: 0\n         * definition: angle `\u03B1` of optical rotation (item 9-47), multiplied by the quotient of cross-sectional area `A` (ISO 80000-3) of a linearly polarized light beam and the mass `m` (ISO 80000-4) of the optically active component in the path of the beam: `\u03B1_m = (\u03B1 A)/m`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificOpticalRotatoryPowerUnit[1];\n    }\n\n    attribute specificOpticalRotatoryPower: SpecificOpticalRotatoryPowerValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificOpticalRotatoryPowerUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n}\n', "Domain Libraries/Quantities and Units/ISQCondensedMatter.sysml": "standard library package ISQCondensedMatter {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-12:2019 \"Condensed matter physics\"\n     * see also https://www.iso.org/standard/63480.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n    private import ISQElectromagnetism::ElectricPotentialDifferenceValue;\n    private import ISQElectromagnetism::MagneticFluxDensityValue;\n    private import ISQElectromagnetism::ResistivityValue;\n    private import ISQSpaceTime::CartesianSpatial3dCoordinateFrame;\n    private import ISQSpaceTime::AngularFrequencyValue;\n    private import ISQSpaceTime::AngularMeasureValue;\n    private import ISQSpaceTime::RepetencyValue;\n    private import ISQThermodynamics::EnergyValue;\n\n    /* ISO-80000-12 item 12-1.1 lattice vector */\n    attribute def CartesianLattice3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 12-1.1 lattice vector\n         * symbol(s): `vec(R)`\n         * application domain: generic\n         * name: LatticeVector (specializes Displacement)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: translation vector that maps the crystal lattice on itself\n         * remarks: The non-SI unit \xE5ngstr\xF6m (\xC5) is widely used by x-ray crystallographers and structural chemists.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianSpatial3dCoordinateFrame[1];\n    }\n\n    attribute cartesianLattice3dVector: CartesianLattice3dVector :> vectorQuantities;\n\n    /* ISO-80000-12 item 12-1.2 fundamental lattice vector */\n    attribute def CartesianFundamentalLattice3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 12-1.2 fundamental lattice vector\n         * symbol(s): `vec(a_1),vec(a_2),vec(a_3)`, `vec(a),vec(b),vec(c)`\n         * application domain: generic\n         * name: FundamentalLatticeVector (specializes Displacement)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: fundamental translation vectors for the crystal lattice\n         * remarks: The lattice vector (item 12-1.1) can be given as `vec(R) = n_1 vec(a_1) + n_2 vec(a_2) + n_3 vec(a_3)` where `n_1`, `n_2` and `n_3` are integers.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianSpatial3dCoordinateFrame[1];\n    }\n\n    attribute cartesianFundamentalLattice3dVector: CartesianFundamentalLattice3dVector :> vectorQuantities;\n\n    /* ISO-80000-12 item 12-2.1 angular reciprocal lattice vector */\n    attribute def AngularReciprocalLatticeVectorMagnitudeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-2.1 angular reciprocal lattice vector (magnitude)\n         * symbol(s): `G`\n         * application domain: generic\n         * name: AngularReciprocalLatticeVectorMagnitude\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: vector whose scalar products with all fundamental lattice vectors are integral multiples of  `2\u03C0`\n         * remarks: In crystallography, however, the quantity `G/(2\u03C0)` is sometimes used.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AngularReciprocalLatticeVectorMagnitudeUnit[1];\n    }\n\n    attribute angularReciprocalLatticeVectorMagnitude: AngularReciprocalLatticeVectorMagnitudeValue[*] nonunique :> scalarQuantities;\n\n    attribute def AngularReciprocalLatticeVectorMagnitudeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    attribute def CartesianAngularReciprocalLattice3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 12-2.1 angular reciprocal lattice vector\n         * symbol(s): `vec(G)`\n         * application domain: generic\n         * name: AngularReciprocalLatticeVector\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 1\n         * definition: vector whose scalar products with all fundamental lattice vectors are integral multiples of  `2\u03C0`\n         * remarks: In crystallography, however, the quantity `G/(2\u03C0)` is sometimes used.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianAngularReciprocalLattice3dCoordinateFrame[1];\n    }\n\n    attribute cartesianAngularReciprocalLattice3dVector: CartesianAngularReciprocalLattice3dVector :> vectorQuantities;\n\n    attribute def CartesianAngularReciprocalLattice3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: AngularReciprocalLatticeVectorMagnitudeUnit[3];\n    }\n\n    /* ISO-80000-12 item 12-2.2 fundamental reciprocal lattice vector */\n    attribute def FundamentalReciprocalLatticeVectorMagnitudeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-2.2 fundamental reciprocal lattice vector (magnitude)\n         * symbol(s): `b_1,b_2,b_3`\n         * application domain: generic\n         * name: FundamentalReciprocalLatticeVectorMagnitude\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: fundamental translation vectors for the reciprocal lattice\n         * remarks: `vec(a_i) * vec(b_i) = 2\u03C0 \u03B4_(ij)`. In crystallography, however, the quantities `vec(b_j)/(2\u03C0)` are also often used.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: FundamentalReciprocalLatticeVectorMagnitudeUnit[1];\n    }\n\n    attribute fundamentalReciprocalLatticeVectorMagnitude: FundamentalReciprocalLatticeVectorMagnitudeValue[*] nonunique :> scalarQuantities;\n\n    attribute def FundamentalReciprocalLatticeVectorMagnitudeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    attribute def CartesianFundamentalReciprocalLattice3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 12-2.2 fundamental reciprocal lattice vector\n         * symbol(s): `vec(b_1),vec(b_2),vec(b_3)`\n         * application domain: generic\n         * name: FundamentalReciprocalLatticeVector\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 1\n         * definition: fundamental translation vectors for the reciprocal lattice\n         * remarks: `vec(a_i) * vec(b_i) = 2\u03C0 \u03B4_(ij)`. In crystallography, however, the quantities `vec(b_j)/(2\u03C0)` are also often used.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianFundamentalReciprocalLattice3dCoordinateFrame[1];\n    }\n\n    attribute cartesianFundamentalReciprocalLattice3dVector: CartesianFundamentalReciprocalLattice3dVector :> vectorQuantities;\n\n    attribute def CartesianFundamentalReciprocalLattice3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: FundamentalReciprocalLatticeVectorMagnitudeUnit[3];\n    }\n\n    /* ISO-80000-12 item 12-3 lattice plane spacing */\n    attribute latticePlaneSpacing: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-3 lattice plane spacing\n         * symbol(s): `d`\n         * application domain: generic\n         * name: LatticePlaneSpacing (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: distance (ISO 80000-3) between successive lattice planes\n         * remarks: The non-SI unit \xE5ngstr\xF6m (\xC5) is widely used by x-ray crystallographers and structural chemists.\n         */\n    }\n\n    /* ISO-80000-12 item 12-4 Bragg angle */\n    attribute braggAngle: AngularMeasureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-4 Bragg angle\n         * symbol(s): `\u03D1`\n         * application domain: generic\n         * name: BraggAngle (specializes AngularMeasure)\n         * quantity dimension: 1\n         * measurement unit(s): \xB0, 1\n         * tensor order: 0\n         * definition: angle between the scattered ray and the lattice plane\n         * remarks: Bragg angle `\u03D1` is given by `2d sin \u03D1 = n\u03BB`, where `d` is the lattice plane spacing (item 12-3), `\u03BB` is the wavelength (ISO 80000-7) of the radiation, and `n` is the order of reflexion which is an integer.\n         */\n    }\n\n    /* ISO-80000-12 item 12-5.1 short-range order parameter */\n    attribute def ShortRangeOrderParameterValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 12-5.1 short-range order parameter\n         * symbol(s): `r`, `\u03C3`\n         * application domain: generic\n         * name: ShortRangeOrderParameter (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: fraction of nearest-neighbour atom pairs in an Ising ferromagnet having magnetic moments in one direction, minus the fraction having magnetic moments in the opposite direction\n         * remarks: Similar definitions apply to other order-disorder phenomena. Other symbols are frequently used.\n         */\n    }\n    attribute shortRangeOrderParameter: ShortRangeOrderParameterValue :> scalarQuantities;\n\n    /* ISO-80000-12 item 12-5.2 long-range order parameter */\n    attribute def LongRangeOrderParameterValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 12-5.2 long-range order parameter\n         * symbol(s): `R`, `s`\n         * application domain: generic\n         * name: LongRangeOrderParameter (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: fraction of atoms in an Ising ferromagnet having magnetic moments in one direction, minus the fraction having magnetic moments in the opposite direction\n         * remarks: Similar definitions apply to other order-disorder phenomena. Other symbols are frequently used.\n         */\n    }\n    attribute longRangeOrderParameter: LongRangeOrderParameterValue :> scalarQuantities;\n\n    /* ISO-80000-12 item 12-5.3 atomic scattering factor */\n    attribute def AtomicScatteringFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 12-5.3 atomic scattering factor\n         * symbol(s): `f`\n         * application domain: generic\n         * name: AtomicScatteringFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of radiation amplitude scattered by the atom and radiation amplitude scattered by a single electron\n         * remarks: The atomic scattering factor can be expressed by: `f = E_a/(E_e`, where `E_a` is the radiation amplitude scattered by the atom and `E_e` is the radiation amplitude scattered by a single electron.\n         */\n    }\n    attribute atomicScatteringFactor: AtomicScatteringFactorValue :> scalarQuantities;\n\n    /* ISO-80000-12 item 12-5.4 structure factor */\n    attribute def StructureFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 12-5.4 structure factor\n         * symbol(s): `F(h,k,l)`\n         * application domain: generic\n         * name: StructureFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantity given by: `F(h,k,l) = sum_(n=1)^N f_n exp[2\u03C0 i (h x_n + k y_n + l z_n)]`, where `f_n` is the atomic scattering factor (item 12-5.3) for atom `n`, `x_n`, `y_n`, `z_n` are fractional coordinates of its position, `N` is the total number of atoms in the unit cell and `h`, `k`, `l` are the Miller indices\n         * remarks: For the Miller indices `h`, `k`, `l`, see Annex A.\n         */\n    }\n    attribute structureFactor: StructureFactorValue :> scalarQuantities;\n\n    /* ISO-80000-12 item 12-6 Burgers vector */\n    attribute def CartesianBurgers3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 12-6 Burgers vector\n         * symbol(s): `vec(b)`\n         * application domain: generic\n         * name: BurgersVector (specializes Displacement)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: closing vector in a sequence of vectors encircling a dislocation\n         * remarks: None.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianSpatial3dCoordinateFrame[1];\n    }\n\n    attribute cartesianBurgers3dVector: CartesianBurgers3dVector :> vectorQuantities;\n\n    /* ISO-80000-12 item 12-7.1 particle position vector */\n    attribute def CartesianParticlePosition3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 12-7.1 particle position vector\n         * symbol(s): `vec(r)`, `vec(R)`\n         * application domain: generic\n         * name: ParticlePositionVector (specializes PositionVector)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: position vector (ISO 80000-3) of a particle\n         * remarks: Often, `r` is used for electrons and `R` is used for atoms and other heavier particles.\n         */\n        attribute :>> isBound = true;\n        attribute :>> mRef: CartesianSpatial3dCoordinateFrame[1];\n    }\n\n    attribute cartesianParticlePosition3dVector: CartesianParticlePosition3dVector :> vectorQuantities;\n\n    /* ISO-80000-12 item 12-7.2 equilibrium position vector */\n    attribute def CartesianEquilibriumPosition3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 12-7.2 equilibrium position vector\n         * symbol(s): `vec(R_0)`\n         * application domain: condensed matter physics\n         * name: EquilibriumPositionVector (specializes PositionVector)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: position vector (ISO 80000-3) of an ion or atom in equilibrium\n         * remarks: None.\n         */\n        attribute :>> isBound = true;\n        attribute :>> mRef: CartesianSpatial3dCoordinateFrame[1];\n    }\n\n    attribute cartesianEquilibriumPosition3dVector: CartesianEquilibriumPosition3dVector :> vectorQuantities;\n\n    /* ISO-80000-12 item 12-7.3 displacement vector */\n    attribute def CartesianDisplacement3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 12-7.3 displacement vector\n         * symbol(s): `vec(u)`\n         * application domain: condensed matter physics\n         * name: DisplacementVector (specializes Displacement)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: difference between the position vector (ISO 80000-3) of an ion or atom and its position vector in equilibrium\n         * remarks: The displacement vector can be expressed by: `vec(u) = vec(R) \u2212 vec(R_0)`, where `vec(R)` is particle position vector (item 12-7.1) and `vec(R_0)` is position vector of an ion or atom in equilibrium (item 12-7.2).\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianSpatial3dCoordinateFrame[1];\n    }\n\n    attribute cartesianDisplacement3dVector: CartesianDisplacement3dVector :> vectorQuantities;\n\n    /* ISO-80000-12 item 12-8 Debye-Waller factor */\n    attribute def DebyeWallerFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 12-8 Debye-Waller factor\n         * symbol(s): `D`, `B`\n         * application domain: generic\n         * name: DebyeWallerFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: factor by which the intensity of a diffraction line is reduced because of the lattice vibrations\n         * remarks: `D` is sometimes expressed as `D = exp(\u22122W)`; in M\xF6ssbauer spectroscopy, it is also called the `f` factor and denoted by `f`.\n         */\n    }\n    attribute debyeWallerFactor: DebyeWallerFactorValue :> scalarQuantities;\n\n    /* ISO-80000-12 item 12-9.1 angular wavenumber, angular repetency */\n    attribute angularWavenumber: RepetencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-9.1 angular wavenumber, angular repetency\n         * symbol(s): `k`, `q`\n         * application domain: condensed matter physics\n         * name: AngularWavenumber (specializes Repetency)\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: quotient of momentum (ISO 80000-4) and the reduced Planck constant (ISO 80000-1)\n         * remarks: The corresponding vector (ISO 80000-2) quantity is called wave vector (ISO 80000-3), expressed by: `vec(k) = vec(p)/\u0127`, where `vec(p)` is the momentum (ISO 80000-4) of quasi free electrons in an electron gas, and `\u0127` is the reduced Planck constant (ISO 80000-1); for phonons, its magnitude is `k = 2\u03C0/\u03BB`, where `\u03BB` is the wavelength (ISO 80000-3) of the lattice vibrations. When a distinction is needed between `k` and the symbol for the Boltzmann constant (ISO 80000-1), `k_B` can be used for the latter. When a distinction is needed, `q` should be used for phonons, and `k` for particles such as electrons and neutrons. The method of cut-off must be specified. In condensed matter physics, angular wavenumber is often called wavenumber.\n         */\n    }\n\n    alias angularRepetency for angularWavenumber;\n\n    /* ISO-80000-12 item 12-9.2 Fermi angular wavenumber, Fermi angular repetency */\n    attribute fermiAngularWavenumber: RepetencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-9.2 Fermi angular wavenumber, Fermi angular repetency\n         * symbol(s): `k_F`\n         * application domain: generic\n         * name: FermiAngularWavenumber (specializes Repetency)\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: angular wavenumber (item 12-9.1) of electrons in states on the Fermi sphere\n         * remarks: In condensed matter physics, angular wavenumber is often called wavenumber.\n         */\n    }\n\n    alias fermiAngularRepetency for fermiAngularWavenumber;\n\n    /* ISO-80000-12 item 12-9.3 Debye angular wavenumber, Debye angular repetency */\n    attribute debyeAngularWavenumber: RepetencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-9.3 Debye angular wavenumber, Debye angular repetency\n         * symbol(s): `q_D`\n         * application domain: generic\n         * name: DebyeAngularWavenumber (specializes Repetency)\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: cut-off angular wavenumber (item 12-9.1) in the Debye model of the vibrational spectrum of a solid\n         * remarks: The method of cut-off must be specified. In condensed matter physics, angular wavenumber is often called wavenumber.\n         */\n    }\n\n    alias debyeAngularRepetency for debyeAngularWavenumber;\n\n    /* ISO-80000-12 item 12-10 Debye angular frequency */\n    attribute debyeAngularFrequency: AngularFrequencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-10 Debye angular frequency\n         * symbol(s): `\u03C9_D`\n         * application domain: generic\n         * name: DebyeAngularFrequency (specializes AngularFrequency)\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: cut-off angular frequency (ISO 80000-3) in the Debye model of the vibrational spectrum of a solid\n         * remarks: The method of cut-off must be specified.\n         */\n    }\n\n    /* ISO-80000-12 item 12-11 Debye temperature */\n    attribute debyeTemperature: ThermodynamicTemperatureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-11 Debye temperature\n         * symbol(s): `\u0398_D`\n         * application domain: generic\n         * name: DebyeTemperature (specializes ThermodynamicTemperature)\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: in the Debye model, quantity given by: `\u0398_D = \u0127*\u03C9_D/k`, where `k` is the Boltzmann constant, (ISO 80000-1), `\u0127` is the reduced Planck constant (ISO 80000-1), and `\u03C9_D` is Debye angular frequency (item 12-10)\n         * remarks: A Debye temperature can also be defined by fitting a Debye model result to a certain quantity, for instance, the heat capacity at a certain temperature.\n         */\n    }\n\n    /* ISO-80000-12 item 12-12 density of vibrational states */\n    attribute def DensityOfVibrationalStatesValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-12 density of vibrational states\n         * symbol(s): `g`\n         * application domain: angular frequency\n         * name: DensityOfVibrationalStates\n         * quantity dimension: L^-3*T^1\n         * measurement unit(s): m^-3*s\n         * tensor order: 0\n         * definition: quotient of the number of vibrational modes in an infinitesimal interval of angular frequency (ISO 80000-3), and the product of the width of that interval and volume (ISO 80000-3)\n         * remarks: `g(\u03C9) = n_\u03C9 = (dn(\u03C9))/(d\u03C9)`, where `n(\u03C9)` is the total number of vibrational modes per volume with angular frequency less than `\u03C9`. The density of states may also be normalized in other ways instead of with respect to volume. See also item 12-16.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DensityOfVibrationalStatesUnit[1];\n    }\n\n    attribute densityOfVibrationalStates: DensityOfVibrationalStatesValue[*] nonunique :> scalarQuantities;\n\n    attribute def DensityOfVibrationalStatesUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-12 item 12-13 thermodynamic Gr\xFCneisen parameter */\n    attribute def 'ThermodynamicGr\xFCneisenParameterValue' :> DimensionOneValue {\n        doc\n        /*\n         * source: item 12-13 thermodynamic Gr\xFCneisen parameter\n         * symbol(s): `\u03B3_G`, `\u0393_G`\n         * application domain: generic\n         * name: ThermodynamicGr\xFCneisenParameter (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantity given by: `\u03B3_G = (\u03B1_V)/(\u03BA_T c_V \u03C1)`, where `\u03B1_V` is cubic expansion coefficient (ISO 80000-5), `\u03BA_T` is isothermal compressibility (ISO 80000-5), `c_V` is specific heat capacity at constant volume (ISO 80000-5), and `\u03C1` is mass density (ISO 80000-4)\n         * remarks: None.\n         */\n    }\n    attribute 'thermodynamicGr\xFCneisenParameter': 'ThermodynamicGr\xFCneisenParameterValue' :> scalarQuantities;\n\n    /* ISO-80000-12 item 12-14 Gr\xFCneisen parameter */\n    attribute def 'Gr\xFCneisenParameterValue' :> DimensionOneValue {\n        doc\n        /*\n         * source: item 12-14 Gr\xFCneisen parameter\n         * symbol(s): `\u03B3`\n         * application domain: generic\n         * name: Gr\xFCneisenParameter (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantity given by minus the partial differential quotient: `\u03B3 = -(del ln \u03C9)/(del ln V)`, where `\u03C9` is a lattice vibration frequency (ISO 80000-3), and `V` is volume (ISO 80000-3)\n         * remarks: `\u03C9` can also refer to an average of the vibrational spectrum, for instance as represented by a Debye angular frequency (item 12-10).\n         */\n    }\n    attribute 'gr\xFCneisenParameter': 'Gr\xFCneisenParameterValue' :> scalarQuantities;\n\n    /* ISO-80000-12 item 12-15.1 mean free path of phonons */\n    attribute meanFreePathOfPhonons: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-15.1 mean free path of phonons\n         * symbol(s): `l_p`\n         * application domain: generic\n         * name: MeanFreePathOfPhonons (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: average distance (ISO 80000-3) that phonons travel between two successive interactions\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-15.2 mean free path of electrons */\n    attribute meanFreePathOfElectrons: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-15.2 mean free path of electrons\n         * symbol(s): `l_e`\n         * application domain: generic\n         * name: MeanFreePathOfElectrons (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: average distance (ISO 80000-3) that electrons travel between two successive interactions\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-16 energy density of states */\n    attribute def EnergyDensityOfStatesValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-16 energy density of states\n         * symbol(s): `n_E(E)`, `\u03C1(E)`\n         * application domain: generic\n         * name: EnergyDensityOfStates\n         * quantity dimension: L^-5*M^-1*T^2\n         * measurement unit(s): J^-1*m^-3*eV^-1*m^-3, kg^-1*m^-5*s^2\n         * tensor order: 0\n         * definition: quantity given by the differential quotient with respect to energy: `n_E(E) = (dn(E))/(dE)`, where `n_E(E)` is the total number of one-electron states per volume (ISO 80000-3) with energy less than `E` (ISO 80000-5)\n         * remarks: Density of states refers to electrons or other entities, e.g. phonons. It may be normalized in other ways instead of with respect to volume, e.g. with respect to amount of substance. See also item 12-12.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EnergyDensityOfStatesUnit[1];\n    }\n\n    attribute energyDensityOfStates: EnergyDensityOfStatesValue[*] nonunique :> scalarQuantities;\n\n    attribute def EnergyDensityOfStatesUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -5; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-12 item 12-17 residual resistivity */\n    attribute residualResistivity: ResistivityValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-17 residual resistivity\n         * symbol(s): `\u03C1_0`\n         * application domain: generic\n         * name: ResidualResistivity (specializes Resistivity)\n         * quantity dimension: L^3*M^1*T^-3*I^-2\n         * measurement unit(s): \u03A9*m, kg*m^3*s^-3*A^-2\n         * tensor order: 0\n         * definition: for metals, the resistivity (IEC 80000-6) extrapolated to zero thermodynamic temperature (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-18 Lorenz coefficient */\n    attribute def LorenzCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-18 Lorenz coefficient\n         * symbol(s): `L`\n         * application domain: generic\n         * name: LorenzCoefficient\n         * quantity dimension: L^4*M^2*T^-6*I^-2*\u0398^-2\n         * measurement unit(s): V^2/K^2, kg^2*m^4*s^-6*A^-2*K^-2\n         * tensor order: 0\n         * definition: quotient of thermal conductivity (ISO 80000-5), and the product of electric conductivity (IEC 80000-6) and thermodynamic temperature (ISO 80000-3)\n         * remarks: The Lorenz coefficient can be expressed by `L = \u03BB/(\u03C3T)`, where `\u03BB` is thermal conductivity (ISO 80000-5), `\u03C3` is electric conductivity (IEC 80000-6), and `T` is thermodynamic temperature (ISO 80000-5).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LorenzCoefficientUnit[1];\n    }\n\n    attribute lorenzCoefficient: LorenzCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def LorenzCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 4; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -6; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-12 item 12-19 Hall coefficient */\n    attribute def HallCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-19 Hall coefficient\n         * symbol(s): `R_H`, `A_H`\n         * application domain: generic\n         * name: HallCoefficient\n         * quantity dimension: L^3*T^-1*I^-1\n         * measurement unit(s): m^3/C, m^3*s^-1*A^-1\n         * tensor order: 0\n         * definition: in an isotropic conductor, relation between electric field strength, `vec(E)`, (IEC 80000-6) and electric current density, `vec(J)`, (IEC 80000-6) expressed as: `vec(E) = \u03C1 vec(J) + R_H (vec(B) xx vec(J))`, where `\u03C1` is resistivity (IEC 80000-6), and `vec(B)` is magnetic flux density (IEC 80000-6)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: HallCoefficientUnit[1];\n    }\n\n    attribute hallCoefficient: HallCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def HallCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, electricCurrentPF); }\n    }\n\n    /* ISO-80000-12 item 12-20 thermoelectric voltage (between substances a and b) */\n    attribute thermoelectricVoltageBetweenSubstancesAAndB: ElectricPotentialDifferenceValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-20 thermoelectric voltage (between substances a and b)\n         * symbol(s): `E_(ab)`\n         * application domain: generic\n         * name: ThermoelectricVoltageBetweenSubstancesAAndB (specializes ElectricPotentialDifference)\n         * quantity dimension: L^2*M^1*T^-3*I^-1\n         * measurement unit(s): V, kg*m^2*s^-3*A^-1\n         * tensor order: 0\n         * definition: voltage (IEC 80000-6) between substances `a` and `b` caused by the thermoelectric effect\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-21 Seebeck coefficient (for substances a and b) */\n    attribute def SeebeckCoefficientForSubstancesAAndBValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-21 Seebeck coefficient (for substances a and b)\n         * symbol(s): `S_(ab)`\n         * application domain: generic\n         * name: SeebeckCoefficientForSubstancesAAndB\n         * quantity dimension: L^2*M^1*T^-3*I^-1*\u0398^-1\n         * measurement unit(s): V/K, kg*m^2*s^-3*A^-1*K^-1\n         * tensor order: 0\n         * definition: differential quotient of thermoelectric voltage with respect to thermodynamic temperature: `S_(ab) =      (dE_(ab))/(dT)`, where `E_(ab)` is the thermoelectric voltage between substances `a` and `b` (item 12-20) and `T` is thermodynamic temperature (ISO 80000-5)\n         * remarks: This term is also called \"thermoelectric power\".\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SeebeckCoefficientForSubstancesAAndBUnit[1];\n    }\n\n    attribute seebeckCoefficientForSubstancesAAndB: SeebeckCoefficientForSubstancesAAndBValue[*] nonunique :> scalarQuantities;\n\n    attribute def SeebeckCoefficientForSubstancesAAndBUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-12 item 12-22 Peltier coefficient (for substances a and b) */\n    attribute peltierCoefficientForSubstancesAAndB: ElectricPotentialDifferenceValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-22 Peltier coefficient (for substances a and b)\n         * symbol(s): `\u03A0_(ab)`\n         * application domain: generic\n         * name: PeltierCoefficientForSubstancesAAndB (specializes ElectricPotentialDifference)\n         * quantity dimension: L^2*M^1*T^-3*I^-1\n         * measurement unit(s): V, kg*m^2*s^-3*A^-1\n         * tensor order: 0\n         * definition: quotient of Peltier heat power (ISO 80000-5) developed at a junction, and the electric current (IEC 80000-6) flowing from substance `a` to substance `b`\n         * remarks: `\u03A0_(ab) = \u03A0_a - \u03A0_b`, where `\u03A0_a` and `\u03A0_b` are the Peltier coefficients of substances `a` and `b`, respectively.\n         */\n    }\n\n    /* ISO-80000-12 item 12-23 Thomson coefficient */\n    attribute def ThomsonCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-23 Thomson coefficient\n         * symbol(s): `\u03BC`\n         * application domain: generic\n         * name: ThomsonCoefficient\n         * quantity dimension: L^2*M^1*T^-3*I^-1*\u0398^-1\n         * measurement unit(s): V/K, kg*m^2*s^-3*A^-1*K^-1\n         * tensor order: 0\n         * definition: quotient of Thomson heat power (ISO 80000-5) developed, and the electric current (IEC 80000-6) and temperature (ISO 80000-5) difference\n         * remarks: `\u03BC` is positive if heat is developed when the temperature decreases in the direction of the electric current.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThomsonCoefficientUnit[1];\n    }\n\n    attribute thomsonCoefficient: ThomsonCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThomsonCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-12 item 12-24.1 work function */\n    attribute workFunction: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-24.1 work function\n         * symbol(s): `\u03D5`\n         * application domain: generic\n         * name: WorkFunction (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, eV, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: difference between energy (ISO 80000-5) of an electron at rest at infinity and the Fermi energy (item 12-27.1)\n         * remarks: The term \"energy level\" is often used for the state of the electron, not only for its energy. The contact potential difference between substances `a` and `b` is given by `V_a - V_b = (\u03D5_a - \u03D5_b)/e`, where `e` is the elementary charge (ISO 80000-1). A set of energy levels, the energies of which occupy an interval practically continuously, is called an energy band. In semi-conductors `E_d` and `E_a` are used for donors and acceptors, respectively.\n         */\n    }\n\n    /* ISO-80000-12 item 12-24.2 ionization energy */\n    attribute ionizationEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-24.2 ionization energy\n         * symbol(s): `E_i`\n         * application domain: generic\n         * name: IonizationEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, eV, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: difference between energy (ISO 80000-5) of an electron at rest at infinity and a certain energy level which is the energy of an electron in the interior of a substance\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-25 electron affinity */\n    attribute electronAffinity: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-25 electron affinity\n         * symbol(s): `\u03C7`\n         * application domain: condensed matter physics\n         * name: ElectronAffinity (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, eV, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: energy (ISO 80000-5) difference between an electron at rest at infinity and an electron at the lowest level of the conduction band in an insulator or semiconductor\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-26 Richardson constant */\n    attribute def RichardsonConstantValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-26 Richardson constant\n         * symbol(s): `A`\n         * application domain: generic\n         * name: RichardsonConstant\n         * quantity dimension: L^-2*I^1*\u0398^-2\n         * measurement unit(s): A*m^-2*K^-2\n         * tensor order: 0\n         * definition: parameter in the expression for the thermionic emission current density `J` (IEC 80000-6) for a metal in terms of the thermodynamic temperature `T` (ISO 80000-5) and work function `\u03D5`, (item 12-24.1): `J = AT^2 exp(\u03D5/(kT))`, where `k` is the Boltzmann constant (ISO 80000-1)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RichardsonConstantUnit[1];\n    }\n\n    attribute richardsonConstant: RichardsonConstantValue[*] nonunique :> scalarQuantities;\n\n    attribute def RichardsonConstantUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-12 item 12-27.1 Fermi energy */\n    attribute fermiEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-27.1 Fermi energy\n         * symbol(s): `E_F`\n         * application domain: generic\n         * name: FermiEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, eV, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: in a metal, highest occupied energy level at zero thermodynamic temperature (ISO 80000-5), where energy level means the energy (ISO 80000-5) of an electron in the interior of a substance\n         * remarks: The term \"energy level\" is often used for the state of the electron, not only for its energy. At `T = 0 [K]`, `E_F` is equal to the chemical potential per electron. In condensed matter physics, the reference level for the energy is sometimes chosen so that, for instance, `E_F = 0`.\n         */\n    }\n\n    /* ISO-80000-12 item 12-27.2 gap energy */\n    attribute gapEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-27.2 gap energy\n         * symbol(s): `E_g`\n         * application domain: generic\n         * name: GapEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, eV, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: difference in energy (ISO 80000-5) between the lowest level of conduction band and the highest level of valence band at zero thermodynamic temperature (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-28 Fermi temperature */\n    attribute fermiTemperature: ThermodynamicTemperatureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-28 Fermi temperature\n         * symbol(s): `T_F`\n         * application domain: generic\n         * name: FermiTemperature (specializes ThermodynamicTemperature)\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: in the free electron model, the Fermi energy (item 12-27.1) divided by the Boltzmann constant (ISO 80000-1)\n         * remarks: The Fermi temperature is expressed by: `T_F = E_F/k`, where `E_F` is Fermi energy (item 12-27.1) and `k` is the Boltzmann constant (ISO 80000-1). `E_F` is relative to the lowest occupied state.\n         */\n    }\n\n    /* ISO-80000-12 item 12-29.1 electron density */\n    attribute def ElectronDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-29.1 electron density\n         * symbol(s): `n`\n         * application domain: generic\n         * name: ElectronDensity\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: quotient of number of electrons in conduction band and volume (ISO 80000-3)\n         * remarks: Subscripts `n` and `p` or `-` and `+` are often used to denote electrons and holes, respectively. `n_n` and `n_p` are also used for electron densities, and `p_n` and `p_p` for hole densities, in `n`-type and `p`-type regions, respectively, of a `n`-`p` junction.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectronDensityUnit[1];\n    }\n\n    attribute electronDensity: ElectronDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectronDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-12 item 12-29.2 hole density */\n    attribute def HoleDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-29.2 hole density\n         * symbol(s): `p`\n         * application domain: generic\n         * name: HoleDensity\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: quotient of number of holes in valence band and volume (ISO 80000-3)\n         * remarks: Subscripts `n` and `p` or `-` and `+` are often used to denote electrons and holes, respectively. `n_n` and `n_p` are also used for electron densities, and `p_n` and `p_p` for hole densities, in `n`-type and `p`-type regions, respectively, of a `n`-`p` junction.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: HoleDensityUnit[1];\n    }\n\n    attribute holeDensity: HoleDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def HoleDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-12 item 12-29.3 intrinsic carrier density */\n    attribute def IntrinsicCarrierDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-29.3 intrinsic carrier density\n         * symbol(s): `n_i`\n         * application domain: generic\n         * name: IntrinsicCarrierDensity\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: quantity given by: `n_i = sqrt(n p)`, where `n` is electron density (item 12-29.1), and `p` is hole\n         * remarks: Subscripts `n` and `p` or `-` and `+` are often used to denote electrons and holes, respectively. `n_n` and `n_p` are also used for electron densities, and `p_n` and `p_p` for hole densities, in `n`-type and `p`-type regions, respectively, of a `n`-`p` junction.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: IntrinsicCarrierDensityUnit[1];\n    }\n\n    attribute intrinsicCarrierDensity: IntrinsicCarrierDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def IntrinsicCarrierDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-12 item 12-29.4 donor density */\n    attribute def DonorDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-29.4 donor density\n         * symbol(s): `n_d`\n         * application domain: generic\n         * name: DonorDensity\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: quotient of number of donor levels and volume (ISO 80000-3)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DonorDensityUnit[1];\n    }\n\n    attribute donorDensity: DonorDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def DonorDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-12 item 12-29.5 acceptor density */\n    attribute def AcceptorDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 12-29.5 acceptor density\n         * symbol(s): `n_a`\n         * application domain: generic\n         * name: AcceptorDensity\n         * quantity dimension: L^-3\n         * measurement unit(s): m^-3\n         * tensor order: 0\n         * definition: quotient of number of acceptor levels and volume (ISO 80000-3)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AcceptorDensityUnit[1];\n    }\n\n    attribute acceptorDensity: AcceptorDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def AcceptorDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-12 item 12-30 effective mass */\n    attribute effectiveMass: MassValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-30 effective mass\n         * symbol(s): `m\"*\"`\n         * application domain: generic\n         * name: EffectiveMass (specializes Mass)\n         * quantity dimension: M^1\n         * measurement unit(s): kg\n         * tensor order: 0\n         * definition: quantity given by: `m^\"*\" = (\u0127^2 k) / ((d\u03B5)/(dk))`, where `k` is wavenumber (ISO 80000-3), `\u03B5` is the energy (ISO 80000-5) of an electron in the interior of a substance, and `\u0127` is the reduced Planck constant (ISO 80000-1)\n         * remarks: When `k` refers to a state where `\u03B5` has an extremum, `m\"*\" = (\u0127^2 k) / ((d^2\u03B5)/(dk^2))`. The effective mass can be generalized to refer to an anisotropic system with `\u03B5 = \u03B5(k)`.\n         */\n    }\n\n    /* ISO-80000-12 item 12-31 mobility ratio */\n    attribute def MobilityRatioValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 12-31 mobility ratio\n         * symbol(s): `b`\n         * application domain: generic\n         * name: MobilityRatio (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mobilities (ISO 80000-10) of electrons and holes, respectively\n         * remarks: The mobility ratio can be expressed by: `b = \u03BC_n/\u03BC_p`, where `\u03BC_n` and `\u03BC_p` are mobilities (ISO 80000-10) for electrons and holes, respectively.\n         */\n    }\n    attribute mobilityRatio: MobilityRatioValue :> scalarQuantities;\n\n    /* ISO-80000-12 item 12-32.1 relaxation time */\n    attribute relaxationTime: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-32.1 relaxation time\n         * symbol(s): `\u03C4`\n         * application domain: condensed matter physics\n         * name: RelaxationTime (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: time constant (ISO 80000-3) for scattering, trapping or annihilation of charge carriers, phonons or other quasiparticles\n         * remarks: For electrons in metals, `\u03C4 = l/v_F`, where `l` is mean free path (item 12-15.2) and `v_F` is speed (ISO 80000-3) of electrons on the Fermi surface.\n         */\n    }\n\n    /* ISO-80000-12 item 12-32.2 carrier lifetime */\n    attribute carrierLifetime: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-32.2 carrier lifetime\n         * symbol(s): `\u03C4`, `\u03C4_n`, `\u03C4_p`\n         * application domain: semiconductors\n         * name: CarrierLifetime (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: time constant (ISO 80000-3) for recombination or trapping of minority charge carriers in semiconductors\n         * remarks: Indices \"n\" and \"p\" denote negative and positive charge carriers, respectively. Positive charge carriers can also be holes.\n         */\n    }\n\n    /* ISO-80000-12 item 12-33 diffusion length */\n    attribute diffusionLengthForCondensedMatterPhysics: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-33 diffusion length\n         * symbol(s): `L`, `L_n`, `L_p`\n         * application domain: condensed matter physics\n         * name: DiffusionLength (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: square root of the product of diffusion coefficient (ISO 80000-10) and lifetime (ISO 80000-10)\n         * remarks: The diffusion length can be expressed by: `L = sqrt(D\u03C4)`, where `D` is the diffusion coefficient (ISO 80000-9) and `\u03C4` is lifetime (ISO 80000-3).\n         */\n    }\n\n    /* ISO-80000-12 item 12-34 exchange integral */\n    attribute exchangeIntegral: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-34 exchange integral\n         * symbol(s): `K`, `J`\n         * application domain: generic\n         * name: ExchangeIntegral (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, eV, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: constituent of the interaction energy (ISO 80000-5) between the spins of adjacent electrons in matter arising from the overlap of electron state functions\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-35.1 Curie temperature */\n    attribute curieTemperature: ThermodynamicTemperatureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-35.1 Curie temperature\n         * symbol(s): `T_C`\n         * application domain: generic\n         * name: CurieTemperature (specializes ThermodynamicTemperature)\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: critical thermodynamic temperature (ISO 80000-5) of a ferromagnet\n         * remarks: `T_(cr)` is used for critical thermodynamic temperature in general.\n         */\n    }\n\n    /* ISO-80000-12 item 12-35.2 N\xE9el temperature */\n    attribute 'n\xE9elTemperature': ThermodynamicTemperatureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-35.2 N\xE9el temperature\n         * symbol(s): `T_N`\n         * application domain: generic\n         * name: N\xE9elTemperature (specializes ThermodynamicTemperature)\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: critical thermodynamic temperature (ISO 80000-5) of an antiferromagnet\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-35.3 superconduction transition temperature */\n    attribute superconductionTransitionTemperature: ThermodynamicTemperatureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-35.3 superconduction transition temperature\n         * symbol(s): `T_c`\n         * application domain: generic\n         * name: SuperconductionTransitionTemperature (specializes ThermodynamicTemperature)\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: critical thermodynamic temperature (ISO 80000-5) of a superconductor\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-36.1 thermodynamic critical magnetic flux density */\n    attribute thermodynamicCriticalMagneticFluxDensity: MagneticFluxDensityValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-36.1 thermodynamic critical magnetic flux density\n         * symbol(s): `B_c`\n         * application domain: generic\n         * name: ThermodynamicCriticalMagneticFluxDensity (specializes MagneticFluxDensity)\n         * quantity dimension: M^1*T^-2*I^-1\n         * measurement unit(s): T, kg*s^-2*A^-1\n         * tensor order: 0\n         * definition: quantity given by: `B_c = sqrt((2\u03BC_0 (G_n - G_s))/V)`, where `G_n` and `G_s` are the Gibbs energies (ISO 80000-5) at zero magnetic flux density (IEC 80000-6) in a normal conductor and superconductor, respectively, `\u03BC_0` is the magnetic constant (IEC 80000-6), and `V` is volume (ISO 80000-3)\n         * remarks: In type I superconductors, `B_c` is the critical magnetic flux density for disappearance of superconductivity. The symbol `B_(c3)` is used for the critical magnetic flux density for disappearance of surface superconductivity.\n         */\n    }\n\n    /* ISO-80000-12 item 12-36.2 lower critical magnetic flux density */\n    attribute lowerCriticalMagneticFluxDensity: MagneticFluxDensityValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-36.2 lower critical magnetic flux density\n         * symbol(s): `B_(c1)`\n         * application domain: generic\n         * name: LowerCriticalMagneticFluxDensity (specializes MagneticFluxDensity)\n         * quantity dimension: M^1*T^-2*I^-1\n         * measurement unit(s): T, kg*s^-2*A^-1\n         * tensor order: 0\n         * definition: for type II superconductors, the threshold magnetic flux density (IEC 80000-6) for magnetic flux (IEC 80000-6) entering the superconductor\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-36.3 upper critical magnetic flux density */\n    attribute upperCriticalMagneticFluxDensity: MagneticFluxDensityValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-36.3 upper critical magnetic flux density\n         * symbol(s): `B_(c2)`\n         * application domain: generic\n         * name: UpperCriticalMagneticFluxDensity (specializes MagneticFluxDensity)\n         * quantity dimension: M^1*T^-2*I^-1\n         * measurement unit(s): T, kg*s^-2*A^-1\n         * tensor order: 0\n         * definition: for type II superconductors, the threshold magnetic flux density (IEC 80000-6) for disappearance of bulk superconductivity\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-37 superconductor energy gap */\n    attribute superconductorEnergyGap: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-37 superconductor energy gap\n         * symbol(s): `\u0394`\n         * application domain: generic\n         * name: SuperconductorEnergyGap (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, eV, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: width of the forbidden energy band (item 12-24.2) in a superconductor\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-38.1 London penetration depth */\n    attribute londonPenetrationDepth: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-38.1 London penetration depth\n         * symbol(s): `\u03BB_L`\n         * application domain: generic\n         * name: LondonPenetrationDepth (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: distance (ISO 80000-3) a magnetic field penetrates the plane surface of a semi-finite superconductor according to the expression: `B(x) = B(0) exp(-x/\u03BB_L)`, where `B` is magnetic flux density (IEC 80000-6) and `x` is distance (ISO 80000-3) from the surface\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-12 item 12-38.2 coherence length */\n    attribute coherenceLength: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 12-38.2 coherence length\n         * symbol(s): `\u03BE`\n         * application domain: generic\n         * name: CoherenceLength (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: distance (ISO 80000-3) in a superconductor over which the effect of a perturbation is appreciable at zero thermodynamic temperature (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n\n}\n", "Domain Libraries/Quantities and Units/ISQElectromagnetism.sysml": "standard library package ISQElectromagnetism {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard IEC-80000-6:2008 \"Electromagnetism\"\n     * see also https://www.iso.org/obp/ui/#iso:std:iec:80000:-6:ed-1:v1:en,fr\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n    private import ISQMechanics::PowerValue;\n    private import ISQSpaceTime::AngularMeasureValue;\n    private import ISQThermodynamics::EnergyValue;\n\n    /* IEC-80000-6 item 6-1 electric current */\n    /* See package ISQBase for the declarations of ElectricCurrentValue and ElectricCurrentUnit */\n\n    /* IEC-80000-6 item 6-2 electric charge */\n    attribute def ElectricChargeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-2 electric charge\n         * symbol(s): `Q`, `q`\n         * application domain: generic\n         * name: ElectricCharge\n         * quantity dimension: T^1*I^1\n         * measurement unit(s): C\n         * tensor order: 0\n         * definition: `d(Q) = I dt` where `I` is electric current (item 6-1) and `t` is time (ISO 80000-3, item 3-7)\n         * remarks: Electric charge is carried by discrete particles and can be positive or negative. The sign convention is such that the elementary electric charge `e`, i.e. the charge of the proton, is positive. See IEC 60050-121, item121-11-01. To denote a point charge `q` is often used, and that is done in the present document.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricChargeUnit[1];\n    }\n\n    attribute electricCharge: ElectricChargeValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricChargeUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-3 electric charge density, volumic electric charge */\n    attribute def ElectricChargeDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-3 electric charge density, volumic electric charge\n         * symbol(s): `\u03C1`, `\u03C1_V`\n         * application domain: generic\n         * name: ElectricChargeDensity\n         * quantity dimension: L^-3*T^1*I^1\n         * measurement unit(s): C/m^3\n         * tensor order: 0\n         * definition: `\u03C1 = (dQ)/(dV)` where `Q` is electric charge (item 6-2) and `V` is volume (ISO 80000-3, item 3-4)\n         * remarks: See IEC 60050-121, item 121-11-07.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricChargeDensityUnit[1];\n    }\n\n    attribute electricChargeDensity: ElectricChargeDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricChargeDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, electricCurrentPF); }\n    }\n\n    alias VolumicElectricChargeUnit for ElectricChargeDensityUnit;\n    alias VolumicElectricChargeValue for ElectricChargeDensityValue;\n    alias volumicElectricCharge for electricChargeDensity;\n\n    /* IEC-80000-6 item 6-4 surface density of electric charge, areic electric charge */\n    attribute def SurfaceDensityOfElectricChargeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-4 surface density of electric charge, areic electric charge\n         * symbol(s): `\u03C1_A`, `sigma`\n         * application domain: generic\n         * name: SurfaceDensityOfElectricCharge\n         * quantity dimension: L^-2*T^1*I^1\n         * measurement unit(s): C/m^2\n         * tensor order: 0\n         * definition: `\u03C1_A = (dQ)/(dA)` where `Q` is electric charge (item 6-2) and `A` is area (ISO 80000-3, item 3-3)`\n         * remarks: See IEC 60050-121, item 121-11-08.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SurfaceDensityOfElectricChargeUnit[1];\n    }\n\n    attribute surfaceDensityOfElectricCharge: SurfaceDensityOfElectricChargeValue[*] nonunique :> scalarQuantities;\n\n    attribute def SurfaceDensityOfElectricChargeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, electricCurrentPF); }\n    }\n\n    alias AreicElectricChargeUnit for SurfaceDensityOfElectricChargeUnit;\n    alias AreicElectricChargeValue for SurfaceDensityOfElectricChargeValue;\n    alias areicElectricCharge for surfaceDensityOfElectricCharge;\n\n    /* IEC-80000-6 item 6-5 linear density of electric charge, lineic electric charge */\n    attribute def LinearDensityOfElectricChargeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-5 linear density of electric charge, lineic electric charge\n         * symbol(s): `\u03C1_l`, `tau`\n         * application domain: generic\n         * name: LinearDensityOfElectricCharge\n         * quantity dimension: L^-1*T^1*I^1\n         * measurement unit(s): C/m\n         * tensor order: 0\n         * definition: `\u03C1_l = (dQ)/(dl)` where `Q` is electric charge (item 6-2) and `l` is length (ISO 80000-3, item 3-1.1)\n         * remarks: See IEC 60050-121, item121-11-09.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearDensityOfElectricChargeUnit[1];\n    }\n\n    attribute linearDensityOfElectricCharge: LinearDensityOfElectricChargeValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearDensityOfElectricChargeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, electricCurrentPF); }\n    }\n\n    alias LineicElectricChargeUnit for LinearDensityOfElectricChargeUnit;\n    alias LineicElectricChargeValue for LinearDensityOfElectricChargeValue;\n    alias lineicElectricCharge for linearDensityOfElectricCharge;\n\n    /* IEC-80000-6 item 6-6 electric dipole moment */\n    attribute def ElectricDipoleMomentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-6 electric dipole moment (magnitude)\n         * symbol(s): `p`\n         * application domain: generic\n         * name: ElectricDipoleMoment\n         * quantity dimension: L^1*T^1*I^1\n         * measurement unit(s): C*m\n         * tensor order: 0\n         * definition: `vec(p) = q (vec(r_+) - vec(r_-))` where `vec(r_+)` and `vec(r_-)` are the position vectors (ISO 80000-3, item 3-1.11) to carriers of electric charges `q` and `-q` (item 6-2), respectively\n         * remarks: The electric dipole moment of a substance within a domain is the vector sum of electric dipole moments of electric dipoles included in the domain. See IEC 60050-121, items 121-11-35 and 121-11-36.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricDipoleMomentUnit[1];\n    }\n\n    attribute electricDipoleMoment: ElectricDipoleMomentValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricDipoleMomentUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianElectricDipoleMoment3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-6 electric dipole moment (vector)\n         * symbol(s): `vec(p)`\n         * application domain: generic\n         * name: ElectricDipoleMoment\n         * quantity dimension: L^1*T^1*I^1\n         * measurement unit(s): C*m\n         * tensor order: 1\n         * definition: `vec(p) = q (vec(r_+) - vec(r_-))` where `vec(r_+)` and `vec(r_-)` are the position vectors (ISO 80000-3, item 3-1.11) to carriers of electric charges `q` and `-q` (item 6-2), respectively\n         * remarks: The electric dipole moment of a substance within a domain is the vector sum of electric dipole moments of electric dipoles included in the domain. See IEC 60050-121, items 121-11-35 and 121-11-36.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianElectricDipoleMoment3dCoordinateFrame[1];\n    }\n\n    attribute cartesianElectricDipoleMoment3dVector: CartesianElectricDipoleMoment3dVector :> vectorQuantities;\n\n    attribute def CartesianElectricDipoleMoment3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: ElectricDipoleMomentUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-7 electric polarization */\n    attribute def ElectricPolarizationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-7 electric polarization (magnitude)\n         * symbol(s): `P`\n         * application domain: generic\n         * name: ElectricPolarization\n         * quantity dimension: L^-2*T^1*I^1\n         * measurement unit(s): C/m^2\n         * tensor order: 0\n         * definition: `vec(P) = (d vec(p))/(dV)` where `vec(p)` is electric dipole moment (item 6-6) of a substance within a domain with volume `V` (ISO 80000-3, item 3-4)\n         * remarks: See IEC 60050-121, item 121-11-37.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricPolarizationUnit[1];\n    }\n\n    attribute electricPolarization: ElectricPolarizationValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricPolarizationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianElectricPolarization3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-7 electric polarization (vector)\n         * symbol(s): `vec(P)`\n         * application domain: generic\n         * name: ElectricPolarization\n         * quantity dimension: L^-2*T^1*I^1\n         * measurement unit(s): C/m^2\n         * tensor order: 1\n         * definition: `vec(P) = (d vec(p))/(dV)` where `vec(p)` is electric dipole moment (item 6-6) of a substance within a domain with volume `V` (ISO 80000-3, item 3-4)\n         * remarks: See IEC 60050-121, item 121-11-37.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianElectricPolarization3dCoordinateFrame[1];\n    }\n\n    attribute cartesianElectricPolarization3dVector: CartesianElectricPolarization3dVector :> vectorQuantities;\n\n    attribute def CartesianElectricPolarization3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: ElectricPolarizationUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-8 electric current density, areic electric current */\n    attribute def ElectricCurrentDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-8 electric current density, areic electric current (magnitude)\n         * symbol(s): `J`\n         * application domain: generic\n         * name: ElectricCurrentDensity\n         * quantity dimension: L^-2*I^1\n         * measurement unit(s): A/m^2\n         * tensor order: 0\n         * definition: `vec(J) = \u03C1 vec(v)` where `\u03C1` is electric charge density (item 6-3) and `vec(v)` is velocity (ISO 80000-3, item 3-8.1)\n         * remarks: Electric current `I` (item 6-1) through a surface `S` is `I = int_S vec(J) * vec(e_n) dA` where `vec(e_n) dA` is vector surface element. See IEC 60050-121, item 121-11-11.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricCurrentDensityUnit[1];\n    }\n\n    attribute electricCurrentDensity: ElectricCurrentDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricCurrentDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianElectricCurrentDensity3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-8 electric current density, areic electric current (vector)\n         * symbol(s): `vec(J)`\n         * application domain: generic\n         * name: ElectricCurrentDensity\n         * quantity dimension: L^-2*I^1\n         * measurement unit(s): A/m^2\n         * tensor order: 1\n         * definition: `vec(J) = \u03C1 vec(v)` where `\u03C1` is electric charge density (item 6-3) and `vec(v)` is velocity (ISO 80000-3, item 3-8.1)\n         * remarks: Electric current `I` (item 6-1) through a surface `S` is `I = int_S vec(J) * vec(e_n) dA` where `vec(e_n) dA` is vector surface element. See IEC 60050-121, item 121-11-11.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianElectricCurrentDensity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianElectricCurrentDensity3dVector: CartesianElectricCurrentDensity3dVector :> vectorQuantities;\n\n    attribute def CartesianElectricCurrentDensity3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: ElectricCurrentDensityUnit[3];\n    }\n\n    alias CartesianAreicElectricCurrent3dCoordinateFrame for CartesianElectricCurrentDensity3dCoordinateFrame;\n    alias cartesianAreicElectricCurrent3dVector for cartesianElectricCurrentDensity3dVector;\n\n    /* IEC-80000-6 item 6-9 linear electric current density, lineic electric current */\n    attribute def LinearElectricCurrentDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-9 linear electric current density, lineic electric current (magnitude)\n         * symbol(s): `J_S`\n         * application domain: generic\n         * name: LinearElectricCurrentDensity\n         * quantity dimension: L^-1*I^1\n         * measurement unit(s): A/m\n         * tensor order: 0\n         * definition: `vec(J_S) = \u03C1_A vec(v)` where `\u03C1_A` is surface density of electric charge (item 6-4) and `vec(v)` is velocity (ISO 80000-3, item 3-8.1)\n         * remarks: Electric current `I` (item 6-1) through a curve `C` on a surface is `I = int_C vec(J_S) xx vec(e_n) * d vec(r)` where `vec(e_n)` is a unit vector perpendicular to the surface and line vector element and `d vec(r)` is the differential of position vector `vec(r)`. See IEC 60050-121, item 121-11-12.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearElectricCurrentDensityUnit[1];\n    }\n\n    attribute linearElectricCurrentDensity: LinearElectricCurrentDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearElectricCurrentDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianLinearElectricCurrentDensity3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-9 linear electric current density, lineic electric current (vector)\n         * symbol(s): `vec(J_S)`\n         * application domain: generic\n         * name: LinearElectricCurrentDensity\n         * quantity dimension: L^-1*I^1\n         * measurement unit(s): A/m\n         * tensor order: 1\n         * definition: `vec(J_S) = \u03C1_A vec(v)` where `\u03C1_A` is surface density of electric charge (item 6-4) and `vec(v)` is velocity (ISO 80000-3, item 3-8.1)\n         * remarks: Electric current `I` (item 6-1) through a curve `C` on a surface is `I = int_C vec(J_S) xx vec(e_n) * d vec(r)` where `vec(e_n)` is a unit vector perpendicular to the surface and line vector element and `d vec(r)` is the differential of position vector `vec(r)`. See IEC 60050-121, item 121-11-12.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianLinearElectricCurrentDensity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianLinearElectricCurrentDensity3dVector: CartesianLinearElectricCurrentDensity3dVector :> vectorQuantities;\n\n    attribute def CartesianLinearElectricCurrentDensity3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: LinearElectricCurrentDensityUnit[3];\n    }\n\n    alias CartesianLineicElectricCurrent3dCoordinateFrame for CartesianLinearElectricCurrentDensity3dCoordinateFrame;\n    alias cartesianLineicElectricCurrent3dVector for cartesianLinearElectricCurrentDensity3dVector;\n\n    /* IEC-80000-6 item 6-10 electric field strength */\n    attribute def ElectricFieldStrengthValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-10 electric field strength (magnitude)\n         * symbol(s): `E`\n         * application domain: generic\n         * name: ElectricFieldStrength\n         * quantity dimension: L^1*M^1*T^-3*I^-1\n         * measurement unit(s): V/m\n         * tensor order: 0\n         * definition: `vec(E) = vec(F)/q` where `vec(F)` is force (ISO 80000-4, item 4-9.1) and `q` is electric charge (item 6-2)\n         * remarks: See IEC 60050, item 121-11-18. `q` is the charge of a test particle at rest.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricFieldStrengthUnit[1];\n    }\n\n    attribute electricFieldStrength: ElectricFieldStrengthValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricFieldStrengthUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianElectricFieldStrength3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-10 electric field strength (vector)\n         * symbol(s): `vec(E)`\n         * application domain: generic\n         * name: ElectricFieldStrength\n         * quantity dimension: L^1*M^1*T^-3*I^-1\n         * measurement unit(s): V/m\n         * tensor order: 1\n         * definition: `vec(E) = vec(F)/q` where `vec(F)` is force (ISO 80000-4, item 4-9.1) and `q` is electric charge (item 6-2)\n         * remarks: See IEC 60050, item 121-11-18. `q` is the charge of a test particle at rest.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianElectricFieldStrength3dCoordinateFrame[1];\n    }\n\n    attribute cartesianElectricFieldStrength3dVector: CartesianElectricFieldStrength3dVector :> vectorQuantities;\n\n    attribute def CartesianElectricFieldStrength3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: ElectricFieldStrengthUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-11.1 electric potential */\n    attribute def ElectricPotentialValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-11.1 electric potential\n         * symbol(s): `V`, `\u03C6`\n         * application domain: generic\n         * name: ElectricPotential\n         * quantity dimension: L^2*M^1*T^-3*I^-1\n         * measurement unit(s): V\n         * tensor order: 0\n         * definition: `-grad(V) = vec(E) + (del A)/(del t)` where `vec(E)` is electric field strength (item 610), `A` is magnetic vector potential (item 6-32) and `t` is time (ISO 80000-3, item 3-7)\n         * remarks: The electric potential is not unique, since any constant scalar field quantity can be added to it without changing its gradient. See IEC 60050-121, item 121-11-25.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricPotentialUnit[1];\n    }\n\n    attribute electricPotential: ElectricPotentialValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricPotentialUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-11.2 electric potential difference */\n    attribute def ElectricPotentialDifferenceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-11.2 electric potential difference\n         * symbol(s): `V_(ab)`\n         * application domain: generic\n         * name: ElectricPotentialDifference\n         * quantity dimension: L^2*M^1*T^-3*I^-1\n         * measurement unit(s): V\n         * tensor order: 0\n         * definition: `V_(ab) = int_(vec(r_a))^(vec(r_b)) (vec(E) + (del A)/(del t)) * d vec(r)` where `vec(E)` is electric field strength (item 610), `A` is magnetic vector potential (item 6-32), `t` is time (ISO 80000-3, item 3-7), and `vec(r)` is position vector (ISO 80000-3, item 3-1.11) along a given curve `C` from point `a` to point `b`\n         * remarks: `V_(ab) = V_a - V_b` where `V_a` and `V_b` are the potentials at points `a` and `b`, respectively. See IEC 60050-121, item 121-11-26.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricPotentialDifferenceUnit[1];\n    }\n\n    attribute electricPotentialDifference: ElectricPotentialDifferenceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricPotentialDifferenceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-11.3 voltage, electric tension */\n    attribute voltage: ElectricPotentialDifferenceValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-11.3 voltage, electric tension\n         * symbol(s): `U`, `U_(ab)`\n         * application domain: generic\n         * name: Voltage (specializes ElectricPotentialDifference)\n         * quantity dimension: L^2*M^1*T^-3*I^-1\n         * measurement unit(s): V\n         * tensor order: 0\n         * definition: in electric circuit theory, `U_(ab) = V_a - V_b` where `V_a` and `V_b` are the electric potentials (item 6-11.1) at points `a` and `b`, respectively\n         * remarks: For an electric field within a medium `U_(ab) = int_(vec(r_a) (C))^(vec(r_b)) vec(E) * d vec(r)` where `vec(E)` is electric field strength (item 6-10) and `vec(r)` is position vector (ISO 80000-3, item 3-1.11) along a given curve `C` from point `a` to point `b`. For an irrotational electric field, the voltage is independent of the path between the two points `a` and `b`. See IEC 60050-121, item 121-11-27.\n         */\n    }\n\n    alias electricTension for voltage;\n\n    /* IEC-80000-6 item 6-12 electric flux density, electric displacement */\n    attribute def ElectricFluxDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-12 electric flux density, electric displacement (magnitude)\n         * symbol(s): `D`\n         * application domain: generic\n         * name: ElectricFluxDensity\n         * quantity dimension: L^-2*T^1*I^1\n         * measurement unit(s): C/m^2\n         * tensor order: 0\n         * definition: `vec(D) = \u03B5_0 vec(E) + vec(P)` where `\u03B5_0` is the electric constant (item 6-14.1 ), `vec(E)` is electric field strength (item 6-10), and `vec(P)` is electric polarization (item 6-7)\n         * remarks: The electric flux density is related to electric charge density via `nabla * vec(D) = \u03C1` where `nabla * vec(D)` denotes the divergence of `vec(D)`. See IEC 60050-121, item 121-11-40.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricFluxDensityUnit[1];\n    }\n\n    attribute electricFluxDensity: ElectricFluxDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricFluxDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianElectricFluxDensity3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-12 electric flux density, electric displacement (vector)\n         * symbol(s): `vec(D)`\n         * application domain: generic\n         * name: ElectricFluxDensity\n         * quantity dimension: L^-2*T^1*I^1\n         * measurement unit(s): C/m^2\n         * tensor order: 1\n         * definition: `vec(D) = \u03B5_0 vec(E) + vec(P)` where `\u03B5_0` is the electric constant (item 6-14.1 ), `vec(E)` is electric field strength (item 6-10), and `vec(P)` is electric polarization (item 6-7)\n         * remarks: The electric flux density is related to electric charge density via `nabla * vec(D) = \u03C1` where `nabla * vec(D)` denotes the divergence of `vec(D)`. See IEC 60050-121, item 121-11-40.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianElectricFluxDensity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianElectricFluxDensity3dVector: CartesianElectricFluxDensity3dVector :> vectorQuantities;\n\n    attribute def CartesianElectricFluxDensity3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: ElectricFluxDensityUnit[3];\n    }\n\n    alias CartesianElectricDisplacement3dCoordinateFrame for CartesianElectricFluxDensity3dCoordinateFrame;\n    alias cartesianElectricDisplacement3dVector for cartesianElectricFluxDensity3dVector;\n\n    /* IEC-80000-6 item 6-13 capacitance */\n    attribute def CapacitanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-13 capacitance\n         * symbol(s): `C`\n         * application domain: generic\n         * name: Capacitance\n         * quantity dimension: L^-2*M^-1*T^4*I^2\n         * measurement unit(s): F\n         * tensor order: 0\n         * definition: `C = Q/U` where `Q` is electric charge (item 6-2) and `U` is voltage (6-11.3)\n         * remarks: See IEC 60050-131, item 131-12-13.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CapacitanceUnit[1];\n    }\n\n    attribute capacitance: CapacitanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def CapacitanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 4; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-14.1 electric constant, permittivity of vacuum */\n    attribute def ElectricConstantValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-14.1 electric constant, permittivity of vacuum\n         * symbol(s): `\u03B5_0`\n         * application domain: generic\n         * name: ElectricConstant\n         * quantity dimension: L^-3*M^-1*T^4*I^2\n         * measurement unit(s): F/m\n         * tensor order: 0\n         * definition: `\u03B5_0 = 1 / (\u03BC_0 * c_0^2)` where `\u03BC_0` is the magnetic constant (item 6-26.1) and `c_0` is the speed of light (item 6-35.2)\n         * remarks: `\u03B5_0 = 8.854188 * 10^-12` F/m. See IEC 60050-121, item 121-11-03.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricConstantUnit[1];\n    }\n\n    attribute electricConstant: ElectricConstantValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricConstantUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 4; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    alias PermittivityOfVacuumUnit for ElectricConstantUnit;\n    alias PermittivityOfVacuumValue for ElectricConstantValue;\n    alias permittivityOfVacuum for electricConstant;\n\n    /* IEC-80000-6 item 6-14.2 permittivity */\n    attribute def PermittivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-14.2 permittivity\n         * symbol(s): `\u03B5`\n         * application domain: generic\n         * name: Permittivity\n         * quantity dimension: L^-3*M^-1*T^4*I^2\n         * measurement unit(s): F/m\n         * tensor order: 0\n         * definition: `vec(D) = \u03B5 vec(E)` where `vec(D)` is electric flux density (item 6-12) and `vec(E)` is electric field strength (item 6-10)\n         * remarks: This definition applies to an isotropic medium. For an anisotropic medium, permittivity is a second order tensor. See IEC 60050-121, item 121-12-12.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PermittivityUnit[1];\n    }\n\n    attribute permittivity: PermittivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def PermittivityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 4; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-15 relative permittivity */\n    attribute def RelativePermittivityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-15 relative permittivity\n         * symbol(s): `\u03B5_r`\n         * application domain: generic\n         * name: RelativePermittivity (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `\u03B5_r = \u03B5 / \u03B5_0` where `\u03B5` is permittivity (item 6-14.2) and `\u03B5_0` is the electric constant (item 6-14.1)\n         * remarks: See IEC 60050-121, item 121-12-13.\n         */\n    }\n    attribute relativePermittivity: RelativePermittivityValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-16 electric susceptibility */\n    attribute def ElectricSusceptibilityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-16 electric susceptibility\n         * symbol(s): `\u03C7`\n         * application domain: generic\n         * name: ElectricSusceptibility (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `vec(P) = \u03B5_0 \u03C7 vec(E)` where `vec(P)` is electric polarization (item 6-7), `\u03B5_0` is the electric constant (item 6-14. 1) and `vec(E)` is electric field strength (item 6-10)\n         * remarks: `\u03C7 = \u03B5_r - 1`. The definition applies to an isotropic medium. For an anisotropic medium, electric susceptibility is a second order tensor. See IEC 60050-121, item 121-12-19.\n         */\n    }\n    attribute electricSusceptibility: ElectricSusceptibilityValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-17 electric flux */\n    attribute def ElectricFluxValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-17 electric flux\n         * symbol(s): `\u03A8`\n         * application domain: generic\n         * name: ElectricFlux\n         * quantity dimension: T^1*I^1\n         * measurement unit(s): C\n         * tensor order: 0\n         * definition: `\u03A8 = int_S vec(D) * vec(e_n) dA` over a surface `S`, where `vec(D)` is electric flux (item 6-12) en `vec(e_n) dA` is the vector surface element (ISO 80000-3 item 3-3)\n         * remarks: See IEC 60050-121, item 121-11-41.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectricFluxUnit[1];\n    }\n\n    attribute electricFlux: ElectricFluxValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectricFluxUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-18 displacement current density */\n    attribute def DisplacementCurrentDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-18 displacement current density (magnitude)\n         * symbol(s): `J_D`\n         * application domain: generic\n         * name: DisplacementCurrentDensity\n         * quantity dimension: L^-2*I^1\n         * measurement unit(s): A/m^2\n         * tensor order: 0\n         * definition: `vec(J_D) = (del vec(D))/(del t)` where `vec(D)` is electric flux density (item 6-12) and `t` is time (ISO 80000-3, item 3-7) \n         * remarks: See IEC 60050-121, item 121-11-42.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DisplacementCurrentDensityUnit[1];\n    }\n\n    attribute displacementCurrentDensity: DisplacementCurrentDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def DisplacementCurrentDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianDisplacementCurrentDensity3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-18 displacement current density (vector)\n         * symbol(s): `vec(J_D)`\n         * application domain: generic\n         * name: DisplacementCurrentDensity\n         * quantity dimension: L^-2*I^1\n         * measurement unit(s): A/m^2\n         * tensor order: 1\n         * definition: `vec(J_D) = (del vec(D))/(del t)` where `vec(D)` is electric flux density (item 6-12) and `t` is time (ISO 80000-3, item 3-7) \n         * remarks: See IEC 60050-121, item 121-11-42.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianDisplacementCurrentDensity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianDisplacementCurrentDensity3dVector: CartesianDisplacementCurrentDensity3dVector :> vectorQuantities;\n\n    attribute def CartesianDisplacementCurrentDensity3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: DisplacementCurrentDensityUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-19.1 displacement current */\n    attribute displacementCurrent: ElectricCurrentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-19.1 displacement current\n         * symbol(s): `I_D`\n         * application domain: generic\n         * name: DisplacementCurrent (specializes ElectricCurrent)\n         * quantity dimension: I^1\n         * measurement unit(s): A\n         * tensor order: 0\n         * definition: `I = int_S vec(J_D) * vec(e_n) dA` over a surface `S`, where `vec(J_D)` is displacement current density (item 6-18) en `vec(e_n) dA` is the vector surface element (ISO 80000-3 item 3-3)\n         * remarks: See IEC 60050-121, item 121-11-43.\n         */\n    }\n\n    /* IEC-80000-6 item 6-19.2 total current */\n    attribute totalCurrent: ElectricCurrentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-19.2 total current\n         * symbol(s): `I_\"tot\"`, `I_t`\n         * application domain: generic\n         * name: TotalCurrent (specializes ElectricCurrent)\n         * quantity dimension: I^1\n         * measurement unit(s): A\n         * tensor order: 0\n         * definition: `I_(tot) = I + I_D` where `I` is electric current (item 6-1) and `I_D` is displacement current (item 6-19.1)\n         * remarks: See IEC 60050-121, item 121-11-45.\n         */\n    }\n\n    /* IEC-80000-6 item 6-20 total current density */\n    attribute def TotalCurrentDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-20 total current density (magnitude)\n         * symbol(s): `J_\"tot\"`, `J_t`\n         * application domain: generic\n         * name: TotalCurrentDensity\n         * quantity dimension: L^-2*I^1\n         * measurement unit(s): A/m^2\n         * tensor order: 0\n         * definition: `vec(J_(tot)) = vec(J) +vec(J_D)` where `vec(J)` is electric current density (item 6-8) and `vec(J_D)` is displacement current density (item 6-18)\n         * remarks: See IEC 60050-121, item 121-11-44.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TotalCurrentDensityUnit[1];\n    }\n\n    attribute totalCurrentDensity: TotalCurrentDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def TotalCurrentDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianTotalCurrentDensity3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-20 total current density (vector)\n         * symbol(s): `vec(J_\"tot\")`, `vec(J_t)`\n         * application domain: generic\n         * name: TotalCurrentDensity\n         * quantity dimension: L^-2*I^1\n         * measurement unit(s): A/m^2\n         * tensor order: 1\n         * definition: `vec(J_(tot)) = vec(J) +vec(J_D)` where `vec(J)` is electric current density (item 6-8) and `vec(J_D)` is displacement current density (item 6-18)\n         * remarks: See IEC 60050-121, item 121-11-44.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianTotalCurrentDensity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianTotalCurrentDensity3dVector: CartesianTotalCurrentDensity3dVector :> vectorQuantities;\n\n    attribute def CartesianTotalCurrentDensity3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: TotalCurrentDensityUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-21 magnetic flux density */\n    attribute def MagneticFluxDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-21 magnetic flux density (magnitude)\n         * symbol(s): `B`\n         * application domain: generic\n         * name: MagneticFluxDensity\n         * quantity dimension: M^1*T^-2*I^-1\n         * measurement unit(s): T\n         * tensor order: 0\n         * definition: `vec(F) = q vec(v) xx vec(B)` where `vec(F)` is force (ISO 80000-4, item 4-9.1) and `vec(v)` is velocity (ISO 80000-3, item 3-8.1) of any test particle with electric charge `q` (item 6-2)\n         * remarks: The magnetic flux density has zero divergence, `nabla * vec(B) = 0`. See IEC 60050-121, item 121-11-19.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticFluxDensityUnit[1];\n    }\n\n    attribute magneticFluxDensity: MagneticFluxDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticFluxDensityUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianMagneticFluxDensity3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-21 magnetic flux density (vector)\n         * symbol(s): `vec(B)`\n         * application domain: generic\n         * name: MagneticFluxDensity\n         * quantity dimension: M^1*T^-2*I^-1\n         * measurement unit(s): T\n         * tensor order: 1\n         * definition: `vec(F) = q vec(v) xx vec(B)` where `vec(F)` is force (ISO 80000-4, item 4-9.1) and `vec(v)` is velocity (ISO 80000-3, item 3-8.1) of any test particle with electric charge `q` (item 6-2)\n         * remarks: The magnetic flux density has zero divergence, `nabla * vec(B) = 0`. See IEC 60050-121, item 121-11-19.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMagneticFluxDensity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMagneticFluxDensity3dVector: CartesianMagneticFluxDensity3dVector :> vectorQuantities;\n\n    attribute def CartesianMagneticFluxDensity3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MagneticFluxDensityUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-22.1 magnetic flux */\n    attribute def MagneticFluxValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-22.1 magnetic flux\n         * symbol(s): `\u03A6`\n         * application domain: generic\n         * name: MagneticFlux\n         * quantity dimension: L^2*M^1*T^-2*I^-1\n         * measurement unit(s): Wb\n         * tensor order: 0\n         * definition: `\u03A6 = int_S vec(B) * vec(e_n) dA` over a surface `S`, where `vec(B)` is magnetic flux density (item 6-21) and `vec(e_n) dA` is vector surface element (ISO 80000-3, item 3-3)\n         * remarks: See IEC 60050-121, item 121-11-21.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticFluxUnit[1];\n    }\n\n    attribute magneticFlux: MagneticFluxValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticFluxUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-22.2 linked flux */\n    attribute def LinkedFluxValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-22.2 linked flux\n         * symbol(s): `\u03A8_m`, `\u03A8`\n         * application domain: generic\n         * name: LinkedFlux\n         * quantity dimension: L^2*M^1*T^-2*I^-1\n         * measurement unit(s): Wb\n         * tensor order: 0\n         * definition: `\u03A8_m = int_C vec(A) * d vec(r)` where `vec(A)` is magnetic vector potential (item 6-32) and `d vec(r)` is line vector element of the curve `C`\n         * remarks: Line vector element `d vec(r)` is the differential of position vector `vec(r)` (ISO 80000-3, item 3-1.11). See IEC 60050-121, item 121-11-24.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinkedFluxUnit[1];\n    }\n\n    attribute linkedFlux: LinkedFluxValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinkedFluxUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-23 magnetic moment, magnetic area moment */\n    attribute def MagneticMomentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-23 magnetic moment, magnetic area moment (magnitude)\n         * symbol(s): `m`\n         * application domain: generic\n         * name: MagneticMoment\n         * quantity dimension: L^2*I^1\n         * measurement unit(s): A*m^2\n         * tensor order: 0\n         * definition: `vec(m) = I vec(e_n) A` where `I` is electric current (item 6-1) in a small closed loop, `vec(e_n)` is a unit vector perpendicular to the loop, and `A` is area (ISO 80000-3, item 3-3) of the loop\n         * remarks: The magnetic moment of a substance within a domain is the vector sum of the magnetic moments of all entities included in the domain. See IEC 60050-121, items 121-11-49 and 121-11-50.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticMomentUnit[1];\n    }\n\n    attribute magneticMoment: MagneticMomentValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticMomentUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianMagneticMoment3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-23 magnetic moment, magnetic area moment (vector)\n         * symbol(s): `vec(m)`\n         * application domain: generic\n         * name: MagneticMoment\n         * quantity dimension: L^2*I^1\n         * measurement unit(s): A*m^2\n         * tensor order: 1\n         * definition: `vec(m) = I vec(e_n) A` where `I` is electric current (item 6-1) in a small closed loop, `vec(e_n)` is a unit vector perpendicular to the loop, and `A` is area (ISO 80000-3, item 3-3) of the loop\n         * remarks: The magnetic moment of a substance within a domain is the vector sum of the magnetic moments of all entities included in the domain. See IEC 60050-121, items 121-11-49 and 121-11-50.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMagneticMoment3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMagneticMoment3dVector: CartesianMagneticMoment3dVector :> vectorQuantities;\n\n    attribute def CartesianMagneticMoment3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MagneticMomentUnit[3];\n    }\n\n    alias CartesianMagneticAreaMoment3dCoordinateFrame for CartesianMagneticMoment3dCoordinateFrame;\n    alias cartesianMagneticAreaMoment3dVector for cartesianMagneticMoment3dVector;\n\n    /* IEC-80000-6 item 6-24 magnetization */\n    attribute def MagnetizationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-24 magnetization (magnitude)\n         * symbol(s): `M`, `H_i`\n         * application domain: generic\n         * name: Magnetization\n         * quantity dimension: L^-1*I^1\n         * measurement unit(s): A/m\n         * tensor order: 0\n         * definition: `vec(M) = (d vec(m)) / (dV)` where `vec(m)` is magnetic moment (item 6-23) of a substance in a domain with volume `V` (ISO 80000-3, item 3-4)\n         * remarks: See IEC 60050-121, item 121-11-52.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagnetizationUnit[1];\n    }\n\n    attribute magnetization: MagnetizationValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagnetizationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianMagnetization3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-24 magnetization (vector)\n         * symbol(s): `vec(M)`, `vec(H_i)`\n         * application domain: generic\n         * name: Magnetization\n         * quantity dimension: L^-1*I^1\n         * measurement unit(s): A/m\n         * tensor order: 1\n         * definition: `vec(M) = (d vec(m)) / (dV)` where `vec(m)` is magnetic moment (item 6-23) of a substance in a domain with volume `V` (ISO 80000-3, item 3-4)\n         * remarks: See IEC 60050-121, item 121-11-52.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMagnetization3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMagnetization3dVector: CartesianMagnetization3dVector :> vectorQuantities;\n\n    attribute def CartesianMagnetization3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MagnetizationUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-25 magnetic field strength, magnetizing field */\n    attribute def MagneticFieldStrengthValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-25 magnetic field strength, magnetizing field (magnitude)\n         * symbol(s): `H`\n         * application domain: generic\n         * name: MagneticFieldStrength\n         * quantity dimension: L^-1*I^1\n         * measurement unit(s): A/m\n         * tensor order: 0\n         * definition: `vec(H) = vec(B)/\u03BC_0 - vec(M)` where `vec(B)` is magnetic flux density (item 6-21), `\u03BC_0` is the magnetic constant (item 6-26.1), and `vec(M)` is magnetization (item 6-24)\n         * remarks: The magnetic field strength is related to the total current density `vec(J_(t ot))` (item 6-20) via `rot vec(H) = vec(J_(t ot))`. See IEC 60050-121, item 121-11-56.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticFieldStrengthUnit[1];\n    }\n\n    attribute magneticFieldStrength: MagneticFieldStrengthValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticFieldStrengthUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianMagneticFieldStrength3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-25 magnetic field strength, magnetizing field (vector)\n         * symbol(s): `vec(H)`\n         * application domain: generic\n         * name: MagneticFieldStrength\n         * quantity dimension: L^-1*I^1\n         * measurement unit(s): A/m\n         * tensor order: 1\n         * definition: `vec(H) = vec(B)/\u03BC_0 - vec(M)` where `vec(B)` is magnetic flux density (item 6-21), `\u03BC_0` is the magnetic constant (item 6-26.1), and `vec(M)` is magnetization (item 6-24)\n         * remarks: The magnetic field strength is related to the total current density `vec(J_(t ot))` (item 6-20) via `rot vec(H) = vec(J_(t ot))`. See IEC 60050-121, item 121-11-56.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMagneticFieldStrength3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMagneticFieldStrength3dVector: CartesianMagneticFieldStrength3dVector :> vectorQuantities;\n\n    attribute def CartesianMagneticFieldStrength3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MagneticFieldStrengthUnit[3];\n    }\n\n    alias CartesianMagnetizingField3dCoordinateFrame for CartesianMagneticFieldStrength3dCoordinateFrame;\n    alias cartesianMagnetizingField3dVector for cartesianMagneticFieldStrength3dVector;\n\n    /* IEC-80000-6 item 6-26.1 magnetic constant, permeability of vacuum */\n    attribute def MagneticConstantValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-26.1 magnetic constant, permeability of vacuum\n         * symbol(s): `\u03BC_0`\n         * application domain: generic\n         * name: MagneticConstant\n         * quantity dimension: L^1*M^1*T^-2*I^-2\n         * measurement unit(s): H/m\n         * tensor order: 0\n         * definition: `\u03BC_0 = 4 \u03C0 * 10^-7` H/m\n         * remarks: For this definition of `\u03BC_0` see item 6-1.a. `\u03BC_0 ~~ 1.256637 * 10^-6` H/m. See IEC 60050-121, item 121-11-14.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticConstantUnit[1];\n    }\n\n    attribute magneticConstant: MagneticConstantValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticConstantUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    alias PermeabilityOfVacuumUnit for MagneticConstantUnit;\n    alias PermeabilityOfVacuumValue for MagneticConstantValue;\n    alias permeabilityOfVacuum for magneticConstant;\n\n    /* IEC-80000-6 item 6-26.2 permeability */\n    attribute def PermeabilityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-26.2 permeability\n         * symbol(s): `\u03BC`\n         * application domain: generic\n         * name: Permeability\n         * quantity dimension: L^1*M^1*T^-2*I^-2\n         * measurement unit(s): H/m\n         * tensor order: 0\n         * definition: `vec(B) = \u03BC vec(H)` where `vec(B)` is magnetic flux density (item 6-21) and `vec(H)` is magnetic field strength (item 6-25)\n         * remarks: This definition applies to an isotropic medium. For an anisotropic medium permeability is a second order tensor. See IEC 60050-121, item 121-12-28.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PermeabilityUnit[1];\n    }\n\n    attribute permeability: PermeabilityValue[*] nonunique :> scalarQuantities;\n\n    attribute def PermeabilityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-27 relative permeability */\n    attribute def RelativePermeabilityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-27 relative permeability\n         * symbol(s): `\u03BC_r`\n         * application domain: generic\n         * name: RelativePermeability (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `\u03BC_r = \u03BC / \u03BC_0`  where `\u03BC` is permeability (item 6-24) and `\u03BC_0` is the magnetic constant (item 6-26.1)\n         * remarks: See IEC 60050-121, item 121-12-29.\n         */\n    }\n    attribute relativePermeability: RelativePermeabilityValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-28 magnetic susceptibility */\n    attribute def MagneticSusceptibilityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-28 magnetic susceptibility\n         * symbol(s): `\u03BA`, `\u03C7_m`\n         * application domain: generic\n         * name: MagneticSusceptibility (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `vec(M) = \u03BA vec(H)` where `vec(M)` is magnetization (item 6-24) and `vec(H)` is magnetic field strength (item 6-25)\n         * remarks: `\u03BA = \u03BC_r - 1` This definition applies to an isotropic medium. For an anisotropic medium magnetic susceptibility is a second order tensor. See IEC 60050-121, item 121-12-37.\n         */\n    }\n    attribute magneticSusceptibility: MagneticSusceptibilityValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-29 magnetic polarization */\n    attribute def MagneticPolarizationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-29 magnetic polarization (magnitude)\n         * symbol(s): `J_m`\n         * application domain: generic\n         * name: MagneticPolarization\n         * quantity dimension: M^1*T^-2*I^-1\n         * measurement unit(s): T\n         * tensor order: 0\n         * definition: `vec(J_m) = \u03BC_0 vec(M)` where `\u03BC_0` is the magnetic constant (item 6-26.1), and `vec(M)` is magnetization (item 6-24)\n         * remarks: See IEC 60050-121, item 121-11-54.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticPolarizationUnit[1];\n    }\n\n    attribute magneticPolarization: MagneticPolarizationValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticPolarizationUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianMagneticPolarization3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-29 magnetic polarization (vector)\n         * symbol(s): `vec(J_m)`\n         * application domain: generic\n         * name: MagneticPolarization\n         * quantity dimension: M^1*T^-2*I^-1\n         * measurement unit(s): T\n         * tensor order: 1\n         * definition: `vec(J_m) = \u03BC_0 vec(M)` where `\u03BC_0` is the magnetic constant (item 6-26.1), and `vec(M)` is magnetization (item 6-24)\n         * remarks: See IEC 60050-121, item 121-11-54.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMagneticPolarization3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMagneticPolarization3dVector: CartesianMagneticPolarization3dVector :> vectorQuantities;\n\n    attribute def CartesianMagneticPolarization3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MagneticPolarizationUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-30 magnetic dipole moment */\n    attribute def MagneticDipoleMomentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-30 magnetic dipole moment (magnitude)\n         * symbol(s): `j_m`, `j`\n         * application domain: generic\n         * name: MagneticDipoleMoment\n         * quantity dimension: L^3*M^1*T^-2*I^-1\n         * measurement unit(s): Wb*m\n         * tensor order: 0\n         * definition: `vec(j_m) = \u03BC_0 vec(m)` where `\u03BC_0` is the magnetic constant (item 6-26.1), and `vec(m)` is magnetic moment (item 6-23)\n         * remarks: See IEC 60050-121, item 121-11-55.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticDipoleMomentUnit[1];\n    }\n\n    attribute magneticDipoleMoment: MagneticDipoleMomentValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticDipoleMomentUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianMagneticDipoleMoment3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-30 magnetic dipole moment (vector)\n         * symbol(s): `vec(j_m)`, `vec(j)`\n         * application domain: generic\n         * name: MagneticDipoleMoment\n         * quantity dimension: L^3*M^1*T^-2*I^-1\n         * measurement unit(s): Wb*m\n         * tensor order: 1\n         * definition: `vec(j_m) = \u03BC_0 vec(m)` where `\u03BC_0` is the magnetic constant (item 6-26.1), and `vec(m)` is magnetic moment (item 6-23)\n         * remarks: See IEC 60050-121, item 121-11-55.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMagneticDipoleMoment3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMagneticDipoleMoment3dVector: CartesianMagneticDipoleMoment3dVector :> vectorQuantities;\n\n    attribute def CartesianMagneticDipoleMoment3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MagneticDipoleMomentUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-31 coercivity */\n    attribute def CoercivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-31 coercivity\n         * symbol(s): `H_(c,B)`\n         * application domain: generic\n         * name: Coercivity\n         * quantity dimension: L^-1*I^1\n         * measurement unit(s): A/m\n         * tensor order: 0\n         * definition: magnetic field strength (item 6-25) to be applied to bring the magnetic flux density (item 6-21) in a substance from its remaining magnetic flux density to zero\n         * remarks: See IEC 60050-121, item 121-12-69. Also called coercive field strength.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CoercivityUnit[1];\n    }\n\n    attribute coercivity: CoercivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def CoercivityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-32 magnetic vector potential */\n    attribute def MagneticVectorPotentialValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-32 magnetic vector potential (magnitude)\n         * symbol(s): `A`\n         * application domain: generic\n         * name: MagneticVectorPotential\n         * quantity dimension: L^1*M^1*T^-2*I^-1\n         * measurement unit(s): Wb/m\n         * tensor order: 0\n         * definition: `vec(B) = rot vec(A)` where `vec(B)` is magnetic flux density (item 6-21)\n         * remarks: The magnetic vector potential is not unique since any irrotational vector field can be added to it without changing its rotation. See IEC 60050-121, item 121-11-23.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagneticVectorPotentialUnit[1];\n    }\n\n    attribute magneticVectorPotential: MagneticVectorPotentialValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagneticVectorPotentialUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    attribute def CartesianMagneticVectorPotential3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-32 magnetic vector potential (vector)\n         * symbol(s): `vec(A)`\n         * application domain: generic\n         * name: MagneticVectorPotential\n         * quantity dimension: L^1*M^1*T^-2*I^-1\n         * measurement unit(s): Wb/m\n         * tensor order: 1\n         * definition: `vec(B) = rot vec(A)` where `vec(B)` is magnetic flux density (item 6-21)\n         * remarks: The magnetic vector potential is not unique since any irrotational vector field can be added to it without changing its rotation. See IEC 60050-121, item 121-11-23.\n         */\n        attribute :>> isBound = true;\n        attribute :>> mRef: CartesianMagneticVectorPotential3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMagneticVectorPotential3dVector: CartesianMagneticVectorPotential3dVector :> vectorQuantities;\n\n    attribute def CartesianMagneticVectorPotential3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = true;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MagneticVectorPotentialUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-33 electromagnetic energy density, volumic electromagnetic energy */\n    attribute def ElectromagneticEnergyDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-33 electromagnetic energy density, volumic electromagnetic energy\n         * symbol(s): `w`\n         * application domain: generic\n         * name: ElectromagneticEnergyDensity\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): J/m^3\n         * tensor order: 0\n         * definition: `\u03C9 = 1/2*(vec(E)*vec(D) + vec(B) * vec(H))` where `vec(E)` is electric field strength (item 6-10), `vec(D)` is electric flux density (item 6-12), `vec(B)` is magnetic flux density (item 6-21), and `vec(H)` is magnetic field strength (item 6-25)\n         * remarks: See IEC 60050-121, item 121-11-65.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ElectromagneticEnergyDensityUnit[1];\n    }\n\n    attribute electromagneticEnergyDensity: ElectromagneticEnergyDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ElectromagneticEnergyDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    alias VolumicElectromagneticEnergyUnit for ElectromagneticEnergyDensityUnit;\n    alias VolumicElectromagneticEnergyValue for ElectromagneticEnergyDensityValue;\n    alias volumicElectromagneticEnergy for electromagneticEnergyDensity;\n\n    /* IEC-80000-6 item 6-34 Poynting vector */\n    attribute def PoyntingVectorMagnitudeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-34 Poynting vector (magnitude)\n         * symbol(s): `S`\n         * application domain: generic\n         * name: PoyntingVectorMagnitude\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/m^2\n         * tensor order: 0\n         * definition: `vec(S) = vec(E) xx vec(H)` where `vec(E)` is electric field strength (item 6-10) and `vec(H)` is magnetic field strength (item 6-25)\n         * remarks: See IEC 60050-121, item 121-11-66.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PoyntingVectorMagnitudeUnit[1];\n    }\n\n    attribute poyntingVectorMagnitude: PoyntingVectorMagnitudeValue[*] nonunique :> scalarQuantities;\n\n    attribute def PoyntingVectorMagnitudeUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    attribute def CartesianPoynting3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 6-34 Poynting vector\n         * symbol(s): `vec(S)`\n         * application domain: generic\n         * name: PoyntingVector\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/m^2\n         * tensor order: 1\n         * definition: `vec(S) = vec(E) xx vec(H)` where `vec(E)` is electric field strength (item 6-10) and `vec(H)` is magnetic field strength (item 6-25)\n         * remarks: See IEC 60050-121, item 121-11-66.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianPoynting3dCoordinateFrame[1];\n    }\n\n    attribute cartesianPoynting3dVector: CartesianPoynting3dVector :> vectorQuantities;\n\n    attribute def CartesianPoynting3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: PoyntingVectorMagnitudeUnit[3];\n    }\n\n    /* IEC-80000-6 item 6-35.1 phase speed of electromagnetic waves */\n    attribute def PhaseSpeedOfElectromagneticWavesValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-35.1 phase speed of electromagnetic waves\n         * symbol(s): `c`\n         * application domain: generic\n         * name: PhaseSpeedOfElectromagneticWaves\n         * quantity dimension: L^1*T^-1\n         * measurement unit(s): m/s\n         * tensor order: 0\n         * definition: `c = \u03C9/k` where `\u03C9` is angular frequency (ISO 80000-3, item 3-16) and `k` is angular wavenumber (ISO 80000-3, item 3-19)\n         * remarks: See ISO 80000-3, item 3-20.1.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhaseSpeedOfElectromagneticWavesUnit[1];\n    }\n\n    attribute phaseSpeedOfElectromagneticWaves: PhaseSpeedOfElectromagneticWavesValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhaseSpeedOfElectromagneticWavesUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* IEC-80000-6 item 6-35.2 speed of light, light speed */\n    attribute def SpeedOfLightValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-35.2 speed of light, light speed\n         * symbol(s): `c_0`\n         * application domain: generic\n         * name: SpeedOfLight\n         * quantity dimension: L^1*T^-1\n         * measurement unit(s): m/s\n         * tensor order: 0\n         * definition: speed of electromagnetic waves in vacuum; `c_0 = 299792458` m/s\n         * remarks: For this value of `c_0` see ISO 80000-3, item 3-1.a. `c_0 = 1/sqrt(\u03B5_0 \u03BC_0)`. See IEC 60050-111, item 111-13-07.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpeedOfLightUnit[1];\n    }\n\n    attribute speedOfLight: SpeedOfLightValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpeedOfLightUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    alias LightSpeedUnit for SpeedOfLightUnit;\n    alias LightSpeedValue for SpeedOfLightValue;\n    alias lightSpeed for speedOfLight;\n\n    /* IEC-80000-6 item 6-36 source voltage, source tension */\n    attribute def SourceVoltageValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-36 source voltage, source tension\n         * symbol(s): `U_s`\n         * application domain: generic\n         * name: SourceVoltage\n         * quantity dimension: L^2*M^1*T^-3*I^-1\n         * measurement unit(s): V\n         * tensor order: 0\n         * definition: voltage (item 6-11.3) between the two terminals of a voltage source when there is no electric current (item 6-1) through the source\n         * remarks: The name \"electromotive force\" with the abbreviation EMF and the symbol `E` is deprecated. See IEC 60050-131, item 131-12-22.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SourceVoltageUnit[1];\n    }\n\n    attribute sourceVoltage: SourceVoltageValue[*] nonunique :> scalarQuantities;\n\n    attribute def SourceVoltageUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    alias SourceTensionUnit for SourceVoltageUnit;\n    alias SourceTensionValue for SourceVoltageValue;\n    alias sourceTension for sourceVoltage;\n\n    /* IEC-80000-6 item 6-37.1 scalar magnetic potential */\n    attribute scalarMagneticPotential: ElectricCurrentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-37.1 scalar magnetic potential\n         * symbol(s): `V_m`, `\u03C6`\n         * application domain: generic\n         * name: ScalarMagneticPotential (specializes ElectricCurrent)\n         * quantity dimension: I^1\n         * measurement unit(s): A\n         * tensor order: 0\n         * definition: for an irrotational magnetic field strength `vec(H) =  -nabla V_m` where `vec(H)` is magnetic field strength (item 6-25)\n         * remarks: The magnetic scalar potential is not unique since any constant scalar field can be added to it without changing its gradient. See IEC 60050-121, item 121-11-58.\n         */\n    }\n\n    /* IEC-80000-6 item 6-37.2 magnetic tension */\n    attribute magneticTension: ElectricCurrentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-37.2 magnetic tension\n         * symbol(s): `U_m`\n         * application domain: generic\n         * name: MagneticTension (specializes ElectricCurrent)\n         * quantity dimension: I^1\n         * measurement unit(s): A\n         * tensor order: 0\n         * definition: `U_m = int_(vec(r_a) (C))^(vec(r_b)) vec(H) * d(vec(r))` where `vec(H)` is magnetic field strength (item 6-25) and `vec(r)` is position vector (ISO 80000-3, item 3-1.11) along a given curve `C` from point `a` to point `b`\n         * remarks: For an irrotational magnetic field strength this quantity is equal to the magnetic potential difference. See IEC 60050-121, item121-11-57.\n         */\n    }\n\n    /* IEC-80000-6 item 6-37.3 magnetomotive force */\n    attribute def MagnetomotiveForceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-37.3 magnetomotive force\n         * symbol(s): `F_m`\n         * application domain: generic\n         * name: MagnetomotiveForce\n         * quantity dimension: I^1\n         * measurement unit(s): A\n         * tensor order: 0\n         * definition: `F_m = oint_C vec(H) * d vec(r)` where `vec(H)` is magnetic field strength (item 6-25) and `vec(r)` is position vector (ISO 80000-3, item 3-1 .11) along a closed curve `C`\n         * remarks: This quantity name is under consideration . Compare remark to item 6-36. See IEC 60050-121, item 121-11-60.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MagnetomotiveForceUnit[1];\n    }\n\n    attribute magnetomotiveForce: MagnetomotiveForceValue[*] nonunique :> scalarQuantities;\n\n    attribute def MagnetomotiveForceUnit :> DerivedUnit {\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = electricCurrentPF; }\n    }\n\n    /* IEC-80000-6 item 6-37.4 current linkage */\n    attribute currentLinkage: ElectricCurrentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-37.4 current linkage\n         * symbol(s): `\u0398`\n         * application domain: generic\n         * name: CurrentLinkage (specializes ElectricCurrent)\n         * quantity dimension: I^1\n         * measurement unit(s): A\n         * tensor order: 0\n         * definition: net electric current (item 6-1) through a surface delimited by a closed loop\n         * remarks: When `\u0398` results from `N` (item 6-38) equal electric currents `I` (item 6-1 ), then `\u0398 = N I`. See IEC 60050-121 , item 121 -11-46.\n         */\n    }\n\n    /* IEC-80000-6 item 6-38 number of turns in a winding */\n    attribute numberOfTurnsInAWinding: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-38 number of turns in a winding\n         * symbol(s): `N`\n         * application domain: generic\n         * name: NumberOfTurnsInAWinding (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of turns in a winding (same as the quantity name)\n         * remarks: N may be non-integer number, see ISO 80000-3, item 3-14.\n         */\n    }\n\n    /* IEC-80000-6 item 6-39 reluctance */\n    attribute def ReluctanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-39 reluctance\n         * symbol(s): `R_m`, `R`\n         * application domain: generic\n         * name: Reluctance\n         * quantity dimension: L^-2*M^-1*T^2*I^2\n         * measurement unit(s): H^-1\n         * tensor order: 0\n         * definition: `R_m = U_m/\u03A6` where `U_m` is magnetic tension (item 6-37.2) and `\u03A6` is magnetic flux (item 6-22 .1)\n         * remarks: See IEC 60050-131 , item 131-12-28.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ReluctanceUnit[1];\n    }\n\n    attribute reluctance: ReluctanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ReluctanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-40 permeance */\n    attribute def PermeanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-40 permeance\n         * symbol(s): `\u039B`\n         * application domain: generic\n         * name: Permeance\n         * quantity dimension: L^2*M^1*T^-2*I^-2\n         * measurement unit(s): H\n         * tensor order: 0\n         * definition: `\u039B = 1/R_m` where `R_m` is reluctance (item 6-39)\n         * remarks: See IEC 60050-131 , item 131-12-29.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PermeanceUnit[1];\n    }\n\n    attribute permeance: PermeanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def PermeanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-41.1 inductance, self inductance */\n    attribute def InductanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-41.1 inductance, self inductance\n         * symbol(s): `L`, `L_m`\n         * application domain: generic\n         * name: Inductance\n         * quantity dimension: L^2*M^1*T^-2*I^-2\n         * measurement unit(s): H\n         * tensor order: 0\n         * definition: `L = \u03A8 / I` where `I` is an electric current (item 6-1) in a thin conducting loop and `\u03A8` is the linked flux (item 6-22.2) caused by that electric current\n         * remarks: The name \"self inductance\" is used for the quantity associated to mutual inductance when `n = m`. See IEC 60050-131 , items 131-12-19 and 131 -12-35.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: InductanceUnit[1];\n    }\n\n    attribute inductance: InductanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def InductanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    alias SelfInductanceUnit for InductanceUnit;\n    alias SelfInductanceValue for InductanceValue;\n    alias selfInductance for inductance;\n\n    /* IEC-80000-6 item 6-41.2 mutual inductance */\n    attribute mutualInductance: InductanceValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-41.2 mutual inductance\n         * symbol(s): `L_(mn)`\n         * application domain: generic\n         * name: MutualInductance (specializes Inductance)\n         * quantity dimension: L^2*M^1*T^-2*I^-2\n         * measurement unit(s): H\n         * tensor order: 0\n         * definition: `L_(mn) = \u03A8_m / I_n` where `I_n` is an electric current (item 6-1) in a thin conducting loop `n` and `\u03A8_m` is the linked flux (item 6-22.2) caused by that electric current in another loop `m`\n         * remarks: `L_(mn) = L_(nm)`. For two loops , the symbol `M` is used for `L_(12)`. See IEC 60050-131, items 131-12-36.\n         */\n    }\n\n    /* IEC-80000-6 item 6-42.1 coupling factor */\n    attribute def CouplingFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-42.1 coupling factor\n         * symbol(s): `k`\n         * application domain: generic\n         * name: CouplingFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for inductive coupling between two inductive elements `k = |L_(mn)| / sqrt(L_m L_n)` where `L_m` and `L_n` are their self inductances (item 6-41 .1 ), and `L_(mn)` is their mutual inductance (item 6-41.2)\n         * remarks: See IEC 60050-131 , item 131-12-41.\n         */\n    }\n    attribute couplingFactor: CouplingFactorValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-42.2 leakage factor */\n    attribute def LeakageFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-42.2 leakage factor\n         * symbol(s): `\u03C3`\n         * application domain: generic\n         * name: LeakageFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `\u03C3 = 1 - k^2` where `k` is the coupling factor (item 6-42 .1)\n         * remarks: See IEC 60050-131 , item 131-12-42.\n         */\n    }\n    attribute leakageFactor: LeakageFactorValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-43 conductivity */\n    attribute def ConductivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-43 conductivity\n         * symbol(s): `\u03C3`, `\u03B3`\n         * application domain: generic\n         * name: Conductivity\n         * quantity dimension: L^-3*M^-1*T^3*I^2\n         * measurement unit(s): S/m\n         * tensor order: 0\n         * definition: `vec(J) = \u03C3 vec(E)` where `vec(J)` is electric current density (item 6-8) and `vec(E)` is electric field strength (item 6-10)\n         * remarks: This definition applies to an isotropic medium. For an anisotropic medium `\u03C3` is a second order tensor. `\u03BA` is used in electrochemistry. See IEC 60050-121 , item 121-12-03.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ConductivityUnit[1];\n    }\n\n    attribute conductivity: ConductivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ConductivityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-44 resistivity */\n    attribute def ResistivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-44 resistivity\n         * symbol(s): `\u03C1`\n         * application domain: generic\n         * name: Resistivity\n         * quantity dimension: L^3*M^1*T^-3*I^-2\n         * measurement unit(s): \u03A9*m\n         * tensor order: 0\n         * definition: `\u03C1 = 1/\u03C3` if is exists, where `\u03C3` is conductivity (item 6-43)\n         * remarks: See IEC 60050-121, item 121-12-04.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ResistivityUnit[1];\n    }\n\n    attribute resistivity: ResistivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ResistivityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-45 electric power, instantaneous power */\n    attribute electricPower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-45 electric power, instantaneous power\n         * symbol(s): `p`\n         * application domain: generic\n         * name: ElectricPower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W\n         * tensor order: 0\n         * definition: `p = ui` where `u` is instantaneous voltage (item 6-11 .3) and `i` is instantaneous electric current (item 6-1)\n         * remarks: See IEC 60050-131 , item 131-11-30.\n         */\n    }\n\n    alias instantaneousPower for electricPower;\n\n    /* IEC-80000-6 item 6-46 resistance */\n    attribute def ResistanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-46 resistance\n         * symbol(s): `R`\n         * application domain: generic\n         * name: Resistance\n         * quantity dimension: L^2*M^1*T^-3*I^-2\n         * measurement unit(s): \u03A9\n         * tensor order: 0\n         * definition: for resistive component `R = u i` where `u` is instantaneous voltage (item 6-11.3) and `i` is instantaneous electric current (item 6-1)\n         * remarks: For alternating current, see item 6-51.2. See IEC 60050-131, item 131-12-04.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ResistanceUnit[1];\n    }\n\n    attribute resistance: ResistanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ResistanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-47 conductance */\n    attribute def ConductanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-47 conductance\n         * symbol(s): `G`\n         * application domain: generic\n         * name: Conductance\n         * quantity dimension: L^-2*M^-1*T^3*I^2\n         * measurement unit(s): S\n         * tensor order: 0\n         * definition: for resistive component `G = 1/R` where `R` is resistance (item 6-46)\n         * remarks: For alternating current, see item 6-52.2. See IEC 60050-131, item 131-12-06.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ConductanceUnit[1];\n    }\n\n    attribute conductance: ConductanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ConductanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-48 phase difference */\n    attribute def PhaseDifferenceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-48 phase difference\n         * symbol(s): `\u03C6`\n         * application domain: generic\n         * name: PhaseDifference\n         * quantity dimension: 1\n         * measurement unit(s): rad\n         * tensor order: 0\n         * definition: `\u03C6 = \u03C6_u - \u03C6_i` where `\u03C6_u` is the initial phase of the voltage (item 6-11 .3) and `\u03C6_i` is the initial phase of the electric current (item 6-1)\n         * remarks: When `u = hat(U) cos(\u03C9t - \u03C6_u)`, `i = hat(I) cos(\u03C9t - \u03C6_i)` where `u` is the voltage (item 6-11 . 3) and `i` is the electric current (item 6-1 ), `\u03C9` is angular frequency (ISO 80000-3, item 3-16) and `t` is time (ISO 80000-3, item 3-7), then `\u03C6` is phase difference. For phase angle, see items 6-49 and 6-50.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhaseDifferenceUnit[1];\n    }\n\n    attribute phaseDifference: PhaseDifferenceValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhaseDifferenceUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-6 item 6-49 electric current phasor */\n    attribute electricCurrentPhasor: ElectricCurrentValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-49 electric current phasor\n         * symbol(s): `underline(I)`\n         * application domain: generic\n         * name: ElectricCurrentPhasor (specializes ElectricCurrent)\n         * quantity dimension: I^1\n         * measurement unit(s): A\n         * tensor order: 0\n         * definition: when `i = hat(I) cos(\u03C9t + \u03B1)`, where `i` is the electric current (item 6-1 ), `\u03C9` is angular frequency (ISO 80000-3, item 3-16), `t` is time (ISO 80000-3, item 3-7), and `\u03B1` is initial phase (ISO 80000-3, item 3-5), then `underline(l) = I e^(j\u03B1)`\n         * remarks: `underline(l)` is the complex representation of the electric current `i = hat(I) cos(\u03C9t + \u03B1)`. `j` is the imaginary unit.\n         */\n    }\n\n    /* IEC-80000-6 item 6-50 voltage phasor */\n    attribute voltagePhasor: ElectricPotentialDifferenceValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-50 voltage phasor\n         * symbol(s): `underline(U)`\n         * application domain: generic\n         * name: VoltagePhasor (specializes ElectricPotentialDifference)\n         * quantity dimension: L^2*M^1*T^-3*I^-1\n         * measurement unit(s): V\n         * tensor order: 0\n         * definition: when `u = hat(U) cos(\u03C9t + \u03B1)`, where `u` is the voltage (item 6-11.3 ), `\u03C9` is angular frequency (ISO 80000-3, item 3-16), `t` is time (ISO 80000-3, item 3-7), and `\u03B1` is initial phase (ISO 80000-3, item 3-5), then `underline(U) = U e^(j\u03B1)`\n         * remarks: `underline(U)` is the complex representation of the voltage `u = hat(U) cos(\u03C9t + \u03B1)`. `j` is the imaginary unit.\n         */\n    }\n\n    /* IEC-80000-6 item 6-51.1 impedance, complex impedance */\n    attribute def ImpedanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-51.1 impedance, complex impedance\n         * symbol(s): `underline(Z)`\n         * application domain: generic\n         * name: Impedance\n         * quantity dimension: L^2*M^1*T^-3*I^-2\n         * measurement unit(s): \u03A9\n         * tensor order: 0\n         * definition: `underline(Z) = underline(U)/underline(I)` where `underline(U)` is the voltage phasor (item 6-50), and `underline(I)` is the electric current phasor (item 6-49)\n         * remarks: `underline(Z) = R + jX`, where `R` is resistance (item 6-51.2) and `X` is reactance (item 6-51 .3). `j` is the imaginary unit. `underline(Z) = |underline(Z)| e^(j\u03C6)`. See IEC 60050-131 , item 131-12-43.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ImpedanceUnit[1];\n    }\n\n    attribute impedance: ImpedanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ImpedanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    alias ComplexImpedanceUnit for ImpedanceUnit;\n    alias ComplexImpedanceValue for ImpedanceValue;\n    alias complexImpedance for impedance;\n\n    /* IEC-80000-6 item 6-51.2 resistance to alternating current */\n    attribute def ResistanceToAlternatingCurrentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-51.2 resistance to alternating current\n         * symbol(s): `R`\n         * application domain: generic\n         * name: ResistanceToAlternatingCurrent\n         * quantity dimension: L^2*M^1*T^-3*I^-2\n         * measurement unit(s): \u03A9\n         * tensor order: 0\n         * definition: `R = \"Re\" underline(Z)` where `underline(Z)`, is impedance (item 6-5.1) and `\"Re\"` denotes the real part\n         * remarks: See IEC 60050-131, item 131-12-45.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ResistanceToAlternatingCurrentUnit[1];\n    }\n\n    attribute resistanceToAlternatingCurrent: ResistanceToAlternatingCurrentValue[*] nonunique :> scalarQuantities;\n\n    attribute def ResistanceToAlternatingCurrentUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-51.3 reactance */\n    attribute def ReactanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-51.3 reactance\n         * symbol(s): `X`\n         * application domain: generic\n         * name: Reactance\n         * quantity dimension: L^2*M^1*T^-3*I^-2\n         * measurement unit(s): \u03A9\n         * tensor order: 0\n         * definition: `X = \"Im\" underline(Z)` where `underline(Z)`, is impedance (item 6-5.1) and `\"Im\"` denotes the imaginary part\n         * remarks: `X = \u03C9L - 1/(\u03C9C)`. See IEC 60050-131 , item 131-12-46.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ReactanceUnit[1];\n    }\n\n    attribute reactance: ReactanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ReactanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-51.4 modulus of impedance */\n    attribute def ModulusOfImpedanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-51.4 modulus of impedance\n         * symbol(s): `Z`\n         * application domain: generic\n         * name: ModulusOfImpedance\n         * quantity dimension: L^2*M^1*T^-3*I^-2\n         * measurement unit(s): \u03A9\n         * tensor order: 0\n         * definition: `Z = |underline(Z)|` where `underline(Z)` is impedance (item 6-51.1)\n         * remarks: See IEC 60050-131 , item 131-12-44. Apparent impedance is defined more generally as the quotient of rms voltage and rms electric  current; it is often denoted by `Z`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ModulusOfImpedanceUnit[1];\n    }\n\n    attribute modulusOfImpedance: ModulusOfImpedanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ModulusOfImpedanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-52.1 admittance, complex admittance */\n    attribute def AdmittanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-52.1 admittance, complex admittance\n         * symbol(s): `underline(Y)`\n         * application domain: generic\n         * name: Admittance\n         * quantity dimension: L^-2*M^-1*T^3*I^2\n         * measurement unit(s): S\n         * tensor order: 0\n         * definition: `underline(Y) = 1/underline(Z)` where `underline(Z)` is impedance (item 6-51.1)\n         * remarks: `underline(Y) = G + jB`, where `G` is conductance (item 6-52 .2) and `B` is susceptance (item 6-52 .3). `j` is the imaginary unit. `underline(Y) = |underline(Y)| e^-(j\u03C6)`. See IEC 60050-131, item 131 -12-51.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AdmittanceUnit[1];\n    }\n\n    attribute admittance: AdmittanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def AdmittanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    alias ComplexAdmittanceUnit for AdmittanceUnit;\n    alias ComplexAdmittanceValue for AdmittanceValue;\n    alias complexAdmittance for admittance;\n\n    /* IEC-80000-6 item 6-52.2 conductance for alternating current */\n    attribute conductanceForAlternatingCurrent: ConductanceValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-52.2 conductance for alternating current\n         * symbol(s): `G`\n         * application domain: generic\n         * name: ConductanceForAlternatingCurrent (specializes Conductance)\n         * quantity dimension: L^-2*M^-1*T^3*I^2\n         * measurement unit(s): S\n         * tensor order: 0\n         * definition: `G = \"Re\" underline(Y)` where I is admittance (item 6-52.1)\n         * remarks: See IEC 60050-131, item 131-12-53.\n         */\n    }\n\n    /* IEC-80000-6 item 6-52.3 susceptance */\n    attribute def SusceptanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-52.3 susceptance\n         * symbol(s): `B`\n         * application domain: generic\n         * name: Susceptance\n         * quantity dimension: L^-2*M^-1*T^3*I^2\n         * measurement unit(s): S\n         * tensor order: 0\n         * definition: `B = \"Im\" underline(Y)` where `underline(Y)` is admittance (item 6-52.1)\n         * remarks: See IEC 60050-131, item 131-12-54.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SusceptanceUnit[1];\n    }\n\n    attribute susceptance: SusceptanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def SusceptanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-52.4 modulus of admittance */\n    attribute def ModulusOfAdmittanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 6-52.4 modulus of admittance\n         * symbol(s): `Y`\n         * application domain: generic\n         * name: ModulusOfAdmittance\n         * quantity dimension: L^-2*M^-1*T^3*I^2\n         * measurement unit(s): S\n         * tensor order: 0\n         * definition: `Y = |underline(Y)|` where `underline(Y)` is admittance (item 6-52.1)\n         * remarks: Apparent admittance is defined more generally as the quotient of rms electric current voltage and rms voltage; it is often denoted by `Y`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ModulusOfAdmittanceUnit[1];\n    }\n\n    attribute modulusOfAdmittance: ModulusOfAdmittanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ModulusOfAdmittanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute electricCurrentPF: QuantityPowerFactor[1] { :>> quantity = isq.I; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, electricCurrentPF); }\n    }\n\n    /* IEC-80000-6 item 6-53 quality factor */\n    attribute def QualityFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-53 quality factor\n         * symbol(s): `Q`\n         * application domain: generic\n         * name: QualityFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: for non-radiating systems, if `underline(Z) = R + jX`, then `Q = |X|/R` where `underline(Z)` is impedance (item 6-51. 1), `R` is resistance (item 6-51 .2), and `X` is reactance (item 6-51.3)\n         * remarks: None.\n         */\n    }\n    attribute qualityFactor: QualityFactorValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-54 loss factor */\n    attribute def LossFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-54 loss factor\n         * symbol(s): `d`\n         * application domain: generic\n         * name: LossFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `d = 1/Q` where `Q` quality factor (item 6-53)\n         * remarks: It is also named dissipation factor.\n         */\n    }\n    attribute lossFactor: LossFactorValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-55 loss angle */\n    attribute lossAngle: AngularMeasureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-55 loss angle\n         * symbol(s): `\u03B4`\n         * application domain: generic\n         * name: LossAngle (specializes AngularMeasure)\n         * quantity dimension: 1\n         * measurement unit(s): rad\n         * tensor order: 0\n         * definition: `\u03B4 = arctan d` where `d` is loss factor (item 6-54)\n         * remarks: See IEC 60050-131 , item 131-12-49.\n         */\n    }\n\n    /* IEC-80000-6 item 6-56 active power */\n    attribute activePower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-56 active power\n         * symbol(s): `P`\n         * application domain: generic\n         * name: ActivePower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W\n         * tensor order: 0\n         * definition: `P = 1/T int_0^T p dt` where `T` is the period (ISO 80000-3, item 3-12) and `p` is instantaneous power (item 6-45)\n         * remarks: In complex notation, `P = \"Re\" underline(S)` where `underline(S)` is complex power (item 6-59).\n         */\n    }\n\n    /* IEC-80000-6 item 6-57 apparent power */\n    attribute apparentPower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-57 apparent power\n         * symbol(s): ``, `underline(S)`, ``\n         * application domain: generic\n         * name: ApparentPower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): V*A\n         * tensor order: 0\n         * definition: `|underline(S)| = U I` where `U` is rms value of voltage (item 6-11.3 and `I` is rms value of electric current (item 6-1)\n         * remarks: `U = sqrt(1/T int_0^T u^2 dt)` and `I = sqrt(1/T int_0^T i^2 dt)`. When `u = sqrt 2 U cos(\u03C9t)` and `i = sqrt 2 I cos(\u03C9t - \u03C6)`, then `P = U I cos(\u03C6)`, `Q = U I sin(\u03C6)` and `\u03BB = cos(\u03C6)` . See IEC 60050-131, item 131-11-41 .\n         */\n    }\n\n    /* IEC-80000-6 item 6-58 power factor */\n    attribute def PowerFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 6-58 power factor\n         * symbol(s): `\u03BB`\n         * application domain: generic\n         * name: PowerFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `\u03BB = |P|/|S|` where `P`  is active power (item 6-56) and `S` is apparent power (item 6-57)\n         * remarks: See I EC 60050-131, item 131-11-46.\n         */\n    }\n    attribute powerFactor: PowerFactorValue :> scalarQuantities;\n\n    /* IEC-80000-6 item 6-59 complex power */\n    attribute complexPower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-59 complex power\n         * symbol(s): `underline(S)`\n         * application domain: generic\n         * name: ComplexPower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): V*A\n         * tensor order: 0\n         * definition: `underline(S) = underline(U) * underline(I)^\"*\"` where `underline(U)` is voltage phasor (item 6-50) and `underline(I)^\"*\"` is the complex conjugate of the current phasor (item 6-49)\n         * remarks: `underline(S) = P + jQ` where `P` is active power (item 6-56) and `Q` is reactive power (item 6-60). See IEC 60050-131, item 131-11-39.\n         */\n    }\n\n    /* IEC-80000-6 item 6-60 reactive power */\n    attribute reactivePower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-60 reactive power\n         * symbol(s): `Q`\n         * application domain: generic\n         * name: ReactivePower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): V*A, var\n         * tensor order: 0\n         * definition: `Q = \"Im\" underline(S)` where `underline(S)` is complex power (item 6-59)\n         * remarks: See IEC 60050-131, item 131-11-44.\n         */\n    }\n\n    /* IEC-80000-6 item 6-61 non-active power */\n    attribute nonActivePower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-61 non-active power\n         * symbol(s): `Q'`\n         * application domain: generic\n         * name: NonActivePower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): V*A\n         * tensor order: 0\n         * definition: `Q' = sqrt(|underline(S)|^2 - P^2)` where `|underline(S)|` is apparent power (item 6-57) and `P` is active power (item 6-56)\n         * remarks: See IEC 60050-131, item 131-11-43.\n         */\n    }\n\n    /* IEC-80000-6 item 6-62 active energy */\n    attribute activeEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 6-62 active energy\n         * symbol(s): `W`\n         * application domain: generic\n         * name: ActiveEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, W*h\n         * tensor order: 0\n         * definition: `W = int_(t_1)^(t_2) p dt` where `p` is instantaneous power (item 6-45), and the integral interval is the time interval from `t_1` to `t_2`\n         * remarks: None.\n         */\n    }\n\n}\n", "Domain Libraries/Quantities and Units/ISQInformation.sysml": 'standard library package ISQInformation {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard IEC-80000-13:2008 "Information science and technology"\n     * see also https://www.iso.org/obp/ui/#iso:std:iec:80000:-13:ed-1:v1:en\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n    private import ISQMechanics::PowerValue;\n    private import ISQSpaceTime::FrequencyValue;\n    private import ISQThermodynamics::EnergyValue;\n\n    /* IEC-80000-13 item 13-1 traffic intensity */\n    attribute def TrafficIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-1 traffic intensity\n         * symbol(s): `A`\n         * application domain: generic\n         * name: TrafficIntensity\n         * quantity dimension: 1\n         * measurement unit(s): E\n         * tensor order: 0\n         * definition: number of simultaneously busy resources in a particular pool of resources\n         * remarks: See IEC 60050-715, item 715-05-02. The name "erlang" was given to the traffic intensity unit in 1946 by the CCIF, in honour of the Danish mathematician, A. K. Erlang (1878-1929), who was the founder of traffic theory in telephony.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TrafficIntensityUnit[1];\n    }\n\n    attribute trafficIntensity: TrafficIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def TrafficIntensityUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-2 traffic offered intensity */\n    attribute def TrafficOfferedIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-2 traffic offered intensity\n         * symbol(s): `A_o`\n         * application domain: generic\n         * name: TrafficOfferedIntensity\n         * quantity dimension: 1\n         * measurement unit(s): E\n         * tensor order: 0\n         * definition: traffic intensity (item 13-1) of the traffic that would have been generated by the users of a pool of resources if their use had not been limited by the size of the pool\n         * remarks: See IEC 60050-715, item 715-05-05. See 13-1 for unit E.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TrafficOfferedIntensityUnit[1];\n    }\n\n    attribute trafficOfferedIntensity: TrafficOfferedIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def TrafficOfferedIntensityUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-3 traffic carried intensity, traffic load */\n    attribute def TrafficCarriedIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-3 traffic carried intensity, traffic load\n         * symbol(s): `Y`\n         * application domain: generic\n         * name: TrafficCarriedIntensity\n         * quantity dimension: 1\n         * measurement unit(s): E\n         * tensor order: 0\n         * definition: traffic intensity (item 13-1) of the traffic served by a particular pool of resources\n         * remarks: General practice is to estimate the traffic intensity as an average over a specified time interval, e.g. the busy hour. See IEC 60050-715, item 715-05-04. See 13-1 for unit E.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TrafficCarriedIntensityUnit[1];\n    }\n\n    attribute trafficCarriedIntensity: TrafficCarriedIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def TrafficCarriedIntensityUnit :> DimensionOneUnit {\n    }\n\n    alias TrafficLoadUnit for TrafficCarriedIntensityUnit;\n    alias TrafficLoadValue for TrafficCarriedIntensityValue;\n    alias trafficLoad for trafficCarriedIntensity;\n\n    /* IEC-80000-13 item 13-4 mean queue length */\n    attribute def MeanQueueLengthValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 13-4 mean queue length\n         * symbol(s): `L`, `(\u03A9)`\n         * application domain: generic\n         * name: MeanQueueLength (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: time average of queue length\n         * remarks: None.\n         */\n    }\n    attribute meanQueueLength: MeanQueueLengthValue :> scalarQuantities;\n\n    /* IEC-80000-13 item 13-5 loss probability */\n    attribute def LossProbabilityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 13-5 loss probability\n         * symbol(s): `B`\n         * application domain: generic\n         * name: LossProbability (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: probability for losing a call attempt\n         * remarks: None.\n         */\n    }\n    attribute lossProbability: LossProbabilityValue :> scalarQuantities;\n\n    /* IEC-80000-13 item 13-6 waiting probability */\n    attribute def WaitingProbabilityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 13-6 waiting probability\n         * symbol(s): `W`\n         * application domain: generic\n         * name: WaitingProbability (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: probability for waiting for a resource\n         * remarks: None.\n         */\n    }\n    attribute waitingProbability: WaitingProbabilityValue :> scalarQuantities;\n\n    /* IEC-80000-13 item 13-7 call intensity, calling rate */\n    attribute def CallIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-7 call intensity, calling rate\n         * symbol(s): `\u03BB`\n         * application domain: generic\n         * name: CallIntensity\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: number of call attempts over a specified time interval divided by the duration (ISO 80000-3, item 3-7) of this interval\n         * remarks: See IEC 60050-715, item 715-03-13.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CallIntensityUnit[1];\n    }\n\n    attribute callIntensity: CallIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def CallIntensityUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    alias CallingRateUnit for CallIntensityUnit;\n    alias CallingRateValue for CallIntensityValue;\n    alias callingRate for callIntensity;\n\n    /* IEC-80000-13 item 13-8 completed call intensity */\n    attribute def CompletedCallIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-8 completed call intensity\n         * symbol(s): `\u03BC`\n         * application domain: generic\n         * name: CompletedCallIntensity\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: call intensity (item 13-7) for the call attempts that result in the transmission of an answer signal\n         * remarks: For a definition of the complete call attempt, see IEC 60050-715, item 715-03-11.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CompletedCallIntensityUnit[1];\n    }\n\n    attribute completedCallIntensity: CompletedCallIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def CompletedCallIntensityUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* IEC-80000-13 item 13-9 storage capacity, storage size */\n    attribute def StorageCapacityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-9 storage capacity, storage size\n         * symbol(s): `M`\n         * application domain: generic\n         * name: StorageCapacity\n         * quantity dimension: 1\n         * measurement unit(s): bit, o, B, 1\n         * tensor order: 0\n         * definition: amount of data that can be contained in a storage device, expressed as a number of specified data elements\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: StorageCapacityUnit[1];\n    }\n\n    attribute storageCapacity: StorageCapacityValue[*] nonunique :> scalarQuantities;\n\n    attribute def StorageCapacityUnit :> DimensionOneUnit {\n    }\n\n    alias StorageSizeUnit for StorageCapacityUnit;\n    alias StorageSizeValue for StorageCapacityValue;\n    alias storageSize for storageCapacity;\n\n    /* IEC-80000-13 item 13-10 equivalent binary storage capacity */\n    attribute def EquivalentBinaryStorageCapacityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-10 equivalent binary storage capacity\n         * symbol(s): `M_e`\n         * application domain: generic\n         * name: EquivalentBinaryStorageCapacity\n         * quantity dimension: 1\n         * measurement unit(s): bit, 1\n         * tensor order: 0\n         * definition: `M_e = log_2 n` where `n` is the number of possible states of the given device\n         * remarks: The minimum storage capacity of a bit-organized storage device which would contain the amount of data in the given storage device is equal to the smallest integer greater than or equal to the equivalent binary storage capacity.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EquivalentBinaryStorageCapacityUnit[1];\n    }\n\n    attribute equivalentBinaryStorageCapacity: EquivalentBinaryStorageCapacityValue[*] nonunique :> scalarQuantities;\n\n    attribute def EquivalentBinaryStorageCapacityUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-11 transfer rate */\n    attribute def TransferRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-11 transfer rate\n         * symbol(s): `r`, `(\u03BD)`\n         * application domain: generic\n         * name: TransferRate\n         * quantity dimension: T^-1\n         * measurement unit(s): o/s, B/s, s^-1\n         * tensor order: 0\n         * definition: quotient of the number of specified data elements transferred in a time interval by the duration of this interval\n         * remarks: The symbol `\u03BD` is the Greek letter nu. A subscript referring to a specified data element can be added to the symbol. EXAMPLES: digit rate, `r_d` or `\u03BD_d` (see IEC 60050-702 and 60050-704, items 702-05-23 and 704-16-06); transfer rate for octets (or bytes), `r_o`, `r_B`, `\u03BD_o`, or `\u03BD_B`; binary digit rate or bit rate (item 13-13).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TransferRateUnit[1];\n    }\n\n    attribute transferRate: TransferRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def TransferRateUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* IEC-80000-13 item 13-12 period of data elements */\n    attribute periodOfDataElements: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 13-12 period of data elements\n         * symbol(s): `T`\n         * application domain: generic\n         * name: PeriodOfDataElements (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: `T = 1/r`, where `r` is transfer rate (item 13-11) when the data elements are transmitted in series\n         * remarks: A subscript referring to a specified data element can be added to the symbol. EXAMPLES: period of digits, `T_d`; period of octets (or bytes), `T_o` or `T_B`.\n         */\n    }\n\n    /* IEC-80000-13 item 13-13 binary digit rate, bit rate */\n    attribute def BinaryDigitRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-13 binary digit rate, bit rate\n         * symbol(s): `r_b`, `r_"bit"`, `(\u03BD_b)`, `(\u03BD_"bit")`\n         * application domain: generic\n         * name: BinaryDigitRate\n         * quantity dimension: T^-1\n         * measurement unit(s): bit/s, s^-1\n         * tensor order: 0\n         * definition: transfer rate (item 13-11) where the data elements are binary digits\n         * remarks: In English, the systematic name would be "transfer rate for binary digits". See IEC 60050-704, item 704-16-07. The bit per second may be combined with prefixes, for example megabit per second, symbol Mbit/s.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: BinaryDigitRateUnit[1];\n    }\n\n    attribute binaryDigitRate: BinaryDigitRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def BinaryDigitRateUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    alias BitRateUnit for BinaryDigitRateUnit;\n    alias BitRateValue for BinaryDigitRateValue;\n    alias bitRate for binaryDigitRate;\n\n    /* IEC-80000-13 item 13-14 period of binary digits, bit period */\n    attribute periodOfBinaryDigits: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 13-14 period of binary digits, bit period\n         * symbol(s): `T_b`, `T_"bit"`\n         * application domain: generic\n         * name: PeriodOfBinaryDigits (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: `T_b = 1/r_b`, where `r_b` is the binary digit rate (item 13-13) when the binary digits are transmitted in series\n         * remarks: None.\n         */\n    }\n\n    alias bitPeriod for periodOfBinaryDigits;\n\n    /* IEC-80000-13 item 13-15 equivalent binary digit rate, equivalent bit rate */\n    attribute def EquivalentBinaryDigitRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-15 equivalent binary digit rate, equivalent bit rate\n         * symbol(s): `r_e`, `(\u03BD_e)`\n         * application domain: generic\n         * name: EquivalentBinaryDigitRate\n         * quantity dimension: T^-1\n         * measurement unit(s): bit/s, s^-1\n         * tensor order: 0\n         * definition: binary digit rate (item 13-13) equivalent to a transfer rate (item 13-11) for specified data elements\n         * remarks: In English, the systematic name would be "equivalent binary transfer rate". See IEC 60050-704, item 704-17-05.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EquivalentBinaryDigitRateUnit[1];\n    }\n\n    attribute equivalentBinaryDigitRate: EquivalentBinaryDigitRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def EquivalentBinaryDigitRateUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    alias EquivalentBitRateUnit for EquivalentBinaryDigitRateUnit;\n    alias EquivalentBitRateValue for EquivalentBinaryDigitRateValue;\n    alias equivalentBitRate for equivalentBinaryDigitRate;\n\n    /* IEC-80000-13 item 13-16 modulation rate, line digit rate */\n    attribute def ModulationRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-16 modulation rate, line digit rate\n         * symbol(s): `r_m`, `u`\n         * application domain: generic\n         * name: ModulationRate\n         * quantity dimension: T^-1\n         * measurement unit(s): Bd, s^-1\n         * tensor order: 0\n         * definition: inverse of the shortest duration of a signal element\n         * remarks: The term \u201Cmodulation rate\u201D is used in conventional telegraphy and data transmission. In isochronous digital transmission, the term "line digit rate" is generally used. See IEC 60050-704, item 704-17-03. Baud is a special name for the second to the power minus one for this quantity. The baud may be combined with prefixes, for example kilobaud, symbol kBd, megabaud, symbol MBd.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ModulationRateUnit[1];\n    }\n\n    attribute modulationRate: ModulationRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def ModulationRateUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    alias LineDigitRateUnit for ModulationRateUnit;\n    alias LineDigitRateValue for ModulationRateValue;\n    alias lineDigitRate for modulationRate;\n\n    /* IEC-80000-13 item 13-17 quantizing distortion rate */\n    attribute quantizingDistortionRate: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 13-17 quantizing distortion rate\n         * symbol(s): `T_Q`\n         * application domain: generic\n         * name: QuantizingDistortionRate (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W\n         * tensor order: 0\n         * definition: distortion of a signal resulting from the process of quantizing an original signal when the values to be quantized are within the working range of the quantizer\n         * remarks: See IEC 60050-704, item 704-24-13.\n         */\n    }\n\n    /* IEC-80000-13 item 13-18 carrier power */\n    attribute carrierPower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 13-18 carrier power\n         * symbol(s): `P_c`, `C`\n         * application domain: generic\n         * name: CarrierPower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W\n         * tensor order: 0\n         * definition: power supplied to the antenna feed line by a radio transmitter taken under the condition of no modulation\n         * remarks: See IEC 60050-713, item 713-09-20.\n         */\n    }\n\n    /* IEC-80000-13 item 13-19 signal energy per binary digit */\n    attribute signalEnergyPerBinaryDigit: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 13-19 signal energy per binary digit\n         * symbol(s): `E_b`, `E_"bit"`\n         * application domain: generic\n         * name: SignalEnergyPerBinaryDigit (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J\n         * tensor order: 0\n         * definition: `E_b = P_c*T_b`, where `P_c` is carrier power (item 13-18) and `T_b` is period of binary digits (item 13-14)\n         * remarks: None.\n         */\n    }\n\n    /* IEC-80000-13 item 13-20 error probability */\n    attribute def ErrorProbabilityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 13-20 error probability\n         * symbol(s): `P`\n         * application domain: generic\n         * name: ErrorProbability (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: probability that a data element be incorrectly received\n         * remarks: A subscript referring to a specified data element can be added to the symbol. EXAMPLES: error probability for binary digits or bit error probability, `P_b` or `P_bit`; block error probability, `P_bl`. The measured value is designated as "error ratio", whereas "error rate" is deprecated, for example, bit error ratio (BER), block error ratio. See IEC 60050-704 and IEC 60050-721.\n         */\n    }\n    attribute errorProbability: ErrorProbabilityValue :> scalarQuantities;\n\n    /* IEC-80000-13 item 13-21 Hamming distance */\n    attribute hammingDistance: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 13-21 Hamming distance\n         * symbol(s): `d_n`\n         * application domain: generic\n         * name: HammingDistance (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of digit positions in which the corresponding digits of two words of the same length are different\n         * remarks: See IEC 60050-721, item 721-08-25.\n         */\n    }\n\n    /* IEC-80000-13 item 13-22 clock frequency, clock rate */\n    attribute clockFrequency: FrequencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 13-22 clock frequency, clock rate\n         * symbol(s): `f_"cl"`\n         * application domain: generic\n         * name: ClockFrequency (specializes Frequency)\n         * quantity dimension: T^-1\n         * measurement unit(s): Hz\n         * tensor order: 0\n         * definition: frequency at which a clock oscillates\n         * remarks: None.\n         */\n    }\n\n    alias clockRate for clockFrequency;\n\n    /* IEC-80000-13 item 13-23 decision content */\n    attribute def DecisionContentValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 13-23 decision content\n         * symbol(s): `D_a`\n         * application domain: generic\n         * name: DecisionContent (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `D_a` = `log_a n`, where `a` is the number of possibilities at each decision and `n` the number of events\n         * remarks: See ISO/IEC 2382-16, item 16.03.01. See also IEC 60027-3. When the same base is used for the same number of events then `D_a = H_0` , where `H_0` is maximum entropy (item 13-28).\n         */\n    }\n    attribute decisionContent: DecisionContentValue :> scalarQuantities;\n\n    /* IEC-80000-13 item 13-24 information content */\n    attribute def InformationContentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-24 information content\n         * symbol(s): `I(x)`\n         * application domain: generic\n         * name: InformationContent\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `I(x) = log_2(1/(p(x)))` Sh `= log(1/(p(x)))` Hart `= ln(1/(p(x)))` nat, where `p(x)` is the probability of event `x`\n         * remarks: See ISO/IEC 2382-16, item 16.03.02. See also IEC 60027-3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: InformationContentUnit[1];\n    }\n\n    attribute informationContent: InformationContentValue[*] nonunique :> scalarQuantities;\n\n    attribute def InformationContentUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-25 entropy */\n    attribute def EntropyForInformationScienceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-25 entropy\n         * symbol(s): `H`\n         * application domain: information science\n         * name: Entropy\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `H(X) = sum_(i=1)^n p(x_i) I(x_i)` for the set `X = {x_1, ..., x_n}`, where `p(x_i)` is the probability and `I(x_i)` is the information content of event `x_i`\n         * remarks: See ISO/IEC 2382-16, item 16.03.02. See also IEC 60027-3.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EntropyForInformationScienceUnit[1];\n    }\n\n    attribute entropyForInformationScience: EntropyForInformationScienceValue[*] nonunique :> scalarQuantities;\n\n    attribute def EntropyForInformationScienceUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-26 maximum entropy */\n    attribute def MaximumEntropyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-26 maximum entropy\n         * symbol(s): `H_0`, `H_"max"`\n         * application domain: information science\n         * name: MaximumEntropy\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: maximum entropy occurs when `p(x_i) = 1/n` for `i = 1, ..., n`\n         * remarks: The maximum entropy is sometimes called "decision content" because the value is the same when the base is an integer, for the same number of events. See item 13-23.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MaximumEntropyUnit[1];\n    }\n\n    attribute maximumEntropy: MaximumEntropyValue[*] nonunique :> scalarQuantities;\n\n    attribute def MaximumEntropyUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-27 relative entropy */\n    attribute def RelativeEntropyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 13-27 relative entropy\n         * symbol(s): `H_r`\n         * application domain: information science\n         * name: RelativeEntropy (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `H_r = H / H_0`, where `H` is entropy (item 13-25) and `H_0` is maximum entropy (item 13-26)\n         * remarks: See ISO/IEC 2382-16, item 16.03.04.\n         */\n    }\n    attribute relativeEntropy: RelativeEntropyValue :> scalarQuantities;\n\n    /* IEC-80000-13 item 13-28 redundancy */\n    attribute def RedundancyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-28 redundancy\n         * symbol(s): `R`\n         * application domain: information science\n         * name: Redundancy\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `R = H_0 \u2212 H`, where `H` is entropy (item 13-25) and `H_0` is maximum entropy (item 13-26)\n         * remarks: See ISO/IEC 2382-16, item 16.03.05.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RedundancyUnit[1];\n    }\n\n    attribute redundancy: RedundancyValue[*] nonunique :> scalarQuantities;\n\n    attribute def RedundancyUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-29 relative redundancy */\n    attribute def RelativeRedundancyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 13-29 relative redundancy\n         * symbol(s): `r`\n         * application domain: information science\n         * name: RelativeRedundancy (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: `r = R / H_0`, where `R` is redundancy (item 13-28) and `H_0` is maximum entropy (item 13-26)\n         * remarks: See ISO/IEC 2382-16, item 16.04.01.\n         */\n    }\n    attribute relativeRedundancy: RelativeRedundancyValue :> scalarQuantities;\n\n    /* IEC-80000-13 item 13-30 joint information content */\n    attribute def JointInformationContentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-30 joint information content\n         * symbol(s): `I(x,y)`\n         * application domain: generic\n         * name: JointInformationContent\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `I(x,y) = log_2(1/(p(x,y)))` Sh `= log(1/(p(x,y)))` Hart `= ln(1/(p(x,y)))` nat, where `p(x,y)` is the joint probability of events `x` and `y`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: JointInformationContentUnit[1];\n    }\n\n    attribute jointInformationContent: JointInformationContentValue[*] nonunique :> scalarQuantities;\n\n    attribute def JointInformationContentUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-31 conditional information content */\n    attribute def ConditionalInformationContentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-31 conditional information content\n         * symbol(s): `I(x|y)`\n         * application domain: generic\n         * name: ConditionalInformationContent\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: information content (item 13-2) of event `x` under the condition that `y` has occurred: `I(x|y) = I(x,y) \u2212 I( y)`\n         * remarks: See ISO/IEC 2382-16, item 16.04.02.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ConditionalInformationContentUnit[1];\n    }\n\n    attribute conditionalInformationContent: ConditionalInformationContentValue[*] nonunique :> scalarQuantities;\n\n    attribute def ConditionalInformationContentUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-32 conditional entropy, mean conditional information content, average conditional information content */\n    attribute def ConditionalEntropyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-32 conditional entropy, mean conditional information content, average conditional information content\n         * symbol(s): `H(X|Y)`\n         * application domain: generic\n         * name: ConditionalEntropy\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `H(X|Y) = sum_(i=1)^n sum_(j=1)^m p(x_i,y_j) I(x_i,y_j)` where `p(x_i,y_j)` is the joint probability of events `x_i` and `y_j`, and `I(x_i,y_j)` is conditional information content (item 13-31)\n         * remarks: See ISO/IEC 2382-16, item 16.04.04.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ConditionalEntropyUnit[1];\n    }\n\n    attribute conditionalEntropy: ConditionalEntropyValue[*] nonunique :> scalarQuantities;\n\n    attribute def ConditionalEntropyUnit :> DimensionOneUnit {\n    }\n\n    alias MeanConditionalInformationContentUnit for ConditionalEntropyUnit;\n    alias MeanConditionalInformationContentValue for ConditionalEntropyValue;\n    alias meanConditionalInformationContent for conditionalEntropy;\n\n    alias AverageConditionalInformationContentUnit for ConditionalEntropyUnit;\n    alias AverageConditionalInformationContentValue for ConditionalEntropyValue;\n    alias averageConditionalInformationContent for conditionalEntropy;\n\n    /* IEC-80000-13 item 13-33 equivocation */\n    attribute def EquivocationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-33 equivocation\n         * symbol(s): `H(X|Y)`\n         * application domain: generic\n         * name: Equivocation\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: conditional entropy (item 13-32) of a set X of emitted characters given the set Y of received characters\n         * remarks: Equivocation is a quantitative measure of the loss of information due to noise. See ISO/IEC 2382-16, item 16.04.05.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EquivocationUnit[1];\n    }\n\n    attribute equivocation: EquivocationValue[*] nonunique :> scalarQuantities;\n\n    attribute def EquivocationUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-34 irrelevance */\n    attribute def IrrelevanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-34 irrelevance\n         * symbol(s): `H(Y|X)`\n         * application domain: generic\n         * name: Irrelevance\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: conditional entropy (item 13-32) of a set `Y` of received characters given the set `X` of emitted characters: `H(Y|X) = H(X|Y) + H(Y) \u2212 H(X)`, where `H(X|Y)` is equivocation (item 13-33) and `H` is entropy (item 13-25)\n         * remarks: Irrelevance is a quantitative measure of the information added to the emitted information due to distortion. See ISO/IEC 2382 16, item 16.04.06.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: IrrelevanceUnit[1];\n    }\n\n    attribute irrelevance: IrrelevanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def IrrelevanceUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-35 transinformation content */\n    attribute def TransinformationContentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-35 transinformation content\n         * symbol(s): `T(x,y)`\n         * application domain: generic\n         * name: TransinformationContent\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `T(x,y) = I(x) + I(y) \u2212 I(x,y)`, where `I(x)` and `I(y)` are the information contents (13-24) of events `x` and `y`, respectively, and `I(x,y)` is their joint information content (13-30)\n         * remarks: See ISO/IEC 2382-16, item 16.04.07.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TransinformationContentUnit[1];\n    }\n\n    attribute transinformationContent: TransinformationContentValue[*] nonunique :> scalarQuantities;\n\n    attribute def TransinformationContentUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-36 mean transinformation content */\n    attribute def MeanTransinformationContentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-36 mean transinformation content\n         * symbol(s): `T`\n         * application domain: generic\n         * name: MeanTransinformationContent\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `T(X,Y) = sum_(i=1)^n sum_(j=1)^m p(x_i,y_j) T(x_i,y_j)` for the sets `X = {x_1, ..., x_n}`, `Y = {y_1, ..., y_m}`, where `p(x_i,y_j)` is the joint probability of events `x_i` and `y_j`, and `T(x_i,y_j)` is their transinformation content (item 13-35)\n         * remarks: See ISO/IEC 2382-16, item 16.04.08. In practice, the unit "shannon per character" is generally used, and sometimes the units "hartley per character" and "natural unit per character".\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MeanTransinformationContentUnit[1];\n    }\n\n    attribute meanTransinformationContent: MeanTransinformationContentValue[*] nonunique :> scalarQuantities;\n\n    attribute def MeanTransinformationContentUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-37 character mean entropy */\n    attribute def CharacterMeanEntropyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-37 character mean entropy\n         * symbol(s): `H\'`\n         * application domain: generic\n         * name: CharacterMeanEntropy\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `H\' = lim_(m->\u221E) H_m/m` where `H_m` is the entropy (item 13-3) of the set of all sequences of `m` characters\n         * remarks: See ISO/IEC 2382-16, item 16.04.09.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CharacterMeanEntropyUnit[1];\n    }\n\n    attribute characterMeanEntropy: CharacterMeanEntropyValue[*] nonunique :> scalarQuantities;\n\n    attribute def CharacterMeanEntropyUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-38 average information rate */\n    attribute def AverageInformationRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-38 average information rate\n         * symbol(s): `H^"*"`\n         * application domain: generic\n         * name: AverageInformationRate\n         * quantity dimension: T^-1\n         * measurement unit(s): Sh/s, Hart/s, nat/s\n         * tensor order: 0\n         * definition: `H^"*" = (H\')/(t(X))`, where `H\'` is character mean entropy (item 13-37) and `t(X)` is the mean value of the duration of a character in the set `X`\n         * remarks: See ISO/IEC 2382-16, item 16.04.10.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AverageInformationRateUnit[1];\n    }\n\n    attribute averageInformationRate: AverageInformationRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def AverageInformationRateUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* IEC-80000-13 item 13-39 character mean transinformation content */\n    attribute def CharacterMeanTransinformationContentValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-39 character mean transinformation content\n         * symbol(s): `T\'`\n         * application domain: generic\n         * name: CharacterMeanTransinformationContent\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `T\' = lim_(m->\u221E) T_m/m` where `T_m` is the mean transinformation content (item 13-36) for all pairs of input and output sequences of `m` characters\n         * remarks: See ISO/IEC 2382-16, item 16.04.11. In practice, the unit "shannon per character" is generally used, and sometimes the units "hartley per character" and "natural unit per character".\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CharacterMeanTransinformationContentUnit[1];\n    }\n\n    attribute characterMeanTransinformationContent: CharacterMeanTransinformationContentValue[*] nonunique :> scalarQuantities;\n\n    attribute def CharacterMeanTransinformationContentUnit :> DimensionOneUnit {\n    }\n\n    /* IEC-80000-13 item 13-40 average transinformation rate */\n    attribute def AverageTransinformationRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-40 average transinformation rate\n         * symbol(s): `T^"*"`\n         * application domain: generic\n         * name: AverageTransinformationRate\n         * quantity dimension: T^-1\n         * measurement unit(s): Sh/s, Hart/s, nat/s\n         * tensor order: 0\n         * definition: `T^"*" =  (T\')/(sum_(i=1)^n sum_(j=1)^m p(x_i,y_j) t(x_i,y_j) )`, where `T\'` is character mean transinformation content (item 13-39) and `t(x_i,y_j)` is the mean duration of the pair of characters `(x_i,y_j)` with joint probability `p(x_i,y_j)`\n         * remarks: See ISO/IEC 2382-16, item 16.04.12.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AverageTransinformationRateUnit[1];\n    }\n\n    attribute averageTransinformationRate: AverageTransinformationRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def AverageTransinformationRateUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* IEC-80000-13 item 13-41 channel capacity per character, channel capacity */\n    attribute def ChannelCapacityPerCharacterValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-41 channel capacity per character, channel capacity\n         * symbol(s): `C\'`\n         * application domain: generic\n         * name: ChannelCapacityPerCharacter\n         * quantity dimension: 1\n         * measurement unit(s): Sh, Hart, nat\n         * tensor order: 0\n         * definition: `C\' = max T\'`, where `T\'` is character mean transinformation content (item 13-39)\n         * remarks: See ISO/IEC 2382-16, item 16.04.13. In practice, the unit "shannon per character" is generally used, and sometimes the units "hartley per character" and "natural unit per character".\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ChannelCapacityPerCharacterUnit[1];\n    }\n\n    attribute channelCapacityPerCharacter: ChannelCapacityPerCharacterValue[*] nonunique :> scalarQuantities;\n\n    attribute def ChannelCapacityPerCharacterUnit :> DimensionOneUnit {\n    }\n\n    alias ChannelCapacityUnit for ChannelCapacityPerCharacterUnit;\n    alias ChannelCapacityValue for ChannelCapacityPerCharacterValue;\n    alias channelCapacity for channelCapacityPerCharacter;\n\n    /* IEC-80000-13 item 13-42 channel time capacity */\n    attribute def ChannelTimeCapacityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 13-42 channel time capacity\n         * symbol(s): `C^"*"`\n         * application domain: generic\n         * name: ChannelTimeCapacity\n         * quantity dimension: T^-1\n         * measurement unit(s): Sh/s, Hart/s, nat/s\n         * tensor order: 0\n         * definition: `C^"*" = max T^"*"`, where `T^"*"` is average transinformation rate (item 13-40)\n         * remarks: See ISO/IEC 2382-16, item 16.04.13. Note for SysML ISQ: Alias "channel capacity", that was present in IEC 80000-12:2008, has been removed as it duplicates the alias of channel capacity per character (item 13-41).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ChannelTimeCapacityUnit[1];\n    }\n\n    attribute channelTimeCapacity: ChannelTimeCapacityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ChannelTimeCapacityUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n}\n', "Domain Libraries/Quantities and Units/ISQLight.sysml": 'standard library package ISQLight {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-7:2019 "Light and radiation"\n     * see also https://www.iso.org/standard/64977.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n    private import ISQThermodynamics::EnergyValue;\n\n    /* ISO-80000-7 item 7-1.1 speed of light in a medium */\n    attribute def SpeedOfLightInAMediumValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-1.1 speed of light in a medium\n         * symbol(s): `c`\n         * application domain: generic\n         * name: SpeedOfLightInAMedium\n         * quantity dimension: L^1*T^-1\n         * measurement unit(s): m*s^-1\n         * tensor order: 0\n         * definition: phase speed of an electromagnetic wave at a given point in a medium\n         * remarks: See also ISO 80000-3. The value of the speed of light in a medium can depend on the frequency, polarization, and direction. For the definition of the speed of electromagnetic waves in vacuum, `c_0`, see ISO 80000-1.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpeedOfLightInAMediumUnit[1];\n    }\n\n    attribute speedOfLightInAMedium: SpeedOfLightInAMediumValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpeedOfLightInAMediumUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-1.2 refractive index */\n    attribute def RefractiveIndexValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-1.2 refractive index\n         * symbol(s): `n`\n         * application domain: generic\n         * name: RefractiveIndex (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of speed of light in vacuum (ISO 80000-1) and speed of light in a medium (item 7-1.1)\n         * remarks: The value of the refractive index can depend on the frequency, polarization, and direction. The refractive index is expressed by n = c_0/c, where c_()_0 is the speed of light in vacuum and c is the speed of light in the medium. For a medium with absorption, the complex refractive index n is defined by n = n + ik where k is spectral absorption index (IEC 60050-845) and i is imaginary unit. The refractivity is expressed by n -1, where n is refractive index.\n         */\n    }\n    attribute refractiveIndex: RefractiveIndexValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-2.1 radiant energy */\n    attribute radiantEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 7-2.1 radiant energy\n         * symbol(s): `Q_e`, `W`, `U`, `(Q)`\n         * application domain: electromagnetism\n         * name: RadiantEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: energy (ISO 80000-5) emitted, transferred or received in form of electromagnetic waves\n         * remarks: Radiant energy can be expressed by the time integral of radiant flux (item 7-4.1), `\u03A6_e`, over a given duration (ISO 80000-3), `\u0394t`: `Q_e = int_(\u0394 t) \u03A6_e dt`. Radiant energy is expressed either as a function of wavelength (ISO 80000-3), `\u03BB`, as a function of frequency (ISO 80000-3), `\u03BD`, or as a function of wavenumber, `\u03C3`. (See also 0.1.) The corresponding photometric quantity is "luminous energy" (item 7-12). The corresponding quantity for photons is "photon energy" (item 7-19.2).\n         */\n    }\n\n    /* ISO-80000-7 item 7-2.2 spectral radiant energy */\n    attribute def SpectralRadiantEnergyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-2.2 spectral radiant energy\n         * symbol(s): `Q_(e,\u03BB)`, `W_\u03BB`, `U_\u03BB`, `(Q_\u03BB)`\n         * application domain: generic\n         * name: SpectralRadiantEnergy\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): J/nm, kg*m*s^-2\n         * tensor order: 0\n         * definition: spectral density of radiant energy, expressed by `Q_(e,\u03BB) = (dQ_e) / (d\u03BB)`, where `Q_e` is radiant energy (item 7-2.1) in terms of wavelength `\u03BB` (ISO 80000-3)\n         * remarks: The integral of (total) radiant energy is determined by the wavelength interval `(\u03BB_1, \u03BB_2)` under consideration: `Q_e = int_(\u03BB_1)^(\u03BB_2) Q_(e,\u03BB) d\u03BB`\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralRadiantEnergyUnit[1];\n    }\n\n    attribute spectralRadiantEnergy: SpectralRadiantEnergyValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralRadiantEnergyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-3.1 radiant energy density */\n    attribute def RadiantEnergyDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-3.1 radiant energy density\n         * symbol(s): `w`, `(\u03C1_e)`\n         * application domain: generic\n         * name: RadiantEnergyDensity\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): J/m^3, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: volumetric density of radiant energy, expressed by `w = (dQ_e)/(dV)`, where `Q_e` is radiant energy (item 7-2.1) in an elementary three-dimensional domain and `V` is the volume (ISO 80000-3) of that domain\n         * remarks: Radiant energy density within a Planckian radiator is given by `w = (4 \u03C3)/(c_0) T^4` where `\u03C3` is the Stefan-Boltzmann constant (ISO 80000-1), `c_0` is speed of light in vacuum (ISO 80000-1) and `T` is thermodynamic temperature (ISO 80000-5).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RadiantEnergyDensityUnit[1];\n    }\n\n    attribute radiantEnergyDensity: RadiantEnergyDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def RadiantEnergyDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-3.2 spectral radiant energy density in terms of wavelength */\n    attribute def SpectralRadiantEnergyDensityInTermsOfWavelengthValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-3.2 spectral radiant energy density in terms of wavelength\n         * symbol(s): `w_\u03BB`\n         * application domain: generic\n         * name: SpectralRadiantEnergyDensityInTermsOfWavelength\n         * quantity dimension: L^-2*M^1*T^-2\n         * measurement unit(s): J/(m^3*nm), kg*m^-2*s^-2\n         * tensor order: 0\n         * definition: change of radiant energy density with wavelength, expressed by `w_\u03BB = (dw)/(d\u03BB)`, where `w` is radiant energy density (item 7-3.1) as a function of wavelength `\u03BB` (ISO 80000-3)\n         * remarks: Spectral radiant energy density within a Planckian radiator is given by `w_\u03BB = 8\u03C0hc_0*f(\u03BB, T)`, where `h` is the Planck constant (ISO 80000-1), `c_0` is speed of light in vacuum (ISO 80000-1), `T` is thermodynamic temperature (ISO 80000-5) and `f(\u03BB,T) = (\u03BB^-5)/(exp(c_2 \u03BB^-1 T^-1) - 1)`. For the radiation constant `c_2` in `f(\u03BB,T)`, see ISO 80000-1.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralRadiantEnergyDensityInTermsOfWavelengthUnit[1];\n    }\n\n    attribute spectralRadiantEnergyDensityInTermsOfWavelength: SpectralRadiantEnergyDensityInTermsOfWavelengthValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralRadiantEnergyDensityInTermsOfWavelengthUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-3.3 spectral radiant energy density in terms of wavenumber */\n    attribute def SpectralRadiantEnergyDensityInTermsOfWavenumberValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-3.3 spectral radiant energy density in terms of wavenumber\n         * symbol(s): `w_\u1E7D`, `\u03C1_\u1E7D`\n         * application domain: generic\n         * name: SpectralRadiantEnergyDensityInTermsOfWavenumber\n         * quantity dimension: M^1*T^-2\n         * measurement unit(s): J/m^2, kg*s^-2\n         * tensor order: 0\n         * definition: change of radiant energy density with wavenumber, expressed by `w_\u1E7D = (dw)/(d\u1E7D)`, where `w` is radiant energy density (item 7-3.1) as a function of wavenumber `\u1E7D` (ISO 80000-3)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralRadiantEnergyDensityInTermsOfWavenumberUnit[1];\n    }\n\n    attribute spectralRadiantEnergyDensityInTermsOfWavenumber: SpectralRadiantEnergyDensityInTermsOfWavenumberValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralRadiantEnergyDensityInTermsOfWavenumberUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-4.1 radiant flux, radiant power */\n    attribute def RadiantFluxValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-4.1 radiant flux, radiant power\n         * symbol(s): `\u03A6_e`, `P_e`, `\u03A6`, `P`\n         * application domain: generic\n         * name: RadiantFlux\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W, kg*m^2*s^-3\n         * tensor order: 0\n         * definition: change in radiant energy with time, expressed by `\u03A6_e = (dQ_e)/(dt)`, where `Q_e` is the radiant energy (item 7-2.1) emitted, transferred or received and `t` is time (ISO 80000-3)\n         * remarks: The corresponding photometric quantity is "luminous flux" (item 7-13). The corresponding quantity for photons is "photon flux" (item 7-20).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RadiantFluxUnit[1];\n    }\n\n    attribute radiantFlux: RadiantFluxValue[*] nonunique :> scalarQuantities;\n\n    attribute def RadiantFluxUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    alias RadiantPowerUnit for RadiantFluxUnit;\n    alias RadiantPowerValue for RadiantFluxValue;\n    alias radiantPower for radiantFlux;\n\n    /* ISO-80000-7 item 7-4.2 spectral radiant flux, spectral radiant power */\n    attribute def SpectralRadiantFluxValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-4.2 spectral radiant flux, spectral radiant power\n         * symbol(s): `\u03A6_(e,\u03BB)`, `P_(e,\u03BB)`, `(\u03A6_\u03BB)`, `(P_\u03BB)`\n         * application domain: generic\n         * name: SpectralRadiantFlux\n         * quantity dimension: L^1*M^1*T^-3\n         * measurement unit(s): W/nm, kg*m*s^-3\n         * tensor order: 0\n         * definition: spectral density of radiant flux, expressed by `\u03A6_(e,\u03BB) = (dQ_e)/(d\u03BB)`, where `\u03A6_e` is radiant flux (item 7-4.1) in terms of wavelength `\u03BB` (ISO 80000-3)\n         * remarks: The integral of (total) radiant flux is determined by the wavelength interval `(\u03BB_1, \u03BB_2)` under consideration: `\u03A6_e = int_(\u03BB_1)^(\u03BB_2) \u03A6_(e,\u03BB) d\u03BB` .\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralRadiantFluxUnit[1];\n    }\n\n    attribute spectralRadiantFlux: SpectralRadiantFluxValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralRadiantFluxUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    alias SpectralRadiantPowerUnit for SpectralRadiantFluxUnit;\n    alias SpectralRadiantPowerValue for SpectralRadiantFluxValue;\n    alias spectralRadiantPower for spectralRadiantFlux;\n\n    /* ISO-80000-7 item 7-5.1 radiant intensity */\n    attribute def RadiantIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-5.1 radiant intensity\n         * symbol(s): `I_e`, `(I)`\n         * application domain: generic\n         * name: RadiantIntensity\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W/sr, kg*m^2*s^-3*sr^-1\n         * tensor order: 0\n         * definition: density of radiant flux with respect to solid angle in a specified direction, expressed by `I_e = (d\u03A6_e)/(d\u03A9)`, where `\u03A6_e` is the radiant flux (item 7-4.1) emitted in a specified direction, and `\u03A9` is the solid angle (ISO 80000-3) containing that direction\n         * remarks: The definition holds strictly only for a point source. The distribution of the radiant intensities as a function of the direction of emission, e.g. given by the polar angles `(\u03B8,\u03C6)`, is used to determine the radiant flux (item 7-4.1) within a certain solid angle (ISO 80000-3), `\u03A9`, of a source: `\u03A6_e = int int_\u03A9 I_e(\u03B8, \u03C6) sin(\u03B8) d\u03C6 d\u03B8`. The corresponding photometric quantity is "luminous intensity" (item 7-14). The corresponding quantity for photons is "photon intensity" (item 7-21).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RadiantIntensityUnit[1];\n    }\n\n    attribute radiantIntensity: RadiantIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def RadiantIntensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-5.2 spectral radiant intensity */\n    attribute def SpectralRadiantIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-5.2 spectral radiant intensity\n         * symbol(s): `I_(e,\u03BB)`, `(I_\u03BB)`\n         * application domain: generic\n         * name: SpectralRadiantIntensity\n         * quantity dimension: L^1*M^1*T^-3\n         * measurement unit(s): W/(sr*nm), kg*m*s^-3*sr^-1\n         * tensor order: 0\n         * definition: spectral density of radiant intensity, expressed by `I_(e, \u03BB) = (d I_e)/(d\u03BB)`, where `I_e` is radiant intensity (item 7-5.1) in terms of wavelength `\u03BB` (ISO 80000-3)\n         * remarks: The integral of (total) radiant intensity is determined by the wavelength interval `(\u03BB_1, \u03BB_2)` under consideration: `I_e = int_(\u03BB_1)^(\u03BB_2) I_(e,\u03BB) d\u03BB` .\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralRadiantIntensityUnit[1];\n    }\n\n    attribute spectralRadiantIntensity: SpectralRadiantIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralRadiantIntensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-6.1 radiance */\n    attribute def RadianceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-6.1 radiance\n         * symbol(s): `L_e`, `(L)`\n         * application domain: generic\n         * name: Radiance\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/(sr*m^2), kg*s^-3*sr^-1\n         * tensor order: 0\n         * definition: density of radiant intensity with respect to projected area in a specified direction at a specified point on a real or imaginary surface, expressed by `L_e = (d I_e)/(dA) * 1/cos(\u03B1)`, where `I_e` is radiant intensity (item 7-5.1), `A` is area (ISO 80000-3), and `\u03B1` is the angle between the normal to the surface at the specified point and the specified direction\n         * remarks: See also 0.1. For Planckian radiation, `L_e = \u03C3/\u03C0 T^4` where `T` is thermodynamic temperature (ISO 80000-5) and `\u03C3` is the Stefan-Boltzmann constant (ISO 80000-1). The corresponding photometric quantity is "luminance" (item 7-15). The corresponding quantity for photons is "photon radiance" (item 7-22).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RadianceUnit[1];\n    }\n\n    attribute radiance: RadianceValue[*] nonunique :> scalarQuantities;\n\n    attribute def RadianceUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-6.2 spectral radiance */\n    attribute def SpectralRadianceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-6.2 spectral radiance\n         * symbol(s): `L_(e,\u03BB)`, `(L_\u03BB)`\n         * application domain: generic\n         * name: SpectralRadiance\n         * quantity dimension: L^-1*M^1*T^-3\n         * measurement unit(s): W/(sr*m^2*nm), kg*m^-1*s^-3*sr^-1\n         * tensor order: 0\n         * definition: density of radiance with respect to wavelength, expressed by `L_(e, \u03BB) = (d L_e)/(d \u03BB)` where `L_e` is radiance (item 7-6.1) in terms of wavelength \u03BB(ISO 80000-3)\n         * remarks: For Planckian radiation, `L_(e, \u03BB)(\u03BB) = (c(\u03BB))/(4 \u03C0) \u03C9_\u03BB(\u03BB) = h c_0^2 * f(\u03BB,T)`, where `c(\u03BB)` is phase speed (ISO 80000-3) of electromagnetic radiation of a wavelength (ISO 80000-3) `\u03BB` in a given medium, `\u03C9_\u03BB(\u03BB)` is spectral radiant energy density in terms of wavelength, `c_0` is speed of light in vacuum (ISO 80000-1), `h` is the Planck constant (ISO 80000-1), and `f(\u03BB,T) = \u03BB^-5/(exp(c_2 \u03BB^-1 T^-1) - 1)`, where the radiation constant `c_2 = (hc)/k`. The integral of (total) radiance is determined by the wavelength interval `(\u03BB_1, \u03BB_2)` under consideration: `L_e = int_(\u03BB_1)^(\u03BB_2) L_(e,\u03BB) d\u03BB` .\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralRadianceUnit[1];\n    }\n\n    attribute spectralRadiance: SpectralRadianceValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralRadianceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-7.1 irradiance */\n    attribute def IrradianceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-7.1 irradiance\n         * symbol(s): `E_e`, `(E)`\n         * application domain: generic\n         * name: Irradiance\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/m^2, kg*s^-3\n         * tensor order: 0\n         * definition: density of incident radiant flux with respect to area at a point on a real or imaginary surface, expressed by `E_e = (d \u03A6_e)/(d A)`, where `\u03A6_e` is radiant flux (item 7-4.1) and `A` is the area (ISO 80000-3) on which the radiant flux is incident\n         * remarks: The corresponding photometric quantity is "illuminance" (item 7-16). The corresponding quantity for photons is "photon irradiance" (item 7-23). The quantity "spherical irradiance" is defined by the mean value of irradiance on the outer curved surface of a very small (real or imaginary) sphere at a point in space. It can be expressed by `E_(e,0) = int_(4 \u03C0) L_e d \u03A9` where `\u03A9` is solid angle (ISO 80000-3) and `L_e` is radiance (item 7-6.1). (See CIE DIS 017/E:2016, term 17-21-054.) It can be expressed by the quotient of the radiant flux (item 7-4.1) of all the radiation incident on the outer surface of an infinitely small sphere centred at the specified point and the area (ISO 80000-3) of the diametrical cross-section of that sphere. Spherical irradiance is also called "fluence rate" or "radiant fluence rate". The corresponding photometric quantity to spherical irradiance is called "spherical illuminance".\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: IrradianceUnit[1];\n    }\n\n    attribute irradiance: IrradianceValue[*] nonunique :> scalarQuantities;\n\n    attribute def IrradianceUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-7.2 spectral irradiance */\n    attribute def SpectralIrradianceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-7.2 spectral irradiance\n         * symbol(s): `E_(e,\u03BB)`, `(E_\u03BB)`\n         * application domain: generic\n         * name: SpectralIrradiance\n         * quantity dimension: L^-1*M^1*T^-3\n         * measurement unit(s): W/(m^2*nm), kg*m^-1*s^-3\n         * tensor order: 0\n         * definition: density of irradiance with respect to wavelength, expressed by `E_(e,\u03BB) = (d E_e)/(d\u03BB)`, where `E_e` is irradiance (item 7-7.1) in terms of wavelength `\u03BB` (ISO 80000-3)\n         * remarks: The integral of (total) irradiance is determined by the wavelength interval `(\u03BB_1, \u03BB_2)` under consideration: `E_e = int_(\u03BB_1)^(\u03BB_2) E_(e,\u03BB) d \u03BB` .\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralIrradianceUnit[1];\n    }\n\n    attribute spectralIrradiance: SpectralIrradianceValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralIrradianceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-8.1 radiant exitance , radiant emittance */\n    attribute def RadiantExitanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-8.1 radiant exitance , radiant emittance\n         * symbol(s): `M_e`, `(M)`\n         * application domain: generic\n         * name: RadiantExitance\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/m^2, kg*s^-3\n         * tensor order: 0\n         * definition: density of exiting radiant flux with respect to area at a point on a real or imaginary surface, expressed by `M_e = (d \u03A6_e)/(dA)`, where `\u03A6_e` is radiant flux (item 7-4.1) and `A` is the area (ISO 80000-3) from which the radiant flux leaves\n         * remarks: For Planckian radiation, `M_e = \u03C3T^4`, where `T` is thermodynamic temperature (ISO 80000-5) and `\u03C3` is the Stefan-Boltzmann constant (ISO 80000-1). The corresponding photometric quantity is "luminous exitance" (item 7-17). The corresponding quantity for photons is "photon exitance" (item 7-24).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RadiantExitanceUnit[1];\n    }\n\n    attribute radiantExitance: RadiantExitanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def RadiantExitanceUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    alias RadiantEmittanceUnit for RadiantExitanceUnit;\n    alias RadiantEmittanceValue for RadiantExitanceValue;\n    alias radiantEmittance for radiantExitance;\n\n    /* ISO-80000-7 item 7-8.2 spectral radiant exitance */\n    attribute def SpectralRadiantExitanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-8.2 spectral radiant exitance\n         * symbol(s): `M_(e,\u03BB)`, `(M_\u03BB)`\n         * application domain: generic\n         * name: SpectralRadiantExitance\n         * quantity dimension: L^-1*M^1*T^-3\n         * measurement unit(s): W/(m^2*nm), kg*m^-1*s^-3\n         * tensor order: 0\n         * definition: density of radiant exitance with respect to wavelength, expressed by `M_(e,\u03BB) = (d M_e)/(d\u03BB)`, where `M_e` is radiant exitance (item 7-8.1) in terms of wavelength `\u03BB` (ISO 80000-3)\n         * remarks: The integral of (total) radiant exitance is determined by the wavelength interval `(\u03BB_1, \u03BB_2)` under consideration: `M_e = int_(\u03BB_1)^(\u03BB_2) M_(e,\u03BB) d \u03BB` .\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralRadiantExitanceUnit[1];\n    }\n\n    attribute spectralRadiantExitance: SpectralRadiantExitanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralRadiantExitanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-9.1 radiant exposure */\n    attribute def RadiantExposureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-9.1 radiant exposure\n         * symbol(s): `H_e`, `(H)`\n         * application domain: generic\n         * name: RadiantExposure\n         * quantity dimension: M^1*T^-2\n         * measurement unit(s): J/m^2, kg*s^-2\n         * tensor order: 0\n         * definition: density of incident radiant energy with respect to area at a point on a real or imaginary surface, expressed by `H_e = (d Q_e)/(dA)`, where `Q_e` is radiant energy (item 7-2.1) and `A` is the area on which the radiant energy is incident (ISO 80000-3)\n         * remarks: The corresponding photometric quantity is "luminous exposure" (item 7-18). The corresponding quantity for photons is "photon exposure" (item 7-25).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RadiantExposureUnit[1];\n    }\n\n    attribute radiantExposure: RadiantExposureValue[*] nonunique :> scalarQuantities;\n\n    attribute def RadiantExposureUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-9.2 spectral radiant exposure */\n    attribute def SpectralRadiantExposureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-9.2 spectral radiant exposure\n         * symbol(s): `H_(e,\u03BB)`, `(H_\u03BB)`\n         * application domain: generic\n         * name: SpectralRadiantExposure\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): J/(m^2*nm), kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: density of radiant exposure with respect to wavelength, expressed by `H_(e,\u03BB) = (d H_e)/(d\u03BB)`, where `H_e` is radiant exposure (item 7-9.1) in terms of wavelength `\u03BB` (ISO 80000-3)\n         * remarks: The integral of (total) radiant exposure is determined by the wavelength interval `(\u03BB_1, \u03BB_2)` under consideration: `H_e = int_(\u03BB_1)^(\u03BB_2) H_(e,\u03BB) d \u03BB` .\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralRadiantExposureUnit[1];\n    }\n\n    attribute spectralRadiantExposure: SpectralRadiantExposureValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralRadiantExposureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-10.1 luminous efficiency */\n    attribute def LuminousEfficiencyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-10.1 luminous efficiency\n         * symbol(s): `V`\n         * application domain: specified photometric condition\n         * name: LuminousEfficiency (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of radiant flux (item 7-4.1) weighted by the spectral luminous efficiency (item 7-10.2) and the corresponding radiant flux for a specified photometric condition\n         * remarks: Luminous efficiency for photopic vision is expressed by `V = (int_0^\u221E \u03A6_(e,\u03BB)(\u03BB) V(\u03BB) d \u03BB)/(int_0^\u221E \u03A6_(e,\u03BB)(\u03BB) d \u03BB) = K/K_m`, where `\u03A6_(e,\u03BB)` is spectral radiant flux (item 7-4.2), `V(\u03BB)` is spectral luminous efficiency, `\u03BB` is wavelength, `K` is luminous efficacy of radiation (item 7-11.1), and `K_m` is maximum luminous efficacy (item 7-11.3). For scotopic and mesopic vision see 0.4 and 0.5. Symbols for different photometric conditions: `V` for photopic vision; `V\'` for scotopic vision; `V_(mes;m)` for mesopic vision; `V_10` for the CIE 10\xB0 photopic photometric observer; `V_M` for the CIE 1988 modified 2\xB0 spectral luminous efficiency function for photopic vision.\n         */\n    }\n    attribute luminousEfficiency: LuminousEfficiencyValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-10.2 spectral luminous efficiency */\n    attribute def SpectralLuminousEfficiencyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-10.2 spectral luminous efficiency\n         * symbol(s): `V(\u03BB)`\n         * application domain: specified photometric condition\n         * name: SpectralLuminousEfficiency (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the radiant flux (item 7-4.1) at wavelength `\u03BB_m` and that at wavelength `\u03BB`, such that both produce equally intense luminous sensations for a specified photometric condition and `\u03BB_m` is chosen so that the maximum value of this quotient is equal to 1\n         * remarks: The spectral luminous efficiency of the human eye depends on a number of factors, particularly the state of visual adaptation and the size and position of the source in the visual field. The photometric condition should be specified (e.g. photopic, scotopic, mesopic). If it is not specified, photopic vision is assumed and the symbol `V(\u03BB)` is used. For scotopic and mesopic vision see 0.4 and 0.5. Symbols for different photometric conditions: `V(\u03BB)` for photopic vision; `V\'(\u03BB)` for scotopic vision; `V_(mes;m)(\u03BB)` for mesopic vision; `V_10(\u03BB)` for the CIE 10\xB0 photopic photometric observer; `V_M(\u03BB)` for the CIE 1988 modified 2\xB0 spectral luminous efficiency function for photopic vision.\n         */\n    }\n    attribute spectralLuminousEfficiency: SpectralLuminousEfficiencyValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-11.1 luminous efficacy of radiation */\n    attribute def LuminousEfficacyOfRadiationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-11.1 luminous efficacy of radiation\n         * symbol(s): `K`\n         * application domain: specified photometric condition\n         * name: LuminousEfficacyOfRadiation\n         * quantity dimension: L^-2*M^-1*T^3*J^1\n         * measurement unit(s): lm/W, cd*sr*kg^-1*m^-2*s^3\n         * tensor order: 0\n         * definition: quotient of luminous flux (item 7-13) and the corresponding radiant flux (item 7-4.1) for a specified photometric condition\n         * remarks: Luminous efficacy of radiation for photopic vision is expressed by `K = \u03A6_V/\u03A6_e`, where `\u03A6_v` is luminous flux (item 7-13) and `\u03A6_e` is radiant flux (item 7-4.1). For scotopic and mesopic vision see 0.4 and 0.5. Symbols for different photometric conditions: `K` for photopic vision; `K\'` for scotopic vision; `K_(mes;m)` for mesopic vision; `K_10` for the CIE 10\xB0 photopic photometric observer; `K_M` for the CIE 1988 modified 2\xB0 spectral luminous efficiency function for photopic vision.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LuminousEfficacyOfRadiationUnit[1];\n    }\n\n    attribute luminousEfficacyOfRadiation: LuminousEfficacyOfRadiationValue[*] nonunique :> scalarQuantities;\n\n    attribute def LuminousEfficacyOfRadiationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-11.2 spectral luminous efficacy */\n    attribute def SpectralLuminousEfficacyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-11.2 spectral luminous efficacy\n         * symbol(s): `K(\u03BB)`\n         * application domain: specified photometric condition\n         * name: SpectralLuminousEfficacy\n         * quantity dimension: L^-2*M^-1*T^3*J^1\n         * measurement unit(s): lm/W, cd*sr*kg^-1*m^-2*s^3\n         * tensor order: 0\n         * definition: product of spectral luminous efficiency (item 7-10.2) and maximum luminous efficacy (item 7-11.3) for a specified photometric condition\n         * remarks: Spectral luminous efficacy for photopic vision is expressed by `K(\u03BB) = K_m V(\u03BB)`, where `K_m` is maximum luminous efficacy (item 7-11.3), `V(\u03BB)` is spectral luminous efficiency (item 7-10.2) and `\u03BB` is wavelength. For scotopic and mesopic vision see 0.4 and 0.5. Symbols for different photometric conditions: `K(\u03BB)` for photopic vision>; `K\'(\u03BB)` for scotopic vision; `K_(mes;m)(\u03BB)` for mesopic vision; `K_10(\u03BB)` for the CIE 10\xB0 photopic photometric observer; `K_M(\u03BB)` for the CIE 1988 modified 2\xB0 spectral luminous efficiency function for photopic vision.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpectralLuminousEfficacyUnit[1];\n    }\n\n    attribute spectralLuminousEfficacy: SpectralLuminousEfficacyValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpectralLuminousEfficacyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-11.3 maximum luminous efficacy */\n    attribute def MaximumLuminousEfficacyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-11.3 maximum luminous efficacy\n         * symbol(s): `K_m`\n         * application domain: specified photometric condition\n         * name: MaximumLuminousEfficacy\n         * quantity dimension: L^-2*M^-1*T^3*J^1\n         * measurement unit(s): lm/W, cd*sr*kg^-1*m^-2*s^3\n         * tensor order: 0\n         * definition: maximum value of spectral luminous efficacy for a specified photometric condition\n         * remarks: See also 0.4 and 0.5. The value of maximum luminous efficacy for photopic vision is calculated by `K_m = 683 / (V(\u03BB_(cd))) ["cd"*"sr"*"W"^-1] = 683 ["lm"*"W"^-1]` where `V(\u03BB)` is the spectral luminous efficiency for photopic vision and `\u03BB_(cd)` is the wavelength in air corresponding to the frequency `540*10^12 ["Hz"]` specified in the definition of the SI unit candela. Symbols for different photometric conditions: `K_m` for photopic vision; `K\'_m` for scotopic vision; `K_(m,mes;m)` for mesopic vision; `K_(m,10)` for the CIE 10\xB0 photopic photometric observer; `K_(m,M)` for the CIE 1988 modified 2\xB0 spectral luminous efficiency function for photopic vision.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MaximumLuminousEfficacyUnit[1];\n    }\n\n    attribute maximumLuminousEfficacy: MaximumLuminousEfficacyValue[*] nonunique :> scalarQuantities;\n\n    attribute def MaximumLuminousEfficacyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-11.4 luminous efficacy of a source */\n    attribute def LuminousEfficacyOfASourceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-11.4 luminous efficacy of a source\n         * symbol(s): `\u03B7_v`, `(\u03B7)`\n         * application domain: generic\n         * name: LuminousEfficacyOfASource\n         * quantity dimension: L^-2*M^-1*T^3*J^1\n         * measurement unit(s): lm/W, cd*sr*kg^-1*m^-2*s^3\n         * tensor order: 0\n         * definition: quotient of the luminous flux emitted and the power consumed by the source, expressed by `\u03B7_v = \u03A6_v/P`, where `\u03A6_v` is luminous flux (item 7-13) and `P` is the power (ISO 80000-4) consumed by the source\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LuminousEfficacyOfASourceUnit[1];\n    }\n\n    attribute luminousEfficacyOfASource: LuminousEfficacyOfASourceValue[*] nonunique :> scalarQuantities;\n\n    attribute def LuminousEfficacyOfASourceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-12 luminous energy, quantity of light */\n    attribute def LuminousEnergyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-12 luminous energy, quantity of light\n         * symbol(s): `Q_v`, `(Q)`\n         * application domain: generic\n         * name: LuminousEnergy\n         * quantity dimension: T^1*J^1\n         * measurement unit(s): lm*s, cd*sr*s\n         * tensor order: 0\n         * definition: energy of electromagnetic waves weighted by the spectral luminous efficiency (item 7-10.2) multiplied by maximum luminous efficacy (item 7-11.3) of a specified photometric condition\n         * remarks: Luminous energy for photopic vision is expressed by `Q_v = K_m int_0^\u221E Q_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB`, where `Q_(e,\u03BB)(\u03BB)` is the spectral radiant energy (item 7-2.2) at wavelength `\u03BB` (ISO 80000-3), `V(\u03BB)` is spectral luminous efficiency (item 7-10.2), and `K_m` is maximum luminous efficacy (7-11.3). Luminous energy can be emitted, transferred or received. Luminous energy can be expressed by the time integral of the luminous flux (item 7-13), `\u03A6_v`, over a given duration (ISO 80000-3), `\u0394t`: `Q_v = int_(\u0394t) \u03A6_v dt` . The corresponding radiometric quantity is "radiant energy" (item 7-2.1). The corresponding quantity for photons is "photon energy" (item 7-19.2).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LuminousEnergyUnit[1];\n    }\n\n    attribute luminousEnergy: LuminousEnergyValue[*] nonunique :> scalarQuantities;\n\n    attribute def LuminousEnergyUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (durationPF, luminousIntensityPF); }\n    }\n\n    alias QuantityOfLightUnit for LuminousEnergyUnit;\n    alias QuantityOfLightValue for LuminousEnergyValue;\n    alias quantityOfLight for luminousEnergy;\n\n    /* ISO-80000-7 item 7-13 luminous flux */\n    attribute def LuminousFluxValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-13 luminous flux\n         * symbol(s): `\u03A6_v`, `(\u03A6)`\n         * application domain: generic\n         * name: LuminousFlux\n         * quantity dimension: J^1\n         * measurement unit(s): lm, cd*sr\n         * tensor order: 0\n         * definition: change in luminous energy with time, expressed by `\u03A6_v = (d Q_v)/(dt)`, where `Q_v` is the luminous energy (item 7-12) emitted, transferred or received and `t` is time (ISO 80000-3)\n         * remarks: Luminous flux is a quantity derived from the radiant flux (item 7-4.1), `\u03A6_e`, by evaluating the radiation according to its action upon the CIE standard photometric observer. (See CIE S 017/E:2011, term 17-738.) Luminous flux can be derived from the spectral radiant flux distribution by `\u03A6_v = K_m int_0^oo \u03A6_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB`, where `K_m` is maximum luminous efficacy (item 7-11.3), `\u03A6_(e,\u03BB)(\u03BB)` is spectral radiant flux (item 7-4.2), `V(\u03BB)` is spectral luminous efficiency (item 7-10.2) and `\u03BB` is wavelength (ISO 80000-3). The corresponding radiometric quantity is "radiant flux" (item 7-4.1). The corresponding quantity for photons is "photon flux" (item 7-20).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LuminousFluxUnit[1];\n    }\n\n    attribute luminousFlux: LuminousFluxValue[*] nonunique :> scalarQuantities;\n\n    attribute def LuminousFluxUnit :> DerivedUnit {\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = luminousIntensityPF; }\n    }\n\n    /* ISO-80000-7 item 7-14 luminous intensity */\n    /* See package ISQBase for the declarations of LuminousIntensityValue and LuminousIntensityUnit */\n\n    /* ISO-80000-7 item 7-15 luminance */\n    attribute def LuminanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-15 luminance\n         * symbol(s): `L_v`, `(L)`\n         * application domain: generic\n         * name: Luminance\n         * quantity dimension: L^-2*J^1\n         * measurement unit(s): cd*m^-2\n         * tensor order: 0\n         * definition: density of luminous intensity with respect to projected area in a specified direction at a specified point on a real or imaginary surface, expressed by `L_v = (dI_v)/(dA) 1/cos(\u03B1)`, where `I_v` is luminous intensity (item 7-14), `A` is area (ISO 80000-3) and `\u03B1` is the angle between the normal to the surface at the specified point and the specified direction\n         * remarks: Luminance can be derived from the spectral radiance distribution by `L_v = K_m int_0^\u221E L_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB`, where `K_m` is maximum luminous efficacy (item 7-11.3), `L_(e,\u03BB)(\u03BB)` is the spectral radiance (item 7-6.2) at wavelength `\u03BB` (ISO 80000-3), and `V(\u03BB)` is spectral luminous efficiency (item 7-10.2). See also 0.1. Integral limits can be confined depending on the spectral sensitivity of the detectors used as a sensor. The corresponding radiometric quantity is "radiance" (item 7-6.1). The corresponding quantity for photons is "photon radiance" (item 7-22).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LuminanceUnit[1];\n    }\n\n    attribute luminance: LuminanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def LuminanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-16 illuminance */\n    attribute def IlluminanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-16 illuminance\n         * symbol(s): `E_v`, `(E)`\n         * application domain: generic\n         * name: Illuminance\n         * quantity dimension: L^-2*J^1\n         * measurement unit(s): lx, cd*sr*m^-2\n         * tensor order: 0\n         * definition: density of incident luminous flux with respect to area at a point on a real or imaginary surface, expressed by `E_v = (d\u03A6_v)/(dA)`, where `\u03A6_v` is luminous flux (item 7-13) and `A` is the area (ISO 80000-3) on which the luminous flux is incident\n         * remarks: Illuminance can be derived from the spectral irradiance distribution by `E_v = K_m int_0^\u221E E_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB`, where `K_m` is maximum luminous efficacy (item 7-11.3), `E_(e,\u03BB)(\u03BB)` is the spectral irradiance (item 7-7.2) at wavelength `\u03BB` (ISO 80000-3), and `V(\u03BB)` is spectral luminous efficiency (item 7-10.2). Integral limits can be confined depending on the spectral sensitivity of the detectors used as a sensor. The corresponding radiometric quantity is "irradiance" (item 7-7.1). The corresponding quantity for photons is "photon irradiance" (item 7-23). The quantity "spherical illuminance" is defined by the mean value of illuminance on the outer curved surface of a very small (real or imaginary) sphere at a point in space. It can be expressed by `E_(v,0) = int_(4\u03C0) L_v d\u03A9`, where `\u03A9` is solid angle (ISO 80000-3) and `L_v` is luminance (item 7-15). It can be expressed by the quotient of the luminous flux (item 7-13) of all the light incident on the outer surface of an infinitely small sphere centred at the given point, and the area (ISO 80000-3) of the diametrical cross-section of that sphere.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: IlluminanceUnit[1];\n    }\n\n    attribute illuminance: IlluminanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def IlluminanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-17 luminous exitance */\n    attribute def LuminousExitanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-17 luminous exitance\n         * symbol(s): `M_v`, `(M)`\n         * application domain: generic\n         * name: LuminousExitance\n         * quantity dimension: L^-2*J^1\n         * measurement unit(s): lm/m^2, cd*sr*m^-2\n         * tensor order: 0\n         * definition: density of exiting luminous flux with respect to area at a point on a real or imaginary surface, expressed by `M_v = (d\u03A6_v)/(dA)`, where `\u03A6_v` is luminous flux (item 7-13) and `A` is the area (ISO 80000-3) from which the luminous flux leaves\n         * remarks: Luminous exitance can be derived from the spectral radiant exitance distribution by `M_v = K_m int_0^\u221E M_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB`, where `K_m` is maximum luminous efficacy (item 7-11.3), `M_(e_\u03BB)(\u03BB)` is the spectral radiant exitance (item 7-8.2) at wavelength \u03BB(ISO 80000-3), and `V(\u03BB)` is spectral luminous efficiency (item 7-10.2). Integral limits can be confined depending on the spectral sensitivity of the detectors used as a sensor. The corresponding radiometric quantity is "radiant exitance" (item 7-8.1). The corresponding quantity for photons is "photon exitance" (item 7-24).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LuminousExitanceUnit[1];\n    }\n\n    attribute luminousExitance: LuminousExitanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def LuminousExitanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-18 luminous exposure, quantity of illumination, light exposure */\n    attribute def LuminousExposureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-18 luminous exposure, quantity of illumination, light exposure\n         * symbol(s): `H_v`, `(H)`\n         * application domain: generic\n         * name: LuminousExposure\n         * quantity dimension: L^-2*T^1*J^1\n         * measurement unit(s): lx*s, cd*sr*m^-2*s\n         * tensor order: 0\n         * definition: density of incident luminous energy with respect to area at a point on a real or imaginary surface, expressed by `H_v = (dQ_v)/(dA)`, where `Q_v` is luminous energy (item 7-12) and `A` is the area on which the luminous energy is incident (ISO 80000-3)\n         * remarks: Luminous exposure can be derived from the spectral radiant exposure distribution by `H_v = K_m int_0^\u221E H_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB`, where `K_m` is maximum luminous efficacy (item 7-11.3), `H_(e_\u03BB)(\u03BB)` is the spectral radiant exposure (item 7-9.2) at wavelength \u03BB(ISO 80000-3), and `V(\u03BB)` is spectral luminous efficiency (item 7-10.2). Integral limits can be confined depending on the spectral sensitivity of the detectors used as a sensor. The corresponding radiometric quantity is "radiant exposure" (item 7-9.1). The corresponding quantity for photons is "photon exposure" (item 7-25).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LuminousExposureUnit[1];\n    }\n\n    attribute luminousExposure: LuminousExposureValue[*] nonunique :> scalarQuantities;\n\n    attribute def LuminousExposureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 1; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, luminousIntensityPF); }\n    }\n\n    alias QuantityOfIlluminationUnit for LuminousExposureUnit;\n    alias QuantityOfIlluminationValue for LuminousExposureValue;\n    alias quantityOfIllumination for luminousExposure;\n\n    alias LightExposureUnit for LuminousExposureUnit;\n    alias LightExposureValue for LuminousExposureValue;\n    alias lightExposure for luminousExposure;\n\n    /* ISO-80000-7 item 7-19.1 photon number, number of photons */\n    attribute def PhotonNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-19.1 photon number, number of photons\n         * symbol(s): `N_p`\n         * application domain: generic\n         * name: PhotonNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of radiant energy and photon energy, expressed by `N_p = Q_e/(h \u03BD)`, where `Q_e` is radiant energy (item 7-2.1), `h` is the Planck constant (ISO 80000-1), and `\u03BD` is the frequency (ISO 80000-3) of the corresponding electromagnetic wave\n         * remarks: Photon number can also be expressed by the time integral of the photon flux (item 7-20), `\u03A6_p`, over a given duration, `\u0394t`, `N_p = int_(\u0394t) \u03A6_p dt`\n         */\n    }\n    attribute photonNumber: PhotonNumberValue :> scalarQuantities;\n\n    alias numberOfPhotons for photonNumber;\n\n    /* ISO-80000-7 item 7-19.2 photon energy */\n    attribute photonEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 7-19.2 photon energy\n         * symbol(s): `Q_p`, `(Q)`\n         * application domain: generic\n         * name: PhotonEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: product of the Planck constant and frequency, expressed by `Q_p = h \u03BD` where `h` is the Planck constant (ISO 80000-1) and `\u03BD` is the frequency (ISO 80000-3) of the corresponding electromagnetic wave\n         * remarks: Photon energy can be emitted, transferred or received. For monochromatic radiation, photon energy may be expressed by photon number (item 7-19.1). The corresponding radiometric quantity is "radiant energy" (item 7-2.1). The corresponding photometric quantity is "luminous energy" (item 7-12).\n         */\n    }\n\n    /* ISO-80000-7 item 7-20 photon flux */\n    attribute def PhotonFluxValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-20 photon flux\n         * symbol(s): `\u03A6_p`, `(\u03A6)`\n         * application domain: generic\n         * name: PhotonFlux\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: rate of photon number per time interval, expressed by `\u03A6_p = (d N_p)/(dt)`, where `N_p` is photon number (e.g. given by item 7-19.1), transmitted or received, and `t` is time (ISO 80000-3)\n         * remarks: Photon flux `\u03A6_p` is related to radiant flux (item 7-4.1), `\u03A6_e`, of monochromatic radiation, by `\u03A6_p = \u03A6_e/(h \u03BD)` where `h` is the Planck constant (ISO 80000-1), and `\u03BD` is the frequency (ISO 80000-3) of the corresponding electromagnetic wave. The corresponding radiometric quantity is "radiant flux" (item 7-4.1). The corresponding photometric quantity is "luminous flux" (item 7-13).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhotonFluxUnit[1];\n    }\n\n    attribute photonFlux: PhotonFluxValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhotonFluxUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-7 item 7-21 photon intensity */\n    attribute def PhotonIntensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-21 photon intensity\n         * symbol(s): `I_p`, `(I)`\n         * application domain: generic\n         * name: PhotonIntensity\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1*sr^-1\n         * tensor order: 0\n         * definition: density of photon flux with respect to solid angle in a specified direction, expressed by `I_p = (d\u03A6_p)/(d\u03A9)`, where `\u03A6_p` is the photon flux (item 7-20) emitted in the given direction, and `\u03A9` is the solid angle (ISO 80000-3) containing that direction\n         * remarks: The distribution of the photon intensities as a function of the direction of emission, e.g. given by the polar angles `(\u03B8,\u03D5)` , is used to determine the photon flux (item 7-20) within a certain solid angle (ISO 80000-3) `\u03A9` of a source: `\u03A6_p = int int_\u03A9 I_v(\u03B8,\u03D5) sin(\u03B8) d\u03D5 d\u03B8`. The corresponding radiometric quantity is "radiant intensity" (item 7-5.1). The corresponding photometric quantity is "luminous intensity" (item 7-14).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhotonIntensityUnit[1];\n    }\n\n    attribute photonIntensity: PhotonIntensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhotonIntensityUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-7 item 7-22 photon radiance */\n    attribute def PhotonRadianceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-22 photon radiance\n         * symbol(s): `L_p`, `(L)`\n         * application domain: generic\n         * name: PhotonRadiance\n         * quantity dimension: L^-2*T^-1\n         * measurement unit(s): m^-2*s^-1*sr^-1\n         * tensor order: 0\n         * definition: density of photon intensity with respect to projected area in a specified direction at a specified point on a real or imaginary surface, expressed by `L_p = (dI_p)/(dA) 1/cos(\u03B1)`, where `I_p` is photon intensity (item 7-21), `A` is area (ISO 80000-3) and `\u03B1` the angle between the normal to the surface at the specified point and the specified direction\n         * remarks: The corresponding radiometric quantity is "radiance" (item 7-6.1). The corresponding photometric quantity is "luminance" (item 7-15).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhotonRadianceUnit[1];\n    }\n\n    attribute photonRadiance: PhotonRadianceValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhotonRadianceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-23 photon irradiance */\n    attribute def PhotonIrradianceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-23 photon irradiance\n         * symbol(s): `E_p`, `(E)`\n         * application domain: generic\n         * name: PhotonIrradiance\n         * quantity dimension: L^-2*T^-1\n         * measurement unit(s): m^-2*s^-1\n         * tensor order: 0\n         * definition: density of incident photon flux with respect to area at a point on a real or imaginary surface, expressed by `E_p = (d\u03A6_p)/(dA)`, where `\u03A6_p` is photon flux (item 7-20) and `A` is the area (ISO 80000-3) on which the photon flux is incident\n         * remarks: The corresponding radiometric quantity is "irradiance" (item 7-7.1). The corresponding photometric quantity is "illuminance" (item 7-16).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhotonIrradianceUnit[1];\n    }\n\n    attribute photonIrradiance: PhotonIrradianceValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhotonIrradianceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-24 photon exitance */\n    attribute def PhotonExitanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-24 photon exitance\n         * symbol(s): `M_p`, `(M)`\n         * application domain: generic\n         * name: PhotonExitance\n         * quantity dimension: L^-2*T^-1\n         * measurement unit(s): m^-2*s^-1\n         * tensor order: 0\n         * definition: density of exiting photon flux with respect to area at a point on a real or imaginary surface, expressed by `M_p = (d\u03A6_p)/(dA)`, where `\u03A6_p` is photon flux (item 7-20) and `A` is the area (ISO 80000-3) from which the photon flux leaves\n         * remarks: The corresponding radiometric quantity is "radiant exitance" (item 7-8.1). The corresponding photometric quantity is "luminous exitance" (item 7-17).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhotonExitanceUnit[1];\n    }\n\n    attribute photonExitance: PhotonExitanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhotonExitanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-7 item 7-25 photon exposure */\n    attribute def PhotonExposureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-25 photon exposure\n         * symbol(s): `H_p`, `(H)`\n         * application domain: generic\n         * name: PhotonExposure\n         * quantity dimension: L^-2\n         * measurement unit(s): m^-2\n         * tensor order: 0\n         * definition: density of incident photon number with respect to area at a point on a real or imaginary surface, expressed by `H_p = (dN_p)/(dA)`, where `N_p` is photon number (item 7-19.1) and `A` is the area (ISO 80000-3) on which the photons are incident\n         * remarks: The corresponding radiometric quantity is "radiant exposure" (item 7-9.1). The corresponding photometric quantity is "luminous exposure" (item 7-18).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhotonExposureUnit[1];\n    }\n\n    attribute photonExposure: PhotonExposureValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhotonExposureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-7 item 7-26.1 tristimulus values for the CIE 1931 standard colorimetric observer */\n    attribute def TristimulusValuesForTheCie1931StandardColorimetricObserverValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-26.1 tristimulus values for the CIE 1931 standard colorimetric observer\n         * symbol(s): `X,Y,Z`\n         * application domain: generic\n         * name: TristimulusValuesForTheCie1931StandardColorimetricObserver\n         * quantity dimension: L^-2*J^1\n         * measurement unit(s): cd*m^-2\n         * tensor order: 0\n         * definition: amounts of the three reference colour stimuli in the CIE 1931 standard colorimetric system, required to match the colour of the stimulus considered\n         * remarks: For a given colour stimulus described by the colour stimulus function `\u03C6_\u03BB(\u03BB)` of a radiometric quantity, `X = k int_0^\u221E \u03C6_\u03BB(\u03BB) overline x(\u03BB) d\u03BB`, `Y = k int_0^\u221E \u03C6_\u03BB(\u03BB) overline y(\u03BB) d\u03BB`, `Z = k int_0^\u221E \u03C6_\u03BB(\u03BB) overline z(\u03BB) d\u03BB`, where `overline x(\u03BB)`, `overline y(\u03BB)`, `overline z(\u03BB)` are the CIE colour-matching functions for the CIE 1931 standard colorimetric observer (2\xB0 observer) (item 7-27.1). For sources, `k` may be chosen as `k = K_m` where `K_m` is the maximum luminous efficacy (item 7-11.3) so that `Y = L_v` (item 7-15) and the unit of `X`, `Y`, `Z` is `[cd*m^-2]`. For object colours, `\u03C6_\u03BB(\u03BB)` is given by one of the three products `\u03C6_\u03BB(\u03BB) = S_\u03BB(\u03BB) * {(\u03C1(\u03BB)), (\u03C4(\u03BB)), (\u03B2(\u03BB)):}` where `S_\u03BB(\u03BB)` is the relative spectral distribution of a quantity characterizing the source illuminating the object, `\u03C1(\u03BB)` is the spectral reflectance, `\u03C4(\u03BB)` is the spectral transmittance, `\u03B2(\u03BB)` is the spectral radiance factor, and `k` is chosen to be `k = 100 // int_0^\u221E S_\u03BB(\u03BB) overline y(\u03BB) d\u03BB`. Integral limits can be confined depending on the spectral sensitivity of the detectors used as a sensor. In this case, the unit of `X`, `Y`, `Z` is `[1]`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TristimulusValuesForTheCie1931StandardColorimetricObserverUnit[1];\n    }\n\n    attribute tristimulusValuesForTheCie1931StandardColorimetricObserver: TristimulusValuesForTheCie1931StandardColorimetricObserverValue[*] nonunique :> scalarQuantities;\n\n    attribute def TristimulusValuesForTheCie1931StandardColorimetricObserverUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-26.2 tristimulus values for the CIE 1964 standard colorimetric observer */\n    attribute def TristimulusValuesForTheCie1964StandardColorimetricObserverValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-26.2 tristimulus values for the CIE 1964 standard colorimetric observer\n         * symbol(s): `X_10,Y_10,Z_10`\n         * application domain: generic\n         * name: TristimulusValuesForTheCie1964StandardColorimetricObserver\n         * quantity dimension: L^-2*J^1\n         * measurement unit(s): cd*m^-2\n         * tensor order: 0\n         * definition: amounts of the three reference colour stimuli in the CIE 1964 standard colorimetric system, required to match the colour of the stimulus considered\n         * remarks: For a given colour stimulus described by the colour stimulus function `\u03C6_\u03BB(\u03BB)` of a radiometric quantity, `X = k int_0^\u221E \u03C6_\u03BB(\u03BB) overline x(\u03BB) d\u03BB`, `Y = k int_0^\u221E \u03C6_\u03BB(\u03BB) overline y(\u03BB) d\u03BB`, `Z = k int_0^\u221E \u03C6_\u03BB(\u03BB) overline z(\u03BB) d\u03BB`, where `overline x(\u03BB)`, `overline y(\u03BB)`, `overline z(\u03BB)` are the CIE colour-matching functions for the CIE 1931 standard colorimetric observer (2\xB0 observer) (item 7-27.1). For sources, `k` may be chosen as `k = K_m` where `K_m` is the maximum luminous efficacy (item 7-11.3) so that `Y = L_v` (item 7-15) and the unit of `X`, `Y`, `Z` is `["cd"*"m"^-2]`. For object colours, `\u03C6_\u03BB(\u03BB)` is given by one of the three products `\u03C6_\u03BB(\u03BB) = S_\u03BB(\u03BB) * {(\u03C1(\u03BB)), (\u03C4(\u03BB)), (\u03B2(\u03BB)):}` where `S_\u03BB(\u03BB)` is the relative spectral distribution of a quantity characterizing the source illuminating the object, `\u03C1(\u03BB)` is the spectral reflectance, `\u03C4(\u03BB)` is the spectral transmittance, `\u03B2(\u03BB)` is the spectral radiance factor, and `k` is chosen to be `k = 100 /( int_0^\u221E S_\u03BB(\u03BB) overline y(\u03BB) d\u03BB)`. Integral limits can be confined depending on the spectral sensitivity of the detectors used as a sensor. In this case, the unit of `X`, `Y`, `Z` is `[1]`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TristimulusValuesForTheCie1964StandardColorimetricObserverUnit[1];\n    }\n\n    attribute tristimulusValuesForTheCie1964StandardColorimetricObserver: TristimulusValuesForTheCie1964StandardColorimetricObserverValue[*] nonunique :> scalarQuantities;\n\n    attribute def TristimulusValuesForTheCie1964StandardColorimetricObserverUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute luminousIntensityPF: QuantityPowerFactor[1] { :>> quantity = isq.J; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, luminousIntensityPF); }\n    }\n\n    /* ISO-80000-7 item 7-27.1 CIE colour-matching functions for the CIE 1931 standard colorimetric observer */\n    attribute def CieColourMatchingFunctionsForTheCie1931StandardColorimetricObserverValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-27.1 CIE colour-matching functions for the CIE 1931 standard colorimetric observer\n         * symbol(s): `overline x(\u03BB)`, `overline y(\u03BB)`, `overline z(\u03BB)`\n         * application domain: generic\n         * name: CieColourMatchingFunctionsForTheCie1931StandardColorimetricObserver (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: functions `overline x(\u03BB)` , `overline y(\u03BB)` , `overline z(\u03BB)` in the CIE 1931 standard colorimetric system\n         * remarks: Values of `overline x(\u03BB)` , `overline y(\u03BB)` and `overline z(\u03BB)` are defined in the CIE 1931 standard colorimetric system (2\xB0 observer) \u2014 applicable to fields of observation of angular opening from 1\xB0 to 4\xB0.\n         */\n    }\n    attribute cieColourMatchingFunctionsForTheCie1931StandardColorimetricObserver: CieColourMatchingFunctionsForTheCie1931StandardColorimetricObserverValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-27.2 CIE colour-matching functions for the CIE 1964 standard colorimetric observer */\n    attribute def CieColourMatchingFunctionsForTheCie1964StandardColorimetricObserverValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-27.2 CIE colour-matching functions for the CIE 1964 standard colorimetric observer\n         * symbol(s): `overline x_10(\u03BB)`, `overline y_10(\u03BB)`, `overline z_10(\u03BB)`\n         * application domain: generic\n         * name: CieColourMatchingFunctionsForTheCie1964StandardColorimetricObserver (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: functions `overline x_10(\u03BB)` , `overline y_10(\u03BB)` , `overline z_10(\u03BB)` in the CIE 1964 standard colorimetric system\n         * remarks: Values of `overline x_10(\u03BB)` , `overline y_10(\u03BB)` and `overline z_10(\u03BB)` are defined in the CIE 1964 standard colorimetric system (10\xB0 observer) \u2014 applicable to fields of observation with angles greater than 4\xB0.\n         */\n    }\n    attribute cieColourMatchingFunctionsForTheCie1964StandardColorimetricObserver: CieColourMatchingFunctionsForTheCie1964StandardColorimetricObserverValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-28.1 chromaticity coordinates in the CIE 1931 standard colorimetric system */\n    attribute def ChromaticityCoordinatesInTheCie1931StandardColorimetricSystemValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-28.1 chromaticity coordinates in the CIE 1931 standard colorimetric system\n         * symbol(s): `x,y,z`\n         * application domain: generic\n         * name: ChromaticityCoordinatesInTheCie1931StandardColorimetricSystem (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: coordinates expressing the quotients of each of a set of three tristimulus values for the CIE 1931 standard colorimetric observer (item 7-26.1) and their sum, expressed by `x = X / (X+Y+Z)` , `y = Y / (X+Y+Z)` , `z = Z / (X+Y+Z)`\n         * remarks: Since `x + y + z = 1`, two variables are sufficient to express chromaticity.\n         */\n    }\n    attribute chromaticityCoordinatesInTheCie1931StandardColorimetricSystem: ChromaticityCoordinatesInTheCie1931StandardColorimetricSystemValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-28.2 chromaticity coordinates in the CIE 1964 standard colorimetric system */\n    attribute def ChromaticityCoordinatesInTheCie1964StandardColorimetricSystemValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-28.2 chromaticity coordinates in the CIE 1964 standard colorimetric system\n         * symbol(s): `x_10,y_10,z_10`\n         * application domain: generic\n         * name: ChromaticityCoordinatesInTheCie1964StandardColorimetricSystem (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: coordinates expressing the quotients of each of a set of three tristimulus values for the CIE 1964 standard colorimetric observer (item 7-26.2) and their sum, expressed by `x_10 = X_10 / (X_10+Y_10+Z_10)`, `y_10 = Y_10 / (X_10+Y_10+Z_10)`, `z_10 = Z_10 / (X_10+Y_10+Z_10)`\n         * remarks: Since `x_10 + y_10 + z_10 = 1`, two variables are sufficient to express chromaticity.\n         */\n    }\n    attribute chromaticityCoordinatesInTheCie1964StandardColorimetricSystem: ChromaticityCoordinatesInTheCie1964StandardColorimetricSystemValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-29.1 colour temperature */\n    attribute colourTemperature: ThermodynamicTemperatureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 7-29.1 colour temperature\n         * symbol(s): `T_c`\n         * application domain: generic\n         * name: ColourTemperature (specializes ThermodynamicTemperature)\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: temperature of a Planckian radiator whose radiation has the same chromaticity as that of a given stimulus\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-7 item 7-29.2 correlated colour temperature */\n    attribute correlatedColourTemperature: ThermodynamicTemperatureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 7-29.2 correlated colour temperature\n         * symbol(s): `T_"cp"`\n         * application domain: generic\n         * name: CorrelatedColourTemperature (specializes ThermodynamicTemperature)\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: temperature of a Planckian radiator having the chromaticity nearest the chromaticity associated with the given spectral distribution on a modified 1976 CIE Uniform Chromaticity Scale (UCS) diagram where `u\',2/3 v\'` are the coordinates of the Planckian locus and the test stimulus\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-7 item 7-30.1 emissivity */\n    attribute def EmissivityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-30.1 emissivity\n         * symbol(s): `\u03B5`, `\u03B5_T`\n         * application domain: generic\n         * name: Emissivity (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the radiant exitance of a radiator and the radiant exitance of a Planckian radiator at the same temperature, expressed by `\u03B5 = M/M_b`, where `M` is the radiant exitance (item 7-8.1) of a thermal radiator and `M_b` is the radiant exitance of a Planckian radiator at the same temperature (ISO 80000-5)\n         * remarks: None.\n         */\n    }\n    attribute emissivity: EmissivityValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-30.2 emissivity at a specified wavelength */\n    attribute def EmissivityAtASpecifiedWavelengthValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-30.2 emissivity at a specified wavelength\n         * symbol(s): `\u03B5(\u03BB)`\n         * application domain: generic\n         * name: EmissivityAtASpecifiedWavelength (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the radiant exitance of a radiator at a specified wavelength and the radiant exitance of a Planckian radiator at the same temperature and at the same wavelength, expressed by `\u03B5(\u03BB) = M(\u03BB) / M_b(\u03BB)`, where `M(\u03BB)` is the radiant exitance (item 7-8.1) of a thermal radiator at a specified wavelength and `M_b(\u03BB)` is the radiant exitance of a Planckian radiator at the same temperature at a specified wavelength (ISO 80000-3)\n         * remarks: None.\n         */\n    }\n    attribute emissivityAtASpecifiedWavelength: EmissivityAtASpecifiedWavelengthValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-31.1 absorptance */\n    attribute def AbsorptanceValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-31.1 absorptance\n         * symbol(s): `\u03B1`, `a`\n         * application domain: generic\n         * name: Absorptance (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of absorbed radiant flux and incident radiant flux, expressed by `\u03B1 = \u03A6_a/\u03A6_m`, where `\u03A6_a` is absorbed radiant flux (item 7-4.1) and `\u03A6_m` is incident radiant flux\n         * remarks: This quantity is also defined spectrally in terms of wavelength, in which case "spectral" is added before the quantity name. Due to energy conservation, `\u03B1 + \u03C1 + \u03C4 = 1` except when polarized radiation is observed, where `\u03C1` is reflectance (item 7-31.3) and `\u03C4` is transmittance (item 7-31.5).\n         */\n    }\n    attribute absorptance: AbsorptanceValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-31.2 luminous absorptance */\n    attribute def LuminousAbsorptanceValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-31.2 luminous absorptance\n         * symbol(s): `\u03B1_v`\n         * application domain: generic\n         * name: LuminousAbsorptance (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of absorbed luminous flux and incident luminous flux, expressed by `\u03B1_v = \u03A6_(v,a)/\u03A6_(v,m)`, where `\u03A6_(v,a)` is absorbed luminous flux (item 7-13) and `\u03A6_(v,m)` is incident luminous flux\n         * remarks: From spectral absorptance, `\u03B1(\u03BB)`, luminous absorptance can be calculated by `\u03B1_v = (int_0^\u221E \u03B1(\u03BB) \u03A6_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB)/(int_0^\u221E \u03A6_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB)`, where `\u03A6_(e,\u03BB)(\u03BB)` is spectral radiant flux (or relative spectral distribution) of the source, and `V(\u03BB)` is spectral luminous efficiency (item 7-10.2). See also item 7-31.1.\n         */\n    }\n    attribute luminousAbsorptance: LuminousAbsorptanceValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-31.3 reflectance */\n    attribute def ReflectanceValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-31.3 reflectance\n         * symbol(s): `\u03C1`\n         * application domain: generic\n         * name: Reflectance (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of reflected radiant flux and incident radiant flux, expressed by `\u03C1 = \u03A6_r/\u03A6_m`, where `\u03A6_r` is reflected radiant flux (item 7-4.1) and `\u03A6_m` is incident radiant flux\n         * remarks: This quantity is also defined spectrally in terms of wavelength, in which case, "spectral" is added before the quantity name. Due to energy conservation, `\u03B1 + \u03C1 + \u03C4 = 1` except when polarized radiation is observed, where `\u03B1` is absorptance (item 7-31.1) and `\u03C4` is transmittance (item 7-31.5).\n         */\n    }\n    attribute reflectance: ReflectanceValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-31.4 luminous reflectance */\n    attribute def LuminousReflectanceValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-31.4 luminous reflectance\n         * symbol(s): `\u03C1_v`\n         * application domain: generic\n         * name: LuminousReflectance (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of reflected luminous flux and incident luminous flux, is expressed by `\u03C1_v = \u03A6_(v,r)/\u03A6_(v,m)`, where `\u03A6_(v,r)` is reflected luminous flux (item 7-13) and `\u03A6_(v,m)` is incident luminous flux\n         * remarks: From spectral reflectance, `\u03C1(\u03BB)`, luminous reflectance can be calculated by `\u03C1_v = (int_0^\u221E \u03C1(\u03BB) \u03A6_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB)/(int_0^\u221E \u03A6_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB)`, where `\u03A6_(e,\u03BB)(\u03BB)` is spectral radiant flux (or relative spectral distribution) of the source, and `V(\u03BB)` is spectral luminous efficiency (item 7-10.2). See also item 7-31.3.\n         */\n    }\n    attribute luminousReflectance: LuminousReflectanceValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-31.5 transmittance */\n    attribute def TransmittanceValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-31.5 transmittance\n         * symbol(s): `\u03C4`, `T`\n         * application domain: generic\n         * name: Transmittance (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of transmitted radiant flux and incident radiant flux, expressed by `\u03C4 = \u03A6_t/\u03A6_m`, where `\u03A6_t` is transmitted radiant flux (item 7-4.1) and `\u03A6_m` is incident radiant flux\n         * remarks: This quantity is also defined spectrally in terms of wavelength, in which case, "spectral" is added before the quantity name. Due to energy conservation, `\u03B1 + \u03C1 + \u03C4 = 1` except when polarized radiation is observed, where `\u03B1` is absorptance (item 7-31.1) and `\u03C1` is reflectance (item 7-31.3).\n         */\n    }\n    attribute transmittance: TransmittanceValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-31.6 luminous transmittance */\n    attribute def LuminousTransmittanceValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-31.6 luminous transmittance\n         * symbol(s): `\u03C4_v`\n         * application domain: generic\n         * name: LuminousTransmittance (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of transmitted luminous flux and incident luminous flux, expressed by `\u03C4_v = \u03A6_(v,t)/\u03A6_(v,m)`, where `\u03A6_(v,t)` is transmitted luminous flux (item 7-13) and `\u03A6_(v,m)` is luminous flux of the incident radiation\n         * remarks: From the spectral transmittance `\u03C4(\u03BB)`, luminous transmittance can be calculated by `\u03C4_v = (int_0^\u221E \u03C4(\u03BB) \u03A6_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB)/(int_0^\u221E \u03A6_(e,\u03BB)(\u03BB) V(\u03BB) d\u03BB)`, where `\u03A6_(e,\u03BB)(\u03BB)` is the spectral radiant flux (or relative spectral distribution) of the source, and `V(\u03BB)` is the spectral luminous efficiency (item 7-10.2). See also item 7-31.5.\n         */\n    }\n    attribute luminousTransmittance: LuminousTransmittanceValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-32.1 transmittance optical density, optical density, transmittance density, decadic absorbance */\n    attribute def TransmittanceOpticalDensityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-32.1 transmittance optical density, optical density, transmittance density, decadic absorbance\n         * symbol(s): `D`, `A_10`, `D_\u03C4`\n         * application domain: generic\n         * name: TransmittanceOpticalDensity (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: logarithm to base 10 of the reciprocal of the transmittance, `\u03C4` (item 7-31.5)\n         * remarks: If defined in terms of wavelength, the optical density can be expressed by `A_10(\u03BB) = -log(\u03C4(\u03BB))`, where `\u03C4(\u03BB)` is the transmittance (item 7-31.5) in terms of wavelength. In spectroscopy, the name "absorbance" `A_10` is generally used.\n         */\n    }\n    attribute transmittanceOpticalDensity: TransmittanceOpticalDensityValue :> scalarQuantities;\n\n    alias opticalDensity for transmittanceOpticalDensity;\n\n    alias transmittanceDensity for transmittanceOpticalDensity;\n\n    alias decadicAbsorbance for transmittanceOpticalDensity;\n\n    /* ISO-80000-7 item 7-32.2 Napierian absorbance */\n    attribute def NapierianAbsorbanceValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-32.2 Napierian absorbance\n         * symbol(s): `A_n`, `B`\n         * application domain: generic\n         * name: NapierianAbsorbance (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: natural (Napierian) logarithm of the reciprocal of the transmittance, `\u03C4` (item 7-31.5)\n         * remarks: If defined in terms of wavelength, the Napierian absorbance can be expressed by `A_n(\u03BB) = B(\u03BB) = -log(\u03C4(\u03BB))`. It can also be expressed as `A_n(\u03BB) = l*\u03B1(\u03BB)`, where `\u03B1` is linear absorption coefficient (item 7-35.2) and `l` is length (ISO 80000-3) traversed.\n         */\n    }\n    attribute napierianAbsorbance: NapierianAbsorbanceValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-33.1 radiance factor */\n    attribute def RadianceFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-33.1 radiance factor\n         * symbol(s): `\u03B2_e`, `(\u03B2)`\n         * application domain: generic\n         * name: RadianceFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the radiance of a surface element in a specified direction and the radiance of the perfect reflecting diffuser or perfect transmitting diffuser identically irradiated and viewed, expressed by `\u03B2_e = L_(e,n)/L_(e,d)`, where `L_(e,n)` is the radiance (item 7-6.1) of a surface element in a given direction and `L_(e,d)` is the radiance of the perfect reflecting or transmitting diffuser identically irradiated and viewed\n         * remarks: The definition holds for a surface element of a non-self-radiating medium, in a given direction and under specified conditions of irradiation. Radiance factor is equivalent to reflectance factor (item 7-34) or luminance factor (item 7-33.2) when the cone angle is infinitely small, and is equivalent to reflectance (item 7-31.3) when the cone angle is `2\u03C0 ["sr"]`. These quantities are also defined spectrally and called spectral radiance factor `\u03B2(\u03BB)` and spectral reflectance factor `R(\u03BB)`. The ideal isotropic (Lambertian) diffuser with reflectance (item 7-31.3) or transmittance (item 7-31.5) equal to 1 is called "perfect diffuser".\n         */\n    }\n    attribute radianceFactor: RadianceFactorValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-33.2 luminance factor */\n    attribute def LuminanceFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-33.2 luminance factor\n         * symbol(s): `\u03B2_v`, `(\u03B2)`\n         * application domain: generic\n         * name: LuminanceFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the luminance of a surface element in a specified direction and the luminance of the perfect reflecting diffuser or perfect transmitting diffuser identically illuminated and viewed, expressed by `\u03B2_v = L_(v,n)/L_(v,d)`, where `L_(v,n)` is the luminance (item 7-15) of a surface element in a given direction and `L_(v,d)` is the luminance of the perfect reflecting or transmitting diffuser identically illuminated and viewed\n         * remarks: The definition holds for a surface element of a non-luminous medium, in a given direction and under specified conditions of irradiation. This quantity is also defined spectrally and is called "spectral luminance factor". For the analogous radiant quantity "radiance factor", see item 7-33.1.\n         */\n    }\n    attribute luminanceFactor: LuminanceFactorValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-34 reflectance factor */\n    attribute def ReflectanceFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 7-34 reflectance factor\n         * symbol(s): `R`\n         * application domain: generic\n         * name: ReflectanceFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of the flux reflected in the directions delimited by a given cone with apex at a surface element and the flux reflected in the same directions by a perfect reflecting diffuser identically irradiated or illuminated, expressed by `R = \u03A6_n/\u03A6_d`, where `\u03A6_n` is the flux reflected in the directions delimited by a given cone and `\u03A6_d` is the flux reflected in the same directions by an identically irradiated diffuser of reflectance (item 7-31.3) equal to 1\n         * remarks: The flux can be a radiant flux (item 7\u20104.1) or a luminous flux (item 7\u201013). The definition holds for a surface element, for the part of the reflected radiation contained in a given cone with apex at the surface element, and for incident radiation of given spectral composition, polarization and geometric distribution. Reflectance factor is equivalent to radiance factor (item 7-33.1) or luminance factor (item 7-33.2) when the cone angle is infinitely small, and is equivalent to reflectance (item 7-31.3) when the cone angle is 2\u03C0 sr. These quantities are also defined spectrally and called spectral radiance factor `\u03B2(\u03BB)` and spectral reflectance factor `R(\u03BB)`. The ideal isotropic (Lambertian) diffuser with reflectance (item 7-31.3) or transmittance (item 7-31.5) equal to 1 is called a perfect diffuser.\n         */\n    }\n    attribute reflectanceFactor: ReflectanceFactorValue :> scalarQuantities;\n\n    /* ISO-80000-7 item 7-35.1 linear attenuation coefficient, linear extinction coefficient */\n    attribute def LinearAttenuationCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-35.1 linear attenuation coefficient, linear extinction coefficient\n         * symbol(s): `\u03BC`, `\u03BC_l`\n         * application domain: radiometry\n         * name: LinearAttenuationCoefficient\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: relative decrease in radiant flux caused by absorption and scattering\n         * remarks: This quantity is also defined spectrally in terms of wavelength, in which case, "spectral" is added before this quantity name. The spectral linear attenuation coefficient can be expressed by the relative decrease in the spectral radiant flux, `\u03A6_(e,\u03BB)(\u03BB)`, with respect to propagation length, `l`, of a collimated beam at a point in an absorbing and scattering medium `\u03BC(\u03BB) = 1/(\u03A6_(e,\u03BB)(\u03BB)) (d \u03A6_(e,\u03BB)(\u03BB))/(dl)`. Similarly, luminous and photon quantities can be defined.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearAttenuationCoefficientUnit[1];\n    }\n\n    attribute linearAttenuationCoefficient: LinearAttenuationCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearAttenuationCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    alias LinearExtinctionCoefficientUnit for LinearAttenuationCoefficientUnit;\n    alias LinearExtinctionCoefficientValue for LinearAttenuationCoefficientValue;\n    alias linearExtinctionCoefficient for linearAttenuationCoefficient;\n\n    /* ISO-80000-7 item 7-35.2 linear absorption coefficient */\n    attribute def LinearAbsorptionCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-35.2 linear absorption coefficient\n         * symbol(s): `\u03B1_l`, `a_l`, `\u03B1`\n         * application domain: radiometry\n         * name: LinearAbsorptionCoefficient\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: relative decrease in radiant flux (item 7-4.1) caused by absorption\n         * remarks: This quantity is also defined spectrally in terms of wavelength, in which case, "spectral" is added before this quantity name. The spectral linear absorption coefficient can be expressed by the relative decrease in the spectral radiant flux, `\u03A6_(e,\u03BB)(\u03BB)`, with respect to propagation length, `l`, of a collimated beam at a point in an absorbing medium `\u03B1_l(\u03BB) = 1/(\u03A6_(e,\u03BB)(\u03BB)) (d \u03A6_(e,\u03BB)(\u03BB))/(dl)`. It can also be expressed as a function of transmittance (item 7-31.5). `\u03B1_l = -ln(\u03C4)/l = A_n/l`. The linear absorption coefficient is that part of the linear attenuation coefficient (item 7-35.1) that is due to absorption. Scattering might also contribute. Similarly, luminous and photon quantities can be defined.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearAbsorptionCoefficientUnit[1];\n    }\n\n    attribute linearAbsorptionCoefficient: LinearAbsorptionCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearAbsorptionCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-7 item 7-36.1 mass attenuation coefficient */\n    attribute def MassAttenuationCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-36.1 mass attenuation coefficient\n         * symbol(s): `\u03BC_m`\n         * application domain: radiometry\n         * name: MassAttenuationCoefficient\n         * quantity dimension: L^2*M^-1\n         * measurement unit(s): kg^-1*m^2\n         * tensor order: 0\n         * definition: quotient of the linear attenuation coefficient (item 7-35.1), `\u03BC`, and the mass density (ISO 80000-4), `\u03C1`, of the medium\n         * remarks: This quantity is also defined spectrally in terms of wavelength, in which case, "spectral" is added before this quantity name, which can be expressed by `\u03BC_m(\u03BB) = (\u03BC(\u03BB))/\u03C1_m`. Similarly, luminous and photon quantities can be defined.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassAttenuationCoefficientUnit[1];\n    }\n\n    attribute massAttenuationCoefficient: MassAttenuationCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassAttenuationCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-7 item 7-36.2 mass absorption coefficient */\n    attribute def MassAbsorptionCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-36.2 mass absorption coefficient\n         * symbol(s): `\u03B1_m`\n         * application domain: radiometry\n         * name: MassAbsorptionCoefficient\n         * quantity dimension: L^2*M^-1\n         * measurement unit(s): kg^-1*m^2\n         * tensor order: 0\n         * definition: quotient of the linear absorption coefficient (item 7-35.2), `\u03B1`, and the mass density (ISO 80000-4), `\u03C1`, of the medium\n         * remarks: This quantity is also defined spectrally in terms of wavelength, in which case, "spectral" is added before this quantity name, which can be expressed by `\u03B1_m(\u03BB) = (\u03B1(\u03BB))/\u03C1_m`. Similarly, luminous and photon quantities can be defined.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassAbsorptionCoefficientUnit[1];\n    }\n\n    attribute massAbsorptionCoefficient: MassAbsorptionCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassAbsorptionCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-7 item 7-37 molar absorption coefficient */\n    attribute def MolarAbsorptionCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 7-37 molar absorption coefficient\n         * symbol(s): `\u03C7`\n         * application domain: radiometry\n         * name: MolarAbsorptionCoefficient\n         * quantity dimension: L^2*N^-1\n         * measurement unit(s): m^2*mol^-1\n         * tensor order: 0\n         * definition: product of linear absorption coefficient and molar volume, expressed by `\u03C7 = \u03B1 V_m`, where `\u03B1` is linear absorption coefficient (item 7-35.2) and `V_m` is molar volume (ISO 80000-9)\n         * remarks: The molar absorption coefficient can also be expressed by `\u03C7 = \u03B1 c` where `c` is amount-of-substance concentration (ISO 80000-9). Similarly, luminous and photon quantities can be defined.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MolarAbsorptionCoefficientUnit[1];\n    }\n\n    attribute molarAbsorptionCoefficient: MolarAbsorptionCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def MolarAbsorptionCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute amountOfSubstancePF: QuantityPowerFactor[1] { :>> quantity = isq.N; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, amountOfSubstancePF); }\n    }\n\n}\n', "Domain Libraries/Quantities and Units/ISQMechanics.sysml": "standard library package ISQMechanics {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-4:2019 \"Mechanics\"\n     * see also https://www.iso.org/standard/64975.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n    private import ISQThermodynamics::EnergyValue;\n\n    /* ISO-80000-4 item 4-1 mass */\n    /* See package ISQBase for the declarations of MassValue and MassUnit */\n\n    /* ISO-80000-4 item 4-2 mass density, density */\n    attribute def MassDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-2 mass density, density\n         * symbol(s): `\u03C1`, `\u03C1_m`\n         * application domain: generic\n         * name: MassDensity\n         * quantity dimension: L^-3*M^1\n         * measurement unit(s): kg*m^-3\n         * tensor order: 0\n         * definition: quantity representing the spatial distribution of mass of a continuous material: `\u03C1(vec(r)) = (dm)/(dV)` where `m` is mass of the material contained in an infinitesimal domain at point `vec(r)` and `V` is volume of this domain\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassDensityUnit[1];\n    }\n\n    attribute massDensity: MassDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    alias DensityUnit for MassDensityUnit;\n    alias DensityValue for MassDensityValue;\n    alias density for massDensity;\n\n    /* ISO-80000-4 item 4-3 specific volume */\n    attribute def SpecificVolumeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-3 specific volume\n         * symbol(s): `v`\n         * application domain: generic\n         * name: SpecificVolume\n         * quantity dimension: L^3*M^-1\n         * measurement unit(s): kg^-1*m^3\n         * tensor order: 0\n         * definition: reciprocal of mass density `\u03C1` (item 4-2): `v = 1/\u03C1`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificVolumeUnit[1];\n    }\n\n    attribute specificVolume: SpecificVolumeValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificVolumeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-4 item 4-4 relative mass density, relative density */\n    attribute def RelativeMassDensityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-4 relative mass density, relative density\n         * symbol(s): `d`\n         * application domain: generic\n         * name: RelativeMassDensity (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mass density of a substance `\u03C1` and mass density of a reference substance `\u03C1_0` : `d = \u03C1/\u03C1_0`\n         * remarks: Conditions and material should be specified for the reference substance.\n         */\n    }\n    attribute relativeMassDensity: RelativeMassDensityValue :> scalarQuantities;\n\n    alias relativeDensity for relativeMassDensity;\n\n    /* ISO-80000-4 item 4-5 surface mass density, surface density */\n    attribute def SurfaceMassDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-5 surface mass density, surface density\n         * symbol(s): `\u03C1_A`\n         * application domain: generic\n         * name: SurfaceMassDensity\n         * quantity dimension: L^-2*M^1\n         * measurement unit(s): kg*m^-2\n         * tensor order: 0\n         * definition: quantity representing the areal distribution of mass of a continuous material: `\u03C1_A(vec(r)) = (dm)/(dA)` where `m` is the mass of the material at position `vec(r)` and `A` is area\n         * remarks: The name \"grammage\" should not be used for this quantity.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SurfaceMassDensityUnit[1];\n    }\n\n    attribute surfaceMassDensity: SurfaceMassDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def SurfaceMassDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    alias SurfaceDensityUnit for SurfaceMassDensityUnit;\n    alias SurfaceDensityValue for SurfaceMassDensityValue;\n    alias surfaceDensity for surfaceMassDensity;\n\n    /* ISO-80000-4 item 4-6 linear mass density, linear density */\n    attribute def LinearMassDensityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-6 linear mass density, linear density\n         * symbol(s): `\u03C1_I`\n         * application domain: generic\n         * name: LinearMassDensity\n         * quantity dimension: L^-1*M^1\n         * measurement unit(s): kg*m^-1\n         * tensor order: 0\n         * definition: quantity representing the linear distribution of mass of a continuous material: `\u03C1_I(vec(r)) = (dm)/(dI)` where `m` is the mass of the material at position `vec(r)` and `l` is length\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearMassDensityUnit[1];\n    }\n\n    attribute linearMassDensity: LinearMassDensityValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearMassDensityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    alias LinearDensityUnit for LinearMassDensityUnit;\n    alias LinearDensityValue for LinearMassDensityValue;\n    alias linearDensity for linearMassDensity;\n\n    /* ISO-80000-4 item 4-7 moment of inertia */\n    attribute def MomentOfInertiaValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-7 moment of inertia (magnitude)\n         * symbol(s): `J`\n         * application domain: generic\n         * name: MomentOfInertia\n         * quantity dimension: L^2*M^1\n         * measurement unit(s): kg*m^2\n         * tensor order: 0\n         * definition: tensor (ISO 80000-2) quantity representing rotational inertia of a rigid body relative to a fixed centre of rotation expressed by the tensor product: `vec(L) = vec(vec(J)) vec(\u03C9)` where `vec(L)` is angular momentum (item 4-11) of the body relative to the reference point and `vec(\u03C9)` is its angular velocity (ISO 80000-3)\n         * remarks: The calculation of the value requires an integration.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MomentOfInertiaUnit[1];\n    }\n\n    attribute momentOfInertia: MomentOfInertiaValue[*] nonunique :> scalarQuantities;\n\n    attribute def MomentOfInertiaUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    attribute def Cartesian3dMomentOfInertiaTensor :> TensorQuantityValue {\n        doc\n        /*\n         * source: item 4-7 moment of inertia (tensor)\n         * symbol(s): `vec(vec(J))`\n         * application domain: generic\n         * name: MomentOfInertia\n         * quantity dimension: L^2*M^1\n         * measurement unit(s): kg*m^2\n         * tensor order: 2\n         * definition: tensor (ISO 80000-2) quantity representing rotational inertia of a rigid body relative to a fixed centre of rotation expressed by the tensor product: `vec(L) = vec(vec(J)) vec(\u03C9)` where `vec(L)` is angular momentum (item 4-11) of the body relative to the reference point and `vec(\u03C9)` is its angular velocity (ISO 80000-3)\n         * remarks: The calculation of the value requires an integration.\n         */\n        attribute :>> isBound = false;\n        attribute :>> num: Real[9];\n        attribute :>> mRef: Cartesian3dMomentOfInertiaMeasurementReference[1];\n    }\n\n    attribute momentOfInertiaTensor: Cartesian3dMomentOfInertiaTensor :> tensorQuantities;\n\n    attribute def Cartesian3dMomentOfInertiaMeasurementReference :> TensorMeasurementReference {\n        attribute :>> dimensions = (3, 3);\n        attribute :>> isBound = false;\n        attribute :>> mRefs: MomentOfInertiaUnit[9];\n    }\n\n    /* ISO-80000-4 item 4-8 momentum */\n    attribute def MomentumValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-8 momentum (magnitude)\n         * symbol(s): `p`\n         * application domain: generic\n         * name: Momentum\n         * quantity dimension: L^1*M^1*T^-1\n         * measurement unit(s): kg*m*s^-1\n         * tensor order: 0\n         * definition: product of mass `m` (item 4-1) of a body and velocity `vec(v)` (ISO 80000-3) of its centre of mass: `vec(p) = m  vec(v)`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MomentumUnit[1];\n    }\n\n    attribute momentum: MomentumValue[*] nonunique :> scalarQuantities;\n\n    attribute def MomentumUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianMomentum3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-8 momentum (vector)\n         * symbol(s): `vec(p)`\n         * application domain: generic\n         * name: Momentum\n         * quantity dimension: L^1*M^1*T^-1\n         * measurement unit(s): kg*m*s^-1\n         * tensor order: 1\n         * definition: product of mass `m` (item 4-1) of a body and velocity `vec(v)` (ISO 80000-3) of its centre of mass: `vec(p) = m  vec(v)`\n         * remarks: None.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMomentum3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMomentum3dVector: CartesianMomentum3dVector :> vectorQuantities;\n\n    attribute def CartesianMomentum3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MomentumUnit[3];\n    }\n\n    /* ISO-80000-4 item 4-9.1 force */\n    attribute def ForceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-9.1 force (magnitude)\n         * symbol(s): `F`\n         * application domain: generic\n         * name: Force\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): N, kg*m*s^-2\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity describing interaction between bodies or particles\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ForceUnit[1];\n    }\n\n    attribute force: ForceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ForceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianForce3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-9.1 force (vector)\n         * symbol(s): `vec(F)`\n         * application domain: generic\n         * name: Force\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): N, kg*m*s^-2\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity describing interaction between bodies or particles\n         * remarks: None.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianForce3dCoordinateFrame[1];\n    }\n\n    attribute cartesianForce3dVector: CartesianForce3dVector :> vectorQuantities;\n\n    attribute def CartesianForce3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: ForceUnit[3];\n    }\n\n    /* ISO-80000-4 item 4-9.2 weight */\n    attribute def CartesianWeight3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-9.2 weight\n         * symbol(s): `vec(F_g)`\n         * application domain: generic\n         * name: Weight (specializes Force)\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): N, kg*m*s^-2\n         * tensor order: 1\n         * definition: force (item 4-9.1) acting on a body in the gravitational field of Earth: `vec(F_g) = m vec(g)` where `m` (item 4-1) is the mass of the body and `vec(g)` is the local acceleration of free fall (ISO 80000-3)\n         * remarks: In colloquial language, the name \"weight\" continues to be used where \"mass\" is meant. This practice should be avoided. Weight is an example of a gravitational force. Weight comprises not only the local gravitational force but also the local centrifugal force due to the rotation of the Earth.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianForce3dCoordinateFrame[1];\n    }\n\n    attribute cartesianWeight3dVector: CartesianWeight3dVector :> vectorQuantities;\n\n    /* ISO-80000-4 item 4-9.3 static friction force, static friction */\n    attribute def CartesianStaticFrictionForce3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-9.3 static friction force, static friction\n         * symbol(s): `vec(F_s)`\n         * application domain: generic\n         * name: StaticFrictionForce (specializes Force)\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): N, kg*m*s^-2\n         * tensor order: 1\n         * definition: force (item 4-9.1) resisting the motion before a body starts to slide on a surface\n         * remarks: For the static friction coefficient, see item 4-23.1.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianForce3dCoordinateFrame[1];\n    }\n\n    attribute cartesianStaticFrictionForce3dVector: CartesianStaticFrictionForce3dVector :> vectorQuantities;\n\n    alias cartesianStaticFriction3dVector for cartesianStaticFrictionForce3dVector;\n\n    /* ISO-80000-4 item 4-9.4 kinetic friction force, dynamic friction force */\n    attribute def CartesianKineticFrictionForce3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-9.4 kinetic friction force, dynamic friction force\n         * symbol(s): `vec(F_\u03BC)`\n         * application domain: generic\n         * name: KineticFrictionForce (specializes Force)\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): N, kg*m*s^-2\n         * tensor order: 1\n         * definition: force (item 4-9.1) resisting the motion when a body slides on a surface\n         * remarks: For the kinetic friction factor, see item 4-23.2.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianForce3dCoordinateFrame[1];\n    }\n\n    attribute cartesianKineticFrictionForce3dVector: CartesianKineticFrictionForce3dVector :> vectorQuantities;\n\n    alias cartesianDynamicFrictionForce3dVector for cartesianKineticFrictionForce3dVector;\n\n    /* ISO-80000-4 item 4-9.5 rolling resistance, rolling drag, rolling friction force */\n    attribute def CartesianRollingResistance3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-9.5 rolling resistance, rolling drag, rolling friction force\n         * symbol(s): `vec(F_\"rr\")`\n         * application domain: generic\n         * name: RollingResistance (specializes Force)\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): N, kg*m*s^-2\n         * tensor order: 1\n         * definition: force (item 4-9.1) resisting the motion when a body rolls on a surface\n         * remarks: For the rolling resistance factor, see item 4-23.3.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianForce3dCoordinateFrame[1];\n    }\n\n    attribute cartesianRollingResistance3dVector: CartesianRollingResistance3dVector :> vectorQuantities;\n\n    alias cartesianRollingDrag3dVector for cartesianRollingResistance3dVector;\n\n    alias cartesianRollingFrictionForce3dVector for cartesianRollingResistance3dVector;\n\n    /* ISO-80000-4 item 4-9.6 drag force */\n    attribute def CartesianDragForce3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-9.6 drag force\n         * symbol(s): `vec(F_D)`\n         * application domain: generic\n         * name: DragForce (specializes Force)\n         * quantity dimension: L^1*M^1*T^-2\n         * measurement unit(s): N, kg*m*s^-2\n         * tensor order: 1\n         * definition: force (item 4-9.1) resisting the motion of a body in a fluid\n         * remarks: For the drag coefficient, see item 4-23.4.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianForce3dCoordinateFrame[1];\n    }\n\n    attribute cartesianDragForce3dVector: CartesianDragForce3dVector :> vectorQuantities;\n\n    /* ISO-80000-4 item 4-10 impulse */\n    attribute def ImpulseValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-10 impulse (magnitude)\n         * symbol(s): `I`\n         * application domain: generic\n         * name: Impulse\n         * quantity dimension: L^1*M^1*T^-1\n         * measurement unit(s): N*s, kg*m*s^-1\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity describing the effect of force acting during a time interval: `vec(I) = int_(t_1)^(t_2) vec(F)*dt` where `vec(F)` is force (item 4-9.1), `t` is time (ISO 80000-3) and `[t_1, t_2]` is considered time interval\n         * remarks: For a time interval `[t_1, t_2]`, `vec(I)(t_1, t_2) = vec(p)(t_1) - vec(p)(t_2) = vec(\u0394p)` where `vec(p)` is momentum (item 4-8).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ImpulseUnit[1];\n    }\n\n    attribute impulse: ImpulseValue[*] nonunique :> scalarQuantities;\n\n    attribute def ImpulseUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianImpulse3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-10 impulse (vector)\n         * symbol(s): `vec(I)`\n         * application domain: generic\n         * name: Impulse\n         * quantity dimension: L^1*M^1*T^-1\n         * measurement unit(s): N*s, kg*m*s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity describing the effect of force acting during a time interval: `vec(I) = int_(t_1)^(t_2) vec(F)*dt` where `vec(F)` is force (item 4-9.1), `t` is time (ISO 80000-3) and `[t_1, t_2]` is considered time interval\n         * remarks: For a time interval `[t_1, t_2]`, `vec(I)(t_1, t_2) = vec(p)(t_1) - vec(p)(t_2) = vec(\u0394p)` where `vec(p)` is momentum (item 4-8).\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianImpulse3dCoordinateFrame[1];\n    }\n\n    attribute cartesianImpulse3dVector: CartesianImpulse3dVector :> vectorQuantities;\n\n    attribute def CartesianImpulse3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: ImpulseUnit[3];\n    }\n\n    /* ISO-80000-4 item 4-11 angular momentum */\n    attribute def AngularMomentumValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-11 angular momentum (magnitude)\n         * symbol(s): `L`\n         * application domain: generic\n         * name: AngularMomentum\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): kg*m^2*s^-1\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity described by the vector product: `vec(L) = vec(r) xx vec(p)` where `vec(r)` is position vector (ISO 80000-3) with respect to the axis of rotation and `vec(p)` is momentum (item 4-8)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AngularMomentumUnit[1];\n    }\n\n    attribute angularMomentum: AngularMomentumValue[*] nonunique :> scalarQuantities;\n\n    attribute def AngularMomentumUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianAngularMomentum3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-11 angular momentum (vector)\n         * symbol(s): `vec(L)`\n         * application domain: generic\n         * name: AngularMomentum\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): kg*m^2*s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity described by the vector product: `vec(L) = vec(r) xx vec(p)` where `vec(r)` is position vector (ISO 80000-3) with respect to the axis of rotation and `vec(p)` is momentum (item 4-8)\n         * remarks: None.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianAngularMomentum3dCoordinateFrame[1];\n    }\n\n    attribute cartesianAngularMomentum3dVector: CartesianAngularMomentum3dVector :> vectorQuantities;\n\n    attribute def CartesianAngularMomentum3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: AngularMomentumUnit[3];\n    }\n\n    /* ISO-80000-4 item 4-12.1 moment of force */\n    attribute def MomentOfForceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-12.1 moment of force (magnitude)\n         * symbol(s): `M`\n         * application domain: generic\n         * name: MomentOfForce\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): N*m, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity described by the vector product: `vec(M) = vec(r) xx vec(F)` where `vec(r)` is position vector (ISO 80000-3) with respect to the axis of rotation and `vec(F)` is force (item 4-9.1)\n         * remarks: The bending moment of force is denoted by `vec(M)_b`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MomentOfForceUnit[1];\n    }\n\n    attribute momentOfForce: MomentOfForceValue[*] nonunique :> scalarQuantities;\n\n    attribute def MomentOfForceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianMomentOfForce3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-12.1 moment of force (vector)\n         * symbol(s): `vec(M)`\n         * application domain: generic\n         * name: MomentOfForce\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): N*m, kg*m^2*s^-2\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity described by the vector product: `vec(M) = vec(r) xx vec(F)` where `vec(r)` is position vector (ISO 80000-3) with respect to the axis of rotation and `vec(F)` is force (item 4-9.1)\n         * remarks: The bending moment of force is denoted by `vec(M)_b`.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMomentOfForce3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMomentOfForce3dVector: CartesianMomentOfForce3dVector :> vectorQuantities;\n\n    attribute def CartesianMomentOfForce3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MomentOfForceUnit[3];\n    }\n\n    /* ISO-80000-4 item 4-12.2 torque */\n    attribute def TorqueValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-12.2 torque\n         * symbol(s): `T`, `M_Q`\n         * application domain: generic\n         * name: Torque\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): N*m, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: quantity described by the scalar product: `T = vec(M)*vec(e_Q)` where `vec(M)` is moment of force (item 4-12.1) and `vec(e_Q)` is unit vector of direction with respect to which the torque is considered\n         * remarks: For example, torque is the twisting moment of force with respect to the longitudinal axis of a beam or shaft.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: TorqueUnit[1];\n    }\n\n    attribute torque: TorqueValue[*] nonunique :> scalarQuantities;\n\n    attribute def TorqueUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-13 angular impulse */\n    attribute def AngularImpulseValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-13 angular impulse (magnitude)\n         * symbol(s): `H`\n         * application domain: generic\n         * name: AngularImpulse\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): N*m*s, kg*m^2*s^-1\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity describing the effect of moment of force during a time interval: `vec(H)(t_1; t_2) = int_(t_1)^(t_2) vec(M) dt` where `vec(M)` is moment of force (item 4-12.1), `t` is time (ISO 80000-3) and `[t_1, t_2]` is considered time interval\n         * remarks: For a time interval `[t_1, t_2]`, `vec(H)(t_1, t_2) = vec(L)(t_1) - vec(L)(t_2) = vec(\u0394L)` where `vec(L)` is angular momentum.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AngularImpulseUnit[1];\n    }\n\n    attribute angularImpulse: AngularImpulseValue[*] nonunique :> scalarQuantities;\n\n    attribute def AngularImpulseUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianAngularImpulse3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-13 angular impulse (vector)\n         * symbol(s): `vec(H)`\n         * application domain: generic\n         * name: AngularImpulse\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): N*m*s, kg*m^2*s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity describing the effect of moment of force during a time interval: `vec(H)(t_1; t_2) = int_(t_1)^(t_2) vec(M) dt` where `vec(M)` is moment of force (item 4-12.1), `t` is time (ISO 80000-3) and `[t_1, t_2]` is considered time interval\n         * remarks: For a time interval `[t_1, t_2]`, `vec(H)(t_1, t_2) = vec(L)(t_1) - vec(L)(t_2) = vec(\u0394L)` where `vec(L)` is angular momentum.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianAngularImpulse3dCoordinateFrame[1];\n    }\n\n    attribute cartesianAngularImpulse3dVector: CartesianAngularImpulse3dVector :> vectorQuantities;\n\n    attribute def CartesianAngularImpulse3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: AngularImpulseUnit[3];\n    }\n\n    /* ISO-80000-4 item 4-14.1 pressure */\n    attribute def PressureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-14.1 pressure\n         * symbol(s): `p`\n         * application domain: generic\n         * name: Pressure\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: quotient of the component of a force normal to a surface and its area: `p = (vec(e_n) * vec(F)) / A` where `vec(e_n)` is unit vector of the surface normal, `vec(F)` is force (item 4-9.1) and `A` is area (ISO 80000-3)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PressureUnit[1];\n    }\n\n    attribute pressure: PressureValue[*] nonunique :> scalarQuantities;\n\n    attribute def PressureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-14.2 gauge pressure */\n    attribute gaugePressure: PressureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 4-14.2 gauge pressure\n         * symbol(s): `p_e`\n         * application domain: generic\n         * name: GaugePressure (specializes Pressure)\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: pressure `p` (item 4-14.1) decremented by ambient pressure `p_amb` : `p_e = p - p_amb`\n         * remarks: Often, `p_amb` is chosen as a standard pressure. Gauge pressure is positive or negative.\n         */\n    }\n\n    /* ISO-80000-4 item 4-15 stress */\n    attribute def StressValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-15 stress (magnitude)\n         * symbol(s): `\u03C3`\n         * application domain: generic\n         * name: Stress\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: tensor (ISO 80000-2) quantity representing state of tension of matter\n         * remarks: Stress tensor is symmetric and has three normal-stress and three shear-stress (Cartesian) components.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: StressUnit[1];\n    }\n\n    attribute stress: StressValue[*] nonunique :> scalarQuantities;\n\n    attribute def StressUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def Cartesian3dStressTensor :> TensorQuantityValue {\n        doc\n        /*\n         * source: item 4-15 stress (tensor)\n         * symbol(s): `vec(vec(\u03C3))`\n         * application domain: generic\n         * name: Stress\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 2\n         * definition: tensor (ISO 80000-2) quantity representing state of tension of matter\n         * remarks: Stress tensor is symmetric and has three normal-stress and three shear-stress (Cartesian) components.\n         */\n        attribute :>> isBound = false;\n        attribute :>> num: Real[9];\n        attribute :>> mRef: Cartesian3dStressMeasurementReference[1];\n    }\n\n    attribute stressTensor: Cartesian3dStressTensor :> tensorQuantities;\n\n    attribute def Cartesian3dStressMeasurementReference :> TensorMeasurementReference {\n        attribute :>> dimensions = (3, 3);\n        attribute :>> isBound = false;\n        attribute :>> mRefs: StressUnit[9];\n    }\n\n    /* ISO-80000-4 item 4-16.1 normal stress */\n    attribute def NormalStressValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-16.1 normal stress\n         * symbol(s): `\u03C3_n`, `\u03C3`\n         * application domain: generic\n         * name: NormalStress\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: scalar (ISO 80000-2) quantity describing surface action of a force into a body equal to: `\u03C3_n = (d F_n)/(dA)` where `F_n` is the normal component of force (item 4-9.1) and `A` is the area (ISO 80000-3) of the surface element\n         * remarks: A couple of mutually opposite forces of magnitude `F` acting on the opposite surfaces of a slice (layer) of homogenous solid matter normal to it, and evenly distributed, cause a constant normal stress `\u03C3_n = F A` in the slice (layer).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: NormalStressUnit[1];\n    }\n\n    attribute normalStress: NormalStressValue[*] nonunique :> scalarQuantities;\n\n    attribute def NormalStressUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-16.2 shear stress */\n    attribute def ShearStressValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-16.2 shear stress\n         * symbol(s): `\u03C4_s`, `\u03C4`\n         * application domain: generic\n         * name: ShearStress\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: scalar (ISO 80000-2) quantity describing surface action of a force into a body equal to: `\u03C4_s = (d F_t)/(dA)` where `F_t` is the tangential component of force (item 4-9.1) and `A` is the area (ISO 80000-3) of the surface element\n         * remarks: A couple of mutually opposite forces of magnitude `F` acting on the opposite surfaces of a slice (layer) of homogenous solid matter parallel to it, and evenly distributed, cause a constant shear stress `\u03C4 = F/A` in the slice (layer).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ShearStressUnit[1];\n    }\n\n    attribute shearStress: ShearStressValue[*] nonunique :> scalarQuantities;\n\n    attribute def ShearStressUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-17.1 strain */\n    attribute def StrainValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-17.1 strain (magnitude)\n         * symbol(s): `\u03B5`\n         * application domain: generic\n         * name: Strain\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: tensor (ISO 80000-2) quantity representing the deformation of matter caused by stress\n         * remarks: Strain tensor is symmetric and has three linear-strain and three shear strain (Cartesian) components.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: StrainUnit[1];\n    }\n\n    attribute strain: StrainValue[*] nonunique :> scalarQuantities;\n\n    attribute def StrainUnit :> DimensionOneUnit {\n    }\n\n    attribute def Cartesian3dStrainTensor :> TensorQuantityValue {\n        doc\n        /*\n         * source: item 4-17.1 strain (tensor)\n         * symbol(s): `vec(vec(\u03B5))`\n         * application domain: generic\n         * name: Strain\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 2\n         * definition: tensor (ISO 80000-2) quantity representing the deformation of matter caused by stress\n         * remarks: Strain tensor is symmetric and has three linear-strain and three shear strain (Cartesian) components.\n         */\n        attribute :>> isBound = false;\n        attribute :>> num: Real[9];\n        attribute :>> mRef: Cartesian3dStrainMeasurementReference[1];\n    }\n\n    attribute strainTensor: Cartesian3dStrainTensor :> tensorQuantities;\n\n    attribute def Cartesian3dStrainMeasurementReference :> TensorMeasurementReference {\n        attribute :>> dimensions = (3, 3);\n        attribute :>> isBound = false;\n        attribute :>> mRefs: StrainUnit[9];\n    }\n\n    /* ISO-80000-4 item 4-17.2 relative linear strain */\n    attribute def RelativeLinearStrainValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-17.2 relative linear strain\n         * symbol(s): `\u03B5`, `(e)`\n         * application domain: generic\n         * name: RelativeLinearStrain (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of change in length `\u0394l` (ISO 80000-3) of an object and its length `l` (ISO 80000-3): `\u03B5 = (\u0394l)/l`\n         * remarks: None.\n         */\n    }\n    attribute relativeLinearStrain: RelativeLinearStrainValue :> scalarQuantities;\n\n    /* ISO-80000-4 item 4-17.3 shear strain */\n    attribute def ShearStrainValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-17.3 shear strain\n         * symbol(s): `\u03B3`\n         * application domain: generic\n         * name: ShearStrain (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of parallel displacement `\u0394x` (ISO 80000-3) of two surfaces of a layer and the thickness `d` (ISO 80000-3) of the layer: `\u03B3 = (\u0394x)/d`\n         * remarks: None.\n         */\n    }\n    attribute shearStrain: ShearStrainValue :> scalarQuantities;\n\n    /* ISO-80000-4 item 4-17.4 relative volume strain */\n    attribute def RelativeVolumeStrainValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-17.4 relative volume strain\n         * symbol(s): `\u03B8`\n         * application domain: generic\n         * name: RelativeVolumeStrain (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of change in volume `\u0394V` (ISO 80000-3) of an object and its volume `V_0` (ISO 80000-3): `\u03B8 = (\u0394V)/V_0`\n         * remarks: None.\n         */\n    }\n    attribute relativeVolumeStrain: RelativeVolumeStrainValue :> scalarQuantities;\n\n    /* ISO-80000-4 item 4-18 Poisson number */\n    attribute def PoissonNumberValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-18 Poisson number\n         * symbol(s): `\u03BC`, `(v)`\n         * application domain: generic\n         * name: PoissonNumber (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of change in width `\u0394b` (width is defined in ISO 80000-3) and change in length `\u0394l` (length is defined in ISO 80000-3) of an object: `\u03BC = (\u0394b)/(\u0394l)`\n         * remarks: None.\n         */\n    }\n    attribute poissonNumber: PoissonNumberValue :> scalarQuantities;\n\n    /* ISO-80000-4 item 4-19.1 modulus of elasticity, Young modulus */\n    attribute def ModulusOfElasticityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-19.1 modulus of elasticity, Young modulus\n         * symbol(s): `E`, `E_m`, `Y`\n         * application domain: generic\n         * name: ModulusOfElasticity\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: quotient of normal stress `\u03C3` (item 4-16.1) and relative linear strain `\u03B5` (item 4-17.2): `E = \u03C3/\u03B5`\n         * remarks: Conditions should be specified (e.g. adiabatic or isothermal process).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ModulusOfElasticityUnit[1];\n    }\n\n    attribute modulusOfElasticity: ModulusOfElasticityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ModulusOfElasticityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    alias YoungModulusUnit for ModulusOfElasticityUnit;\n    alias YoungModulusValue for ModulusOfElasticityValue;\n    alias youngModulus for modulusOfElasticity;\n\n    /* ISO-80000-4 item 4-19.2 modulus of rigidity, shear modulus */\n    attribute def ModulusOfRigidityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-19.2 modulus of rigidity, shear modulus\n         * symbol(s): `G`\n         * application domain: generic\n         * name: ModulusOfRigidity\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: quotient of shear stress `\u03C4` (item 4-16.2) and shear strain `\u03B3` (item 4-17.3): `G = \u03C4/\u03B3`\n         * remarks: Conditions should be specified (e.g. isentropic or isothermal process).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ModulusOfRigidityUnit[1];\n    }\n\n    attribute modulusOfRigidity: ModulusOfRigidityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ModulusOfRigidityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    alias ShearModulusUnit for ModulusOfRigidityUnit;\n    alias ShearModulusValue for ModulusOfRigidityValue;\n    alias shearModulus for modulusOfRigidity;\n\n    /* ISO-80000-4 item 4-19.3 modulus of compression, bulk modulus */\n    attribute def ModulusOfCompressionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-19.3 modulus of compression, bulk modulus\n         * symbol(s): `K`, `K_m`, `B`\n         * application domain: generic\n         * name: ModulusOfCompression\n         * quantity dimension: L^-1*M^1*T^-2\n         * measurement unit(s): Pa, N*m^-2, kg*m^-1*s^-2\n         * tensor order: 0\n         * definition: negative of the quotient of pressure `p` (item 4-14.1) and relative volume strain `\u03B8` (item 4-17.4): `K = -(p/\u03B8)`\n         * remarks: Conditions should be specified (e.g. isentropic or isothermal process).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ModulusOfCompressionUnit[1];\n    }\n\n    attribute modulusOfCompression: ModulusOfCompressionValue[*] nonunique :> scalarQuantities;\n\n    attribute def ModulusOfCompressionUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    alias BulkModulusUnit for ModulusOfCompressionUnit;\n    alias BulkModulusValue for ModulusOfCompressionValue;\n    alias bulkModulus for modulusOfCompression;\n\n    /* ISO-80000-4 item 4-20 compressibility */\n    attribute def CompressibilityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-20 compressibility\n         * symbol(s): `\u03F0`\n         * application domain: generic\n         * name: Compressibility\n         * quantity dimension: L^1*M^-1*T^2\n         * measurement unit(s): Pa^-1, kg^-1*m*s^2\n         * tensor order: 0\n         * definition: negative relative change of volume `V` (ISO 80000-3) of an object under pressure `p` (item 4-14.1) expressed by: `\u03F0 = -(1/V)(dV)/(dp)`\n         * remarks: Conditions should be specified (e.g. isentropic or isothermal process). See also ISO 80000-5.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CompressibilityUnit[1];\n    }\n\n    attribute compressibility: CompressibilityValue[*] nonunique :> scalarQuantities;\n\n    attribute def CompressibilityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-21.1 second axial moment of area */\n    attribute def SecondAxialMomentOfAreaValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-21.1 second axial moment of area\n         * symbol(s): `I_a`\n         * application domain: generic\n         * name: SecondAxialMomentOfArea\n         * quantity dimension: L^4\n         * measurement unit(s): m^4\n         * tensor order: 0\n         * definition: geometrical characteristic of a shape of a body equal to: `I_a = int int_M r_Q^2 dA` where `M` is the two-dimensional domain of the cross-section of a plane and considered body, `r_Q` is radial distance (ISO 80000-3) from a Q-axis in the plane of the surface considered and `A` is area (ISO 80000-3)\n         * remarks: This quantity is often referred to wrongly as \"moment of inertia\" (item 4-7). The subscript, `a`, may be omitted when there is no risk of confusion.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SecondAxialMomentOfAreaUnit[1];\n    }\n\n    attribute secondAxialMomentOfArea: SecondAxialMomentOfAreaValue[*] nonunique :> scalarQuantities;\n\n    attribute def SecondAxialMomentOfAreaUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 4; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-4 item 4-21.2 second polar moment of area */\n    attribute def SecondPolarMomentOfAreaValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-21.2 second polar moment of area\n         * symbol(s): `I_p`\n         * application domain: generic\n         * name: SecondPolarMomentOfArea\n         * quantity dimension: L^4\n         * measurement unit(s): m^4\n         * tensor order: 0\n         * definition: geometrical characteristic of a shape of a body equal to: `I_p = int int_M r_Q^2 * dA` where `M` is the two-dimensional domain of the cross-section of a plane and considered body, `r_Q` is radial distance (ISO 80000-3) from a Q-axis perpendicular to the plane of the surface considered and `A` is area (ISO 80000-3)\n         * remarks: This quantity is often referred to wrongly as \"moment of inertia\" (item 4-7). The subscript, `p`, may be omitted when there is no risk of confusion.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SecondPolarMomentOfAreaUnit[1];\n    }\n\n    attribute secondPolarMomentOfArea: SecondPolarMomentOfAreaValue[*] nonunique :> scalarQuantities;\n\n    attribute def SecondPolarMomentOfAreaUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 4; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-4 item 4-22 section modulus */\n    attribute def SectionModulusValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-22 section modulus\n         * symbol(s): `Z`, `(W)`\n         * application domain: generic\n         * name: SectionModulus\n         * quantity dimension: L^3\n         * measurement unit(s): m^3\n         * tensor order: 0\n         * definition: geometrical characteristic of a shape of a body equal to: `Z = I_a/r_(Q_max)` where `I_a` is the second axial moment of area (item 4-21.1) and `r_(Q,max)` is the maximum radial distance (ISO 80000-3) of any point in the surface considered from the Q-axis with respect to which `I_a` is defined\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SectionModulusUnit[1];\n    }\n\n    attribute sectionModulus: SectionModulusValue[*] nonunique :> scalarQuantities;\n\n    attribute def SectionModulusUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-4 item 4-23.1 static friction coefficient, static friction factor, coefficient of static friction */\n    attribute def StaticFrictionCoefficientValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-23.1 static friction coefficient, static friction factor, coefficient of static friction\n         * symbol(s): `\u03BC_s`, `(f_s)`\n         * application domain: generic\n         * name: StaticFrictionCoefficient (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: proportionality factor between the maximum magnitude of the tangential component `F_max` of the static friction force (item 4-9.3) and the magnitude of the normal component `N` of the contact force (item 4-9.1) between two bodies at relative rest with respect to each other: `F_max = \u03BC_s * N`\n         * remarks: When it is not necessary to distinguish between dynamic friction factor and static friction factor, the name friction factor may be used for both.\n         */\n    }\n    attribute staticFrictionCoefficient: StaticFrictionCoefficientValue :> scalarQuantities;\n\n    alias staticFrictionFactor for staticFrictionCoefficient;\n\n    alias coefficientOfStaticFriction for staticFrictionCoefficient;\n\n    /* ISO-80000-4 item 4-23.2 kinetic friction factor, dynamic friction factor */\n    attribute def KineticFrictionFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-23.2 kinetic friction factor, dynamic friction factor\n         * symbol(s): `\u03BC`, `(f)`\n         * application domain: generic\n         * name: KineticFrictionFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: proportionality factor between the magnitudes of the kinetic friction force, `F_\u03BC` (item 4-9.4) and the normal component `N` of the contact force (item 4-9.1): `F_\u03BC = \u03BC * N`\n         * remarks: When it is not necessary to distinguish between dynamic friction factor and static friction factor, the name friction factor may be used for both. The dynamic friction factor `\xB5` is independent in first approximation of the contact surface.\n         */\n    }\n    attribute kineticFrictionFactor: KineticFrictionFactorValue :> scalarQuantities;\n\n    alias dynamicFrictionFactor for kineticFrictionFactor;\n\n    /* ISO-80000-4 item 4-23.3 rolling resistance factor */\n    attribute def RollingResistanceFactorValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-23.3 rolling resistance factor\n         * symbol(s): `C_\"rr\"`\n         * application domain: generic\n         * name: RollingResistanceFactor (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: proportionality factor between the magnitude of the tangential component `F` and the magnitude of the normal component `N` of the force applied to a body rolling on a surface at constant speed: `F = C_(rr)*N`\n         * remarks: Also known as rolling resistance coefficient, RRC.\n         */\n    }\n    attribute rollingResistanceFactor: RollingResistanceFactorValue :> scalarQuantities;\n\n    /* ISO-80000-4 item 4-23.4 drag coefficient, drag factor */\n    attribute def DragCoefficientValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-23.4 drag coefficient, drag factor\n         * symbol(s): `C_D`\n         * application domain: generic\n         * name: DragCoefficient (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: factor proportional to magnitude `F_D` of the drag force (item 4-9.6) of a body moving in a fluid, dependent on the shape and speed `v` (ISO 80000-3) of a body: `F_D = 1/2 * C_D * \u03C1 * v^2 * A` where `\u03C1` is mass density (item 4-2) of the fluid and `A` is cross-section area (ISO 80000-3) of the body\n         * remarks: None.\n         */\n    }\n    attribute dragCoefficient: DragCoefficientValue :> scalarQuantities;\n\n    alias dragFactor for dragCoefficient;\n\n    /* ISO-80000-4 item 4-24 dynamic viscosity, viscosity */\n    attribute def DynamicViscosityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-24 dynamic viscosity, viscosity\n         * symbol(s): `\u03B7`\n         * application domain: generic\n         * name: DynamicViscosity\n         * quantity dimension: L^-1*M^1*T^-1\n         * measurement unit(s): Pa*s, kg*m^-1*s^-1\n         * tensor order: 0\n         * definition: for laminar flows, proportionality constant between shear stress `\u03C4_(xz)` (item 4-16.2) in a fluid moving with a velocity `v_x` (ISO 80000-3) and gradient `(d v_x)/dz` perpendicular to the plane of shear: `\u03C4_(xz) = \u03B7 (d v_x)/(dz)`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DynamicViscosityUnit[1];\n    }\n\n    attribute dynamicViscosity: DynamicViscosityValue[*] nonunique :> scalarQuantities;\n\n    attribute def DynamicViscosityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    alias ViscosityUnit for DynamicViscosityUnit;\n    alias ViscosityValue for DynamicViscosityValue;\n    alias viscosity for dynamicViscosity;\n\n    /* ISO-80000-4 item 4-25 kinematic viscosity */\n    attribute def KinematicViscosityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-25 kinematic viscosity\n         * symbol(s): `v`\n         * application domain: generic\n         * name: KinematicViscosity\n         * quantity dimension: L^2*T^-1\n         * measurement unit(s): m^2*s^-1\n         * tensor order: 0\n         * definition: quotient of dynamic viscosity `\u03B7` (item 4-24) and mass density `\u03C1` (item 4-2) of a fluid: `v = \u03B7/\u03C1`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: KinematicViscosityUnit[1];\n    }\n\n    attribute kinematicViscosity: KinematicViscosityValue[*] nonunique :> scalarQuantities;\n\n    attribute def KinematicViscosityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-26 surface tension */\n    attribute def SurfaceTensionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-26 surface tension\n         * symbol(s): `\u03B3`, `\u03C3`\n         * application domain: generic\n         * name: SurfaceTension\n         * quantity dimension: M^1*T^-2\n         * measurement unit(s): N*m^-1, kg*s^-2\n         * tensor order: 0\n         * definition: magnitude of a force acting against the enlargement of area portion of a surface separating a liquid from its surrounding\n         * remarks: The concept of surface energy is closely related to surface tension and has the same dimension.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SurfaceTensionUnit[1];\n    }\n\n    attribute surfaceTension: SurfaceTensionValue[*] nonunique :> scalarQuantities;\n\n    attribute def SurfaceTensionUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-27.1 power */\n    attribute def PowerValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-27.1 power\n         * symbol(s): `P`\n         * application domain: generic\n         * name: Power\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W, J*s^-1, kg*m^2*s^-3\n         * tensor order: 0\n         * definition: quotient of energy (ISO 80000-5) and duration (ISO 80000-3)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PowerUnit[1];\n    }\n\n    attribute power: PowerValue[*] nonunique :> scalarQuantities;\n\n    attribute def PowerUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-27 mechanical power */\n    attribute mechanicalPower: PowerValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 4-27 mechanical power\n         * symbol(s): `P`\n         * application domain: mechanics\n         * name: MechanicalPower (specializes Power)\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W, N*m*s^-1, kg*m^2*s^-3\n         * tensor order: 0\n         * definition: scalar product of force `vec(F)` (item 4-9.1) acting to a body and its velocity `vec(v)` (ISO 80000-3): `P = vec(F) * vec(v)`\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-4 item 4-28.1 potential energy */\n    attribute potentialEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 4-28.1 potential energy\n         * symbol(s): `V`, `E_p`\n         * application domain: generic\n         * name: PotentialEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: for conservative force `vec(F)`, scalar additive quantity obeying condition `vec(F) = -nabla F`, if it exists\n         * remarks: For the definition of energy, see ISO 80000-5. A force is conservative when the force field is irrotational, i.e. `rot(F) = 0` , or `vec(F)` is perpendicular to the speed of the body to ensure `vec(F) * d vec(r) = 0` .\n         */\n    }\n\n    /* ISO-80000-4 item 4-28.2 kinetic energy */\n    attribute kineticEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 4-28.2 kinetic energy\n         * symbol(s): `T`, `E_k`\n         * application domain: generic\n         * name: KineticEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: scalar (ISO 80000-2) quantity characterizing a moving body expressed by: `T = 1/2 m v^2` where `m` is mass (item 4-1) of the body and `v` is its speed (ISO 80000-3)\n         * remarks: For the definition of energy, see ISO 80000-5.\n         */\n    }\n\n    /* ISO-80000-4 item 4-28.3 mechanical energy */\n    attribute mechanicalEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 4-28.3 mechanical energy\n         * symbol(s): `E`, `W`\n         * application domain: generic\n         * name: MechanicalEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: sum of kinetic energy `T` (item 4-28.2) and potential energy `V` (item 4-28.1): `E = T+V`\n         * remarks: The symbols `E` and `W` are also used for other kinds of energy. This definition is understood in a classical way and it does not include thermal motion.\n         */\n    }\n\n    /* ISO-80000-4 item 4-28.4 mechanical work, work */\n    attribute mechanicalWork: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 4-28.4 mechanical work, work\n         * symbol(s): `A`, `W`\n         * application domain: generic\n         * name: MechanicalWork (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: process quantity describing the total action of a force `vec(F)` (item 4-9.1) along a continuous curve `\u0393` in three-dimensional space with infinitesimal displacement (ISO 80000-3) `dvec(r)`, as a line integral of their scalar product: `A = int_\u0393 vec(F) * d vec(r)`\n         * remarks: The definition covers the case `A = -int_\u0393 p*dV` where `\u0393` is a curve in the phase space and implies that work generally depends upon `\u0393`, and that type of process must be defined (e.g. isentropic or isothermic).\n         */\n    }\n\n    alias work for mechanicalWork;\n\n    /* ISO-80000-4 item 4-29 mechanical efficiency */\n    attribute def MechanicalEfficiencyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 4-29 mechanical efficiency\n         * symbol(s): `\u03B7`\n         * application domain: mechanics\n         * name: MechanicalEfficiency (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of output power `P_\"out\"` (item 4-27) from a system and input power `P_\"in\"` (item 4-27) to this system: `\u03B7 = P_\"out\"/P_\"in\"`\n         * remarks: The system must be specified. This quantity is often expressed by the unit percent, symbol %.\n         */\n    }\n    attribute mechanicalEfficiency: MechanicalEfficiencyValue :> scalarQuantities;\n\n    /* ISO-80000-4 item 4-30.1 mass flow */\n    attribute def MassFlowValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-30.1 mass flow (magnitude)\n         * symbol(s): `j_m`\n         * application domain: generic\n         * name: MassFlow\n         * quantity dimension: L^-2*M^1*T^-1\n         * measurement unit(s): kg*m^-2*s^-1\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity characterizing a flowing fluid by the product of its local mass density `\u03C1` (item 4-2) and local velocity `vec(v)` (ISO 80000-3): `vec(j_m) = \u03C1 vec(v)`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassFlowUnit[1];\n    }\n\n    attribute massFlow: MassFlowValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassFlowUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    attribute def CartesianMassFlow3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 4-30.1 mass flow (vector)\n         * symbol(s): `vec(j_m)`\n         * application domain: generic\n         * name: MassFlow\n         * quantity dimension: L^-2*M^1*T^-1\n         * measurement unit(s): kg*m^-2*s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity characterizing a flowing fluid by the product of its local mass density `\u03C1` (item 4-2) and local velocity `vec(v)` (ISO 80000-3): `vec(j_m) = \u03C1 vec(v)`\n         * remarks: None.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianMassFlow3dCoordinateFrame[1];\n    }\n\n    attribute cartesianMassFlow3dVector: CartesianMassFlow3dVector :> vectorQuantities;\n\n    attribute def CartesianMassFlow3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: MassFlowUnit[3];\n    }\n\n    /* ISO-80000-4 item 4-30.2 mass flow rate */\n    attribute def MassFlowRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-30.2 mass flow rate\n         * symbol(s): `q_m`\n         * application domain: generic\n         * name: MassFlowRate\n         * quantity dimension: M^1*T^-1\n         * measurement unit(s): kg*s^-1\n         * tensor order: 0\n         * definition: scalar (ISO 80000-2) quantity characterizing the total flow through the two-dimensional domain `A` with normal vector `vec(e)_n` of a flowing fluid with mass flow `vec(j)_m` (item 4-30.1) as an integral: `q_m = int int_A vec(j)_m * vec(e)_n dA` where `dA` is the area (ISO 80000-3) of an element of the two-dimensional domain `A`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassFlowRateUnit[1];\n    }\n\n    attribute massFlowRate: MassFlowRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassFlowRateUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-30.3 mass change rate */\n    attribute def MassChangeRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-30.3 mass change rate\n         * symbol(s): `q_m`\n         * application domain: generic\n         * name: MassChangeRate\n         * quantity dimension: M^1*T^-1\n         * measurement unit(s): kg*s^-1\n         * tensor order: 0\n         * definition: rate of increment of mass `m` (item 4-1): `q_m = (dm)/(dt)` where `dm` is the infinitesimal mass (item 4-1) increment and `dt` is the infinitesimal duration (ISO 80000-3)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassChangeRateUnit[1];\n    }\n\n    attribute massChangeRate: MassChangeRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassChangeRateUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-31 volume flow rate */\n    attribute def VolumeFlowRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-31 volume flow rate\n         * symbol(s): `q_v`\n         * application domain: generic\n         * name: VolumeFlowRate\n         * quantity dimension: L^3*T^-1\n         * measurement unit(s): m^3*s^-1\n         * tensor order: 0\n         * definition: scalar (ISO 80000-2) quantity characterizing the total flow through the two-dimensional domain `A` with the normal vector `vec(e)_n` of a flowing fluid with velocity `vec(v)` (ISO 80000-3) as an integral: `q_v = int int_A vec(v) * vec(e)_n dA` where `dA` is the area (ISO 80000-3) of an element of the two-dimensional domain `A`\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: VolumeFlowRateUnit[1];\n    }\n\n    attribute volumeFlowRate: VolumeFlowRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def VolumeFlowRateUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-4 item 4-32 action quantity */\n    attribute def ActionQuantityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 4-32 action quantity\n         * symbol(s): `S`\n         * application domain: generic\n         * name: ActionQuantity\n         * quantity dimension: L^2*M^1*T^-1\n         * measurement unit(s): J*s, kg*m^2*s^-1\n         * tensor order: 0\n         * definition: time integral of energy `E` over a time interval `(t_1, t_2)`: `S = int_(t_1)^(t_2) E dt`\n         * remarks: The energy may be expressed by a Lagrangian or Hamiltonian function. Note for SysML: the ISQ quantity \"action\" has been renamed to \"action quantity\" to avoid the name clash with the SysML action keyword.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ActionQuantityUnit[1];\n    }\n\n    attribute actionQuantity: ActionQuantityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ActionQuantityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n}\n", "Domain Libraries/Quantities and Units/ISQSpaceTime.sysml": "standard library package ISQSpaceTime {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-3:2019 \"Space and Time\"\n     * see also https://www.iso.org/standard/64974.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* ISO-80000-3 item 3-1.1 length */\n    /* See package ISQBase for the declarations of LengthValue and LengthUnit */\n\n    /* ISO-80000-3 item 3-1.2 width, breadth */\n    attribute width: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.2 width, breadth\n         * symbol(s): `b`, `B`\n         * application domain: generic\n         * name: Width (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: minimum length of a straight line segment between two parallel straight lines (in two dimensions) or planes (in three dimensions) that enclose a given geometrical shape\n         * remarks: This quantity is non-negative.\n         */\n    }\n\n    alias breadth for width;\n\n    /* ISO-80000-3 item 3-1.3 height, depth, altitude */\n    attribute height: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.3 height, depth, altitude\n         * symbol(s): `h`, `H`\n         * application domain: generic\n         * name: Height (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: minimum length of a straight line segment between a point and a reference line or reference surface\n         * remarks: This quantity is usually signed. The sign expresses the position of the particular point with respect to the reference line or surface and is chosen by convention. The symbol `H` is often used to denote altitude, i.e. height above sea level.\n         */\n    }\n\n    alias depth for height;\n\n    alias altitude for height;\n\n    /* ISO-80000-3 item 3-1.4 thickness */\n    attribute thickness: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.4 thickness\n         * symbol(s): `d`, `\u03B4`\n         * application domain: generic\n         * name: Thickness (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: width (item 3-1.2)\n         * remarks: This quantity is non-negative.\n         */\n    }\n\n    /* ISO-80000-3 item 3-1.5 diameter */\n    attribute diameter: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.5 diameter\n         * symbol(s): `d`, `D`\n         * application domain: generic\n         * name: Diameter (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: width (item 3-1.2) of a circle, cylinder or sphere\n         * remarks: This quantity is non-negative.\n         */\n    }\n\n    /* ISO-80000-3 item 3-1.6 radius */\n    attribute radius: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.6 radius\n         * symbol(s): `r`, `R`\n         * application domain: generic\n         * name: Radius (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: half of a diameter (item 3-1.5)\n         * remarks: This quantity is non-negative.\n         */\n    }\n\n    /* ISO-80000-3 item 3-1.7 path length, arc length */\n    attribute pathLength: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.7 path length, arc length\n         * symbol(s): `s`\n         * application domain: generic\n         * name: PathLength (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: length of a rectifiable curve between two of its points\n         * remarks: The differential path length at a given point of a curve is: `ds = sqrt(dx^2 + dy^2 + dz^2)` where `x`, `y`, and `z` denote the Cartesian coordinates (ISO 80000-2) of the particular point. There are curves which are not rectifiable, for example fractal curves.\n         */\n    }\n\n    alias arcLength for pathLength;\n\n    /* ISO-80000-3 item 3-1.8 distance */\n    attribute distance: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.8 distance\n         * symbol(s): `d`, `r`\n         * application domain: generic\n         * name: Distance (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: shortest path length (item 3-1.7) between two points in a metric space\n         * remarks: A metric space might be curved. An example of a curved metric space is the surface of the Earth. In this case, distances are measured along great circles. A metric is not necessarily Euclidean.\n         */\n    }\n\n    /* ISO-80000-3 item 3-1.9 radial distance */\n    attribute radialDistance: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.9 radial distance\n         * symbol(s): `r_Q`, `\u03C1`\n         * application domain: generic\n         * name: RadialDistance (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: distance (item 3-1.8), where one point is located on an axis or within a closed non self-intersecting curve or surface\n         * remarks: The subscript Q denotes the point from which the radial distance is measured. Examples of closed non self-intersecting curves are circles or ellipses. Examples of closed non self-intersecting surfaces are surfaces of spheres or egg-shaped objects.\n         */\n    }\n\n    /* Spatial coordinate frames */\n    \n    attribute def Spatial3dCoordinateFrame :> '3dCoordinateFrame' {\n        doc\n        /*\n         * Most general spatial 3D coordinate frame\n         */\n        attribute :>> isBound = true;\n    }\n\n    attribute def CartesianSpatial3dCoordinateFrame :> Spatial3dCoordinateFrame {\n        doc\n        /*\n         * Cartesian spatial 3D coordinate frame\n         *\n         * source: ISO 80000-2 item 2-17.1 Cartesian coordinates\n         *\n         * The components of a vector expressed on a Cartesian spatial coordinate frame are all LengthValues, and denoted with symbols `x`, `y`, `z`.\n         *\n         * Note 1: The Cartesian basis vectors `vec(e_x)`, `vec(e_y)` and `vec(e_z)` form an orthonormal right-handed coordinate frame.\n         * Note 2: The measurement units for the 3 dimensions are typically the same, but may be different.\n         */\n        attribute xUnit : LengthUnit = mRefs#(1);\n        attribute yUnit : LengthUnit = mRefs#(2);\n        attribute zUnit : LengthUnit = mRefs#(3);\n        attribute :>> mRefs : LengthUnit[3];\n        attribute :>> isOrthogonal = true;\n    }\n\n    attribute universalCartesianSpatial3dCoordinateFrame : CartesianSpatial3dCoordinateFrame[1] {\n        doc\n        /*\n         * A singleton CartesianSpatial3dCoordinateFrame that can be used as a default universal Cartesian 3D coordinate frame.\n         */\n         \n        attribute :>> mRefs default (SI::m, SI::m, SI::m) {\n            doc /*\n             * By default, the universalCartesianSpatial3dCoordinateFrame uses meters as the units on all three axes.\n             */\n        }\n        \n        attribute :>> transformation[0..0] {\n            doc /*\n             * The universalCartesianSpatial3dCoordinateFrame is the \"top-level\" coordinate frame, not nested in any other frame.\n             */\n        }\n        \n    }\n\n    attribute def CylindricalSpatial3dCoordinateFrame :> Spatial3dCoordinateFrame {\n        doc\n        /*\n         * Cylindrical spatial 3D coordinate frame\n         *\n         * source: ISO 80000-2 item 2-17.2 cylindrical coordinates\n         *\n         * The components of a (position) vector to a point P in a cylindrical coordinate frame are:\n         * - radialDistance (symbol `\u03C1`) defined by LengthValue, that is the radial distance from the cylinder axis to P\n         * - azimuth (symbol `\u03C6`) defined by AngularMeasure, that is the angle between the azimuth reference direction and the line segment\n         * from the cylinder axis, in the plane that is orthogonal to the cylinder axis and intersects P\n         * - z coordinate (symbol `z`) defined by LengthValue, the coordinate along the clyinder axis.\n         *\n         * Note 1: The basis vectors `vec(e_\u03C1)(\u03C6)`, `vec(e_\u03C6)(\u03C6)` and `vec(e_z)` form an orthonormal right-handed coordinate frame, where\n         * `vec(e_\u03C6)` is tangent to the circular arc in the `\u03C6` direction.\n         * Note 2: In order to enable transformation to and from a CartesianSpatial3dCoordinateFrame the `vec(e_x)` Cartesian basis vector is aligned\n         * with the `\u03C6=0` direction in the cylindrical frame, and the `vec(e_z)` Cartesian basis vector is aligned with\n         * the `vec(e_z)` cylindrical basis vector.\n         * Note 3: If `z = 0`, then `\u03C1` and `\u03C6` are polar coordinates in the XY-plane.\n         * Note 4: See also https://en.wikipedia.org/wiki/Cylindrical_coordinate_system .\n         */\n        attribute radialDistanceUnit : LengthUnit;\n        attribute azimuthUnit : AngularMeasureUnit;\n        attribute zUnit : LengthUnit;\n        attribute :>> mRefs = (radialDistanceUnit, azimuthUnit, zUnit);\n        attribute :>> isOrthogonal = true;\n    }\n\n    attribute def SphericalSpatial3dCoordinateFrame :> Spatial3dCoordinateFrame {\n        doc\n        /*\n         * Spherical spatial 3D coordinate frame\n         *\n         * source: ISO 80000-2 item 2-17.3 spherical coordinates\n         *\n         * The components of a (position) vector to a point P specified in a spherical coordinate frame are:\n         * - radialDistance (symbol `r`) defined by LengthValue, that is the distance from the origin to P\n         * - inclination (symbol `\u03B8`) defined by AngularMeasure, that is the angle between the zenith direction and the line segment from origin to P\n         * - azimuth (symbol `\u03C6`) defined by AngularMeasure, that is the angle between the azimuth reference direction and the line segment\n         * from the origin to the orthogonal projection of P on the reference plane, normal to the zenith direction.\n         *\n         * Note 1: The basis vectors `vec(e_r)(\u03B8,\u03C6)`, `vec(e_\u03B8)(\u03B8,\u03C6)` and `vec(e_\u03C6)(\u03C6)` form an orthonormal right-handed frame, where\n         * `vec(e_\u03B8)` and `vec(e_\u03C6)` are tangent to the respective circular arcs in the `\u03B8` and `\u03C6` directions.\n         * Note 2: In order to transform to and from a CartesianSpatial3dCoordinateFrame the `vec(e_x)` Cartesian basis vector is aligned\n         * with the `\u03B8=\u03C0/4` and `\u03C6=0` direction in the spherical frame, and the `vec(e_z)` Cartesian basis vector is aligned\n         * with the `\u03B8=0` zenith direction in the spherical frame.\n         * Note 3: If `\u03B8 = \u03C0/4`, then `\u03C1` and `\u03C6` are polar coordinates in the XY-plane.\n         * Note 4: See also https://en.wikipedia.org/wiki/Spherical_coordinate_system .\n         */\n        attribute radialDistanceUnit : LengthUnit;\n        attribute inclinationUnit : AngularMeasureUnit;\n        attribute azimuthUnit : AngularMeasureUnit;\n        attribute :>> mRefs = (radialDistanceUnit, inclinationUnit, azimuthUnit);\n        attribute :>> isOrthogonal = true;\n    }\n\n     attribute def PlanetarySpatial3dCoordinateFrame :> Spatial3dCoordinateFrame {\n        doc\n        /*\n         * Planetary spatial 3D coordinate frame\n         *\n         * A planetary spatial 3D coordinate frame is a generalization for any planet of the geographic coordinate frame and geocentric coordinate\n         * for Earth. In such coordinate frames, typically the origin is located at the planet's centre of gravity, and the surface of the planet\n         * is approximated by a reference ellipsoid centred on the origin, with its major axes oriented along the south to north pole vector and\n         * the equatorial plane.\n         *\n         * The components of a (position) vector to a point P specified in a planetary coordinate frame are:\n         * - latitude (symbol `lat` or `\u03C6`) defined by AngularMeasure, that is the angle between the equatorial plane and the vector from\n         *   the origin to P, similar to the inclination in a spherical spatial coordinate frame. Typically, the zero reference latitude is chosen\n         *   for positions in the equatorial plane, with positive latitude for positions in the northern hemisphere and negative latitude for positions\n         *   in the southern hemisphere.\n         * - longitude (symbol `long` or `\u03BB`) defined by AngularMeasure, that is the angle between a reference meridian and the meridian\n         *   passing through P, similar to the azimuth of a spherical spatial coordinate frame. The convention is to connotate positive longitude\n         *   with eastward direction and negative longitude with westward direction. The reference meridian for `long=0` is chosen to pass\n         *   through a particular feature of the planet, e.g., for Earth typically the position of the British Royal Observatory in Greenwich, UK.\n         * - altitude (symbol `h`) defined by LengthValue, that is the distance between P and the reference ellipsoid\n         *   in the normal direction to the ellipsoid. Positive altitude specifies a position above the reference ellipsoid surface,\n         *   while a negative value specifies a position below.\n         *\n         * Note 1: The reference meridian is also called prime meridian.\n         * Note 2: The basis vectors `vec(e_\u03C6)(\u03C6)`, `vec(e_\u03BB)(\u03BB)` and `vec(e_h)(\u03C6,\u03BB)` form an orthonormal right-handed frame, where\n         * `vec(e_\u03C6)` and `vec(e_\u03BB)` are tangent to the reference ellipsoid in the respective latitude and longitude directions,\n         * and `vec(e_h)` is normal to the reference ellipsoid.\n         * Note 3: In order to transform to and from a CartesianSpatial3dCoordinateFrame the `vec(e_x)` Cartesian basis vector is aligned\n         * with the `\u03C6=0` and `\u03BB=0` direction in the planetary frame, and the `vec(e_z)` Cartesian basis vector is aligned\n         * with the `\u03BB=\u03C0/2` (north pole) direction in the planetary frame.\n         * Note 4: See also https://en.wikipedia.org/wiki/Planetary_coordinate_system .\n         */\n        attribute latitudeUnit : AngularMeasureUnit;\n        attribute longitudeUnit : AngularMeasureUnit;\n        attribute altitudeUnit : LengthUnit;\n        attribute :>> mRefs = (longitudeUnit, latitudeUnit, altitudeUnit);\n        attribute :>> isOrthogonal = true;\n    }\n\n    /* ISO-80000-3 item 3-1.10 position vector */\n    attribute def Position3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 3-1.10 position vector\n         * symbol(s): `vec(r)`\n         * application domain: generic\n         * name: PositionVector\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity from the origin of a coordinate system to a point in space\n         * remarks: Position vectors are so-called bounded vectors, i.e. their magnitude (ISO 80000-2) and direction depend on the particular coordinate system used.\n         */\n        attribute :>> isBound = true;\n        attribute :>> mRef: Spatial3dCoordinateFrame[1];\n    }\n\n    attribute position3dVector: Position3dVector :> vectorQuantities;\n\n    attribute def CartesianPosition3dVector :> Position3dVector {\n        attribute x : LengthValue = num#(1) [mRef.mRefs#(1)];\n        attribute y : LengthValue = num#(2) [mRef.mRefs#(2)];\n        attribute z : LengthValue = num#(3) [mRef.mRefs#(3)];\n        attribute :>> mRef : CartesianSpatial3dCoordinateFrame[1];\n    }\n    attribute cartesianPosition3dVector : CartesianPosition3dVector :> position3dVector;\n\n    attribute def CylindricalPosition3dVector :> Position3dVector {\n        attribute <'\u03C1'> radialDistance : LengthValue = num#(1) [mRef.mRefs#(1)];\n        attribute <'\u03C6'> azimuth : AngularMeasureUnit = num#(2) [mRef.mRefs#(2)];\n        attribute <h> height : LengthValue = num#(3) [mRef.mRefs#(3)];\n        attribute :>> mRef : CylindricalSpatial3dCoordinateFrame[1];\n    }\n    attribute cylindricalPosition3dVector : CylindricalPosition3dVector :> position3dVector;\n\n    attribute def SphericalPosition3dVector :> Position3dVector {\n        attribute <r> radialDistance : LengthValue = num#(1) [mRef.mRefs#(1)];\n        attribute <'\u03B8'> inclination : AngularMeasureUnit = num#(2) [mRef.mRefs#(2)];\n        attribute <'\u03C6'> azimuth : AngularMeasureUnit = num#(3) [mRef.mRefs#(3)];\n        attribute :>> mRef : SphericalSpatial3dCoordinateFrame[1];\n    }\n    attribute sphericalPosition3dVector : SphericalPosition3dVector :> position3dVector;\n\n    attribute def PlanetaryPosition3dVector :> Position3dVector {\n        attribute <lat> latitude : AngularMeasureUnit = num#(1) [mRef.mRefs#(1)];\n        attribute <long> longitude : AngularMeasureUnit = num#(2) [mRef.mRefs#(2)];\n        attribute <h> altitude : LengthValue = num#(3) [mRef.mRefs#(3)];\n        attribute :>> mRef : PlanetarySpatial3dCoordinateFrame[1];\n    }\n    attribute planetaryPosition3dVector : PlanetaryPosition3dVector :> position3dVector;\n\n    /* ISO-80000-3 item 3-1.11 displacement */\n    attribute def Displacement3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 3-1.11 displacement\n         * symbol(s): `vec(\u0394r)`\n         * application domain: generic\n         * name: Displacement\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity between any two points in space\n         * remarks: Displacement vectors are so-called free vectors, i.e. their magnitude (ISO 80000-2) and direction do not depend on a particular coordinate system. The magnitude of this vector is also called displacement.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: Spatial3dCoordinateFrame[1];\n    }\n\n    attribute displacement3dVector: Displacement3dVector :> vectorQuantities;\n\n    attribute def CartesianDisplacement3dVector :> Displacement3dVector {\n        attribute x : LengthValue = num#(1) [mRef.mRefs#(1)];\n        attribute y : LengthValue = num#(2) [mRef.mRefs#(2)];\n        attribute z : LengthValue = num#(3) [mRef.mRefs#(3)];\n        attribute :>> mRef : CartesianSpatial3dCoordinateFrame[1];\n    }\n    attribute cartesianDisplacement3dVector : CartesianDisplacement3dVector :> displacement3dVector;\n\n    attribute def CylindricalDisplacement3dVector :> Displacement3dVector {\n        attribute <'\u03C1'> radialDistance : LengthValue = num#(1) [mRef.mRefs#(1)];\n        attribute <'\u03C6'> azimuth : AngularMeasureUnit = num#(2) [mRef.mRefs#(2)];\n        attribute <h> height : LengthValue = num#(3) [mRef.mRefs#(3)];\n        attribute :>> mRef : CylindricalSpatial3dCoordinateFrame[1];\n    }\n    attribute cylindricalDisplacement3dVector : CylindricalDisplacement3dVector :> displacement3dVector;\n\n    attribute def SphericalDisplacement3dVector :> Displacement3dVector {\n        attribute <r> radialDistance : LengthValue = num#(1) [mRef.mRefs#(1)];\n        attribute <'\u03B8'> inclination : AngularMeasureUnit = num#(2) [mRef.mRefs#(2)];\n        attribute <'\u03C6'> azimuth : AngularMeasureUnit = num#(3) [mRef.mRefs#(3)];\n        attribute :>> mRef : SphericalSpatial3dCoordinateFrame[1];\n    }\n    attribute sphericalDisplacement3dVector : SphericalDisplacement3dVector :> displacement3dVector;\n\n    /* ISO-80000-3 item 3-1.12 radius of curvature */\n    attribute radiusOfCurvature: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-1.12 radius of curvature\n         * symbol(s): `\u03C1`\n         * application domain: generic\n         * name: RadiusOfCurvature (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: radius (item 3-1.6) of the osculating circle of a planar curve at a particular point of the curve\n         * remarks: The radius of curvature is only defined for curves which are at least twice continuously differentiable.\n         */\n    }\n\n    /* ISO-80000-3 item 3-2 curvature */\n    attribute def CurvatureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-2 curvature\n         * symbol(s): `\u03BA`\n         * application domain: generic\n         * name: Curvature\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: inverse of the radius of curvature (item 3-1.12)\n         * remarks: The curvature is given by: `\u03BA = 1/\u03C1` where `\u03C1` denotes the radius of curvature (item 3-1.12).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CurvatureUnit[1];\n    }\n\n    attribute curvature: CurvatureValue[*] nonunique :> scalarQuantities;\n\n    attribute def CurvatureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-3 item 3-3 area */\n    attribute def AreaValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-3 area\n         * symbol(s): `A`, `S`\n         * application domain: generic\n         * name: Area\n         * quantity dimension: L^2\n         * measurement unit(s): m^2\n         * tensor order: 0\n         * definition: extent of a two-dimensional geometrical shape\n         * remarks: The surface element at a given point of a surface is given by: `dA = g du dv` where `u` and `v` denote the Gaussian surface coordinates and `g` denotes the determinant of the metric tensor (ISO 80000-2) at the particular point. The symbol `d\u03C3` is also used for the surface element.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AreaUnit[1];\n    }\n\n    attribute area: AreaValue[*] nonunique :> scalarQuantities;\n\n    attribute def AreaUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-3 item 3-4 volume */\n    attribute def VolumeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-4 volume\n         * symbol(s): `V`, `(S)`\n         * application domain: generic\n         * name: Volume\n         * quantity dimension: L^3\n         * measurement unit(s): m^3\n         * tensor order: 0\n         * definition: extent of a three-dimensional geometrical shape\n         * remarks: The volume element in Euclidean space is given by: `dV = dx dy dz` where `dx`, `dy`, and `dz` denote the differentials of the Cartesian coordinates (ISO 80000-2). The symbol `d\u03C4` is also used for the volume element.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: VolumeUnit[1];\n    }\n\n    attribute volume: VolumeValue[*] nonunique :> scalarQuantities;\n\n    attribute def VolumeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-3 item 3-5 angular measure, plane angle */\n    attribute def AngularMeasureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-5 angular measure, plane angle\n         * symbol(s): `\u03B1`, `\u03B2`, `\u03B3`\n         * application domain: generic\n         * name: AngularMeasure\n         * quantity dimension: 1\n         * measurement unit(s): rad, 1\n         * tensor order: 0\n         * definition: measure of a geometric figure, called plane angle, formed by two rays, called the sides of the plane angle, emanating from a common point, called the vertex of the plane angle\n         * remarks: The angular measure is given by: `\u03B1 = s/r` where `s` denotes the arc length (item 3-1.7) of the included arc of a circle, centred at the vertex of the plane angle, and `r` the radius (item 3-1.6) of that circle. Other symbols are also used.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AngularMeasureUnit[1];\n    }\n\n    attribute angularMeasure: AngularMeasureValue[*] nonunique :> scalarQuantities;\n\n    attribute def AngularMeasureUnit :> DimensionOneUnit {\n    }\n\n    alias PlaneAngleUnit for AngularMeasureUnit;\n    alias PlaneAngleValue for AngularMeasureValue;\n    alias planeAngle for angularMeasure;\n\n    /* ISO-80000-3 item 3-6 rotational displacement, angular displacement */\n    attribute rotationalDisplacement: AngularMeasureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-6 rotational displacement, angular displacement\n         * symbol(s): `\u03D1`, `\u03C6`\n         * application domain: generic\n         * name: RotationalDisplacement (specializes AngularMeasure)\n         * quantity dimension: 1\n         * measurement unit(s): rad, 1\n         * tensor order: 0\n         * definition: quotient of the traversed circular path length (item 3-1.7) of a point in space during a rotation and its distance (item 3-1.8) from the axis or centre of rotation\n         * remarks: The rotational displacement is given by: `\u03C6 = s/r` where `s` denotes the traversed path length (item 3-1.7) along the periphery of a circle, centred at the vertex of the plane angle, and `r` the radius (item 3-1.6) of that circle. The rotational displacement is signed. The sign denotes the direction of rotation and is chosen by convention. Other symbols are also used.\n         */\n    }\n\n    alias angularDisplacement for rotationalDisplacement;\n\n    /* ISO-80000-3 item 3-7 phase angle */\n    attribute phaseAngle: AngularMeasureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-7 phase angle\n         * symbol(s): `\u03C6`, `\u03D5`\n         * application domain: generic\n         * name: PhaseAngle (specializes AngularMeasure)\n         * quantity dimension: 1\n         * measurement unit(s): rad, 1\n         * tensor order: 0\n         * definition: angular measure (item 3-5) between the positive real axis and the radius of the polar representation of the complex number in the complex plane\n         * remarks: The phase angle (often imprecisely referred to as the \"phase\") is the argument of a complex number. Other symbols are also used.\n         */\n    }\n\n    /* ISO-80000-3 item 3-8 solid angular measure */\n    attribute def SolidAngularMeasureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-8 solid angular measure\n         * symbol(s): `\u03A9`\n         * application domain: generic\n         * name: SolidAngularMeasure\n         * quantity dimension: 1\n         * measurement unit(s): sr, 1\n         * tensor order: 0\n         * definition: measure of a conical geometric figure, called solid angle, formed by all rays, originating from a common point, called the vertex of the solid angle, and passing through the points of a closed, non-self-intersecting curve in space considered as the border of a surface\n         * remarks: The differential solid angular measure expressed in spherical coordinates (ISO 80000-2) is given by: `d\u03A9 = A/r^2 * sin(\u03B8 * d\u03B8 * d\u03C6)` where `A` is area, `r` is radius, `\u03B8` and `\u03C6` are spherical coordinates.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SolidAngularMeasureUnit[1];\n    }\n\n    attribute solidAngularMeasure: SolidAngularMeasureValue[*] nonunique :> scalarQuantities;\n\n    attribute def SolidAngularMeasureUnit :> DimensionOneUnit {\n    }\n\n    /* ISO-80000-3 item 3-9 duration, time */\n    /* See package ISQBase for the declarations of DurationValue and DurationUnit */\n\n    alias TimeUnit for DurationUnit;\n    alias TimeValue for DurationValue;\n    alias time for duration;\n\n    /* ISO-80000-3 item 3-10.1 velocity */\n    attribute def CartesianVelocity3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 3-10.1 velocity\n         * symbol(s): `vec(v)`, `u,v,w`\n         * application domain: generic\n         * name: Velocity\n         * quantity dimension: L^1*T^-1\n         * measurement unit(s): m/s, m*s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity giving the rate of change of a position vector (item 3-1.10)\n         * remarks: The velocity vector is given by: `vec(v) = (d vec(r)) / (dt)` where `vec(r)` denotes the position vector (item 3-1.10) and `t` the duration (item 3-9). When the general symbol `vec(v)` is not used for the velocity, the symbols `u`, `v`, `w` may be used for the components (ISO 80000-2) of the velocity.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianVelocity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianVelocity3dVector: CartesianVelocity3dVector :> vectorQuantities;\n\n    attribute def CartesianVelocity3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: SpeedUnit[3];\n    }\n\n    /* ISO-80000-3 item 3-10.2 speed */\n    attribute def SpeedValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-10.2 speed\n         * symbol(s): `v`\n         * application domain: generic\n         * name: Speed\n         * quantity dimension: L^1*T^-1\n         * measurement unit(s): m/s, m*s^-1\n         * tensor order: 0\n         * definition: magnitude (ISO 80000-2) of the velocity (item 3-10.1)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpeedUnit[1];\n    }\n\n    attribute speed: SpeedValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpeedUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-3 item 3-11 acceleration */\n    attribute def AccelerationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-11 acceleration (magnitude)\n         * symbol(s): `a`\n         * application domain: generic\n         * name: Acceleration\n         * quantity dimension: L^1*T^-2\n         * measurement unit(s): m*s^-2\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity giving the rate of change of velocity (item 3-10)\n         * remarks: The acceleration vector is given by: `vec(a) = (d vec(v))/(dt)` where `vec(v)` denotes the velocity (item 3-10.1) and `t` the duration (item 3-9). The magnitude (ISO 80000-2) of the acceleration of free fall is usually denoted by `g`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AccelerationUnit[1];\n    }\n\n    attribute acceleration: AccelerationValue[*] nonunique :> scalarQuantities;\n\n    attribute def AccelerationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    attribute def CartesianAcceleration3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 3-11 acceleration (vector)\n         * symbol(s): `vec(a)`\n         * application domain: generic\n         * name: Acceleration\n         * quantity dimension: L^1*T^-2\n         * measurement unit(s): m*s^-2\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity giving the rate of change of velocity (item 3-10)\n         * remarks: The acceleration vector is given by: `vec(a) = (d vec(v))/(dt)` where `vec(v)` denotes the velocity (item 3-10.1) and `t` the duration (item 3-9). The magnitude (ISO 80000-2) of the acceleration of free fall is usually denoted by `g`.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianAcceleration3dCoordinateFrame[1];\n    }\n\n    attribute cartesianAcceleration3dVector: CartesianAcceleration3dVector :> vectorQuantities;\n\n    attribute def CartesianAcceleration3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: AccelerationUnit[3];\n    }\n\n    /* ISO-80000-3 item 3-12 angular velocity */\n    attribute def AngularVelocityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-12 angular velocity (magnitude)\n         * symbol(s): `\u03C9`\n         * application domain: generic\n         * name: AngularVelocity\n         * quantity dimension: T^-1\n         * measurement unit(s): rad*s^-1, s^-1\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity giving the rate of change of the rotational displacement (item 3-6) as its magnitude (ISO 80000-2) and with a direction equal to the direction of the axis of rotation\n         * remarks: The angular velocity vector is given by: `vec(\u03C9) = (d \u03C6) / (dt) vec(u)` where `\u03C6` denotes the angular displacement (item 3-6), `t` the duration (item 3-9), and `vec(u)` the unit vector (ISO 80000-2) along the axis of rotation in the direction for which the rotation corresponds to a right-hand spiral.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AngularVelocityUnit[1];\n    }\n\n    attribute angularVelocity: AngularVelocityValue[*] nonunique :> scalarQuantities;\n\n    attribute def AngularVelocityUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    attribute def CartesianAngularVelocity3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 3-12 angular velocity (vector)\n         * symbol(s): `vec(\u03C9)`\n         * application domain: generic\n         * name: AngularVelocity\n         * quantity dimension: T^-1\n         * measurement unit(s): rad*s^-1, s^-1\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity giving the rate of change of the rotational displacement (item 3-6) as its magnitude (ISO 80000-2) and with a direction equal to the direction of the axis of rotation\n         * remarks: The angular velocity vector is given by: `vec(\u03C9) = (d \u03C6) / (dt) vec(u)` where `\u03C6` denotes the angular displacement (item 3-6), `t` the duration (item 3-9), and `vec(u)` the unit vector (ISO 80000-2) along the axis of rotation in the direction for which the rotation corresponds to a right-hand spiral.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianAngularVelocity3dCoordinateFrame[1];\n    }\n\n    attribute cartesianAngularVelocity3dVector: CartesianAngularVelocity3dVector :> vectorQuantities;\n\n    attribute def CartesianAngularVelocity3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: AngularVelocityUnit[3];\n    }\n\n    /* ISO-80000-3 item 3-13 angular acceleration */\n    attribute def AngularAccelerationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-13 angular acceleration (magnitude)\n         * symbol(s): `\u03B1`\n         * application domain: generic\n         * name: AngularAcceleration\n         * quantity dimension: T^-2\n         * measurement unit(s): rad*s^-2, s^-2\n         * tensor order: 0\n         * definition: vector (ISO 80000-2) quantity giving the rate of change of angular velocity (item 3-12)\n         * remarks: The angular acceleration vector is given by: `vec \u03B1 = (d vec(\u03C9))/(dt)` Where `vec(\u03C9)` denotes the angular velocity (item 3-12) and `t` the duration (item 3-9).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AngularAccelerationUnit[1];\n    }\n\n    attribute angularAcceleration: AngularAccelerationValue[*] nonunique :> scalarQuantities;\n\n    attribute def AngularAccelerationUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    attribute def CartesianAngularAcceleration3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 3-13 angular acceleration (vector)\n         * symbol(s): `vec(\u03B1)`\n         * application domain: generic\n         * name: AngularAcceleration\n         * quantity dimension: T^-2\n         * measurement unit(s): rad*s^-2, s^-2\n         * tensor order: 1\n         * definition: vector (ISO 80000-2) quantity giving the rate of change of angular velocity (item 3-12)\n         * remarks: The angular acceleration vector is given by: `vec \u03B1 = (d vec(\u03C9))/(dt)` Where `vec(\u03C9)` denotes the angular velocity (item 3-12) and `t` the duration (item 3-9).\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianAngularAcceleration3dCoordinateFrame[1];\n    }\n\n    attribute cartesianAngularAcceleration3dVector: CartesianAngularAcceleration3dVector :> vectorQuantities;\n\n    attribute def CartesianAngularAcceleration3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: AngularAccelerationUnit[3];\n    }\n\n    /* ISO-80000-3 item 3-14 period duration, period */\n    attribute periodDuration: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-14 period duration, period\n         * symbol(s): `T`\n         * application domain: generic\n         * name: PeriodDuration (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: duration (item 3-9) of one cycle of a periodic event\n         * remarks: A periodic event is an event that occurs regularly with a fixed time interval.\n         */\n    }\n\n    alias period for periodDuration;\n\n    /* ISO-80000-3 item 3-15 time constant */\n    attribute timeConstant: DurationValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-15 time constant\n         * symbol(s): `\u03C4`, `T`\n         * application domain: generic\n         * name: TimeConstant (specializes Duration)\n         * quantity dimension: T^1\n         * measurement unit(s): s\n         * tensor order: 0\n         * definition: parameter characterizing the response to a step input of a first-order, linear time-invariant system\n         * remarks: If a quantity is a function of the duration (item 3-9) expressed by: `F(t) prop e^(-t/\u03C4)` where `t` denotes the duration (item 3-9), then `\u03C4` denotes the time constant. Here the time constant `\u03C4` applies to an exponentially decaying quantity.\n         */\n    }\n\n    /* ISO-80000-3 item 3-16 rotation */\n    attribute rotation: CountValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-16 rotation\n         * symbol(s): `N`\n         * application domain: generic\n         * name: Rotation (specializes Count)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: number of revolutions\n         * remarks: `N` is the number (not necessarily an integer) of revolutions, for example, of a rotating body about a given axis. Its value is given by: `N = \u03C6/(2 \u03C0)` where `\u03C6` denotes the measure of rotational displacement (item 3-6).\n         */\n    }\n\n    /* ISO-80000-3 item 3-17.1 frequency */\n    attribute def FrequencyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-17.1 frequency\n         * symbol(s): `f`, `\u03BD`\n         * application domain: generic\n         * name: Frequency\n         * quantity dimension: T^-1\n         * measurement unit(s): Hz, s^-1\n         * tensor order: 0\n         * definition: inverse of period duration (item 3-14)\n         * remarks: The frequency is given by: `f = 1/T` where `T` denotes the period duration (item 3-14).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: FrequencyUnit[1];\n    }\n\n    attribute frequency: FrequencyValue[*] nonunique :> scalarQuantities;\n\n    attribute def FrequencyUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-3 item 3-17.2 rotational frequency */\n    attribute rotationalFrequency: FrequencyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-17.2 rotational frequency\n         * symbol(s): `n`\n         * application domain: generic\n         * name: RotationalFrequency (specializes Frequency)\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: duration (item 3-9) of one cycle of a periodic event\n         * remarks: The rotational frequency is given by: `n = (dN) / (dt)` where `N` denotes the rotation (item 3-16) and `t` is the duration (item 3-9).\n         */\n    }\n\n    /* ISO-80000-3 item 3-18 angular frequency */\n    attribute def AngularFrequencyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-18 angular frequency\n         * symbol(s): `\u03C9`\n         * application domain: generic\n         * name: AngularFrequency\n         * quantity dimension: T^-1\n         * measurement unit(s): rad*s^-1, s^-1\n         * tensor order: 0\n         * definition: rate of change of the phase angle (item 3-7)\n         * remarks: The angular frequency is given by: `\u03C9 = 2 \u03C0 f` where `f` denotes the frequency (item 3-17.1).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AngularFrequencyUnit[1];\n    }\n\n    attribute angularFrequency: AngularFrequencyValue[*] nonunique :> scalarQuantities;\n\n    attribute def AngularFrequencyUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-3 item 3-19 wavelength */\n    attribute wavelength: LengthValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-19 wavelength\n         * symbol(s): `\u03BB`\n         * application domain: generic\n         * name: Wavelength (specializes Length)\n         * quantity dimension: L^1\n         * measurement unit(s): m\n         * tensor order: 0\n         * definition: length (item 3-1.1) of the repetition interval of a wave\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-3 item 3-20 repetency, wavenumber */\n    attribute def RepetencyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-20 repetency, wavenumber\n         * symbol(s): `\u03C3`, `\u1E7D`\n         * application domain: generic\n         * name: Repetency\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: inverse of the wavelength (item 3-19)\n         * remarks: The repetency is given by: `\u03C3 = 1 / \u03BB` where `\u03BB` denotes the wavelength (item 3-19).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RepetencyUnit[1];\n    }\n\n    attribute repetency: RepetencyValue[*] nonunique :> scalarQuantities;\n\n    attribute def RepetencyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    alias WavenumberUnit for RepetencyUnit;\n    alias WavenumberValue for RepetencyValue;\n    alias wavenumber for repetency;\n\n    /* ISO-80000-3 item 3-21 wave vector */\n    attribute def CartesianWave3dVector :> '3dVectorQuantityValue' {\n        doc\n        /*\n         * source: item 3-21 wave vector\n         * symbol(s): `vec(k)`\n         * application domain: generic\n         * name: WaveVector\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 1\n         * definition: vector normal to the surfaces of constant phase angle (item 3-7) of a wave, with the magnitude (ISO 80000-2) of repetency (item 3-20)\n         * remarks: None.\n         */\n        attribute :>> isBound = false;\n        attribute :>> mRef: CartesianWaveVector3dCoordinateFrame[1];\n    }\n\n    attribute cartesianWave3dVector: CartesianWave3dVector :> vectorQuantities;\n\n    attribute def CartesianWaveVector3dCoordinateFrame :> '3dCoordinateFrame' {\n        attribute :>> isBound = false;\n        attribute :>> isOrthogonal = true;\n        attribute :>> mRefs: RepetencyUnit[3];\n    }\n\n    /* ISO-80000-3 item 3-22 angular repetency, angular wavenumber */\n    attribute def AngularRepetencyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-22 angular repetency, angular wavenumber\n         * symbol(s): `k`\n         * application domain: generic\n         * name: AngularRepetency\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: magnitude (ISO 80000-2) of the wave vector (item 3-21)\n         * remarks: The angular repetency is given by: `\u03BA = (2 \u03C0)/\u03BB` where `\u03BB` denotes the wavelength (item 3-19).\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AngularRepetencyUnit[1];\n    }\n\n    attribute angularRepetency: AngularRepetencyValue[*] nonunique :> scalarQuantities;\n\n    attribute def AngularRepetencyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    alias AngularWavenumberUnit for AngularRepetencyUnit;\n    alias AngularWavenumberValue for AngularRepetencyValue;\n    alias angularWavenumber for angularRepetency;\n\n    /* ISO-80000-3 item 3-23.1 phase velocity, phase speed */\n    attribute def PhaseVelocityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-23.1 phase velocity, phase speed\n         * symbol(s): `c`, `v`, `(\u03BD)`, `c_\u03C6`, `v_\u03C6`, `(\u03BD_\u03C6)`\n         * application domain: generic\n         * name: PhaseVelocity\n         * quantity dimension: L^1*T^-1\n         * measurement unit(s): m*s^-1\n         * tensor order: 0\n         * definition: speed with which the phase angle (item 3-7) of a wave propagates in space\n         * remarks: The phase velocity is given by: `c = \u03C9/\u03BA` where `\u03C9` denotes the angular frequency (item 3-18) and `k` the angular repetency (item 3-22). If phase velocities of electromagnetic waves and other phase velocities are both involved, then `c` should be used for the former and `\u03C5` for the latter. Phase velocity can also be written as `c = \u03BB f`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhaseVelocityUnit[1];\n    }\n\n    attribute phaseVelocity: PhaseVelocityValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhaseVelocityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    alias PhaseSpeedUnit for PhaseVelocityUnit;\n    alias PhaseSpeedValue for PhaseVelocityValue;\n    alias phaseSpeed for phaseVelocity;\n\n    /* ISO-80000-3 item 3-23.2 group velocity, group speed */\n    attribute groupVelocity: SpeedValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 3-23.2 group velocity, group speed\n         * symbol(s): `c_g`, `v_g`, `(\u03BD_g)`\n         * application domain: generic\n         * name: GroupVelocity (specializes Speed)\n         * quantity dimension: L^1*T^-1\n         * measurement unit(s): m*s^-1\n         * tensor order: 0\n         * definition: speed with which the envelope of a wave propagates in space\n         * remarks: The group velocity is given by: `c_g = (d \u03C9)/ (dk)` where `\u03C9` denotes the angular frequency (item 3-18) and `k` the angular repetency (item 3-22).\n         */\n    }\n\n    alias groupSpeed for groupVelocity;\n\n    /* ISO-80000-3 item 3-24 damping coefficient */\n    attribute def DampingCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-24 damping coefficient\n         * symbol(s): `\u03B4`\n         * application domain: generic\n         * name: DampingCoefficient\n         * quantity dimension: T^-1\n         * measurement unit(s): s^-1\n         * tensor order: 0\n         * definition: inverse of the time constant (item 3-15) of an exponentially varying quantity\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DampingCoefficientUnit[1];\n    }\n\n    attribute dampingCoefficient: DampingCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def DampingCoefficientUnit :> DerivedUnit {\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = durationPF; }\n    }\n\n    /* ISO-80000-3 item 3-25 logarithmic decrement */\n    attribute def LogarithmicDecrementValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 3-25 logarithmic decrement\n         * symbol(s): `\u039B`\n         * application domain: generic\n         * name: LogarithmicDecrement (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: product of damping coefficient (item 3-24) and period duration (item 3-14)\n         * remarks: None.\n         */\n    }\n    attribute logarithmicDecrement: LogarithmicDecrementValue :> scalarQuantities;\n\n    /* ISO-80000-3 item 3-26.1 attenuation, extinction */\n    attribute def AttenuationValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-26.1 attenuation, extinction\n         * symbol(s): `\u03B1`\n         * application domain: generic\n         * name: Attenuation\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: gradual decrease in magnitude (ISO 80000-2) of any kind of flux through a medium\n         * remarks: If a quantity is a function of distance (item 3-1.8) expressed by: `f(x) prop e^(-\u03B1 x)` where `x` denotes distance (item 3-1.8), then `\u03B1` denotes attenuation. The inverse of attenuation is called attenuation length.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: AttenuationUnit[1];\n    }\n\n    attribute attenuation: AttenuationValue[*] nonunique :> scalarQuantities;\n\n    attribute def AttenuationUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    alias ExtinctionUnit for AttenuationUnit;\n    alias ExtinctionValue for AttenuationValue;\n    alias extinction for attenuation;\n\n    /* ISO-80000-3 item 3-26.2 phase coefficient */\n    attribute def PhaseCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-26.2 phase coefficient\n         * symbol(s): `\u03B2`\n         * application domain: generic\n         * name: PhaseCoefficient\n         * quantity dimension: L^-1\n         * measurement unit(s): rad/m, m^-1\n         * tensor order: 0\n         * definition: change of phase angle (item 3-7) with the length (item 3-1.1) along the path travelled by a plane wave\n         * remarks: If a quantity is a function of distance expressed by: `f(x) prop cos(\u03B2(x-x_0))` where `x` denotes distance (item 3-1.8), then `\u03B2` denotes the phase coefficient.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PhaseCoefficientUnit[1];\n    }\n\n    attribute phaseCoefficient: PhaseCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def PhaseCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n    /* ISO-80000-3 item 3-26.3 propagation coefficient */\n    attribute def PropagationCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 3-26.3 propagation coefficient\n         * symbol(s): `\u03B3`\n         * application domain: generic\n         * name: PropagationCoefficient\n         * quantity dimension: L^-1\n         * measurement unit(s): m^-1\n         * tensor order: 0\n         * definition: measure of the change of amplitude and phase angle (item 3-7) of a plane wave propagating in a given direction\n         * remarks: The propagation coefficient is given by: `\u03B3 = \u03B1 + i\u03B2` where `\u03B1` denotes attenuation (item 3-26.1) and `\u03B2` the phase coefficient (item 3-26.2) of a plane wave.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PropagationCoefficientUnit[1];\n    }\n\n    attribute propagationCoefficient: PropagationCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def PropagationCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = lengthPF; }\n    }\n\n}\n", "Domain Libraries/Quantities and Units/ISQThermodynamics.sysml": "standard library package ISQThermodynamics {\n    doc\n    /*\n     * International System of Quantities and Units\n     * Generated on 2025-03-13T15:00:05Z from standard ISO-80000-5:2019 \"Thermodynamics\"\n     * see also https://www.iso.org/standard/64976.html\n     * \n     * Note 1: In documentation comments, AsciiMath notation (see http://asciimath.org/) is used for mathematical concepts,\n     * with Greek letters in Unicode encoding. In running text, AsciiMath is placed between backticks.\n     * Note 2: For vector and tensor quantities currently the unit and quantity value type for their (scalar) magnitude is \n     * defined, as well as their typical Cartesian 3d VectorMeasurementReference (i.e. coordinate system) \n     * or TensorMeasurementReference.\n     */\n\n    private import ScalarValues::Real;\n    private import Quantities::*;\n    private import MeasurementReferences::*;\n    private import ISQBase::*;\n\n    /* Quantity definitions referenced from other ISQ packages */\n\n\n    /* ISO-80000-5 item 5-1 thermodynamic temperature, temperature */\n    /* See package ISQBase for the declarations of ThermodynamicTemperatureValue and ThermodynamicTemperatureUnit */\n\n    alias TemperatureUnit for ThermodynamicTemperatureUnit;\n    alias TemperatureValue for ThermodynamicTemperatureValue;\n    alias temperature for thermodynamicTemperature;\n\n    /* ISO-80000-5 item 5-2 Celsius temperature */\n    attribute def CelsiusTemperatureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-2 Celsius temperature\n         * symbol(s): `t`, `\u03B8`\n         * application domain: generic\n         * name: CelsiusTemperature\n         * quantity dimension: \u0398^1\n         * measurement unit(s): \xB0C\n         * tensor order: 0\n         * definition: temperature difference from the thermodynamic temperature of the ice point is called the Celsius temperature t, which is defined by the quantity equation: `t = T - T_0` where `T` is thermodynamic temperature (item 5-1) and `T_0 = 273,15 K`\n         * remarks: The unit degree Celsius is a special name for the kelvin for use in stating values of Celsius temperature. The unit degree Celsius is by definition equal in magnitude to the kelvin. A difference or interval of temperature may be expressed in kelvin or in degrees Celsius. The thermodynamic temperature `T_0` is 0,01 K below the thermodynamic temperature of the triple point of water. The symbol \xB0C for the degree Celsius shall be preceded by a space (see ISO 80000-1). Prefixes are not allowed in combination with the unit \xB0C.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CelsiusTemperatureUnit[1];\n    }\n\n    attribute celsiusTemperature: CelsiusTemperatureValue[*] nonunique :> scalarQuantities;\n\n    attribute def CelsiusTemperatureUnit :> DerivedUnit {\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = thermodynamicTemperaturePF; }\n    }\n\n    /* ISO-80000-5 item 5-3.1 linear expansion coefficient */\n    attribute def LinearExpansionCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-3.1 linear expansion coefficient\n         * symbol(s): `\u03B1_l`\n         * application domain: generic\n         * name: LinearExpansionCoefficient\n         * quantity dimension: \u0398^-1\n         * measurement unit(s): K^-1\n         * tensor order: 0\n         * definition: relative change of length with temperature: `\u03B1_l = 1/l * (dl)/(dT)` where l is length (ISO 80000-3) and `T` is thermodynamic temperature (item 5-1)\n         * remarks: The subscripts in the symbols may be omitted when there is no risk of confusion.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: LinearExpansionCoefficientUnit[1];\n    }\n\n    attribute linearExpansionCoefficient: LinearExpansionCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def LinearExpansionCoefficientUnit :> DerivedUnit {\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = thermodynamicTemperaturePF; }\n    }\n\n    /* ISO-80000-5 item 5-3.2 cubic expansion coefficient */\n    attribute def CubicExpansionCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-3.2 cubic expansion coefficient\n         * symbol(s): `\u03B1_V`, `\u03B3`\n         * application domain: generic\n         * name: CubicExpansionCoefficient\n         * quantity dimension: \u0398^-1\n         * measurement unit(s): K^-1\n         * tensor order: 0\n         * definition: relative change of volume with temperature: `\u03B1_V = 1/V * (dV)/(dT)` where `V` is volume (ISO 80000-3) and `T` is thermodynamic temperature (item 5-1)\n         * remarks: Also called volumetric expansion coefficient. The subscripts in the symbols may be omitted when there is no risk of confusion.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CubicExpansionCoefficientUnit[1];\n    }\n\n    attribute cubicExpansionCoefficient: CubicExpansionCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def CubicExpansionCoefficientUnit :> DerivedUnit {\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = thermodynamicTemperaturePF; }\n    }\n\n    /* ISO-80000-5 item 5-3.3 relative pressure coefficient */\n    attribute def RelativePressureCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-3.3 relative pressure coefficient\n         * symbol(s): `\u03B1_p`\n         * application domain: generic\n         * name: RelativePressureCoefficient\n         * quantity dimension: \u0398^-1\n         * measurement unit(s): K^-1\n         * tensor order: 0\n         * definition: relative change of pressure with temperature at constant volume: `\u03B1_p = 1/p * ((partial p)/(partial T))_V` where `p` is pressure (ISO 80000-4), `T` is thermodynamic temperature (item 5-1), and `V` is volume (ISO 80000-3)\n         * remarks: The subscripts in the symbols may be omitted when there is no risk of confusion.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: RelativePressureCoefficientUnit[1];\n    }\n\n    attribute relativePressureCoefficient: RelativePressureCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def RelativePressureCoefficientUnit :> DerivedUnit {\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = thermodynamicTemperaturePF; }\n    }\n\n    /* ISO-80000-5 item 5-4 pressure coefficient */\n    attribute def PressureCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-4 pressure coefficient\n         * symbol(s): `\u03B2`\n         * application domain: generic\n         * name: PressureCoefficient\n         * quantity dimension: L^-1*M^1*T^-2*\u0398^-1\n         * measurement unit(s): Pa/K, kg*m^-1*s^-2*K^-1\n         * tensor order: 0\n         * definition: change of pressure with temperature at constant volume: `\u03B2 = ((partial p)/(partial T))_V` where `p` is pressure (ISO 80000-4), `T` is thermodynamic temperature (item 5-1), and `V` is volume (ISO 80000-3)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PressureCoefficientUnit[1];\n    }\n\n    attribute pressureCoefficient: PressureCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def PressureCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-5.1 isothermal compressibility */\n    attribute def IsothermalCompressibilityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-5.1 isothermal compressibility\n         * symbol(s): `\u03F0_T`\n         * application domain: generic\n         * name: IsothermalCompressibility\n         * quantity dimension: L^1*M^-1*T^2\n         * measurement unit(s): Pa^-1, kg^-1*m*s^2\n         * tensor order: 0\n         * definition: negative relative change of volume with pressure at constant temperature: `\u03F0_T = -1/V * ((partial V)/(partial p))_T` where `V` is volume (ISO 80000-3), `p` is pressure (ISO 80000-4), and `T` is thermodynamic temperature (item 5-1)\n         * remarks: The subscripts in the symbols may be omitted when there is no risk of confusion.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: IsothermalCompressibilityUnit[1];\n    }\n\n    attribute isothermalCompressibility: IsothermalCompressibilityValue[*] nonunique :> scalarQuantities;\n\n    attribute def IsothermalCompressibilityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-5 item 5-5.2 isentropic compressibility */\n    attribute def IsentropicCompressibilityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-5.2 isentropic compressibility\n         * symbol(s): `\u03F0_S`\n         * application domain: generic\n         * name: IsentropicCompressibility\n         * quantity dimension: L^1*M^-1*T^2\n         * measurement unit(s): Pa^-1, kg^-1*m*s^2\n         * tensor order: 0\n         * definition: negative relative change of volume with pressure at constant entropy: `\u03F0_S = -1/V * ((partial V)/(partial p))_S` where `V` is volume (ISO 80000-3), `p` is pressure (ISO 80000-4), and `S` is entropy (item 5-18)\n         * remarks: The subscripts in the symbols may be omitted when there is no risk of confusion.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: IsentropicCompressibilityUnit[1];\n    }\n\n    attribute isentropicCompressibility: IsentropicCompressibilityValue[*] nonunique :> scalarQuantities;\n\n    attribute def IsentropicCompressibilityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-5 item 5-6.1 heat, amount of heat */\n    attribute heat: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-6.1 heat, amount of heat\n         * symbol(s): `Q`\n         * application domain: generic\n         * name: Heat (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: difference between the increase in the internal energy (item 5-20.2) of a system and the work (ISO 80000-4) done on the system, provided that the amounts of substances within the system are not changed\n         * remarks: The heat transferred in an isothermal phase transformation should be expressed as the change in the appropriate state functions, e.g. `T \u0394S`, where `T` is thermodynamic temperature (item 5-1) and `S` is entropy (item 5-18), or `\u0394H`, where `H` is enthalpy (item 5-20.3). NOTE A supply of heat can correspond to an increase in thermodynamic temperature or to other effects, such as phase change or chemical processes; see item 5-6.2.\n         */\n    }\n\n    alias amountOfHeat for heat;\n\n    /* ISO-80000-5 item 5-6.2 latent heat */\n    attribute latentHeat: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-6.2 latent heat\n         * symbol(s): `Q`\n         * application domain: generic\n         * name: LatentHeat (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: energy released or absorbed by a system during a constant-temperature process\n         * remarks: Examples of latent heat are latent heat of fusion (melting) and latent heat of vaporization (boiling).\n         */\n    }\n\n    /* ISO-80000-5 item 5-7 heat flow rate */\n    attribute def HeatFlowRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-7 heat flow rate\n         * symbol(s): `dot(Q)`\n         * application domain: generic\n         * name: HeatFlowRate\n         * quantity dimension: L^2*M^1*T^-3\n         * measurement unit(s): W, J/s, kg*m^2*s^-3\n         * tensor order: 0\n         * definition: time rate at which heat (item 5-6.1) crosses a given surface\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: HeatFlowRateUnit[1];\n    }\n\n    attribute heatFlowRate: HeatFlowRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def HeatFlowRateUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-5 item 5-8 density of heat flow rate */\n    attribute def DensityOfHeatFlowRateValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-8 density of heat flow rate\n         * symbol(s): `q`, `\u03C6`\n         * application domain: generic\n         * name: DensityOfHeatFlowRate\n         * quantity dimension: M^1*T^-3\n         * measurement unit(s): W/m^2, kg*s^-3\n         * tensor order: 0\n         * definition: quotient of heat flow rate and area: `q = dot Q / A` where `dot Q` is heat flow rate (item 5-7) and A is area (ISO 80000-3) of a given surface\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: DensityOfHeatFlowRateUnit[1];\n    }\n\n    attribute densityOfHeatFlowRate: DensityOfHeatFlowRateValue[*] nonunique :> scalarQuantities;\n\n    attribute def DensityOfHeatFlowRateUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF); }\n    }\n\n    /* ISO-80000-5 item 5-9 thermal conductivity */\n    attribute def ThermalConductivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-9 thermal conductivity\n         * symbol(s): `\u03BB_l`, `(\u03F0)`\n         * application domain: generic\n         * name: ThermalConductivity\n         * quantity dimension: L^1*M^1*T^-3*\u0398^-1\n         * measurement unit(s): W/(m*K), kg*m*s^-3*K^-1\n         * tensor order: 0\n         * definition: quotient of density of heat flow rate (item 5-8) and thermodynamic temperature gradient that has the same direction as the heat flow\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThermalConductivityUnit[1];\n    }\n\n    attribute thermalConductivity: ThermalConductivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThermalConductivityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-10.1 coefficient of heat transfer */\n    attribute def CoefficientOfHeatTransferValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-10.1 coefficient of heat transfer\n         * symbol(s): `K`, `(k)`\n         * application domain: generic\n         * name: CoefficientOfHeatTransfer\n         * quantity dimension: M^1*T^-3*\u0398^-1\n         * measurement unit(s): W/(m^2*K), kg*s^-3*K^-1\n         * tensor order: 0\n         * definition: quotient of density of heat flow rate (item 5-8) and thermodynamic temperature (item 5-1) difference\n         * remarks: In building technology, the coefficient of heat transfer is often called thermal transmittance, with the symbol U (no longer recommended). See remark to item 5-13.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: CoefficientOfHeatTransferUnit[1];\n    }\n\n    attribute coefficientOfHeatTransfer: CoefficientOfHeatTransferValue[*] nonunique :> scalarQuantities;\n\n    attribute def CoefficientOfHeatTransferUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-10.2 surface coefficient of heat transfer */\n    attribute def SurfaceCoefficientOfHeatTransferValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-10.2 surface coefficient of heat transfer\n         * symbol(s): `h`, `(\u03B1)`\n         * application domain: generic\n         * name: SurfaceCoefficientOfHeatTransfer\n         * quantity dimension: M^1*T^-3*\u0398^-1\n         * measurement unit(s): W/(m^2*K), kg*s^-3*K^-1\n         * tensor order: 0\n         * definition: quotient of density of heat flow rate and the difference of the temperature at the surface and a reference temperature: `h = q / (T_s - T_r)` where q is density of heat flow rate (item 5-8), `T_s` is the thermodynamic temperature (item 5-1) at the surface, and `T_r` is a reference thermodynamic temperature characterizing the adjacent surroundings\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SurfaceCoefficientOfHeatTransferUnit[1];\n    }\n\n    attribute surfaceCoefficientOfHeatTransfer: SurfaceCoefficientOfHeatTransferValue[*] nonunique :> scalarQuantities;\n\n    attribute def SurfaceCoefficientOfHeatTransferUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-11 thermal insulance, coefficient of thermal insulance */\n    attribute def ThermalInsulanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-11 thermal insulance, coefficient of thermal insulance\n         * symbol(s): `M`\n         * application domain: generic\n         * name: ThermalInsulance\n         * quantity dimension: M^-1*T^3*\u0398^1\n         * measurement unit(s): m^2*K/W, kg^-1*s^3*K\n         * tensor order: 0\n         * definition: inverse of coefficient of heat transfer `K`: `M = 1/K` where `K` is coefficient of heat transfer (item 5-10.1)\n         * remarks: In building technology, this quantity is often called thermal resistance, with the symbol R.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThermalInsulanceUnit[1];\n    }\n\n    attribute thermalInsulance: ThermalInsulanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThermalInsulanceUnit :> DerivedUnit {\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    alias CoefficientOfThermalInsulanceUnit for ThermalInsulanceUnit;\n    alias CoefficientOfThermalInsulanceValue for ThermalInsulanceValue;\n    alias coefficientOfThermalInsulance for thermalInsulance;\n\n    /* ISO-80000-5 item 5-12 thermal resistance */\n    attribute def ThermalResistanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-12 thermal resistance\n         * symbol(s): `R`\n         * application domain: generic\n         * name: ThermalResistance\n         * quantity dimension: L^-2*M^-1*T^3*\u0398^1\n         * measurement unit(s): K/W, kg^-1*m^-2*s^3*K\n         * tensor order: 0\n         * definition: quotient of thermodynamic temperature (item 5-1) difference and heat flow rate (item 5-7)\n         * remarks: See remark to item 5-11.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThermalResistanceUnit[1];\n    }\n\n    attribute thermalResistance: ThermalResistanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThermalResistanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 3; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-13 thermal conductance */\n    attribute def ThermalConductanceValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-13 thermal conductance\n         * symbol(s): `G`, `(H)`\n         * application domain: generic\n         * name: ThermalConductance\n         * quantity dimension: L^2*M^1*T^-3*\u0398^-1\n         * measurement unit(s): W/K, kg*m^2*s^-3*K^-1\n         * tensor order: 0\n         * definition: inverse of thermal resistance `R`: `G = 1/R` where `R` is thermal resistance (item 5-12)\n         * remarks: See remark to item 5-11. This quantity is also called heat transfer coefficient. See item 5-10.1.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThermalConductanceUnit[1];\n    }\n\n    attribute thermalConductance: ThermalConductanceValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThermalConductanceUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -3; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-14 thermal diffusivity */\n    attribute def ThermalDiffusivityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-14 thermal diffusivity\n         * symbol(s): `a`\n         * application domain: generic\n         * name: ThermalDiffusivity\n         * quantity dimension: L^2*T^-1\n         * measurement unit(s): m^2*s^-1\n         * tensor order: 0\n         * definition: quotient of thermal conductivity and the product of mass density and specific heat capacity: `a = \u03BB / (\u03C1 C_p)` where `\u03BB` is thermal conductivity (item 5-9), `\u03C1` is mass density (ISO 80000-4), and `c_p` is specific heat capacity at constant pressure (item 5-16.2)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: ThermalDiffusivityUnit[1];\n    }\n\n    attribute thermalDiffusivity: ThermalDiffusivityValue[*] nonunique :> scalarQuantities;\n\n    attribute def ThermalDiffusivityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-5 item 5-15 heat capacity */\n    attribute def HeatCapacityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-15 heat capacity\n         * symbol(s): `C`\n         * application domain: generic\n         * name: HeatCapacity\n         * quantity dimension: L^2*M^1*T^-2*\u0398^-1\n         * measurement unit(s): J/K, kg*m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: derivative of added heat with respect to thermodynamic temperature of a system: `C = (dQ)/(dT)` where `Q` is amount of heat (item 5-6.1) and `T` is thermodynamic temperature (item 5-1)\n         * remarks: Heat capacity is not completely defined unless specified as seen in items 5-16.2, 5-16.3 and 5-16.4.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: HeatCapacityUnit[1];\n    }\n\n    attribute heatCapacity: HeatCapacityValue[*] nonunique :> scalarQuantities;\n\n    attribute def HeatCapacityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-16.1 specific heat capacity */\n    attribute def SpecificHeatCapacityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-16.1 specific heat capacity\n         * symbol(s): `c`\n         * application domain: generic\n         * name: SpecificHeatCapacity\n         * quantity dimension: L^2*T^-2*\u0398^-1\n         * measurement unit(s): J/(kg*K), m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: quotient of heat capacity and mass: `c = C/m` where `C` is heat capacity (item 5-15) and `m` is mass (ISO 80000-4)\n         * remarks: For the corresponding quantities related to the amount of substance, see ISO 80000-9.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificHeatCapacityUnit[1];\n    }\n\n    attribute specificHeatCapacity: SpecificHeatCapacityValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificHeatCapacityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-16.2 specific heat capacity at constant pressure */\n    attribute def SpecificHeatCapacityAtConstantPressureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-16.2 specific heat capacity at constant pressure\n         * symbol(s): `c_p`\n         * application domain: generic\n         * name: SpecificHeatCapacityAtConstantPressure\n         * quantity dimension: L^2*T^-2*\u0398^-1\n         * measurement unit(s): J/(kg*K), m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: specific heat capacity (item 5-16.1) at constant pressure (ISO 80000-4)\n         * remarks: Also called specific isobaric heat capacity.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificHeatCapacityAtConstantPressureUnit[1];\n    }\n\n    attribute specificHeatCapacityAtConstantPressure: SpecificHeatCapacityAtConstantPressureValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificHeatCapacityAtConstantPressureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-16.3 specific heat capacity at constant volume */\n    attribute def SpecificHeatCapacityAtConstantVolumeValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-16.3 specific heat capacity at constant volume\n         * symbol(s): `c_V`\n         * application domain: generic\n         * name: SpecificHeatCapacityAtConstantVolume\n         * quantity dimension: L^2*T^-2*\u0398^-1\n         * measurement unit(s): J/(kg*K), m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: specific heat capacity (item 5-16.1) at constant volume (ISO 80000-3)\n         * remarks: Also called specific isochoric heat capacity.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificHeatCapacityAtConstantVolumeUnit[1];\n    }\n\n    attribute specificHeatCapacityAtConstantVolume: SpecificHeatCapacityAtConstantVolumeValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificHeatCapacityAtConstantVolumeUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-16.4 specific heat capacity at saturated vapour pressure */\n    attribute def SpecificHeatCapacityAtSaturatedVapourPressureValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-16.4 specific heat capacity at saturated vapour pressure\n         * symbol(s): `c_\"sat\"`\n         * application domain: generic\n         * name: SpecificHeatCapacityAtSaturatedVapourPressure\n         * quantity dimension: L^2*T^-2*\u0398^-1\n         * measurement unit(s): J/(kg*K), m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: specific heat capacity (item 5-16.1) at saturated vapour pressure (ISO 80000-4)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificHeatCapacityAtSaturatedVapourPressureUnit[1];\n    }\n\n    attribute specificHeatCapacityAtSaturatedVapourPressure: SpecificHeatCapacityAtSaturatedVapourPressureValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificHeatCapacityAtSaturatedVapourPressureUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-17.1 ratio of specific heat capacities */\n    attribute def RatioOfSpecificHeatCapacitiesValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-17.1 ratio of specific heat capacities\n         * symbol(s): `\u03B3`\n         * application domain: generic\n         * name: RatioOfSpecificHeatCapacities (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of specific heat capacity at constant pressure and specific heat capacity at constant volume: `\u03B3 = c_p/c_V` where `c_p` is specific heat capacity at constant pressure (item 5-16.2) and `c_V` is specific heat capacity at constant volume (item 5-16.3)\n         * remarks: This quantity can also be expressed by `\u03B3 = C_p/C_V` where `C_p` is heat capacity at constant pressure and `C_V` is heat capacity at constant volume.\n         */\n    }\n    attribute ratioOfSpecificHeatCapacities: RatioOfSpecificHeatCapacitiesValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-17.2 isentropic exponent, isentropic expansion factor */\n    attribute def IsentropicExponentValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-17.2 isentropic exponent, isentropic expansion factor\n         * symbol(s): `\u03F0`\n         * application domain: generic\n         * name: IsentropicExponent (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: the negative of relative pressure change, divided by relative volume change, at constant entropy: `\u03F0 = -V/p * ((partial p)/(partial V))_S` where `V` is volume (ISO 80000-3), `p` is pressure (ISO 80000-4), and `S` is entropy (item 5-18)\n         * remarks: For an ideal gas, `\u03F0` is equal to `\u03B3` (item 5-17.1).\n         */\n    }\n    attribute isentropicExponent: IsentropicExponentValue :> scalarQuantities;\n\n    alias isentropicExpansionFactor for isentropicExponent;\n\n    /* ISO-80000-5 item 5-18 entropy */\n    attribute def EntropyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-18 entropy\n         * symbol(s): `S`\n         * application domain: generic\n         * name: Entropy\n         * quantity dimension: L^2*M^1*T^-2*\u0398^-1\n         * measurement unit(s): J/K, kg*m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: natural logarithm of number of equally probable microscopic configurations in a macroscopic system, multiplied by the Boltzmann constant: `S = k lnW` where `W` is number of configurations and `k` is the Boltzmann constant (ISO 80000-1)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EntropyUnit[1];\n    }\n\n    attribute entropy: EntropyValue[*] nonunique :> scalarQuantities;\n\n    attribute def EntropyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-19 specific entropy */\n    attribute def SpecificEntropyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-19 specific entropy\n         * symbol(s): `s`\n         * application domain: generic\n         * name: SpecificEntropy\n         * quantity dimension: L^2*T^-2*\u0398^-1\n         * measurement unit(s): J/(kg*K), m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: quotient of entropy and mass: `s = S/m` where `S` is entropy (item 5-18) and `m` is mass (ISO 80000-4)\n         * remarks: For the corresponding quantity related to amount of substance, see ISO 80000-9.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificEntropyUnit[1];\n    }\n\n    attribute specificEntropy: SpecificEntropyValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificEntropyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-20.1 energy */\n    attribute def EnergyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-20.1 energy\n         * symbol(s): `E`\n         * application domain: thermodynamics\n         * name: Energy\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: ability of a system to do work (ISO 80000-4)\n         * remarks: Energy exists in different forms that are mutually transformable into each other, either totally or partially. In contrast to internal energy (item 5-20.2), energy is not a state function.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: EnergyUnit[1];\n    }\n\n    attribute energy: EnergyValue[*] nonunique :> scalarQuantities;\n\n    attribute def EnergyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF); }\n    }\n\n    /* ISO-80000-5 item 5-20.2 internal energy, thermodynamic energy */\n    attribute internalEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-20.2 internal energy, thermodynamic energy\n         * symbol(s): `U`\n         * application domain: generic\n         * name: InternalEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: energy of a system whose change is given by the amount of the heat (item 5-6.1) transferred to the system and the work (ISO 80000-4) done on the system, provided that the system is closed and no chemical reactions occur\n         * remarks: In thermodynamic text books, usually the formula `\u0394U = Q + W` is used. Note that the zero of the energy is undefined.\n         */\n    }\n\n    alias thermodynamicEnergy for internalEnergy;\n\n    /* ISO-80000-5 item 5-20.3 enthalpy */\n    attribute enthalpy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-20.3 enthalpy\n         * symbol(s): `H`\n         * application domain: generic\n         * name: Enthalpy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: sum of internal energy of the system and the product of pressure and volume of the system: `H = U + p*V` where U is internal energy (item 5-20.2), `p` is pressure (ISO 80000-4), and `V` is volume (ISO 80000-3)\n         * remarks: None.\n         */\n    }\n\n    /* ISO-80000-5 item 5-20.4 Helmholtz energy, Helmholtz function */\n    attribute helmholtzEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-20.4 Helmholtz energy, Helmholtz function\n         * symbol(s): `A`, `F`\n         * application domain: generic\n         * name: HelmholtzEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: difference of internal energy of the system and the product of thermodynamic temperature and entropy of the system: `A = U - TS` where `U` is internal energy (item 5-20.2), `T` is thermodynamic temperature (item 5-1), and `S` is entropy (item 5-18)\n         * remarks: The name Helmholtz free energy is also used. However, this term is not recommended.\n         */\n    }\n\n    alias helmholtzFunction for helmholtzEnergy;\n\n    /* ISO-80000-5 item 5-20.5 Gibbs energy, Gibbs function */\n    attribute gibbsEnergy: EnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-20.5 Gibbs energy, Gibbs function\n         * symbol(s): `G`\n         * application domain: generic\n         * name: GibbsEnergy (specializes Energy)\n         * quantity dimension: L^2*M^1*T^-2\n         * measurement unit(s): J, kg*m^2*s^-2\n         * tensor order: 0\n         * definition: difference of the enthalpy and the product of thermodynamic temperature and entropy of the system: `G = H - T*S` where H is enthalpy (item 5-20.3), `T` is thermodynamic temperature (item 5-1), and `S` is entropy (item 5-18)\n         * remarks: The name Gibbs free energy is also used. However, this term is not recommended.\n         */\n    }\n\n    alias gibbsFunction for gibbsEnergy;\n\n    /* ISO-80000-5 item 5-21.1 specific energy */\n    attribute def SpecificEnergyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-21.1 specific energy\n         * symbol(s): `e`\n         * application domain: generic\n         * name: SpecificEnergy\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: quotient of energy and mass: `e = E/m` where `E` is energy (item 5-20.1) and `m` is mass (ISO 80000-4)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificEnergyUnit[1];\n    }\n\n    attribute specificEnergy: SpecificEnergyValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificEnergyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-5 item 5-21.2 specific internal energy, specific thermodynamic energy */\n    attribute specificInternalEnergy: SpecificEnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-21.2 specific internal energy, specific thermodynamic energy\n         * symbol(s): `u`\n         * application domain: generic\n         * name: SpecificInternalEnergy (specializes SpecificEnergy)\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: quotient of internal energy and mass: `u = U/m` where `U` is internal energy (item 5-20.2) and `m` is mass (ISO 80000-4)\n         * remarks: None.\n         */\n    }\n\n    alias specificThermodynamicEnergy for specificInternalEnergy;\n\n    /* ISO-80000-5 item 5-21.3 specific enthalpy */\n    attribute def SpecificEnthalpyValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-21.3 specific enthalpy\n         * symbol(s): `h`\n         * application domain: generic\n         * name: SpecificEnthalpy\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: quotient of enthalpy and mass: `h = H/m` where `H` is enthalpy (item 5-20.3) and `m` is mass (ISO 80000-4)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificEnthalpyUnit[1];\n    }\n\n    attribute specificEnthalpy: SpecificEnthalpyValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificEnthalpyUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF); }\n    }\n\n    /* ISO-80000-5 item 5-21.4 specific Helmholtz energy, specific Helmholtz function */\n    attribute specificHelmholtzEnergy: SpecificEnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-21.4 specific Helmholtz energy, specific Helmholtz function\n         * symbol(s): `a`, `f`\n         * application domain: generic\n         * name: SpecificHelmholtzEnergy (specializes SpecificEnergy)\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: quotient of Helmholtz energy and mass: `a = A/m` where A is Helmholtz energy (item 5-20.4) and m is mass (ISO 80000-4)\n         * remarks: The name specific Helmholtz free energy is also used. However, this term is not recommended.\n         */\n    }\n\n    alias specificHelmholtzFunction for specificHelmholtzEnergy;\n\n    /* ISO-80000-5 item 5-21.5 specific Gibbs energy, specific Gibbs function */\n    attribute specificGibbsEnergy: SpecificEnergyValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-21.5 specific Gibbs energy, specific Gibbs function\n         * symbol(s): `g`\n         * application domain: generic\n         * name: SpecificGibbsEnergy (specializes SpecificEnergy)\n         * quantity dimension: L^2*T^-2\n         * measurement unit(s): J/kg, m^2*s^-2\n         * tensor order: 0\n         * definition: quotient of Gibbs energy and mass: `g = G/m` where `G` is Gibbs energy (item 5-20.5) and `m` is mass (ISO 80000-4)\n         * remarks: The name specific Gibbs free energy is also used. However, this term is not recommended.\n         */\n    }\n\n    alias specificGibbsFunction for specificGibbsEnergy;\n\n    /* ISO-80000-5 item 5-22 Massieu function */\n    attribute def MassieuFunctionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-22 Massieu function\n         * symbol(s): `J`\n         * application domain: generic\n         * name: MassieuFunction\n         * quantity dimension: L^2*M^1*T^-2*\u0398^-1\n         * measurement unit(s): J/K, kg*m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: quotient of the negative of Helmholtz energy and temperature: `J = -A/T` where `A` is Helmholtz energy (item 5-20.4) and `T` is thermodynamic temperature (item 5-1)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassieuFunctionUnit[1];\n    }\n\n    attribute massieuFunction: MassieuFunctionValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassieuFunctionUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-23 Planck function */\n    attribute def PlanckFunctionValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-23 Planck function\n         * symbol(s): `Y`\n         * application domain: generic\n         * name: PlanckFunction\n         * quantity dimension: L^2*M^1*T^-2*\u0398^-1\n         * measurement unit(s): J/K, kg*m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: quotient of the negative of Gibbs energy and temperature: `Y = -G/T` where G is Gibbs energy (item 5-20.5) and `T` is thermodynamic temperature (item 5-1)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: PlanckFunctionUnit[1];\n    }\n\n    attribute planckFunction: PlanckFunctionValue[*] nonunique :> scalarQuantities;\n\n    attribute def PlanckFunctionUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-24 Joule-Thomson coefficient */\n    attribute def JouleThomsonCoefficientValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-24 Joule-Thomson coefficient\n         * symbol(s): `\u03BC_\"JT\"`\n         * application domain: generic\n         * name: JouleThomsonCoefficient\n         * quantity dimension: L^1*M^-1*T^2*\u0398^1\n         * measurement unit(s): K/Pa, kg^-1*m*s^2*K\n         * tensor order: 0\n         * definition: change of thermodynamic temperature with respect to pressure in a Joule-Thomson process at constant enthalpy: `\u03BC_(JT) = ((partial T)/(partial p))_H` where `T` is thermodynamic temperature (item 5-1), `p` is pressure (ISO 80000-4) and H is enthalpy (item 5-20.3)\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: JouleThomsonCoefficientUnit[1];\n    }\n\n    attribute jouleThomsonCoefficient: JouleThomsonCoefficientValue[*] nonunique :> scalarQuantities;\n\n    attribute def JouleThomsonCoefficientUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 1; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = -1; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = 2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-25.1 thermal efficiency */\n    attribute def ThermalEfficiencyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-25.1 thermal efficiency\n         * symbol(s): `\u03B7`\n         * application domain: thermodynamics\n         * name: ThermalEfficiency (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of work (ISO 80000-4) delivered by a heat engine and supplied heat: `\u03B7 = W/Q` where `W` is work (ISO 80000-4) and `Q` is heat (item 5-6.1)\n         * remarks: None.\n         */\n    }\n    attribute thermalEfficiency: ThermalEfficiencyValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-25.2 maximum thermal efficiency */\n    attribute def MaximumThermalEfficiencyValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-25.2 maximum thermal efficiency\n         * symbol(s): `\u03B7_\"max\"`\n         * application domain: generic\n         * name: MaximumThermalEfficiency (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: efficiency determined by the quotient of the temperatures of the hot source and the cold sink: `\u03B7_max = 1 - T_c/T_h` where `T_c` is the thermodynamic temperature (item 5-1) of the cold sink and `T_h` is the thermodynamic temperature (item 5-1) of the hot source\n         * remarks: An ideal heat engine operating according to the Carnot process is delivering the maximum efficiency.\n         */\n    }\n    attribute maximumThermalEfficiency: MaximumThermalEfficiencyValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-26 specific gas constant */\n    attribute def SpecificGasConstantValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-26 specific gas constant\n         * symbol(s): `R_s`\n         * application domain: generic\n         * name: SpecificGasConstant\n         * quantity dimension: L^2*T^-2*\u0398^-1\n         * measurement unit(s): J/(kg*K), m^2*s^-2*K^-1\n         * tensor order: 0\n         * definition: quotient of the Boltzmann constant `k` (ISO 80000-1) and the mass `m` (ISO 80000-4) of the gas particle\n         * remarks: None.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: SpecificGasConstantUnit[1];\n    }\n\n    attribute specificGasConstant: SpecificGasConstantValue[*] nonunique :> scalarQuantities;\n\n    attribute def SpecificGasConstantUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = 2; }\n        private attribute durationPF: QuantityPowerFactor[1] { :>> quantity = isq.T; :>> exponent = -2; }\n        private attribute thermodynamicTemperaturePF: QuantityPowerFactor[1] { :>> quantity = isq.'\u0398'; :>> exponent = -1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, durationPF, thermodynamicTemperaturePF); }\n    }\n\n    /* ISO-80000-5 item 5-27 mass concentration of water */\n    attribute def MassConcentrationOfWaterValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-27 mass concentration of water\n         * symbol(s): `w`\n         * application domain: generic\n         * name: MassConcentrationOfWater\n         * quantity dimension: L^-3*M^1\n         * measurement unit(s): kg*m^-3\n         * tensor order: 0\n         * definition: quotient of mass of water and a specified volume: `w = m/V` where `m` is mass (ISO 80000-4) of water, irrespective of the form of aggregation state, and `V` is volume (ISO 80000-3)\n         * remarks: Mass concentration of water at saturation is denoted `w_\"sat\"`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassConcentrationOfWaterUnit[1];\n    }\n\n    attribute massConcentrationOfWater: MassConcentrationOfWaterValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassConcentrationOfWaterUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-5 item 5-28 mass concentration of water vapour absolute humidity */\n    attribute def MassConcentrationOfWaterVapourAbsoluteHumidityValue :> ScalarQuantityValue {\n        doc\n        /*\n         * source: item 5-28 mass concentration of water vapour absolute humidity\n         * symbol(s): `v`\n         * application domain: generic\n         * name: MassConcentrationOfWaterVapourAbsoluteHumidity\n         * quantity dimension: L^-3*M^1\n         * measurement unit(s): kg*m^-3\n         * tensor order: 0\n         * definition: quotient of mass of water vapour and a specified volume: `v = m/V` where m is mass (ISO 80000-4) of water vapour and `V` is volume (ISO 80000-3)\n         * remarks: Mass concentration of water vapour at saturation is denoted `v_\"sat\"`.\n         */\n        attribute :>> num: Real;\n        attribute :>> mRef: MassConcentrationOfWaterVapourAbsoluteHumidityUnit[1];\n    }\n\n    attribute massConcentrationOfWaterVapourAbsoluteHumidity: MassConcentrationOfWaterVapourAbsoluteHumidityValue[*] nonunique :> scalarQuantities;\n\n    attribute def MassConcentrationOfWaterVapourAbsoluteHumidityUnit :> DerivedUnit {\n        private attribute lengthPF: QuantityPowerFactor[1] { :>> quantity = isq.L; :>> exponent = -3; }\n        private attribute massPF: QuantityPowerFactor[1] { :>> quantity = isq.M; :>> exponent = 1; }\n        attribute :>> quantityDimension { :>> quantityPowerFactors = (lengthPF, massPF); }\n    }\n\n    /* ISO-80000-5 item 5-29 mass ratio of water to dry matter */\n    attribute def MassRatioOfWaterToDryMatterValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-29 mass ratio of water to dry matter\n         * symbol(s): `u`\n         * application domain: generic\n         * name: MassRatioOfWaterToDryMatter (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mass of water and mass of dry matter: `u = m/m_d` where `m` is mass (ISO 80000-4) of water and `m_d` is mass of dry matter\n         * remarks: Mass ratio of water to dry matter at saturation is denoted `u_\"sat\"`.\n         */\n    }\n    attribute massRatioOfWaterToDryMatter: MassRatioOfWaterToDryMatterValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-30 mass ratio of water vapour to dry gas */\n    attribute def MassRatioOfWaterVapourToDryGasValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-30 mass ratio of water vapour to dry gas\n         * symbol(s): `r`, `(x)`\n         * application domain: generic\n         * name: MassRatioOfWaterVapourToDryGas (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mass of water vapour and mass of dry gas: `r = m/m_d` where `m` is mass (ISO 80000-4) of water vapour and `m_d` is mass of dry gas\n         * remarks: Mass ratio of water vapour to dry gas at saturation is denoted `r_\"sat\"`. Mass ratio of water vapour to dry gas is also called mixing ratio.\n         */\n    }\n    attribute massRatioOfWaterVapourToDryGas: MassRatioOfWaterVapourToDryGasValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-31 mass fraction of water */\n    attribute def MassFractionOfWaterValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-31 mass fraction of water\n         * symbol(s): `w_(H_(2)O)`\n         * application domain: generic\n         * name: MassFractionOfWater (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantity given by: `w_(H_(2)O) = u/(1+u)` where `u` is mass ratio of water to dry matter (item 5-29)\n         * remarks: None.\n         */\n    }\n    attribute massFractionOfWater: MassFractionOfWaterValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-32 mass fraction of dry matter */\n    attribute def MassFractionOfDryMatterValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-32 mass fraction of dry matter\n         * symbol(s): `w_d`\n         * application domain: generic\n         * name: MassFractionOfDryMatter (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quantity given by: `w_d = 1 - w_(H_(2)O)` where `w_(H_(2)O)` is mass fraction of water (item 5-31)\n         * remarks: None.\n         */\n    }\n    attribute massFractionOfDryMatter: MassFractionOfDryMatterValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-33 relative humidity */\n    attribute def RelativeHumidityValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-33 relative humidity\n         * symbol(s): `\u03C6`\n         * application domain: generic\n         * name: RelativeHumidity (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of partial pressure of water vapour and partial pressure at its saturation: `\u03C6 = p/p_\"sat\"` where `p` is partial pressure (ISO 80000-4) of vapour and `p_\"sat\"` is its partial pressure at saturation at the same temperature\n         * remarks: Relative humidity is often referred to as RH and expressed in percent. See also remark in item 5-35.\n         */\n    }\n    attribute relativeHumidity: RelativeHumidityValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-34 relative mass concentration of vapour */\n    attribute def RelativeMassConcentrationOfVapourValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-34 relative mass concentration of vapour\n         * symbol(s): `\u03C6`\n         * application domain: generic\n         * name: RelativeMassConcentrationOfVapour (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mass concentration of water vapour and mass concentration at its saturation: `\u03C6 = v/v_\"sat\"` where `v` is mass concentration of water vapour (item 5-28) and `v_\"sat\"` is its mass concentration of water vapour at saturation of the same temperature\n         * remarks: For water vapour concentrations up to 1 kg/m^3, the relative humidity (item 5-33) is assumed to be equal to relative mass concentration of vapour. For details see Reference [8].\n         */\n    }\n    attribute relativeMassConcentrationOfVapour: RelativeMassConcentrationOfVapourValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-35 relative mass ratio of vapour */\n    attribute def RelativeMassRatioOfVapourValue :> DimensionOneValue {\n        doc\n        /*\n         * source: item 5-35 relative mass ratio of vapour\n         * symbol(s): `\u03C8`\n         * application domain: generic\n         * name: RelativeMassRatioOfVapour (specializes DimensionOneQuantity)\n         * quantity dimension: 1\n         * measurement unit(s): 1\n         * tensor order: 0\n         * definition: quotient of mass ratio of water vapour to dry gas and mass ratio of water vapour to dry gas at saturation: `\u03C8 = r/r_\"sat\"` where `r` is mass ratio of water vapour to dry gas (item 5-30) and `r_\"sat\"` is its mass ratio of water vapour to dry gas at saturation of the same temperature\n         * remarks: This quantity is also used as an approximation of relative humidity (item 5-33).\n         */\n    }\n    attribute relativeMassRatioOfVapour: RelativeMassRatioOfVapourValue :> scalarQuantities;\n\n    /* ISO-80000-5 item 5-36 dew-point temperature */\n    attribute dewPointTemperature: ThermodynamicTemperatureValue :> scalarQuantities {\n        doc\n        /*\n         * source: item 5-36 dew-point temperature\n         * symbol(s): `T_d`\n         * application domain: generic\n         * name: DewPointTemperature (specializes ThermodynamicTemperature)\n         * quantity dimension: \u0398^1\n         * measurement unit(s): K\n         * tensor order: 0\n         * definition: temperature at which water vapour in the air reaches saturation under isobaric conditions\n         * remarks: The corresponding Celsius temperature, denoted `t_d`, is still called dew-point temperature. The unit for the corresponding Celsius temperature is degree Celsius, symbol \xB0C.\n         */\n    }\n\n}\n", "Domain Libraries/Quantities and Units/MeasurementRefCalculations.sysml": "standard library package MeasurementRefCalculations {\n	doc\n	/*\n	 * This package package defines calculations on MeasurementUnits and CoordinateFrames.\n	 */\n	 \n    private import ScalarValues::String;\n    private import ScalarValues::Real;\n    private import MeasurementReferences::MeasurementUnit;\n    private import MeasurementReferences::ScalarMeasurementReference;\n    private import MeasurementReferences::CoordinateFrame;\n        \n    /* MeasurementUnit operations */\n    calc def '*' specializes DataFunctions::'*' { in x: MeasurementUnit[1]; in y: MeasurementUnit[1]; return : MeasurementUnit[1]; }\n    calc def '/' specializes DataFunctions::'/' { in x: MeasurementUnit[1]; in y: MeasurementUnit[1]; return : MeasurementUnit[1]; }\n    calc def '**' specializes DataFunctions::'**' { in x: MeasurementUnit[1]; in y: Real[1]; return : MeasurementUnit[1]; }\n    calc def '^' specializes DataFunctions::'^' { in x: MeasurementUnit[1]; in y: Real[1]; return : MeasurementUnit[1]; }\n\n    /* CoordinateFrame and MeasurementUnit operations */\n    calc def 'CoordinateFrame*' specializes DataFunctions::'*' { in x: CoordinateFrame[1]; in y: MeasurementUnit[1]; return : CoordinateFrame[1]; }\n    calc def 'CoordinateFrame/' specializes DataFunctions::'/' { in x: CoordinateFrame[1]; in y: MeasurementUnit[1]; return : CoordinateFrame[1]; }\n\n    calc def ToString specializes BaseFunctions::ToString { \n        doc \n        /*\n         * Returns the Unicode string symbol representing a scalar measurement reference.\n         */\n        in x: ScalarMeasurementReference[1]; return : String[1];\n    }\n}\n", "Domain Libraries/Quantities and Units/MeasurementReferences.sysml": `standard library package MeasurementReferences {
	doc
	/*
	 * This package defines the representations for measurement references.
	 */

	private import Collections::Array;
	private import Collections::List;
	private import ScalarValues::*;
	private import VectorValues::ThreeVectorValue;

	private import SequenceFunctions::size;
	private import SequenceFunctions::equals;
	private import ControlFunctions::forAll;
	private import Quantities::QuantityDimension;
	private import Quantities::VectorQuantityValue;
	private import Quantities::scalarQuantities;
	private import Quantities::ScalarQuantityValue;
	private import Quantities::SystemOfQuantities;
	private import ISQSpaceTime::angularMeasure;

	attribute def TensorMeasurementReference :> Array {
		doc
		/*
		 * TensorMeasurementReference is the most general AttributeDefinition to represent measurement references.
		 *
		 * The concept "measurement reference" is defined in [VIM] "quantity" NOTE 2 as "A reference can be a measurement unit,
		 * a measurement procedure, a reference material, or a combination of such.", see https://jcgm.bipm.org/vim/en/1.1.html .
		 * In addition [VIM] "quantity" NOTE 5 states that "A quantity as defined here is a scalar. However, a vector or a tensor, 
		 * the components of which are quantities, is also considered to be a quantity". However, the rest of [VIM] does not explicitly 
		 * define how tensor and vector quantities can be or should be supported.
		 *
		 * In this package, in line with TensorQuantityValue in package Quantities, the most general kind of measurement reference
		 * is TensorMeasurementReference that represents a measurement reference for any order of tensor quantity. Since the order can 
		 * also be one or zero, this includes vector and scalar quantities. The specializations VectorMeasurementReference and 
		 * ScalarMeasurementReference are defined to specifically represent measurement references for vector and scalar quantities.
		 * 
		 * TensorMeasurementReference specializes Array, which provides its multi-dimensional structure. The order of a tensor is equivalent
		 * to the rank of an Array.
		 * 
		 * Attribute isBound specifies whether the vector space product is bound (isBound is true) or free (isBound is false).
		 * 
		 * Attribute mRefs specifies the scalar measurement references for all dimensions of a tensor quantity.
		 *
		 * The short name of a TensorMeasurementReference is the unique symbol by which the measurement reference is known.
		 * The name of a TensorMeasurementReference is spelled-out human readable name of the measurement reference.
		 *
		 * For example, typical measurement references for (scalar) quantity speed are declared with the following humanId and name:
		 * <'m/s'> and 'metre per second',
		 * <'km/h'> and 'kilometre per hour',
		 * <'mi/h'> and 'mile per hour'.
		 *
		 * A measurement reference can have zero or more definitionalQuantityValues that allow to specify
		 * quantity values that carry a particular meaning or relevance for the measurement reference.
		 */
	
		attribute isBound: Boolean[1] default false;
		attribute order :>> rank;
		attribute mRefs: ScalarMeasurementReference[1..*] nonunique :>> elements;
		attribute definitionalQuantityValues: DefinitionalQuantityValue[0..*];
	}

	attribute def VectorMeasurementReference :> TensorMeasurementReference {
		doc
		/*
		 * A VectorMeasurementReference is a specialization of TensorMeasurementReference for vector quantities that are
		 * typed by a VectorQuantityValue. Its order is one. Implicitly, it defines a vector space of dimension \`n\` = dimensions[1].
		 * The magnitudes of the \`n\` basis unit vectors that span the vector space are defined by the mRefs which each are
		 * a ScalarMeasurementReference, typically a MeasurementUnit or an IntervalScale.
		 * 
		 * Attribute isOrthogonal declares whether the basis vectors of the vector space are orthogonal, i.e., whether all
		 * inner products of any pair of basis vectors are equal to zero.
		 * 
		 * A pair of a specialization of VectorQuantityValue and a specialization of VectorMeasurementReference can also be used to
		 * define a vector space for state vectors as used in state-space representation models.
		 */
	
		attribute :>> dimensions: Positive[0..1];
		attribute isOrthogonal: Boolean[1] default true;
	}

	abstract attribute def ScalarMeasurementReference :> VectorMeasurementReference {
		doc
		/*
		 * A ScalarMeasurementReference is a specialization of VectorMeasurementReference for scalar quantities
		 * that are typed by a ScalarQuantityValue and for components of tensor or vector quantities.
		 * Its order is zero. A ScalarMeasurementReference is also a generalization of MeasurementUnit and MeasurementScale.
		 * It establishes how to interpret the numerical value (num) of a ScalarQuantityValue or a component of
		 * a tensor or vector quantity value, and establishes its actual quantity dimension.
		 *
		 * Attribute mRefs is bound to self for a ScalarMeasurementReference, for consistency with tensor and vector measurement references,
		 * as the dimension or component of a scalar quantity is itself.
		 */
	
		attribute :>> dimensions = ();
		attribute :>> isOrthogonal = true;
		attribute :>> mRefs = self;
		attribute quantityDimension: QuantityDimension[1];
	}
	
	attribute def CoordinateFrame :> VectorMeasurementReference {
		doc
		/*
		 * CoordinateFrame is a VectorMeasurementReference with the specific purpose to quantify (i.e., coordinatize) a vector space, 
		 * and locate and orient it with respect to another CoordinateFrame.
		 * 
		 * Optional attribute transformation enables specification of the location and orientation of this CoordinateFrame as dependent
		 * and nested with respect to another (reference) coordinate frame. Typically the other CoordinateFrame is the frame of 
		 * the next higher element (Object, Item or Part) in a composite structure.
		 */
	
		attribute transformation: CoordinateTransformation[0..1] {
			attribute :>> target = that;
		}
	}

    attribute def '3dCoordinateFrame' :> CoordinateFrame {
        doc
    	/*
         * Most general 3-dimensional coordinate frame
         */
        attribute :>> dimensions = 3;
    }
    alias ThreeDCoordinateFrame for '3dCoordinateFrame';

    abstract attribute def CoordinateTransformation {
        doc
        /*
	     * CoordinateTransformation is the most general representation of the transformation of a target VectorMeasurementReference 
	     * with respect to a source VectorMeasurementReference.
	     */
	 	attribute source: VectorMeasurementReference[1];
	 	attribute target: VectorMeasurementReference[1];
	 	assert constraint validSourceTargetDimensions { source.dimensions == target.dimensions }
    }

	attribute def CoordinateFramePlacement :> CoordinateTransformation {
    	doc
    	/*
    	 * CoordinateFramePlacement is a CoordinateTransformation by placement of the target frame in the source frame.
    	 *  
    	 * Attribute origin specifies the location of the origin of the target frame as a vector in the source frame.
    	 * 
    	 * Attribute basisDirections specifies the orientation of the target frame by specifying the directions of 
    	 * the respective basis vectors of the target frame via direction vectors in the source frame. An empty sequence of
    	 * basisDirections signifies no change of orientation of the target coordinate frame.
    	 */

		attribute origin : VectorQuantityValue[1];
		attribute basisDirections : VectorQuantityValue[0..*] ordered nonunique;
		assert constraint validOriginDimensions { origin.dimensions == source.dimensions }
		assert constraint { size(basisDirections) == 0 or size(basisDirections) == source.dimensions#(1)}
        assert constraint validateBasisDirections { basisDirections->forAll { in basisDirection : VectorQuantityValue; 
            basisDirection.dimensions->equals(source.dimensions) }
        }
	 }

	abstract attribute def TranslationOrRotation {
		doc
		/*
		 * TranslationOrRotation is an abstract union of Translation and Rotation
		 */
	}

	attribute def Translation :> TranslationOrRotation {
		doc
		/*
		 * Representation of a translation with respect to a coordinate frame
		 * 
		 * Attribute translationVector specifies the displacement vector that constitutes the translation.
		 */
	
		attribute translationVector : VectorQuantityValue[1];
	}

	attribute def Rotation :> TranslationOrRotation {
		doc
		/*
		 * Representation of a rotation about an axis over an angle
		 * 
		 * Attribute axisDirection specifies the direction of the rotation axis.
		 * Attribute angle specifies the angle of rotation, where a positive value implies right-handed rotation.
		 * Attribute isIntrinsic asserts whether the intermediate coordinate frame moves with the rotation or not, 
		 * i.e. whether an instrinsic or extrinsic rotation is specified.
		 * 
		 * See https://en.wikipedia.org/wiki/Davenport_chained_rotations for details.
		 */
	
		attribute axisDirection : VectorQuantityValue[1];
		attribute angle :>> angularMeasure;
		attribute isIntrinsic : Boolean[1] default true;
	}

	attribute def TranslationRotationSequence :> CoordinateTransformation, List {
	doc
	/*
	 * Coordinate frame transformation specified by a sequence of translations and/or rotations
	 *
	 * Note: This is a coordinate transformation that is convenient for interpretation by humans.
	 * In particular a sequence of rotations about the principal axes of a coordinate frame is much more easy understandable 
	 * than a rotation about an arbitrary axis.
	 * Any sequence can be reduced to a single combination of a translation and a rotation about a particular axis, but in general 
	 * the original sequence cannot be retrieved as there are infinitely many sequences representing the reduced transformation.
	 */
	
		attribute :>> elements : TranslationOrRotation[1..*] ordered nonunique;
	}

	attribute def AffineTransformationMatrix3d :> CoordinateTransformation, Array {
		doc
		/*
		 * AffineTransformationMatrix3d is a three dimensional CoordinateTransformation specified via an affine transformation matrix
		 *
		 * The interpretation of the matrix is as follows:
		 * - the upper left 3x3 matrix represents the rotation matrix
		 * - the uper right 3x1 column vector represents the translation vector
		 * - the bottom row must be the row vector (0, 0, 0, 1).
		 *
		 * I.e. the matrix has the following form:
		 * ( R, R, R, T,
		 *   R, R, R, T,
		 *   R, R, R, T,
		 *   0, 0, 0, 1 )
		 * where the cells marked R form the rotation matrix and the cells marked T form the translation vector.
		 * 
		 * Note: See https://en.wikipedia.org/wiki/Transformation_matrix, under affine transformations for a general explanation.
		 */
	
		    attribute rotationMatrix : Array {
				attribute :>> elements : Real[9] ordered nonunique;
				attribute :>> dimensions = (3, 3);
		    }
			attribute translationVector : ThreeVectorValue[1] { :>> elements : Real[3]; }
			attribute :>> dimensions = (4, 4);
			attribute :>> elements : Real[16] ordered nonunique = (
				rotationMatrix.elements#(1), rotationMatrix.elements#(2), rotationMatrix.elements#(3), translationVector#(1),
				rotationMatrix.elements#(4), rotationMatrix.elements#(5), rotationMatrix.elements#(6), translationVector#(2),
				rotationMatrix.elements#(7), rotationMatrix.elements#(8), rotationMatrix.elements#(9), translationVector#(3),
				0, 0, 0, 1);
			assert constraint validSourceDimensions { source.dimensions == 3 }
	}

	attribute def NullTransformation :> AffineTransformationMatrix3d {
		doc
		/*
		 * NullTransformation is a three dimensional CoordinateTransformation that places the target CoordinateFrame at the
		 * same position and orientation as the source CoordinateFrame.
		 */
		 attribute :>> rotationMatrix {
		     attribute :>> elements = (1, 0, 0, 0, 1, 0, 0, 0, 1);
		 }
		 attribute :>> translationVector {
		     attribute :>> elements = (0, 0, 0);
		 }
 	}

	attribute nullTransformation : NullTransformation [1];

	abstract attribute def MeasurementUnit :> ScalarMeasurementReference {
		doc
		/*
		 * Representation of a measurement unit.
		 *
		 * Note: MeasurementUnit directly specializes ScalarMeasurementReference in order to allow for efficient and intuitive definition of a ratio scale.
		 *
		 * A MeasurementUnit can be used in two ways:
		 * 1. Directly as the mRef in a ScalarQuantityValue, which implies that the effective measurement reference is a ratio scale defined by the unit.
		 * 2. As the unit of a MeasurementScale.
		 *
		 * A MeasurementUnit specifies one or more UnitPowerFactors.
		 */
	
		attribute :>> isBound = false;
		attribute unitPowerFactors: UnitPowerFactor[0..*] ordered;
		attribute unitConversion: UnitConversion[0..1];
        assert constraint hasValidUnitPowerFactors : VerifyUnitPowerFactors {
        	in unitPowerFactors = MeasurementUnit::unitPowerFactors;
        	in quantityDimension = MeasurementUnit::quantityDimension;
		}
	}


	abstract attribute def SimpleUnit :> MeasurementUnit {
		doc
		/*
		 * Representation of a measurement unit that does not depend on any other measurement unit.
		 */
	
		private attribute simpleUnitSelf: SimpleUnit = self;
	    attribute :>> unitPowerFactors: UnitPowerFactor[1] {
			attribute unit :>> UnitPowerFactor::unit = simpleUnitSelf;
			attribute exponent :>> UnitPowerFactor::exponent = 1;
		}
	}


	abstract attribute def DerivedUnit :> MeasurementUnit {
		doc
		/*
		 * Representation of a derived measurement unit that depends on one or more powers of other measurement units.
		 *
		 * VIM defines "derived unit" as "measurement unit for a derived quantity", see https://jcgm.bipm.org/vim/en/1.11.html .
		 */
	}


	attribute def UnitPowerFactor {
		doc
		/*
		 * Representation of a measurement unit power factor, which is a tuple
		 * of a referenced measurement unit and an exponent.
		 */
	
		attribute unit: MeasurementUnit;
		attribute exponent: Real;
	}

	abstract attribute def UnitConversion {
		doc
		/*
		 * Representation of the linear conversion relationship between one measurement unit and another measurement unit, that acts as a reference.
		 *
		 * Attribute isExact asserts whether the conversionFactor is exact or not. By default it is set true.
		 */
	
		attribute referenceUnit: MeasurementUnit;
		attribute conversionFactor: Real;
		attribute isExact: Boolean default true;
	}

	attribute def ConversionByConvention :> UnitConversion {
		doc
		/*
		 * Representation of a UnitConversion that is defined according to some convention.
		 */
	}

	attribute def ConversionByPrefix :> UnitConversion {
		doc
		/*
		 * Representation of a UnitConversion that is defined through reference to a named unit prefix,
		 * that in turn represents a decimal or binary multiple or sub-multiple, as defined in ISO/IEC 80000-1.
		 *
		 * Note: The actual value of the conversion factor is derived from the definition of the unit prefix.
		 *
		 * Examples: kilometre for conversion factor 1000 with reference unit metre, nanofarad for 1E-9 farad.
		 */
	
		attribute prefix: UnitPrefix[1];
		attribute conversionFactor redefines UnitConversion::conversionFactor = prefix.conversionFactor;
	}

	attribute def UnitPrefix {
		doc
		/*
		 * Representation of a multiple or sub-multiple measurement unit prefix as defined in ISO/IEC 80000-1.
		 */
	
		attribute longName: String;
		attribute symbol: String;
		attribute conversionFactor: Real;
	}


	abstract attribute def MeasurementScale :> ScalarMeasurementReference {
		doc
		/*
		 * Representation of a non-ratio measurement scale as opposed to a ratio measurement scale defined by a MeasurementUnit.
		 *
		 * Note: A ratio scale is implied by direct use of a MeasurementUnit as the mRef in a ScalarQuantityValue.
		 */
	
		attribute unit: MeasurementUnit;
		attribute quantityValueMapping: QuantityValueMapping[0..1];
	}

	attribute def OrdinalScale :> MeasurementScale {
		doc
		/*
		 * Representation of an ordinal measurement scale.
		 */
	}

	attribute def IntervalScale :> MeasurementScale, CoordinateFrame {
		doc
		/*
		 * Representation of an interval measurement scale.
		 *
		 * An IntervalScale is also a CoordinateFrame
		 * The offset of one interval measurement scale w.r.t. another interval or ratio scale is defined through a quantityValueMapping, see MeasurementReference.
		 */
	
		attribute :>> isBound = true;
	}

	attribute def CyclicRatioScale :> MeasurementScale {
		doc
		/*
		 * Representation of a ratio measurement scale with a periodic cycle.
		 *
		 * Note: The magnitude of the periodic cycle is defined by the modulus of the scale.
		 * Example: Planar angle with modulus 360 degrees, therefore on such a cyclic ratio scale,
		 * an angle of 450 degrees is equivalent to an angle of 90 degrees, and -60 degrees is equivalent to 300 degrees.
		 */
	
		attribute modulus: Number;
	}

	attribute def LogarithmicScale :> MeasurementScale {
		doc
		/*
		 * Representation of a logarithmic measurement scale
		 *
		 * The magnitude v of a ratio quantity value expressed on a logarithmic scale
		 * for a magnitude x of a quantity value expressed on a ratio scale is computed as follows:
		 *   v = f * log_base( (x / x_ref )^a )
	     * where:
		 *   f is a multiplication factor,
	     *   log_base is the log function for the given logarithm base,
	     *   x is the actual quantity,
	     *   x_ref is a reference quantity,
	     *   a is an exponent.
		 */
	
		attribute logarithmBase: Number;
		attribute factor: Number;
		attribute exponent: Number;
		attribute referenceQuantity: ScalarQuantityValue[0..1];
	}

	attribute def QuantityValueMapping {
		doc
		/*
		 * Representation of the mapping of equivalent quantity values expressed on two different MeasurementReferences
		 *
		 * A QuantityValueMapping specifies a mapping from a given mappedQuantityValue owned by the MeasurementReference
		 * that owns the QuantityValueMapping to a referenceQuantityValue owned by another MeasurementReference.
		 *
		 * Example: The mapping between the temperature value of 0.01 degree Celsius on the celsius temperature scale
		 * to the equivalent temperature value of 273.16 K on the kelvin temperature scale,
		 * would specify a mappedQuantityValue referencing the
		 * the DefinitionalQuantityValue (0.01, "absolute thermodynamic temperature of the triple point of water")
		 * of the celsius interval scale, and a referenceQuantityValue referencing the
		 * DefinitionalQuantityValue (273.16, "absolute thermodynamic temperature of the triple point of water")
		 * of the kelvin ratio scale.
		 */
	
		attribute mappedQuantityValue: DefinitionalQuantityValue;
		attribute referenceQuantityValue: DefinitionalQuantityValue;
	}

	attribute def DefinitionalQuantityValue {
		doc
		/*
		 * Representation of a particular quantity value that is used in the definition of a TensorMeasurementReference
		 *
		 * Typically such a particular value is defined by convention. It can be used to define a selected reference value,
		 * such as the meaning of zero on a measurement scale or the origin of a top-level coordinate frame.
		 *
		 * Example: The 'kelvin' MeasurementReference for thermodynamic temperature could have a
		 * DefinitionalQuantityValue {
		 *     :>> num = 273.16;
		 *     :>> definition = "thermodynamic temperature of the triple point of Vienna Standard Mean Ocean Water in kelvin";
		 * }
		 * that is value of the definition of the scale.
		 */
	
		attribute num: Number[1..*];
		attribute definition: String;
	}

	attribute def DimensionOneUnit :> DerivedUnit {
		doc
		/*
		 * Explicit definition of "unit of dimension one", also known as "dimensionless unit".
		 */
	
		attribute :>> unitPowerFactors = ();
	}
	attribute def DimensionOneValue :> ScalarQuantityValue {
		doc
		/*
		 * A ScalarQuantityValue with a DimensionOneUnit.
		 */
		attribute :>> num: Real;
		attribute :>> mRef: DimensionOneUnit;
	}
	attribute dimensionOneQuantities : DimensionOneValue[*] nonunique :> scalarQuantities;

	attribute one : DimensionOneUnit[1] = new DimensionOneUnit();

	attribute def CountValue :> DimensionOneValue {
		doc
		/*
		 * Explicit definition of a generic "count" quantity as a DimensionOneValue.
		 */
	}
	attribute countQuantities : CountValue[*] nonunique :> dimensionOneQuantities;

	attribute def SystemOfUnits {
		doc
		/*
		 * A SystemOfUnits represents the essentials of [VIM] concept "system of units" (https://jcgm.bipm.org/vim/en/1.13.html), defined as a
		 * "set of base units and derived units, together with their multiples and submultiples, defined in accordance with given rules,
		 * for a given system of quantities".
		 * The base units are a particular selection of measurement units for each of the base quantities of a system of quantities,
		 * that form the basis on top of which all other (derived) units are defined.
		 *
		 * Attribute systemOfQuantities speficies the associated SystemOfQuantities.
		 */
	
		attribute longName: String[1];
		attribute systemOfQuantities : SystemOfQuantities[1];
		attribute baseUnits: SimpleUnit[1..*] ordered;
	}

    constraint def VerifyUnitPowerFactors {
		doc
		/*
		 * Constraint definition to verify that the given unit power factors comply with the required quantity dimension
		 */
	
    	in unitPowerFactors: UnitPowerFactor[*] ordered;
    	in quantityDimension: QuantityDimension[1];
	}
}
`, "Domain Libraries/Quantities and Units/Quantities.sysml": `standard library package Quantities {
	doc
	/*
	 * This package defines the root representations for quantities and their values.
	 */

	private import Collections::*;
	private import ScalarValues::NumericalValue;
	private import ScalarValues::Number;
	private import ScalarValues::Real;
	private import ScalarValues::Natural;
	private import ScalarValues::Boolean;
	private import ScalarValues::String;
	private import VectorValues::NumericalVectorValue;
	private import VectorValues::ThreeVectorValue;

	abstract attribute def TensorQuantityValue :> Array {
		doc
		/*
		 * The value of a quantity is a tuple of one or more numbers (i.e. mathematical number values) and a reference to a measurement reference.
		 * The most general case is a multi-dimensional, tensor quantity of any order. In engineering, the majority of quantities used are 
		 * scalar and vector quantities, that are tensor quantities of order 0 and 1 respectively.
		 * The measurement reference used to express a quantity value must have a type, dimensions and order that match the quantity, i.e.,
		 * a TensorQuantityValue must use a TensorMeasurementReference, a VectorQuantityValue a VectorMeasurementReference, 
		 * and a ScalarQuantityValue a ScalarMeasurementReference. See package MeasurementReferences for details.
		 */
	
		attribute isBound: Boolean;
		attribute num: Number[1..*] ordered nonunique :>> elements;
		attribute mRef: MeasurementReferences::TensorMeasurementReference;
        attribute :>> dimensions = mRef.dimensions;
		attribute order :>> rank;
        attribute contravariantOrder: Natural;
        attribute covariantOrder: Natural;

        assert constraint orderSum { contravariantOrder + covariantOrder == order }
        assert constraint boundMatch { (isBound == mRef.isBound) or (not isBound and mRef.isBound) }
	}

	abstract attribute def VectorQuantityValue :> TensorQuantityValue, NumericalVectorValue {
		attribute :>> mRef: MeasurementReferences::VectorMeasurementReference;
	}

	abstract attribute def ScalarQuantityValue :> VectorQuantityValue, NumericalValue {
		attribute :>> mRef: MeasurementReferences::ScalarMeasurementReference;
	}
	
	abstract attribute tensorQuantities: TensorQuantityValue[*] nonunique {
		doc
		/*
		 * Quantities are defined as self-standing features that can be used to consistently specify quantities as 
		 * features of occurrences. Each single quantity feature is subsetting the root feature tensorQuantities. 
		 * In other words, the codomain of a quantity feature is a suitable specialization of TensorQuantityValue.
		 */
	}
	abstract attribute vectorQuantities: VectorQuantityValue[*] nonunique :> tensorQuantities;
	abstract attribute scalarQuantities: ScalarQuantityValue[*] nonunique :> vectorQuantities;

	abstract attribute def '3dVectorQuantityValue' :> VectorQuantityValue, ThreeVectorValue {
        doc
    	/*
    	 * Most general representation of real 3-vector quantities
    	 */

        attribute :>> num: Real[3];
	}
	alias ThreeDVectorQuantityValue for '3dVectorQuantityValue';
	
    /*
     * Define generic aliases QuantityValue and quantities for the top level quantity attribute def and attribute.
     */
	alias QuantityValue for TensorQuantityValue;
	alias quantities for tensorQuantities;

	attribute def SystemOfQuantities {
		doc
		/*
		 * A SystemOfQuantities represents the essentials of [VIM] concept "system of quantities" (https://jcgm.bipm.org/vim/en/1.3.html), defined as a
		 * "set of quantities together with a set of noncontradictory equations relating those quantities".
		 * In order to establish such a set of noncontradictory equations a set of base quantities is selected. Subsequently the system of quantities is 
		 * completed by adding derived quantities which are products of powers of the base quantities.
		 */
	
		attribute baseQuantities: ScalarQuantityValue[*] ordered :> scalarQuantities;
	}

	attribute def QuantityPowerFactor {
		doc
		/*
		 * Representation of a quantity power factor, being the combination of a quantity and an exponent.
		 * 
		 * A sequence of QuantityPowerFactors for the baseQuantities of a SystemOfQuantities define the QuantityDimension of a scalar quantity.
		 */
	
		attribute quantity: ScalarQuantityValue[1];
		attribute exponent: Real[1];
	}

	attribute def QuantityDimension {
		doc
		/*
		 * Representation of quantity dimension, which is the product of powers of the set of base quantities defined for a particular system of quantities, units and scales.
		 */
	
		 attribute quantityPowerFactors: QuantityPowerFactor[*] ordered;
	}
}
`, "Domain Libraries/Quantities and Units/QuantityCalculations.sysml": "standard library package QuantityCalculations {\n	doc\n	/*\n	 * This package package defines calculations for the construction of and computations on ScalarQuantityValues.\n	 */\n	 \n	private import ScalarValues::*;\n    private import Quantities::ScalarQuantityValue;\n    private import MeasurementReferences::ScalarMeasurementReference;\n    private import MeasurementReferences::DimensionOneValue;\n    \n    calc def '[' specializes BaseFunctions::'[' { \n    	in num: Number[1]; \n    	in mRef: ScalarMeasurementReference[1]; \n    	return quantity : ScalarQuantityValue[1];\n    }\n\n    calc def isZero specializes NumericalFunctions::isZero { \n    	in x: ScalarQuantityValue[1]; \n        return : Boolean[1] = NumericalFunctions::isZero(x.num);\n    }\n    calc def isUnit specializes NumericalFunctions::isUnit { \n    	in x: ScalarQuantityValue[1]; \n        return : Boolean[1] = NumericalFunctions::isUnit(x.num);\n    }\n    \n	calc def abs specializes NumericalFunctions::abs { in x: ScalarQuantityValue[1]; return : ScalarQuantityValue[1]; }\n\n	calc def '+' specializes NumericalFunctions::'+' { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[0..1]; return : ScalarQuantityValue; }\n	calc def '-' specializes NumericalFunctions::'-' { in x: ScalarQuantityValue; in y: ScalarQuantityValue[0..1]; return : ScalarQuantityValue[1]; }\n	calc def '*' specializes NumericalFunctions::'*' { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : ScalarQuantityValue[1]; }\n	calc def '/' specializes NumericalFunctions::'/' { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : ScalarQuantityValue[1]; }\n	calc def '**' specializes NumericalFunctions::'**' { in x: ScalarQuantityValue[1]; in y: Real[1]; return : ScalarQuantityValue[1]; }\n	calc def '^' specializes NumericalFunctions::'^' { in x: ScalarQuantityValue[1]; in y: Real[1]; return : ScalarQuantityValue[1]; }\n	\n	calc def '<' specializes NumericalFunctions::'<' { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : Boolean[1]; }\n	calc def '>' specializes NumericalFunctions::'>' { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : Boolean[1]; }\n	calc def '<=' specializes NumericalFunctions::'<=' { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : Boolean[1]; }\n	calc def '>=' specializes NumericalFunctions::'>=' { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : Boolean[1]; }\n\n	calc def max specializes NumericalFunctions::max { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : ScalarQuantityValue[1]; }\n	calc def min specializes NumericalFunctions::min { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : ScalarQuantityValue[1]; }\n\n	calc def '==' specializes DataFunctions::'==' { in x: ScalarQuantityValue[1]; in y: ScalarQuantityValue[1]; return : Boolean[1]; }\n		\n	calc def sqrt{ in x: ScalarQuantityValue[1]; return : ScalarQuantityValue[1]; }\n\n	calc def floor { in x: ScalarQuantityValue[1]; return : ScalarQuantityValue[1]; }\n	calc def round { in x: ScalarQuantityValue[1]; return : ScalarQuantityValue[1]; }\n	\n	calc def ToString specializes BaseFunctions::ToString { in x: ScalarQuantityValue[1]; return : String; }\n	calc def ToInteger { in x: ScalarQuantityValue[1]; return : Integer[1]; }\n	calc def ToRational { in x: ScalarQuantityValue[1]; return : Rational[1]; }\n	calc def ToReal { in x: ScalarQuantityValue[1]; return : Real[1]; }\n	calc def ToDimensionOneValue { in x: Real[1]; return : DimensionOneValue[1]; }\n	\n	calc def sum specializes NumericalFunctions::sum { in collection: ScalarQuantityValue[0..*]; \n        private attribute zero : ScalarQuantityValue[1];\n		assert constraint { isZero(zero) }\n		return : ScalarQuantityValue = NumericalFunctions::sum0(collection, zero);\n	}\n	\n	calc def product specializes NumericalFunctions::product { in collection: ScalarQuantityValue[0..*]; \n		private attribute one : ScalarQuantityValue[1];\n		assert constraint { isUnit(one) }\n        return : ScalarQuantityValue = NumericalFunctions::product1(collection, one);\n	}\n\n    calc def ConvertQuantity{ in x: ScalarQuantityValue[1]; in targetMRef: ScalarMeasurementReference[1]; return : ScalarQuantityValue[1]; }\n}\n", "Domain Libraries/Quantities and Units/SI.sysml": `standard library package SI {
	doc
	/*
	 * International System of (Measurement) Units -- Syst\xE8me International d'Unit\xE9s (SI), as defined in ISO/IEC 80000
	 *
	 * Note 1: In accordance with ISO/IEC 80000 en-GB spelling is used for the names and definitions of the units.
	 * Note 2: This is a representative but not yet complete list of measurement units.
	 */

    private import MeasurementReferences::*;
    public import ISQ::*;
    public import SIPrefixes::*;

    /*
     * SI simple unit needed in support of creation of the base units
     */
    attribute <g> gram : MassUnit;

    /*
     * SI base units
     */
    attribute <m> metre : LengthUnit;
    attribute <kg> kilogram : MassUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = kilo; :>> referenceUnit = g; } }
    attribute <s> second : DurationUnit;
    attribute <A> ampere : ElectricCurrentUnit;
    attribute <K> kelvin : ThermodynamicTemperatureUnit, TemperatureDifferenceUnit {
        attribute temperatureOfWaterAtTriplePointInK: DefinitionalQuantityValue {
            :>> num = 27316/100;
            :>> definition = "temperature in kelvin of pure water at the triple point";
        }
        attribute :>> definitionalQuantityValues = temperatureOfWaterAtTriplePointInK;
        attribute :>> ThermodynamicTemperatureUnit::quantityDimension, TemperatureDifferenceUnit::quantityDimension {
            :>> ThermodynamicTemperatureUnit::quantityDimension::quantityPowerFactors, TemperatureDifferenceUnit::quantityDimension::quantityPowerFactors;
        }
    }
    attribute <mol> mole : AmountOfSubstanceUnit;
    attribute <cd> candela : LuminousIntensityUnit;

    /*
     * Declare the SI system of units with its explicit base units
     * and its associated system of quantities, the ISQ.
     */
	attribute <si> 'ISO/IEC 80000 International System of Units' : SystemOfUnits {
		:>> systemOfQuantities = isq;
		:>> baseUnits = (m, kg, s, A, K, mol, cd);
	}

    /*
     * Units with special names
     */
    attribute <B> byte : StorageCapacityUnit = one;
    attribute <Bd> baud : ModulationRateUnit = s^-1;
    attribute <bit> bit : StorageCapacityUnit = one;
    attribute <Bq> becquerel : NuclearActivityUnit = s^-1;
    attribute <C> coulomb : ElectricChargeUnit = A*s;
    attribute <dB> decibel : SoundPressureLevelUnit = one;
    attribute <dec> decade : LogarithmicFrequencyRangeUnit = one;
    attribute <E> erlang : TrafficIntensityUnit = one;
    attribute <F> farad : CapacitanceUnit = C/V;
    attribute <Gy> gray : AbsorbedDoseUnit = J/kg;
    attribute <H> henry : PermeanceUnit, InductanceUnit = Wb/A {
        attribute :>> PermeanceUnit::quantityDimension, InductanceUnit::quantityDimension {
            :>> PermeanceUnit::quantityDimension::quantityPowerFactors, InductanceUnit::quantityDimension::quantityPowerFactors;
        }
    }
    attribute <Hart> hartley : InformationContentUnit = one;
    attribute <Hz> hertz : FrequencyUnit = s^-1;
    attribute <J> joule : EnergyUnit = N*m;
    //attribute <kat> katal : CatalyticActivityUnit = mol/s;
    attribute <lm> lumen : LuminousFluxUnit = cd*sr;
    attribute <lx> lux : IlluminanceUnit = lm/m^2;
    attribute <N> newton : ForceUnit = kg*m/s^2;
    attribute <nat> 'natural unit of information' : InformationContentUnit = one;
    attribute <o> octet : StorageCapacityUnit = one;
    attribute <oct> octave : LogarithmicFrequencyRangeUnit = one;
    attribute <Pa> pascal : PressureUnit = N/m^2;
    attribute <rad> radian : AngularMeasureUnit = m/m;
    attribute <S> siemens : ConductanceUnit = '\u03A9'^-1;
    attribute <Sh> shannon : InformationContentUnit = one;
    attribute <sr> steradian : SolidAngularMeasureUnit = m^2/m^2;
    attribute <Sv> sievert : DoseEquivalentUnit = J/kg;
    attribute <T> tesla : MagneticFluxDensityUnit = Wb/m^2;
    attribute <V> volt : ElectricPotentialUnit = W/A;
    attribute <W> watt : PowerUnit = J/s;
    attribute <Wb> weber : MagneticFluxUnit = V*s;
    attribute <'\u03A9'> ohm : ResistanceUnit = V/A;

    /*
     * Units recognized in SI as specified in ISO 80000-1:2009
     */
    attribute <'\xC5'> '\xE5ngstr\xF6m' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 1.0e-10; } }
    attribute <b> barn : AreaUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = 'm\xB2'; :>> conversionFactor = 1.0e-28; } }
    attribute <d> day: DurationUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = hour; :>> conversionFactor = 24; } }
    attribute <Da> dalton : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 1.66053906660e-27; :>> isExact = false; } }
    attribute <eV> electronvolt : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.602176487e-19; :>> isExact = false; } }
    attribute <h> hour: DurationUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = min; :>> conversionFactor = 60; } }
    attribute <min> minute : DurationUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = s; :>> conversionFactor = 60; } }
    attribute <L> litre : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = 'm\xB3'; :>> conversionFactor = 1.0e-3; } }
    attribute tonne : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 1.0e-3; } }
    alias 'metric ton' for tonne;
    attribute <u> 'atomic mass unit' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Da; :>> conversionFactor = 1.0; } }
    attribute <ua> 'astronomical unit' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 149597870691e11; :>> isExact = false; } }
    attribute <var> 'volt ampere reactive' : PowerUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = V*A; :>> conversionFactor = 1.0; } }
    attribute <'\xB0'> degree : AngularMeasureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = rad; :>> conversionFactor = 1.745329E-02; :>> isExact = false; } } // conversionFactor should become pi/180
    attribute <'\u2032'> 'minute (angle)' : AngularMeasureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = rad; :>> conversionFactor = 2.908882E-04; :>> isExact = false; } }
    alias arcmin for '\u2032';
    attribute <'\u2033'> 'second (angle)' : AngularMeasureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = rad; :>> conversionFactor = 4.848137E-06; :>> isExact = false; } }
    alias arcsec for '\u2033';

    /*
     * Derived units used in parts 3 to 12 of ISO/IEC 80000
     */
    attribute <'A\u22C5m\u207B\xB2\u22C5K\u207B\xB2'> 'ampere metre to the power minus 2 kelvin to the power minus 2' : RichardsonConstantUnit = A*m^-2*K^-2;
    attribute <'A\u22C5m\xB2'> 'ampere metre squared' : MagneticMomentUnit = A*m^2;
    attribute <'A\u22C5m\xB2\u22C5J\u207B\xB9\u22C5s\u207B\xB9'> 'ampere metre squared joule to the power minus 1 second to the power minus 1' : GyromagneticRatioUnit = A*m^2*J^-1*s^-1;
    attribute <'A\u22C5s/kg'> 'ampere second per kilogram' : GyromagneticRatioUnit = A*s/kg;
    attribute <'A/m'> 'ampere per metre' : LinearElectricCurrentDensityUnit = A/m;
    attribute <'A/m\xB2'> 'ampere per square metre' : ElectricCurrentDensityUnit = A/m^2;
    attribute <'B/s'> 'byte per second' : TransferRateUnit = B/s;
    attribute <'bit/s'> 'bit per second' : BinaryDigitRateUnit = bit/s;
    attribute <'Bq/kg'> 'becquerel per kilogram' : SpecificActivityUnit = Bq/kg;
    attribute <'Bq/m\xB2'> 'becquerel per square metre' : SurfaceActivityDensityUnit = Bq/m^2;
    attribute <'Bq/m\xB3'> 'becquerel per cubic metre' : ActivityDensityUnit = Bq/m^3;
    attribute <'C\u22C5m'> 'coulomb metre' : ElectricDipoleMomentUnit = C*m;
    attribute <'C/(kg\u22C5s)'> 'coulomb per kilogram second' : ExposureRateUnit = C/(kg*s);
    attribute <'C/kg'> 'coulomb per kilogram' : ExposureUnit = C/kg;
    attribute <'C/m'> 'coulomb per metre' : LinearDensityOfElectricChargeUnit = C/m;
    attribute <'C/m\xB2'> 'coulomb per square metre' : SurfaceDensityOfElectricChargeUnit = C/m^2;
    attribute <'C/m\xB3'> 'coulomb per cubic metre' : ElectricChargeDensityUnit = C/m^3;
    attribute <'cd\u22C5m\u207B\xB2'> 'candela metre to the power minus 2' : LuminanceUnit = cd*m^-2;
    attribute <'cd\u22C5sr'> 'candela steradian' : LuminousFluxUnit = cd*sr;
    attribute <'cd\u22C5sr\u22C5kg\u207B\xB9\u22C5m\u207B\xB2\u22C5s\xB3'> 'candela steradian kilogram to the power minus 1 metre to the power minus 2 second to the power 3' : LuminousEfficacyOfRadiationUnit = cd*sr*kg^-1*m^-2*s^3;
    attribute <'cd\u22C5sr\u22C5m\u207B\xB2'> 'candela steradian metre to the power minus 2' : IlluminanceUnit = cd*sr*m^-2;
    attribute <'cd\u22C5sr\u22C5m\u207B\xB2\u22C5s'> 'candela steradian metre to the power minus 2 second' : LuminousExposureUnit = cd*sr*m^-2*s;
    attribute <'cd\u22C5sr\u22C5s'> 'candela steradian second' : LuminousEnergyUnit = cd*sr*s;
    attribute <'eV\u22C5J\u22C5kg\u22C5m\xB2\u22C5s\u207B\xB2'> 'electronvolt joule kilogram metre squared second to the power minus 2' : HartreeEnergyUnit = eV*J*kg*m^2*s^-2;
    attribute <'eV\u22C5m\u207B\xB2/kg'> 'electronvolt metre to the power minus 2 per kilogram' : TotalMassStoppingPowerUnit = eV*m^-2/kg;
    attribute <'eV/m'> 'electronvolt per metre' : TotalLinearStoppingPowerUnit = eV/m;
    attribute <'eV/m\xB2'> 'electronvolt per square metre' : EnergyFluenceUnit = eV/m^2;
    attribute <'F/m'> 'farad per metre' : ElectricConstantUnit = F/m;
    attribute <'g/L'> 'g per l' : MassConcentrationUnit = g/L;
    attribute <'g/mol'> 'g per mole' : MolarMassUnit = g/mol;
    attribute <'Gy/s'> 'gray per second' : AbsorbedDoseRateUnit = Gy/s;
    attribute <'H/m'> 'henry per metre' : MagneticConstantUnit = H/m;
    attribute <'H\u207B\xB9'> 'henry to the power minus 1' : ReluctanceUnit = H^-1;
    attribute <'Hart/s'> 'hartley per second' : AverageInformationRateUnit = Hart/s;
    attribute <'J\u22C5m\xB2/kg'> 'joule metre squared per kilogram' : TotalMassStoppingPowerUnit = J*m^2/kg;
    attribute <'J\u22C5s'> 'joule second' : ActionQuantityUnit = J*s;
    attribute <'J\u22C5s\u22C5eV\u22C5s'> 'joule second electronvolt second' : TotalAngularMomentumUnit = J*s*eV*s;
    attribute <'J\u22C5s\u207B\xB9'> 'joule second to the power minus 1' : PowerUnit = J*s^-1;
    attribute <'J/(kg\u22C5K)'> 'joule per kilogram kelvin' : SpecificHeatCapacityUnit = J/(kg*K);
    attribute <'J/(m\xB2\u22C5nm)'> 'joule per square metre nm' : SpectralRadiantExposureUnit = J/(m^2*nm);
    attribute <'J/(m\xB3\u22C5nm)'> 'joule per cubic metre nm' : SpectralRadiantEnergyDensityInTermsOfWavelengthUnit = J/(m^3*nm);
    attribute <'J/(mol\u22C5K)'> 'joule per mole kelvin' : MolarHeatCapacityUnit = J/(mol*K);
    attribute <'J/K'> 'joule per kelvin' : HeatCapacityUnit = J/K;
    attribute <'J/kg'> 'joule per kilogram' : SpecificEnergyUnit = J/kg;
    attribute <'J/m'> 'joule per metre' : TotalLinearStoppingPowerUnit = J/m;
    attribute <'J/m\xB2'> 'joule per square metre' : SpectralRadiantEnergyDensityInTermsOfWavenumberUnit = J/m^2;
    attribute <'J/m\xB3'> 'joule per cubic metre' : ElectromagneticEnergyDensityUnit = J/m^3;
    attribute <'J/mol'> 'joule per mole' : MolarInternalEnergyUnit = J/mol;
    attribute <'J/nm'> 'joule per nm' : SpectralRadiantEnergyUnit = J/nm;
    attribute <'J/s'> 'joule per second' : HeatFlowRateUnit = J/s;
    attribute <'J\u207B\xB9\u22C5m\u207B\xB3\u22C5eV\u207B\xB9\u22C5m\u207B\xB3'> 'joule to the power minus 1 metre to the power minus 3 electronvolt to the power minus 1 metre to the power minus 3' : EnergyDensityOfStatesUnit = J^-1*m^-3*eV^-1*m^-3;
    attribute <'K/Pa'> 'kelvin per pascal' : JouleThomsonCoefficientUnit = K/Pa;
    attribute <'K/W'> 'kelvin per watt' : ThermalResistanceUnit = K/W;
    attribute <'K\u207B\xB9'> 'kelvin to the power minus 1' : LinearExpansionCoefficientUnit = K^-1;
    attribute <'kg\u22C5m\u22C5s\u207B\xB9'> 'kilogram metre second to the power minus 1' : MomentumUnit = kg*m*s^-1;
    attribute <'kg\u22C5m\u22C5s\u207B\xB2'> 'kilogram metre second to the power minus 2' : ForceUnit = kg*m*s^-2;
    attribute <'kg\u22C5m\u22C5s\u207B\xB3'> 'kilogram metre second to the power minus 3' : SpectralRadiantFluxUnit = kg*m*s^-3;
    attribute <'kg\u22C5m\u22C5s\u207B\xB3\u22C5K\u207B\xB9'> 'kilogram metre second to the power minus 3 kelvin to the power minus 1' : ThermalConductivityUnit = kg*m*s^-3*K^-1;
    attribute <'kg\u22C5m\u22C5s\u207B\xB3\u22C5sr\u207B\xB9'> 'kilogram metre second to the power minus 3 steradian to the power minus 1' : SpectralRadiantIntensityUnit = kg*m*s^-3*sr^-1;
    attribute <'kg\u22C5m\u207B\xB9'> 'kilogram metre to the power minus 1' : LinearMassDensityUnit = kg*m^-1;
    attribute <'kg\u22C5m\u207B\xB9\u22C5s\u207B\xB9'> 'kilogram metre to the power minus 1 second to the power minus 1' : DynamicViscosityUnit = kg*m^-1*s^-1;
    attribute <'kg\u22C5m\u207B\xB9\u22C5s\u207B\xB2'> 'kilogram metre to the power minus 1 second to the power minus 2' : PressureUnit = kg*m^-1*s^-2;
    attribute <'kg\u22C5m\u207B\xB9\u22C5s\u207B\xB2\u22C5K\u207B\xB9'> 'kilogram metre to the power minus 1 second to the power minus 2 kelvin to the power minus 1' : PressureCoefficientUnit = kg*m^-1*s^-2*K^-1;
    attribute <'kg\u22C5m\u207B\xB9\u22C5s\u207B\xB3'> 'kilogram metre to the power minus 1 second to the power minus 3' : SpectralIrradianceUnit = kg*m^-1*s^-3;
    attribute <'kg\u22C5m\u207B\xB9\u22C5s\u207B\xB3\u22C5sr\u207B\xB9'> 'kilogram metre to the power minus 1 second to the power minus 3 steradian to the power minus 1' : SpectralRadianceUnit = kg*m^-1*s^-3*sr^-1;
    attribute <'kg\u22C5m\u207B\xB2'> 'kilogram metre to the power minus 2' : SurfaceMassDensityUnit = kg*m^-2;
    attribute <'kg\u22C5m\u207B\xB2\u22C5s\u207B\xB9'> 'kilogram metre to the power minus 2 second to the power minus 1' : MassFlowUnit = kg*m^-2*s^-1;
    attribute <'kg\u22C5m\u207B\xB2\u22C5s\u207B\xB2'> 'kilogram metre to the power minus 2 second to the power minus 2' : SpectralRadiantEnergyDensityInTermsOfWavelengthUnit = kg*m^-2*s^-2;
    attribute <'kg\u22C5m\u207B\xB3'> 'kilogram metre to the power minus 3' : MassDensityUnit = kg*m^-3;
    attribute <'kg\u22C5m\u207B\u2074\u22C5s\u207B\xB9'> 'kilogram metre to the power minus 4 second to the power minus 1' : AcousticImpedanceUnit = kg*m^-4*s^-1;
    attribute <'kg\u22C5m\xB2'> 'kilogram metre squared' : MomentOfInertiaUnit = kg*m^2;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB9'> 'kilogram metre squared second to the power minus 1' : AngularMomentumUnit = kg*m^2*s^-1;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB2'> 'kilogram metre squared second to the power minus 2' : MomentOfForceUnit = kg*m^2*s^-2;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB2\u22C5K\u207B\xB9'> 'kilogram metre squared second to the power minus 2 kelvin to the power minus 1' : HeatCapacityUnit = kg*m^2*s^-2*K^-1;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB2\u22C5K\u207B\xB9\u22C5mol\u207B\xB9'> 'kilogram metre squared second to the power minus 2 kelvin to the power minus 1 mole to the power minus 1' : MolarHeatCapacityUnit = kg*m^2*s^-2*K^-1*mol^-1;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB2\u22C5mol\u207B\xB9'> 'kilogram metre squared second to the power minus 2 mole to the power minus 1' : MolarInternalEnergyUnit = kg*m^2*s^-2*mol^-1;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB3'> 'kilogram metre squared second to the power minus 3' : PowerUnit = kg*m^2*s^-3;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB3\u22C5A\u207B\xB9'> 'kilogram metre squared second to the power minus 3 ampere to the power minus 1' : ElectricPotentialDifferenceUnit = kg*m^2*s^-3*A^-1;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB3\u22C5A\u207B\xB9\u22C5K\u207B\xB9'> 'kilogram metre squared second to the power minus 3 ampere to the power minus 1 kelvin to the power minus 1' : SeebeckCoefficientForSubstancesAAndBUnit = kg*m^2*s^-3*A^-1*K^-1;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB3\u22C5K\u207B\xB9'> 'kilogram metre squared second to the power minus 3 kelvin to the power minus 1' : ThermalConductanceUnit = kg*m^2*s^-3*K^-1;
    attribute <'kg\u22C5m\xB2\u22C5s\u207B\xB3\u22C5sr\u207B\xB9'> 'kilogram metre squared second to the power minus 3 steradian to the power minus 1' : RadiantIntensityUnit = kg*m^2*s^-3*sr^-1;
    attribute <'kg\u22C5m\xB3\u22C5s\u207B\xB3\u22C5A\u207B\xB2'> 'kilogram metre cubed second to the power minus 3 ampere to the power minus 2' : ResistivityUnit = kg*m^3*s^-3*A^-2;
    attribute <'kg\u22C5mol\u207B\xB9'> 'kilogram mole to the power minus 1' : MolarMassUnit = kg*mol^-1;
    attribute <'kg\u22C5s\u207B\xB9'> 'kilogram second to the power minus 1' : MassFlowRateUnit = kg*s^-1;
    attribute <'kg\u22C5s\u207B\xB2'> 'kilogram second to the power minus 2' : SurfaceTensionUnit = kg*s^-2;
    attribute <'kg\u22C5s\u207B\xB2\u22C5A\u207B\xB9'> 'kilogram second to the power minus 2 ampere to the power minus 1' : MagneticFluxDensityUnit = kg*s^-2*A^-1;
    attribute <'kg\u22C5s\u207B\xB3'> 'kilogram second to the power minus 3' : DensityOfHeatFlowRateUnit = kg*s^-3;
    attribute <'kg\u22C5s\u207B\xB3\u22C5K\u207B\xB9'> 'kilogram second to the power minus 3 kelvin to the power minus 1' : CoefficientOfHeatTransferUnit = kg*s^-3*K^-1;
    attribute <'kg\u22C5s\u207B\xB3\u22C5sr\u207B\xB9'> 'kilogram second to the power minus 3 steradian to the power minus 1' : RadianceUnit = kg*s^-3*sr^-1;
    attribute <'kg\u207B\xB9\u22C5A'> 'kilogram to the power minus 1 ampere' : ExposureRateUnit = kg^-1*A;
    attribute <'kg\u207B\xB9\u22C5m\u22C5s\xB2'> 'kilogram to the power minus 1 metre second to the power 2' : CompressibilityUnit = kg^-1*m*s^2;
    attribute <'kg\u207B\xB9\u22C5m\u22C5s\xB2\u22C5K'> 'kilogram to the power minus 1 metre second to the power 2 kelvin' : JouleThomsonCoefficientUnit = kg^-1*m*s^2*K;
    attribute <'kg\u207B\xB9\u22C5m\u207B\xB2\u22C5s\xB3\u22C5K'> 'kilogram to the power minus 1 metre to the power minus 2 second to the power 3 kelvin' : ThermalResistanceUnit = kg^-1*m^-2*s^3*K;
    attribute <'kg\u207B\xB9\u22C5m\u207B\xB3\u22C5s\xB3\u22C5A\xB2'> 'kilogram to the power minus 1 metre to the power minus 3 second to the power 3 ampere to the power 2' : ElectrolyticConductivityUnit = kg^-1*m^-3*s^3*A^2;
    attribute <'kg\u207B\xB9\u22C5m\u207B\u2075\u22C5s\xB2'> 'kilogram to the power minus 1 metre to the power minus 5 second to the power 2' : EnergyDensityOfStatesUnit = kg^-1*m^-5*s^2;
    attribute <'kg\u207B\xB9\u22C5m\xB2'> 'kilogram to the power minus 1 metre squared' : MassAttenuationCoefficientUnit = kg^-1*m^2;
    attribute <'kg\u207B\xB9\u22C5m\xB3'> 'kilogram to the power minus 1 metre cubed' : SpecificVolumeUnit = kg^-1*m^3;
    attribute <'kg\u207B\xB9\u22C5s\u22C5A'> 'kilogram to the power minus 1 second ampere' : GyromagneticRatioUnit = kg^-1*s*A;
    attribute <'kg\u207B\xB9\u22C5s\u207B\xB9'> 'kilogram to the power minus 1 second to the power minus 1' : SpecificActivityUnit = kg^-1*s^-1;
    attribute <'kg\u207B\xB9\u22C5s\xB2'> 'kilogram to the power minus 1 second to the power 2' : EnergyDistributionOfCrossSectionUnit = kg^-1*s^2;
    attribute <'kg\u207B\xB9\u22C5s\xB2\u22C5A'> 'kilogram to the power minus 1 second to the power 2 ampere' : MobilityUnit = kg^-1*s^2*A;
    attribute <'kg\u207B\xB9\u22C5s\xB3\u22C5A\xB2\u22C5mol\u207B\xB9'> 'kilogram to the power minus 1 second to the power 3 ampere to the power 2 mole to the power minus 1' : MolarConductivityUnit = kg^-1*s^3*A^2*mol^-1;
    attribute <'kg\u207B\xB9\u22C5s\xB3\u22C5K'> 'kilogram to the power minus 1 second to the power 3 kelvin' : ThermalInsulanceUnit = kg^-1*s^3*K;
    attribute <'kg\xB2\u22C5m\u207B\xB2\u22C5s\u207B\xB3'> 'kilogram to the power 2 metre to the power minus 2 second to the power minus 3' : SoundExposureUnit = kg^2*m^-2*s^-3;
    attribute <'kg\xB2\u22C5m\u2074\u22C5s\u207B\u2076\u22C5A\u207B\xB2\u22C5K\u207B\xB2'> 'kilogram to the power 2 metre to the power 4 second to the power minus 6 ampere to the power minus 2 kelvin to the power minus 2' : LorenzCoefficientUnit = kg^2*m^4*s^-6*A^-2*K^-2;
    attribute <'lm\u22C5s'> 'lumen second' : LuminousEnergyUnit = lm*s;
    attribute <'lm/m\xB2'> 'lumen per square metre' : LuminousExitanceUnit = lm/m^2;
    attribute <'lm/W'> 'lumen per watt' : LuminousEfficacyOfRadiationUnit = lm/W;
    attribute <'lx\u22C5s'> 'lux second' : LuminousExposureUnit = lx*s;
    attribute <'m\u22C5s\u207B\xB9'> 'metre second to the power minus 1' : SpeedUnit = m*s^-1;
    attribute <'m\u22C5s\u207B\xB2'> 'metre second to the power minus 2' : AccelerationUnit = m*s^-2;
    attribute <'m/s'> 'metre per second' : SpeedUnit = m/s;
    attribute <'m\u207B\xB9'> 'metre to the power minus 1' : CurvatureUnit = m^-1;
    attribute <'m\u207B\xB2'> 'metre to the power minus 2' : PhotonExposureUnit = m^-2;
    attribute <'m\u207B\xB2\u22C5s\u207B\xB9'> 'metre to the power minus 2 second to the power minus 1' : PhotonIrradianceUnit = m^-2*s^-1;
    attribute <'m\u207B\xB2\u22C5s\u207B\xB9\u22C5sr\u207B\xB9'> 'metre to the power minus 2 second to the power minus 1 steradian to the power minus 1' : PhotonRadianceUnit = m^-2*s^-1*sr^-1;
    attribute <'m\u207B\xB3'> 'metre to the power minus 3' : ParticleConcentrationUnit = m^-3;
    attribute <'m\u207B\xB3\u22C5s'> 'metre to the power minus 3 second' : DensityOfVibrationalStatesUnit = m^-3*s;
    attribute <'m\u207B\xB3\u22C5s\u207B\xB9'> 'metre to the power minus 3 second to the power minus 1' : ActivityDensityUnit = m^-3*s^-1;
    attribute <'m\xB2'> 'metre squared' : AreaUnit = m^2;
    attribute <'m\xB2\u22C5A'> 'metre squared ampere' : MagneticDipoleMomentUnit = m^2*A;
    attribute <'m\xB2\u22C5K/W'> 'metre squared kelvin per watt' : ThermalInsulanceUnit = m^2*K/W;
    attribute <'m\xB2\u22C5mol\u207B\xB9'> 'metre squared mole to the power minus 1' : MolarAbsorptionCoefficientUnit = m^2*mol^-1;
    attribute <'m\xB2\u22C5s\u207B\xB9'> 'metre squared second to the power minus 1' : KinematicViscosityUnit = m^2*s^-1;
    attribute <'m\xB2\u22C5s\u207B\xB2'> 'metre squared second to the power minus 2' : SpecificEnergyUnit = m^2*s^-2;
    attribute <'m\xB2\u22C5s\u207B\xB2\u22C5K\u207B\xB9'> 'metre squared second to the power minus 2 kelvin to the power minus 1' : SpecificHeatCapacityUnit = m^2*s^-2*K^-1;
    attribute <'m\xB2\u22C5s\u207B\xB3'> 'metre squared second to the power minus 3' : DoseEquivalentUnit = m^2*s^-3;
    attribute <'m\xB2\u22C5sr\u207B\xB9'> 'metre squared steradian to the power minus 1' : DirectionDistributionOfCrossSectionUnit = m^2*sr^-1;
    attribute <'m\xB2/(J\u22C5sr)'> 'metre squared per joule steradian' : DirectionAndEnergyDistributionOfCrossSectionUnit = m^2/(J*sr);
    attribute <'m\xB2/(V\u22C5s)'> 'metre squared per volt second' : MobilityUnit = m^2/(V*s);
    attribute <'m\xB2/J'> 'metre squared per joule' : EnergyDistributionOfCrossSectionUnit = m^2/J;
    attribute <'m\xB3'> 'metre cubed' : VolumeUnit = m^3;
    attribute <'m\xB3\u22C5mol\u207B\xB9'> 'metre cubed mole to the power minus 1' : MolarVolumeUnit = m^3*mol^-1;
    attribute <'m\xB3\u22C5s\u207B\xB9'> 'metre cubed second to the power minus 1' : VolumeFlowRateUnit = m^3*s^-1;
    attribute <'m\xB3/C\u22C5m\xB3\u22C5s\u207B\xB9\u22C5A\u207B\xB9'> 'metre cubed per coulomb cubic metre second to the power minus 1 ampere to the power minus 1' : HallCoefficientUnit = m^3/C*m^3*s^-1*A^-1;
    attribute <'m\u2074'> 'metre to the power 4' : SecondAxialMomentOfAreaUnit = m^4;
    attribute <'m\u2074\u22C5s\u207B\xB2'> 'metre to the power 4 second to the power minus 2' : TotalMassStoppingPowerUnit = m^4*s^-2;
    attribute <'mL/L '> 'ml per l' : VolumeFractionUnit = mL/L;
    attribute <'mol\u22C5kg\u207B\xB9'> 'mole kilogram to the power minus 1' : IonicStrengthUnit = mol*kg^-1;
    attribute <'mol\u22C5m\u207B\xB3'> 'mole metre to the power minus 3' : AmountOfSubstanceConcentrationUnit = mol*m^-3;
    attribute <'mol/kg'> 'mole per kilogram' : MolalityUnit = mol/kg;
    attribute <'mol/L'> 'mole per l' : AmountOfSubstanceConcentrationUnit = mol/L;
    attribute <'mol/m\xB3'> 'mole per cubic metre' : EquilibriumConstantOnConcentrationBasisUnit = mol/m^3;
    attribute <'N\u22C5m'> 'newton metre' : MomentOfForceUnit, TorqueUnit = N*m {
        attribute :>> MomentOfForceUnit::quantityDimension, TorqueUnit::quantityDimension {
            :>> MomentOfForceUnit::quantityDimension::quantityPowerFactors, TorqueUnit::quantityDimension::quantityPowerFactors;
        }
    }
    attribute <'N\u22C5m\u22C5s'> 'newton metre second' : AngularImpulseUnit = N*m*s;
    attribute <'N\u22C5m\u22C5s\u207B\xB9'> 'newton metre second to the power minus 1' : PowerUnit = N*m*s^-1;
    attribute <'N\u22C5m\u207B\xB9'> 'newton metre to the power minus 1' : SurfaceTensionUnit = N*m^-1;
    attribute <'N\u22C5m\u207B\xB2'> 'newton metre to the power minus 2' : PressureUnit = N*m^-2;
    attribute <'N\u22C5s'> 'newton second' : ImpulseUnit = N*s;
    attribute <'nat/s'> 'natural unit of information per second' : AverageInformationRateUnit = nat/s;
    attribute <'o/s'> 'octet per second' : TransferRateUnit = o/s;
    attribute <'Pa\u22C5s'> 'pascal second' : DynamicViscosityUnit = Pa*s;
    attribute <'Pa\u22C5s/m'> 'pascal second per metre' : CharacteristicImpedanceOfAMediumForLongitudinalWavesUnit = Pa*s/m;
    attribute <'Pa\u22C5s/m\xB3'> 'pascal second per cubic metre' : AcousticImpedanceUnit = Pa*s/m^3;
    attribute <'Pa/K'> 'pascal per kelvin' : PressureCoefficientUnit = Pa/K;
    attribute <'Pa\u207B\xB9'> 'pascal to the power minus 1' : CompressibilityUnit = Pa^-1;
    attribute <'Pa\xB2\u22C5s'> 'pascal to the power 2 second' : SoundExposureUnit = Pa^2*s;
    attribute <'rad\u22C5m\xB2/kg\xB9'> 'radian metre squared per kilogram to the power 1' : SpecificOpticalRotatoryPowerUnit = rad*m^2/kg^1;
    attribute <'rad\u22C5m\xB2/mol'> 'radian metre squared per mole' : MolarOpticalRotatoryPowerUnit = rad*m^2/mol;
    attribute <'rad\u22C5s\u207B\xB9'> 'radian second to the power minus 1' : AngularVelocityUnit = rad*s^-1;
    attribute <'rad\u22C5s\u207B\xB2'> 'radian second to the power minus 2' : AngularAccelerationUnit = rad*s^-2;
    attribute <'rad/m'> 'radian per metre' : PhaseCoefficientUnit = rad/m;
    attribute <'s\u22C5A'> 'second ampere' : ElectricChargeUnit = s*A;
    attribute <'S\u22C5m\xB2/mol'> 'siemens metre squared per mole' : MolarConductivityUnit = S*m^2/mol;
    attribute <'S/m'> 'siemens per metre' : ConductivityUnit = S/m;
    attribute <'s\u207B\xB9'> 'second to the power minus 1' : AngularVelocityUnit = s^-1;
    attribute <'s\u207B\xB9\u22C5sr\u207B\xB9'> 'second to the power minus 1 steradian to the power minus 1' : PhotonIntensityUnit = s^-1*sr^-1;
    attribute <'s\u207B\xB2'> 'second to the power minus 2' : AngularAccelerationUnit = s^-2;
    attribute <'Sh/s'> 'shannon per second' : AverageInformationRateUnit = Sh/s;
    attribute <'Sv/s'> 'sievert per second' : DoseEquivalentUnit = Sv/s;
    attribute <'V\u22C5A'> 'volt ampere' : PowerUnit = V*A;
    attribute <'V/K'> 'volt per kelvin' : SeebeckCoefficientForSubstancesAAndBUnit = V/K;
    attribute <'V/m'> 'volt per metre' : ElectricFieldStrengthUnit = V/m;
    attribute <'V\xB2/K\xB2'> 'volt to the power 2 per kelvin to the power 2' : LorenzCoefficientUnit = V^2/K^2;
    attribute <'W\u22C5h'> 'watt hour' : EnergyUnit = W*h;
    attribute <'W/(m\u22C5K)'> 'watt per metre kelvin' : ThermalConductivityUnit = W/(m*K);
    attribute <'W/(m\xB2\u22C5K)'> 'watt per square metre kelvin' : CoefficientOfHeatTransferUnit = W/(m^2*K);
    attribute <'W/(m\xB2\u22C5nm)'> 'watt per square metre nm' : SpectralIrradianceUnit = W/(m^2*nm);
    attribute <'W/(sr\u22C5m\xB2)'> 'watt per steradian square metre' : RadianceUnit = W/(sr*m^2);
    attribute <'W/(sr\u22C5m\xB2\u22C5nm)'> 'watt per steradian square metre nm' : SpectralRadianceUnit = W/(sr*m^2*nm);
    attribute <'W/(sr\u22C5nm)'> 'watt per steradian nm' : SpectralRadiantIntensityUnit = W/(sr*nm);
    attribute <'W/K'> 'watt per kelvin' : ThermalConductanceUnit = W/K;
    attribute <'W/kg'> 'watt per kilogram' : DoseEquivalentUnit = W/kg;
    attribute <'W/m\xB2'> 'watt per square metre' : DensityOfHeatFlowRateUnit = W/m^2;
    attribute <'W/nm'> 'watt per nm' : SpectralRadiantFluxUnit = W/nm;
    attribute <'W/sr'> 'watt per steradian' : RadiantIntensityUnit = W/sr;
    attribute <'Wb\u22C5m'> 'weber metre' : MagneticDipoleMomentUnit = Wb*m;
    attribute <'Wb/m'> 'weber per metre' : MagneticVectorPotentialUnit = Wb/m;
    attribute <'\u03A9\u22C5m'> 'ohm metre' : ResistivityUnit = '\u03A9'*m;

    alias 'm/s\xB2' for 'm\u22C5s\u207B\xB2';

    /*
     * Prefixed units
     */

    /* Length */
    attribute <nm> nanometre : LengthUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = nano; :>> referenceUnit = m; } }
    attribute <mm> millimetre : LengthUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = milli; :>> referenceUnit = m; } }
    attribute <cm> centimetre : LengthUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = centi; :>> referenceUnit = m; } }
    attribute <km> kilometre : LengthUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = kilo; :>> referenceUnit = m; } }

    /* Volume */
    attribute <mL> millilitre : VolumeUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = milli; :>> referenceUnit = L; } }

    /* Force */
    attribute <mN> millinewton : ForceUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = milli; :>> referenceUnit = N; } }

    /* Energy */
    attribute <kJ> kilojoule : EnergyUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = kilo; :>> referenceUnit = J; } }
    attribute <MJ> megajoule : EnergyUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = mega; :>> referenceUnit = J; } }
    attribute <GJ> gigajoule : EnergyUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = giga; :>> referenceUnit = J; } }

    /* Power */
    attribute <kW> kilowatt : PowerUnit { :>> unitConversion: ConversionByPrefix { :>> prefix = kilo; :>> referenceUnit = W; } }

    /* Speed */
    attribute <'km/h'> 'kilometre per hour': SpeedUnit = km/h;

	/* 
	 * Celsius units
	 */
	 
    attribute <'\xB0C'> 'degree celsius (temperature difference)' : TemperatureDifferenceUnit {
    	doc
	    /*
	     * degree Celsius unit for temperature interval (i.e. temperature difference) quantities
	     */
	     
        attribute :>> unitConversion: ConversionByConvention { :>> referenceUnit = K; :>> conversionFactor = 1; }
   	}

    attribute <'\xB0C_abs'> 'degree celsius (absolute temperature scale)' : IntervalScale {
    	doc
	     /*
	     * degree Celsius interval scale for absolute (thermodynamic) temperature quantities
	     *
	     * The interval scale is defined with an explicit transformation with respect to 
	     * the kelvin thermodynamic temperature scale that specifies the zero shift.
	     */
 
        attribute :>> unit = '\xB0C';
        attribute temperatureWaterAtFreezingPointInC: DefinitionalQuantityValue {
            :>> num = 0; :>> definition = "temperature in degree Celsius of pure water at freezing point";
        }
        private attribute temperatureWaterAtTriplePointInC: DefinitionalQuantityValue {
            :>> num = 1/100; :>> definition = "temperature in degree Celsius of pure water at the triple point";
        }
        private attribute celsiusToKelvinScaleMapping: QuantityValueMapping {
            :>> mappedQuantityValue = temperatureWaterAtTriplePointInC; 
            :>> referenceQuantityValue = K.temperatureOfWaterAtTriplePointInK;
        }
        attribute :>> definitionalQuantityValues = (temperatureWaterAtTriplePointInC, temperatureWaterAtFreezingPointInC);
        attribute :>> quantityValueMapping = celsiusToKelvinScaleMapping;

        /* CoordinateFramePlacement (zero shift) w.r.t. the kelvin thermodynamic temperature scale */
        private attribute zeroDegreeCelsiusInKelvin: ThermodynamicTemperatureValue = 273.15 [K];
        attribute zeroDegreeCelsiusToKelvinShift : CoordinateFramePlacement :>> transformation { 
        	:>> source = K; :>> origin = zeroDegreeCelsiusInKelvin;
        }
    }
}
`, "Domain Libraries/Quantities and Units/SIPrefixes.sysml": 'standard library package SIPrefixes {\n	doc\n	/*\n	 * Definition of SI unit prefixes as specified in ISO/IEC 80000-1\n	 */\n\n	private import MeasurementReferences::*;\n\n	/*\n	 * ISO/IEC 80000-1 prefixes for decimal multiples and sub-multiples\n	 * \n	 * See also https://en.wikipedia.org/wiki/Unit_prefix\n	 */\n	attribute yocto: UnitPrefix { :>> longName = "yocto"; :>> symbol = "y"; :>> conversionFactor = 1E-24; }\n	attribute zepto: UnitPrefix { :>> longName = "zepto"; :>> symbol = "z"; :>> conversionFactor = 1E-21; }\n	attribute atto: UnitPrefix { :>> longName = "atto"; :>> symbol = "a"; :>> conversionFactor = 1E-18; }\n	attribute femto: UnitPrefix { :>> longName = "femto"; :>> symbol = "f"; :>> conversionFactor = 1E-15; }\n	attribute pico: UnitPrefix { :>> longName = "pico"; :>> symbol = "p"; :>> conversionFactor = 1E-12; }\n	attribute nano: UnitPrefix { :>> longName = "nano"; :>> symbol = "n"; :>> conversionFactor = 1E-9; }\n	attribute micro: UnitPrefix { :>> longName = "micro"; :>> symbol = "\u03BC"; :>> conversionFactor = 1E-6; }\n	attribute milli: UnitPrefix { :>> longName = "milli"; :>> symbol = "m"; :>> conversionFactor = 1E-3; }\n	attribute centi: UnitPrefix { :>> longName = "centi"; :>> symbol = "c"; :>> conversionFactor = 1E-2; }\n	attribute deci: UnitPrefix { :>> longName = "deci"; :>> symbol = "d"; :>> conversionFactor = 1E-1; }\n	attribute deca: UnitPrefix { :>> longName = "deca"; :>> symbol = "da"; :>> conversionFactor = 1E1; }\n	attribute hecto: UnitPrefix { :>> longName = "hecto"; :>> symbol = "h"; :>> conversionFactor = 1E2; }\n	attribute kilo: UnitPrefix { :>> longName = "kilo"; :>> symbol = "k"; :>> conversionFactor = 1E3; }\n	attribute mega: UnitPrefix { :>> longName = "mega"; :>> symbol = "M"; :>> conversionFactor = 1E6; }\n	attribute giga: UnitPrefix { :>> longName = "giga"; :>> symbol = "G"; :>> conversionFactor = 1E9; }\n	attribute tera: UnitPrefix { :>> longName = "tera"; :>> symbol = "T"; :>> conversionFactor = 1E12; }\n	attribute peta: UnitPrefix { :>> longName = "peta"; :>> symbol = "P"; :>> conversionFactor = 1E15; }\n	attribute exa: UnitPrefix { :>> longName = "exa"; :>> symbol = "E"; :>> conversionFactor = 1E18; }\n	attribute zetta: UnitPrefix { :>> longName = "zetta"; :>> symbol = "Z"; :>> conversionFactor = 1E21; }\n	attribute yotta: UnitPrefix { :>> longName = "yotta"; :>> symbol = "Y"; :>> conversionFactor = 1E24; }\n	\n	/*\n	 * ISO/IEC 80000-1 prefixes for binary multiples, i.e. multiples of 1024 (= 2^10)\n	 * \n	 * See also https://en.wikipedia.org/wiki/Binary_prefix\n	 */\n	attribute kibi: UnitPrefix { :>> longName = "kibi"; :>> symbol = "Ki"; :>> conversionFactor = 1024; }\n	attribute mebi: UnitPrefix { :>> longName = "mebi"; :>> symbol = "Mi"; :>> conversionFactor = 1024^2; }\n	attribute gibi: UnitPrefix { :>> longName = "gibi"; :>> symbol = "Gi"; :>> conversionFactor = 1024^3; }\n	attribute tebi: UnitPrefix { :>> longName = "tebi"; :>> symbol = "Ti"; :>> conversionFactor = 1024^4; }\n	attribute pebi: UnitPrefix { :>> longName = "pebi"; :>> symbol = "Pi"; :>> conversionFactor = 1024^5; }\n	attribute exbi: UnitPrefix { :>> longName = "exbi"; :>> symbol = "Ei"; :>> conversionFactor = 1024^6; }\n	attribute zebi: UnitPrefix { :>> longName = "zebi"; :>> symbol = "Zi"; :>> conversionFactor = 1024^7; }\n	attribute yobi: UnitPrefix { :>> longName = "yobi"; :>> symbol = "Yi"; :>> conversionFactor = 1024^8; }\n}\n', "Domain Libraries/Quantities and Units/TensorCalculations.sysml": "standard library package TensorCalculations {\n	doc\n	/*\n	 * This package package defines calculations for the construction of and computations on TensorQuantityValues.\n	 */\n	 \n    private import ScalarValues::Boolean;\n    private import ScalarValues::Number;\n    private import Quantities::ScalarQuantityValue;\n    private import Quantities::VectorQuantityValue;\n    private import Quantities::TensorQuantityValue;\n    private import MeasurementReferences::TensorMeasurementReference;\n    private import MeasurementReferences::CoordinateTransformation;\n    \n    calc def '[' specializes BaseFunctions::'[' { \n    	in elements: Number[1..n] ordered; \n    	in mRef: TensorMeasurementReference[1]; \n    	return quantity: TensorQuantityValue[1];\n    	private attribute n = mRef.flattenedSize;\n    }\n\n    calc def isZeroTensorQuantity { \n    	in x : TensorQuantityValue[1]; \n    	return : Boolean[1];\n    }\n    calc def isUnitTensorQuantity { \n    	in x : TensorQuantityValue[1]; \n    	return : Boolean[1];\n    }\n\n    /* Addition and subtraction */\n    calc def '+' :> DataFunctions::'+' { in : TensorQuantityValue[1]; in : TensorQuantityValue[1]; return : TensorQuantityValue[1]; }\n    calc def '-' :> DataFunctions::'-' { in : TensorQuantityValue[1]; in : TensorQuantityValue[1]; return : TensorQuantityValue[1]; }\n\n    /* Multiplication and division */\n    calc def scalarTensorMult { in : Number[1]; in : TensorQuantityValue[1]; return : TensorQuantityValue[1]; }\n    calc def TensorScalarMult { in : TensorQuantityValue[1]; in : Number[1]; return : TensorQuantityValue[1]; }\n    calc def scalarQuantityTensorMult { in : ScalarQuantityValue[1]; in : TensorQuantityValue[1]; return : TensorQuantityValue[1]; }\n    calc def TensorScalarQuantityMult { in : TensorQuantityValue[1]; in : ScalarQuantityValue[1]; return : TensorQuantityValue[1]; }\n    calc def tensorVectorMult { in : TensorQuantityValue[1]; in : VectorQuantityValue[1]; return : VectorQuantityValue[1]; }\n    calc def vectorTensorMult { in : VectorQuantityValue[1]; in : TensorQuantityValue[1]; return : VectorQuantityValue[1]; }\n    calc def tensorTensorMult { in : TensorQuantityValue[1]; in : TensorQuantityValue[1]; return : TensorQuantityValue[1]; }\n    \n    /* Tensor transformation */\n    calc def transform {\n        in transformation : CoordinateTransformation;\n        in sourceTensor : TensorQuantityValue;\n        return targetTensor : TensorQuantityValue;\n    }\n}", "Domain Libraries/Quantities and Units/Time.sysml": `standard library package Time {
	doc
	/*
	 * This package specifies concepts to support time-related quantities and metrology, beyond 
	 * the quantities duration and time as defined in [ISO 80000-3]. Representations of the 
	 * Gregorian calendar date and time of day as specified by the [ISO 8601-1] standard are used.
	 */

	private import Occurrences::Occurrence;
	private import ScalarValues::Real;
	private import ScalarValues::Integer;
	private import ScalarValues::Natural;
	private import ScalarValues::String;
	private import Quantities::ScalarQuantityValue;
	private import Quantities::scalarQuantities;
    private import MeasurementReferences::*;
    public import ISQBase::DurationValue;
    public import ISQBase::DurationUnit;
    public import ISQBase::duration;
    public import ISQSpaceTime::TimeValue;
    public import ISQSpaceTime::TimeUnit;
    public import ISQSpaceTime::time;
    
    part universalClock : Clock[1] :> Clocks::universalClock {
   	    doc
	    /*
	     * universalClock is a single Clock that can be used as a default universal time reference.
	     */
    }

	part def Clock :> Clocks::Clock {
		doc
		/*
		 * A Clock provides a currentTime as a TimeInstantValue that advances montonically over its lifetime.
		 */
	
		attribute :>> currentTime : TimeInstantValue;
	}
	
	calc def TimeOf :> Clocks::TimeOf {
		doc
		/*
		 * TimeOf returns a TimeInstantValue for a given Occurrence relative to a given Clock. This TimeInstantValue is the 
		 * time of the start of the Occurrence, which is considered to be synchronized with the snapshot of the Clock with a 
		 * currentTime equal to the returned timeInstant.
		 */
	
		in o : Occurrence[1]; 
		in clock : Clock[1] default localClock;
		return timeInstant : TimeInstantValue[1];
	}

	calc def DurationOf :> Clocks::DurationOf {
		doc
		/*
		 * DurationOf returns the duration of a given Occurrence relative to a given Clock, which is equal to the TimeOf 
		 * the end snapshot of the Occurrence minus the TimeOf its start snapshot.
		 */
	
		in o : Occurrence[1]; 
		in clock : Clock[1] default localClock;
		return duration : DurationValue;
	}
	
    attribute def TimeScale :> IntervalScale {
		doc
		/*
		 * Generic time scale to express a time instant, including a textual definition of the meaning of zero time instant value
		 * 
		 * Attribute definitionalEpoch captures the specification of the time instant with value zero, also known as the (reference) epoch.
		 */
	
		attribute :>> unit: DurationUnit[1];
		attribute definitionalEpoch: DefinitionalQuantityValue[1];
		attribute :>> definitionalQuantityValues = definitionalEpoch;
    }

    attribute def TimeInstantValue :> ScalarQuantityValue {
		doc
		/*
		 * Representation of a time instant quantity
		 *
		 * Also known as instant (of time), or, point in time.
		 */
	
        attribute :>> num: Real[1];
        attribute :>> mRef: TimeScale[1];
    }
    attribute timeInstant: TimeInstantValue :> scalarQuantities;

	abstract attribute def DateTime :> TimeInstantValue {
		doc
		/*
		 * Generic representation of a time instant as a calendar date and time of day
		 */
	}

	abstract attribute def Date :> TimeInstantValue {
		doc
		/*
		 * Generic representation of a time instant as a calendar date
		 */
	}

	abstract attribute def TimeOfDay :> TimeInstantValue {
		doc
		/*
		 * Generic representation of a time instant as a time of day
		 */
	}

	attribute <UTC> 'Coordinated Universal Time' : TimeScale {
		doc
		/*
		 * Representation of the Coordinated Universal Time (UTC) time scale
		 *
		 * UTC is the primary time standard by which the world regulates clocks and time. It is within about 1 second of mean solar time
		 * at 0\xB0 longitude and is not adjusted for daylight saving time.
		 * UTC is obtained from International Atomic Time (TAI) by the insertion of leap seconds according to the advice of
		 * the International Earth Rotation and Reference Systems Service (IERS) to ensure approximate agreement
		 * with the time derived from the rotation of the Earth.
		 *
		 * References:
		 * ITU-R TF.460-6 (see https://www.itu.int/rec/R-REC-TF.460/en)
		 * BIPM technical services: Time Metrology (see https://www.bipm.org/en/time-metrology)
		 *
		 * Introductions:
		 * For UTC see https://en.wikipedia.org/wiki/Coordinated_Universal_Time
		 * For TAI see https://en.wikipedia.org/wiki/International_Atomic_Time
		 */
	
		attribute :>> unit = SI::s;
		attribute :>> definitionalEpoch: DefinitionalQuantityValue { :>> num = 0; :>> definition = "UTC epoch at 1 January 1958 at 0 hour 0 minute 0 second"; }
	}

	attribute def UtcTimeInstantValue :> DateTime { 
		:>> mRef = UTC {
			doc
			/*
			 * Representation of a time instant expressed on the Coordinated Universal Time (UTC) time scale
			 */
		} 
	}
	attribute utcTimeInstant: UtcTimeInstantValue :> timeInstant;

	/*
	 * Representations of a Gregorian calendar date and time of day as specified by the ISO 8601-1 standard.
	 *
	 * As explained in ISO 8601-1 clause 4.2.1:
	 * ISO 8601-1 uses the Gregorian calendar for the identification of calendar days.
	 *
	 * The Gregorian calendar provides a time scale consisting of a series of contiguous calendar years,
	 * each identified by a year number represented by an integer, greater than that of the
	 * immediately preceding calendar year by 1. ISO 8601-1 allows the identification of calendar years
	 * by their year number for years both before and after the introduction of the Gregorian calendar.
	 *
	 * The Gregorian calendar distinguishes common years of 365 consecutive calendar days and leap years
	 * of 366 consecutive calendar days.
	 *
	 * In the Gregorian calendar each calendar year is divided into 12 sequential calendar months,
	 * each consisting of a specific number of calendar days in the range 28 to 31. Usage of the Gregorian calendar
	 * for identifying dates preceding its introduction (15 October 1582) should only be by mutual agreement
	 * of the communicating partners.
	 *
	 * Reference: ISO 8601-1:2019 (First edition)
	 * "Date and time \u2014 Representations for information interchange \u2014 Part 1: Basic rules"
	 * (see https://www.iso.org/standard/70907.html)
	 */

	attribute def Iso8601DateTimeEncoding :> String {
	    doc
	    /*
	     * Extended string encoding of an ISO 8601-1 date and time
	     *
	     * The format of the string must comply with the following EBNF production:
	     * ['+' | '-'] YYYY '-' MM '-' DD 'T' hh ':' mm ':' ss ['.' fff [fff]] ('Z' | timezoneOffset )
	     * where:
	     *   YYYY is 4-or-more-digit year number, which can be negative for years before 0000;
	     *   MM is 2-digit month in year number, in which 01 is January, 02 is February, ..., 12 is December;
	     *   DD is 2-digit day in month number in range 01 to 28, 29, 30, 31 depending on month and leap year;
	     *   hh is 2-digit hour in day number in range 00 to 23;
	     *   mm is 2-digit minute in hour in range 00 to 59;
	     *   ss is 2-digit second in minute in range 00 to 60, in  in case of leap second;
	     *   ['.' fff [fff]] is an optional 3-digit millisecond or 6-digit microsecond fraction;
	     *   timezoneOffset is ('+' | '-') hhOffset ':' mmOffset, denoting the local timezone hour and minute offset w.r.t. UTC,
	     *   in which '+' specifies an offset ahead of UTC and '-' specifies an offset behind UTC;
	     *
	     * Note 1: All components are expressed with leading zeros.
	     * Note 2: 'Z' instead of timezoneOffset denotes a UTC time, i.e. zero time offset.
	     * Note 3: The ss value may only be 60 when a leap second is inserted.
	     *
	     * Examples of such a date and time value are:
	     * 2021-08-30T12:30:24Z (UTC date and time with second precision)
	     * 2018-01-23T23:14:44.304827Z (UTC date and time with microsecond precision)
	     * 1969-07-20T20:17:00Z (UTC date and time with second precision)
	     * 1969-07-20T15:17:00-05:00 (local date and time with second precision for a timezone 5 hour behind UTC)
	     * 1969-07-20T22:17:00+02:00 (local date and time with second precision for a timezone 2 hour ahead of UTC)
	     */
    }

    attribute def Iso8601DateTime :> UtcTimeInstantValue {
		doc
		/*
	     * Representation of an ISO 8601-1 date and time in extended string format
		 */
	
    	attribute val: Iso8601DateTimeEncoding;
    	attribute :>> num = getElapsedUtcTime(val);
    	private calc getElapsedUtcTime {
    		in iso8601DateTime: Iso8601DateTimeEncoding;
    		/* Return the number of seconds elapsed since the UTC epoch. 
    		 * Can be negative when the date and time is earlier than the epoch.
    		 */
    		return : Real;
    	}
    }

    attribute def Iso8601DateTimeStructure :> UtcTimeInstantValue {
		doc
		/*
	     * Representation of an ISO 8601 date and time with explicit date and time component attributes
	     *
	     * The total time offset is equal to the summation of hourOffset and minuteOffset.
		 */
	
    	attribute year: Integer;
    	attribute month: Natural;
    	attribute day: Natural;
    	attribute hour: Natural;
    	attribute minute: Natural;
    	attribute second: Natural;
    	attribute microsecond: Natural;
    	attribute hourOffset: Integer;
    	attribute minuteOffset: Integer;
    	attribute :>> num = getElapsedUtcTime(year, month, day, hour, minute, second, microsecond, hourOffset, minuteOffset);
    	private calc getElapsedUtcTime {
    		in year: Integer; 
    		in month: Natural; 
    		in day: Natural;
    		in hour: Natural;
    		in minute: Natural;
    		in second: Natural;
    		in microsecond: Natural;
    		in hourOffset: Integer;
    		in minuteOffest: Integer;
    		return : Real;
    	}
    }

	calc convertIso8601DateTimeToStructure {
	    doc
	    /*
		 * Calculation to convert an ISO 8601 date and time instant from string to component structure representation
	     */
    
		in iso8601DateTime: Iso8601DateTime;
		/* Parse ISO 8601 string encoding to date and time components */
		return : Iso8601DateTimeStructure;
	}

	calc convertIso8601StructureToDateTime {
		doc
		/*
		 * Calculation to convert an ISO 8601 date and time instant from component structure to string representation
		 */
	
		in iso8601DateTimeStructure: Iso8601DateTimeStructure;
		attribute x: Iso8601DateTime;
		/* Concatenate ISO 8601 date and time components to string 
		 *     year-month-dayThour:minute:second\xB1hourOffset:minuteOffset
		 */
		return : Iso8601DateTime;
	}
}
`, "Domain Libraries/Quantities and Units/USCustomaryUnits.sysml": `standard library package <USCU> USCustomaryUnits {
	doc
	/*
	 * Measurement unit declarations generated from NIST SP811 Appendix B
	 *
	 * See https://www.nist.gov/pml/special-publication-811/nist-guide-si-appendix-b-conversion-factors/nist-guide-si-appendix-b8
	 */

    private import MeasurementReferences::*;
    public import ISQ::*;
    private import SI::*;

    attribute 'acre (based on US survey foot)' : AreaUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^2; :>> conversionFactor = 4.046873E+03; :>> isExact = false; } }
    attribute 'acre foot (based on US survey foot)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 1.233489E+03; :>> isExact = false; } }
    attribute <bbl> 'barrel (for petroleum, 42 gallons (US))' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 1.589873E-01; :>> isExact = false; } }
    attribute <Btu_IT> 'British thermal unit (IT)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.055056E+03; :>> isExact = false; } }
    alias Btu for Btu_IT;
    attribute <Btu_th> 'British thermal unit (th)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.054350E+03; :>> isExact = false; } }
    attribute <Btu_mean> 'British thermal unit (mean)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.05587E+03; :>> isExact = false; } }
    attribute <'Btu_39\xB0F'> 'British thermal unit (39 \xB0F)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.05967E+03; :>> isExact = false; } }
    attribute <'Btu_59\xB0F'> 'British thermal unit (59 \xB0F)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.05480E+03; :>> isExact = false; } }
    attribute <'Btu_60\xB0F'> 'British thermal unit (60 \xB0F)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.05468E+03; :>> isExact = false; } }
    attribute <'Btu_IT\u22C5ft/(h\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (IT) foot per hour square foot degree Fahrenheit' : ThermalConductivityUnit = Btu_IT*ft/(h*ft^2*'\xB0F');
    attribute <'Btu_th\u22C5ft/(h\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (th) foot per hour square foot degree Fahrenheit' : ThermalConductivityUnit = Btu_th*ft/(h*ft^2*'\xB0F');
    attribute <'Btu_IT\u22C5in/(h\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (IT) inch per hour square foot degree Fahrenheit' : ThermalConductivityUnit = Btu_IT*'in'/(h*ft^2*'\xB0F');
    attribute <'Btu_th\u22C5in/(h\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (th) inch per hour square foot degree Fahrenheit' : ThermalConductivityUnit = Btu_th*'in'/(h*ft^2*'\xB0F');
    attribute <'Btu_IT\u22C5in/(s\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (IT) inch per second square foot degree Fahrenheit' : ThermalConductivityUnit = Btu_IT*'in'/(s*ft^2*'\xB0F');
    attribute <'Btu_th\u22C5in/(s\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (th) inch per second square foot degree Fahrenheit' : ThermalConductivityUnit = Btu_th*'in'/(s*ft^2*'\xB0F');
    //attribute <'Btu_IT/ft\xB3'> 'British thermal unit (IT) per cubic foot' : EnergyDensityUnit = Btu_IT/ft^3;
    //attribute <'Btu_th/ft\xB3'> 'British thermal unit (th) per cubic foot' : EnergyDensityUnit = Btu_th/ft^3;
    attribute <'Btu_IT/\xB0F'> 'British thermal unit (IT) per degree Fahrenheit' : HeatCapacityUnit = Btu_IT/'\xB0F';
    attribute <'Btu_th/\xB0F'> 'British thermal unit (th) per degree Fahrenheit' : HeatCapacityUnit = Btu_th/'\xB0F';
    attribute <'Btu_IT/\xB0R'> 'British thermal unit (IT) per degree Rankine' : HeatCapacityUnit = Btu_IT/'\xB0R';
    attribute <'Btu_th/\xB0R'> 'British thermal unit (th) per degree Rankine' : HeatCapacityUnit = Btu_th/'\xB0R';
    attribute <'Btu_IT/h'> 'British thermal unit (IT) per hour' : PowerUnit = Btu_IT/h;
    attribute <'Btu_th/h'> 'British thermal unit (th) per hour' : PowerUnit = Btu_th/h;
    attribute <'Btu_IT/(h\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (IT) per hour square foot degree Fahrenheit' : CoefficientOfHeatTransferUnit = Btu_IT/(h*ft^2*'\xB0F');
    attribute <'Btu_th/(h\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (th) per hour square foot degree Fahrenheit' : CoefficientOfHeatTransferUnit = Btu_th/(h*ft^2*'\xB0F');
    attribute <'Btu_th/min'> 'British thermal unit (th) per minute' : PowerUnit = Btu_th/min;
    attribute <'Btu_IT/lb'> 'British thermal unit (IT) per pound' : SpecificEnergyUnit = Btu_IT/lb;
    attribute <'Btu_th/lb'> 'British thermal unit (th) per pound' : SpecificEnergyUnit = Btu_th/lb;
    attribute <'Btu_IT/(lb\u22C5\xB0F)'> 'British thermal unit (IT) per pound degree Fahrenheit' : SpecificHeatCapacityUnit = Btu_IT/(lb*'\xB0F');
    attribute <'Btu_th/(lb\u22C5\xB0F)'> 'British thermal unit (th) per pound degree Fahrenheit' : SpecificHeatCapacityUnit = Btu_th/(lb*'\xB0F');
    attribute <'Btu_IT/(lb\u22C5\xB0R)'> 'British thermal unit (IT) per pound degree Rankine' : SpecificHeatCapacityUnit = Btu_IT/(lb*'\xB0R');
    attribute <'Btu_th/(lb\u22C5\xB0R)'> 'British thermal unit (th) per pound degree Rankine' : SpecificHeatCapacityUnit = Btu_th/(lb*'\xB0R');
    attribute <'Btu_IT/s'> 'British thermal unit (IT) per second' : PowerUnit = Btu_IT/s;
    attribute <'Btu_th/s'> 'British thermal unit (th) per second' : PowerUnit = Btu_th/s;
    attribute <'Btu_IT/(s\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (IT) per second square foot degree Fahrenheit' : CoefficientOfHeatTransferUnit = Btu_IT/(s*ft^2*'\xB0F');
    attribute <'Btu_th/(s\u22C5ft\xB2\u22C5\xB0F)'> 'British thermal unit (th) per second square foot degree Fahrenheit' : CoefficientOfHeatTransferUnit = Btu_th/(s*ft^2*'\xB0F');
    //attribute <'Btu_IT/ft\xB2'> 'British thermal unit (IT) per square foot' : SurfaceHeatDensityUnit = Btu_IT/ft^2;
    //attribute <'Btu_th/ft\xB2'> 'British thermal unit (th) per square foot' : SurfaceHeatDensityUnit = Btu_th/ft^2;
    attribute <'Btu_IT/(ft\xB2\u22C5h)'> 'British thermal unit (IT) per square foot hour' : DensityOfHeatFlowRateUnit = Btu_IT/(ft^2*h);
    attribute <'Btu_th/(ft\xB2\u22C5h)'> 'British thermal unit (th) per square foot hour' : DensityOfHeatFlowRateUnit = Btu_th/(ft^2*h);
    attribute <'Btu_th/(ft\xB2\u22C5min)'> 'British thermal unit (th) per square foot minute' : DensityOfHeatFlowRateUnit = Btu_th/(ft^2*min);
    attribute <'Btu_IT/(ft\xB2\u22C5s)'> 'British thermal unit (IT) per square foot second' : DensityOfHeatFlowRateUnit = Btu_IT/(ft^2*s);
    attribute <'Btu_th/(ft\xB2\u22C5s)'> 'British thermal unit (th) per square foot second' : DensityOfHeatFlowRateUnit = Btu_th/(ft^2*s);
    attribute <'Btu_th/(in\xB2\u22C5s)'> 'British thermal unit (th) per square inch second' : DensityOfHeatFlowRateUnit = Btu_th/('in'^2*s);
    attribute <bu> 'bushel (US)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 3.523907E-02; :>> isExact = false; } }
    attribute <'cd/in\xB2'> 'candela per square inch' : LuminanceUnit = cd/'in'^2;
    attribute <ch> 'chain (based on US survey foot)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 2.011684E+01; :>> isExact = false; } }
    attribute 'circular mil' : AreaUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^2; :>> conversionFactor = 5.067075E-10; :>> isExact = false; } }
    attribute 'clo' : ThermalInsulanceUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^2*K/W; :>> conversionFactor = 1.55E-01; :>> isExact = false; } }
    attribute 'cord (128 ft^3)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 3.624556E+00; :>> isExact = false; } }
    attribute <'ft\xB3'> 'cubic foot' : VolumeUnit = ft^3;
    attribute <'ft\xB3/min'> 'cubic foot per minute' : VolumeFlowRateUnit = ft^3/min;
    attribute <'ft\xB3/s'> 'cubic foot per second' : VolumeFlowRateUnit = ft^3/s;
    attribute <'in\xB3'> 'cubic inch' : VolumeUnit = 'in'^3;
    attribute <'in\xB3/min'> 'cubic inch per minute' : VolumeFlowRateUnit = 'in'^3/min;
    attribute <'mi\xB3'> 'cubic mile' : VolumeUnit = mi^3;
    attribute <'yd\xB3'> 'cubic yard' : VolumeUnit = yd^3;
    attribute <'yd\xB3/min'> 'cubic yard per minute' : VolumeFlowRateUnit = yd^3/min;
    attribute 'cup (US)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 2.365882E-04; :>> isExact = false; } }
    attribute <'\xB0F'> 'degree Fahrenheit (temperature difference)' : TemperatureDifferenceUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = K; :>> conversionFactor = 5/9; :>> isExact = true; } }
    attribute <'\xB0F\u22C5h/Btu_IT'> 'degree Fahrenheit hour per British thermal unit (IT)' : ThermalResistanceUnit = '\xB0F'*h/Btu_IT;
    attribute <'\xB0F\u22C5h/Btu_th'> 'degree Fahrenheit hour per British thermal unit (th)' : ThermalResistanceUnit = '\xB0F'*h/Btu_th;
    attribute <'\xB0F\u22C5h\u22C5ft\xB2/Btu_IT'> 'degree Fahrenheit hour square foot per British thermal unit (IT)' : ThermalInsulanceUnit = '\xB0F'*h*ft^2/Btu_IT;
    attribute <'\xB0F\u22C5h\u22C5ft\xB2/Btu_th'> 'degree Fahrenheit hour square foot per British thermal unit (th)' : ThermalInsulanceUnit = '\xB0F'*h*ft^2/Btu_th;
    //attribute <'\xB0F\u22C5h\u22C5ft\xB2/(Btu_IT\u22C5in)'> 'degree Fahrenheit hour square foot per British thermal unit (IT) inch' : ThermalResistivityUnit = '\xB0F'*h*ft^2/(Btu_IT*'in');
    //attribute <'\xB0F\u22C5h\u22C5ft\xB2/(Btu_th\u22C5in)'> 'degree Fahrenheit hour square foot per British thermal unit (th) inch' : ThermalResistivityUnit = '\xB0F'*h*ft^2/(Btu_th*'in');
    attribute <'\xB0F\u22C5s/Btu_IT'> 'degree Fahrenheit second per British thermal unit (IT)' : ThermalResistanceUnit = '\xB0F'*s/Btu_IT;
    attribute <'\xB0F\u22C5s/Btu_th'> 'degree Fahrenheit second per British thermal unit (th)' : ThermalResistanceUnit = '\xB0F'*s/Btu_th;
    attribute <'\xB0R'> 'degree Rankine' : ThermodynamicTemperatureUnit, TemperatureDifferenceUnit { 
        :>> unitConversion: ConversionByConvention { :>> referenceUnit = K; :>> conversionFactor = 5/9; :>> isExact = true; }
        :>> ThermodynamicTemperatureUnit::quantityDimension, TemperatureDifferenceUnit::quantityDimension {
            :>> ThermodynamicTemperatureUnit::quantityDimension::quantityPowerFactors, TemperatureDifferenceUnit::quantityDimension::quantityPowerFactors;
        }
    }
    attribute 'fathom (based on US survey foot)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 1.828804E+00; :>> isExact = false; } }
    attribute <floz> 'fluid ounce (US)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 2.957353E-05; :>> isExact = false; } }
    attribute <ft> 'foot' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 3.048E-01; } }
    attribute 'foot (US survey)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 3.048006E-01; :>> isExact = false; } }
    attribute 'footcandle' : IlluminanceUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = lx; :>> conversionFactor = 1.076391E+01; :>> isExact = false; } }
    attribute 'footlambert' : LuminanceUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = cd/m^2; :>> conversionFactor = 3.426259E+00; :>> isExact = false; } }
    attribute <ftHg> 'foot of mercury, conventional' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 4.063666E+04; :>> isExact = false; } }
    attribute 'foot of water (39.2 \xB0F)' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 2.98898E+03; :>> isExact = false; } }
    attribute <ftH2O> 'foot of water, conventional' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 2.989067E+03; :>> isExact = false; } }
    attribute <'ft/h'> 'foot per hour' : SpeedUnit = ft/h;
    attribute <'ft/min'> 'foot per minute' : SpeedUnit = ft/min;
    attribute <'ft/s'> 'foot per second' : SpeedUnit = ft/s;
    attribute <'ft/s\xB2'> 'foot per second squared' : AccelerationUnit = ft/s^2;
    attribute 'foot poundal' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 4.214011E-02; :>> isExact = false; } }
    attribute <'ft\u22C5lbf'> 'foot pound-force' : EnergyUnit = ft*lbf;
    attribute <'ft\u22C5lbf/h'> 'foot pound-force per hour' : PowerUnit = ft*lbf/h;
    attribute <'ft\u22C5lbf/min'> 'foot pound-force per minute' : PowerUnit = ft*lbf/min;
    attribute <'ft\u22C5lbf/s'> 'foot pound-force per second' : PowerUnit = ft*lbf/s;
    attribute <'ft\u2074'> 'foot to the fourth power' : SecondAxialMomentOfAreaUnit = ft^4;
    attribute <gal> 'gallon (US)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 3.785412E-03; :>> isExact = false; } }
    attribute <'gal/d'> 'gallon (US) per day' : VolumeFlowRateUnit = gal/d;
    //attribute <'gal/(hp\u22C5h)'> 'gallon (US) per horsepower hour' : EnergySpecificVolumeUnit = gal/(hp*h);
    attribute <'gal/min'> 'gallon (US) per minute (gpm)' : VolumeFlowRateUnit = gal/min;
    attribute <gi> 'gill (US)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 1.182941E-04; :>> isExact = false; } }
    attribute <gr> 'grain' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 6.479891E-05; } }
    attribute <'gr/gal'> 'grain per gallon (US)' : MassDensityUnit = gr/gal;
    attribute <hp> 'horsepower (550 ft*lbf/s)' : PowerUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = W; :>> conversionFactor = 7.456999E+02; :>> isExact = false; } }
    attribute 'horsepower (boiler)' : PowerUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = W; :>> conversionFactor = 9.80950E+03; :>> isExact = false; } }
    attribute 'horsepower (electric)' : PowerUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = W; :>> conversionFactor = 7.46E+02; } }
    attribute 'horsepower (water)' : PowerUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = W; :>> conversionFactor = 7.46043E+02; :>> isExact = false; } }
    attribute 'hundredweight (long, 112 lb)' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 5.080235E+01; :>> isExact = false; } }
    attribute 'hundredweight (short, 100 lb)' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 4.535924E+01; :>> isExact = false; } }
    attribute <'in'> 'inch' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 2.54E-02; } }
    attribute 'inch of mercury (32 \xB0F)' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 3.38638E+03; :>> isExact = false; } }
    attribute 'inch of mercury (60 \xB0F)' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 3.37685E+03; :>> isExact = false; } }
    attribute <inHg> 'inch of mercury, conventional' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 3.386389E+03; :>> isExact = false; } }
    attribute 'inch of water (39.2 \xB0F)' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 2.49082E+02; :>> isExact = false; } }
    attribute 'inch of water (60 \xB0F)' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 2.4884E+02; :>> isExact = false; } }
    attribute <inH2O> 'inch of water, conventional' : PressureUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Pa; :>> conversionFactor = 2.490889E+02; :>> isExact = false; } }
    attribute <'in/s'> 'inch per second' : SpeedUnit = 'in'/s;
    attribute <'in/s\xB2'> 'inch per second squared' : AccelerationUnit = 'in'/s^2;
    attribute <'in\u2074'> 'inch to the fourth power' : SecondAxialMomentOfAreaUnit = 'in'^4;
    attribute <kip> 'kip (1 kip = 1000 lbf)' : ForceUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = N; :>> conversionFactor = 4.448222E+03; :>> isExact = false; } }
    attribute <'kip/in\xB2'> 'kip per square inch (ksi)' : PressureUnit = kip/'in'^2;
    attribute <knot> 'knot (nautical mile per hour)' : SpeedUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m/s; :>> conversionFactor = 5.144444E-01; :>> isExact = false; } }
    //attribute <'cal_th/cm\xB2'> 'langley' : SurfaceHeatDensityUnit = cal_th/cm^2;
    attribute <'lm/ft\xB2'> 'lumen per square foot' : IlluminanceUnit = lm/ft^2;
    attribute 'microinch' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 2.54E-08; } }
    attribute <mil> 'mil (0.001 in)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 2.54E-05; } }
    attribute <mi> 'mile' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 1.609344E+03; } }
    attribute 'mile (based on US survey foot)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 1.609347E+03; :>> isExact = false; } }
    attribute <nmi> 'mile, nautical' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 1.852E+03; } }
    alias NM for nmi;
    //attribute <'mi/gal'> 'mile per gallon (US)' : FuelEconomyUnit = mi/gal;
    //alias mpg for 'mi/gal';
    attribute <'mi/h'> 'mile per hour' : SpeedUnit = mi/h;
    alias mph for 'mi/h';
    attribute <'mi/min'> 'mile per minute' : SpeedUnit = mi/min;
    attribute <'mi/s'> 'mile per second' : SpeedUnit = mi/s;
    attribute 'ohm circular-mil per foot' : ResistivityUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = '\u03A9'*m; :>> conversionFactor = 1.662426E-09; :>> isExact = false; } }
    attribute <oz> 'ounce (avoirdupois)' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 2.834952E-02; :>> isExact = false; } }
    attribute 'ounce (US fluid)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 2.957353E-05; :>> isExact = false; } }
    attribute <ozf> 'ounce (avoirdupois)-force' : ForceUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = N; :>> conversionFactor = 2.780139E-01; :>> isExact = false; } }
    attribute <'ozf\u22C5in'> 'ounce (avoirdupois)-force inch' : MomentOfForceUnit = ozf*'in';
    attribute <'oz/in\xB3'> 'ounce (avoirdupois) per cubic inch' : MassDensityUnit = oz/'in'^3;
    attribute <'oz/gal'> 'ounce (avoirdupois) per gallon (US)' : MassDensityUnit = oz/gal;
    attribute <'oz/ft\xB2'> 'ounce (avoirdupois) per square foot' : SurfaceMassDensityUnit = oz/ft^2;
    attribute <'oz/in\xB2'> 'ounce (avoirdupois) per square inch' : SurfaceMassDensityUnit = oz/'in'^2;
    attribute <'oz/yd\xB2'> 'ounce (avoirdupois) per square yard' : SurfaceMassDensityUnit = oz/yd^2;
    attribute <pk> 'peck (US)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 8.809768E-03; :>> isExact = false; } }
    //attribute 'perm (0 \xB0C)' : VapourTransmissionUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg/(Pa*s*m^2); :>> conversionFactor = 5.72135E-11; :>> isExact = false; } }
    //attribute 'perm (23 \xB0C)' : VapourTransmissionUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg/(Pa*s*m^2); :>> conversionFactor = 5.74525E-11; :>> isExact = false; } }
    //attribute 'perm inch (0 \xB0C)' : VapourTransmissionUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg/('Pa\xB7s\xB7m'); :>> conversionFactor = 1.45322E-12; :>> isExact = false; } }
    //attribute 'perm inch (23 \xB0C)' : VapourTransmissionUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg/('Pa\xB7s\xB7m'); :>> conversionFactor = 1.45929E-12; :>> isExact = false; } }
    attribute <pica> 'pica (computer) (1/6 in)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 4.233333E-03; :>> isExact = false; } }
    attribute 'pica (printer\u2032s)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 4.217518E-03; :>> isExact = false; } }
    attribute <drypt> 'pint (US dry)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 5.506105E-04; :>> isExact = false; } }
    attribute <liqpt> 'pint (US liquid)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 4.731765E-04; :>> isExact = false; } }
    attribute <pt> 'point (computer) (1/72 in)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 3.527778E-04; :>> isExact = false; } }
    attribute 'point (printer\u2032s)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 3.514598E-04; :>> isExact = false; } }
    attribute <lb> 'pound (avoirdupois)' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 4.535924E-01; :>> isExact = false; } }
    attribute <'lb\u22C5ft\xB2'> 'pound foot squared' : MomentOfInertiaUnit = lb*ft^2;
    attribute <lbf> 'pound-force' : ForceUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = N; :>> conversionFactor = 4.448222E+00; :>> isExact = false; } }
    attribute <'lbf\u22C5ft'> 'pound-force foot' : MomentOfForceUnit = lbf*ft;
    attribute <'lbf\u22C5ft/in'> 'pound-force foot per inch' : ForceUnit = lbf*ft/'in';
    attribute <'lbf\u22C5in'> 'pound-force inch' : MomentOfForceUnit = lbf*'in';
    attribute <'lbf\u22C5in/in'> 'pound-force inch per inch' : ForceUnit = lbf*'in'/'in';
    attribute <'lbf/ft'> 'pound-force per foot' : SurfaceTensionUnit = lbf/ft;
    attribute <'lbf/in'> 'pound-force per inch' : SurfaceTensionUnit = lbf/'in';
    //attribute 'pound-force per pound (lbf/lb) (thrust to mass ratio)' : ThrustToMassRatioUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = N/kg; :>> conversionFactor = 9.80665E+00; } }
    attribute <'lbf/ft\xB2'> 'pound-force per square foot' : PressureUnit = lbf/ft^2;
    attribute <'lbf/in\xB2'> 'pound-force per square inch' : PressureUnit = lbf/'in'^2;
    alias psi for 'lbf/in\xB2';
    attribute <'lbf\u22C5s/ft\xB2'> 'pound-force second per square foot' : DynamicViscosityUnit = lbf*s/ft^2;
    attribute <'lbf\u22C5s/in\xB2'> 'pound-force second per square inch' : DynamicViscosityUnit = lbf*s/'in'^2;
    attribute <'lb\u22C5in\xB2'> 'pound inch squared' : MomentOfInertiaUnit = lb*'in'^2;
    attribute <'lb/ft\xB3'> 'pound per cubic foot' : MassDensityUnit = lb/ft^3;
    attribute <'lb/in\xB3'> 'pound per cubic inch' : MassDensityUnit = lb/'in'^3;
    attribute <'lb/yd\xB3'> 'pound per cubic yard' : MassDensityUnit = lb/yd^3;
    attribute <'lb/ft'> 'pound per foot' : LinearMassDensityUnit = lb/ft;
    attribute <'lb/(ft\u22C5h)'> 'pound per foot hour' : DynamicViscosityUnit = lb/(ft*h);
    attribute <'lb/(ft\u22C5s)'> 'pound per foot second' : DynamicViscosityUnit = lb/(ft*s);
    attribute <'lb/gal'> 'pound per gallon (US)' : MassDensityUnit = lb/gal;
    //attribute <'lb/(hp\u22C5h)'> 'pound per horsepower hour' : FuelConsumptionUnit = lb/(hp*h);
    attribute <'lb/h'> 'pound per hour' : MassFlowRateUnit = lb/h;
    attribute <'lb/in'> 'pound per inch' : LinearMassDensityUnit = lb/'in';
    attribute <'lb/min'> 'pound per minute' : MassFlowRateUnit = lb/min;
    attribute <'lb/s'> 'pound per second' : MassFlowRateUnit = lb/s;
    attribute <'lb/ft\xB2'> 'pound per square foot' : SurfaceMassDensityUnit = lb/ft^2;
    attribute <'lb/in\xB2'> 'pound per square inch (not pound-force)' : SurfaceMassDensityUnit = lb/'in'^2;
    attribute <'lb/yd'> 'pound per yard' : LinearMassDensityUnit = lb/yd;
    attribute 'pound-force per square inch (psi)' : PressureUnit = lbf/'in'^2;
    attribute 'quad (10^15 Btu_IT)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.055056E+18; :>> isExact = false; } }
    attribute <dryqt> 'quart (US dry)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 1.101221E-03; :>> isExact = false; } }
    attribute <liqqt> 'quart (US liquid)' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 9.463529E-04; :>> isExact = false; } }
    attribute <rd> 'rod (based on US survey foot)' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 5.029210E+00; :>> isExact = false; } }
    attribute <slug> 'slug' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 1.459390E+01; :>> isExact = false; } }
    attribute <'slug/ft\xB3'> 'slug per cubic foot' : MassDensityUnit = slug/ft^3;
    attribute <'slug/(ft\u22C5s)'> 'slug per foot second' : DynamicViscosityUnit = slug/(ft*s);
    attribute <'ft\xB2'> 'square foot' : AreaUnit = ft^2;
    attribute <'ft\xB2/h'> 'square foot per hour' : KinematicViscosityUnit = ft^2/h;
    attribute <'ft\xB2/s'> 'square foot per second' : KinematicViscosityUnit = ft^2/s;
    attribute <'in\xB2'> 'square inch' : AreaUnit = 'in'^2;
    attribute <'mi\xB2'> 'square mile' : AreaUnit = mi^2;
    attribute 'square mile (based on US survey foot)' : AreaUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^2; :>> conversionFactor = 2.589998E+06; :>> isExact = false; } }
    attribute <'yd\xB2'> 'square yard' : AreaUnit = yd^2;
    attribute 'tablespoon' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 1.478676E-05; :>> isExact = false; } }
    attribute 'teaspoon' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 4.928922E-06; :>> isExact = false; } }
    attribute 'therm (EC)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.05506E+08; } }
    attribute 'therm (US)' : EnergyUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = J; :>> conversionFactor = 1.054804E+08; } }
    attribute <AT> 'ton, assay' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 2.916667E-02; :>> isExact = false; } }
    attribute 'ton-force (2000 lbf)' : ForceUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = N; :>> conversionFactor = 8.896443E+03; :>> isExact = false; } }
    attribute 'ton, long (2240 lb)' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 1.016047E+03; :>> isExact = false; } }
    attribute 'ton, long, per cubic yard' : MassDensityUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg/m^3; :>> conversionFactor = 1.328939E+03; :>> isExact = false; } }
    attribute 'ton of refrigeration (12 000 Btu_IT/h)' : PowerUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = W; :>> conversionFactor = 3.516853E+03; :>> isExact = false; } }
    attribute 'ton, register' : VolumeUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m^3; :>> conversionFactor = 2.831685E+00; :>> isExact = false; } }
    attribute 'ton, short (2000 lb)' : MassUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg; :>> conversionFactor = 9.071847E+02; :>> isExact = false; } }
    attribute 'ton, short, per cubic yard' : MassDensityUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg/m^3; :>> conversionFactor = 1.186553E+03; :>> isExact = false; } }
    attribute 'ton, short, per hour' : MassFlowRateUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = kg/s; :>> conversionFactor = 2.519958E-01; :>> isExact = false; } }
    attribute 'unit pole' : MagneticFluxUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = Wb; :>> conversionFactor = 1.256637E-07; :>> isExact = false; } }
    attribute <'W/in\xB2'> 'watt per square inch' : DensityOfHeatFlowRateUnit = W/'in'^2;
    attribute <yd> 'yard' : LengthUnit { :>> unitConversion: ConversionByConvention { :>> referenceUnit = m; :>> conversionFactor = 9.144E-01; } }


	attribute <'\xB0F_abs'> 'degree fahrenheit (absolute temperature scale)' : IntervalScale {
		doc
		/*
		 * degree Fahrenheit interval scale for absolute (thermodynamic) temperature quantities
		 *
	     * The interval scale is defined with an explicit transformation with respect to 
	     * the kelvin thermodynamic temperature scale that specifies the zero shift.
		 */
		
		:>> unit = '\xB0F';
		private attribute temperatureWaterAtFreezingPointInF: DefinitionalQuantityValue {
			:>> num = 32.0;
			:>> definition = "temperature in degree Fahrenheit of pure water at freezing point";
		}
		private attribute fahrenheitToCelsiusScaleMapping: QuantityValueMapping {
			:>> mappedQuantityValue = temperatureWaterAtFreezingPointInF;
			:>> referenceQuantityValue = '\xB0C_abs'.temperatureWaterAtFreezingPointInC;

		}
		attribute :>> definitionalQuantityValues = temperatureWaterAtFreezingPointInF;
		attribute :>> quantityValueMapping = fahrenheitToCelsiusScaleMapping;

        /* CoordinateFramePlacement (zero shift) w.r.t. the kelvin thermodynamic temperature scale */
        private attribute zeroDegreeFahrenheitInKelvin: ThermodynamicTemperatureValue = 229835/900 [K];
        attribute zeroDegreeFahrenheitToKelvinShift : CoordinateFramePlacement :>> transformation { 
        	:>> source = K; :>> origin = zeroDegreeFahrenheitInKelvin;
        }
	}
}
`, "Domain Libraries/Quantities and Units/VectorCalculations.sysml": "standard library package VectorCalculations {\n	doc\n	/*\n	 * This package package defines calculations for the construction of and computations on VectorQuantityValues.\n	 */\n	 \n	private import ScalarValues::Boolean;\n	private import ScalarValues::Number;\n    private import Quantities::ScalarQuantityValue;\n    private import Quantities::VectorQuantityValue;\n    private import MeasurementReferences::VectorMeasurementReference;\n    private import MeasurementReferences::CoordinateTransformation;\n    \n    calc def '[' :> BaseFunctions::'[' { \n    	in elements: Number[1..n] ordered; \n    	in mRef: VectorMeasurementReference[1]; \n    	return quantity : VectorQuantityValue[1];\n    	private attribute n = mRef.flattenedSize;\n    }\n\n    calc def isZeroVectorQuantity :> VectorFunctions::isZeroVector { \n    	in : VectorQuantityValue[1]; \n    	return : Boolean[1];\n    }\n    calc def isUnitVectorQuantity { \n    	in : VectorQuantityValue[1]; \n    	return : Boolean[1];\n    }\n\n    /* Addition and subtraction */\n	calc def '+' :> VectorFunctions::'+' { in : VectorQuantityValue[1]; in : VectorQuantityValue[1]; return : VectorQuantityValue[1]; }\n	calc def '-' :> VectorFunctions::'-' { in : VectorQuantityValue[1]; in : VectorQuantityValue[1]; return : VectorQuantityValue[1]; }\n\n    /* Multiplication and division */\n	calc def scalarVectorMult :> VectorFunctions::scalarVectorMult { in : Number[1]; in : VectorQuantityValue[1]; return : VectorQuantityValue[1]; }\n	calc def vectorScalarMult :> VectorFunctions::vectorScalarMult { in : VectorQuantityValue[1]; in : Number[1]; return : VectorQuantityValue[1]; }\n    calc def scalarQuantityVectorMult { in : ScalarQuantityValue[1]; in : VectorQuantityValue[1]; return : VectorQuantityValue[1]; }\n    calc def vectorScalarQuantityMult { in : VectorQuantityValue[1]; in : ScalarQuantityValue[1]; return : VectorQuantityValue[1]; }\n	calc def vectorScalarDiv :> VectorFunctions::vectorScalarDiv { in : VectorQuantityValue[1]; in : Number[1]; return : VectorQuantityValue[1]; }\n    calc def vectorScalarQuantityDiv { in : VectorQuantityValue[1]; in : ScalarQuantityValue[1]; return : VectorQuantityValue[1]; }\n	calc def inner :> VectorFunctions::inner { in : VectorQuantityValue[1]; in : VectorQuantityValue[1]; return : Number[1]; }\n    calc def outer { in : VectorQuantityValue[1]; in : VectorQuantityValue[1]; return : VectorQuantityValue[1]; }\n	\n    alias '*' for scalarVectorMult;\n    \n    /* Norm and angle */\n	calc def norm :> VectorFunctions::norm { in : VectorQuantityValue[1]; return : Number[1]; }\n	calc def angle :> VectorFunctions::angle { in : VectorQuantityValue[1]; in : VectorQuantityValue[1]; return : Number[1]; }\n	\n	/* Coordinate transformation */\n	calc def transform {\n	    in transformation : CoordinateTransformation;\n	    in sourceVector : VectorQuantityValue {\n	        :>> mRef = transformation.source;\n	    }\n	    return targetVector : VectorQuantityValue {\n	        :>> mRef = transformation.target {\n	            :>> dimensions = sourceVector.mRef.dimensions;\n	        }\n    	}\n	}\n}\n", "Domain Libraries/Requirement Derivation/DerivationConnections.sysml": "standard library package DerivationConnections {\n	doc\n	/*\n	 * This package provides a library model for derivation connections between requirements.\n	 */\n	 \n	private import SequenceFunctions::excludes;\n	private import ControlFunctions::allTrue;\n	\n	requirement originalRequirements[*] {\n		doc /* originalRequirements are the original requirements in Derivation connections. */\n	}\n	requirement derivedRequirements[*] {\n		doc /* derivedRequirements are the derived requirments in Derivation connections. */\n	}\n	\n	abstract connection def Derivation {\n		doc\n		/*\n		 * A Derivation connection asserts that one or more derivedRequirements are derived from\n		 * a single originalRequirement. This means that any subject that satisfies the\n		 * originalRequirement should, in itself or though other things related to it, satisfy\n		 * each of the derivedRequirements.\n		 * \n		 * A connection usage typed by Derivation must have requirement usages for all its ends.\n		 * The single end for the originalRequirement should subset originalRequirement, while\n		 * the rest of the ends should subset derivedRequirements.\n		 */\n		\n		// Note: This redefinition causes a distinguishibility problem for binary connections, becuse\n		// participant is already redefined for them to limit the multiplicity to 2.\n		// ref requirement :>> participant {\n		//	doc /* All the participants in a Derivation must be requirements. */\n		// }\n		\n		ref requirement originalRequirement[1] :>> originalRequirements :> participant {\n			doc /* The single original requirement. */\n		}\n		ref requirement :>> derivedRequirements[1..*] :> participant {\n			doc /* The one or more requirements that are derived from the original requirement. */\n		}\n		\n		private assert constraint originalNotDerived {\n			doc /* The original requirement must not be a derived requirement. */\n			\n			derivedRequirements->excludes(originalRequirement)\n		}\n		\n		private assert constraint originalImpliesDerived {\n			doc \n			/* \n			 * Whenever the originalRequirement is satisfied, all of the derivedRequirements must also\n			 * be satisfied.\n			 */\n			 \n			originalRequirement.result implies allTrue(derivedRequirements.result)\n		}	\n	}\n	\n	abstract connection derivations : Derivation[*] {\n		doc /* derivations is the base feature for Derivation connection usages. */\n	}\n}", "Domain Libraries/Requirement Derivation/RequirementDerivation.sysml": "standard library package RequirementDerivation {\n	doc /* This package provides language-extension metadata for modeling requirement derivation. */\n	\n	public import DerivationConnections::*;\n	private import Metaobjects::SemanticMetadata;\n	\n	metadata def <original> OriginalRequirementMetadata :> SemanticMetadata {\n		doc\n		/*\n		 * OriginalRequirementMetadata identifies a usage as an original requirement.\n		 * It is intended to be used to tag the original requirement end of a Derivation.\n		 */\n		 \n		:> annotatedElement : SysML::Usage;\n		:>> baseType = originalRequirements meta SysML::Usage;\n	}\n	\n	metadata def <derive> DerivedRequirementMetadata :> SemanticMetadata {\n		doc\n		/*\n		 * DerivedRequirementMetadata identifies a usage as a derived requirement.\n		 * It is intended to be used to tag the derived requirement ends of a Derivation.\n		 */\n		 \n		:> annotatedElement : SysML::Usage;	\n		:>> baseType = derivedRequirements meta SysML::Usage;\n	}\n	\n	metadata def <derivation> DerivationMetadata :> SemanticMetadata {\n		doc\n		/*\n		 * DerivationMetadata is SemanticMetadata for a Derivation connection.\n		 */\n		 \n		:> annotatedElement : SysML::ConnectionDefinition;\n		:> annotatedElement : SysML::ConnectionUsage;\n		:>> baseType = derivations meta SysML::Usage;\n	}	\n}", "Kernel Libraries/Kernel Data Type Library/Collections.kerml": "standard library package Collections {\n	doc\n	/*\n	 * This package defines a standard set of Collection data types. Unlike sequences of values \n	 * defined directly using multiplicity, these data types allow for the possibility of collections \n	 * as elements of collections.\n	 */\n\n	private import Base::*;\n	private import ScalarValues::*;\n	private import SequenceFunctions::size;\n	private import IntegerFunctions::*;\n	private import ControlFunctions::*;\n\n	abstract datatype Collection {\n		doc\n		/*\n		 * Collection is the top level abstract supertype of all collection types.\n		 * The name elements is used to denote the members or contents of the collection.\n		 */\n		\n		feature elements[0..*] nonunique;\n	}\n\n    abstract datatype OrderedCollection :> Collection {\n    	doc\n		/*\n		 * OrderedCollection is the abstract supertype for all ordered collection types.\n		 */\n    	\n		feature elements[0..*] ordered nonunique :>> Collection::elements;\n    }\n\n    abstract datatype UniqueCollection :> Collection {\n    	doc\n		/*\n		 * UniqueCollection is the abstract supertype for all collection types with unique elements.\n		 */\n		\n		feature elements[0..*] :>> Collection::elements {\n			/* Note: Redefinition of 'elements' is unique by default. */\n		}\n    }\n\n    datatype Array :> OrderedCollection {\n    	doc\n	    /*\n	     * An Array is a fixed size, multi-dimensional Collection of which the elements are nonunique and ordered. \n	     * Its dimensions specify how many dimensions the array has, and how many elements there are in each dimension. \n	     * The rank is equal to the number of dimensions. The flattenedSize is equal to the total number of elements \n	     * in the array.\n	     * \n	     * Feature elements is a flattened sequence of all elements of an Array and can be accessed by a tuple of indices. \n	     * The number of indices is equal to rank. The elements are packed according to row-major convention, as in the C programming language.\n	     * \n	     * The elements of an Array can be assessed by a tuple of indices. The number of indices in such tuple is equal to rank. \n		 * The packing of the elements, i.e. the flattened representation, follows the row-major convention, \n		 * as in the C programming language.\n		 * \n		 * Note 1. Feature dimensions may be empty, which denotes a zero dimensional array, allowing an Array to collapse to a single element. \n		 * This is useful to allow for specialization of an Array into a type restricted to represent a scalar. \n		 * The flattenedSize of a zero dimensional array is 1.\n		 * \n		 * Note 2: An Array can represent the generalized mathematical concept of an infinite matrix of any rank, i.e. not limited to rank two.\n	     */\n	     \n        feature dimensions: Positive[0..*] ordered nonunique {\n        	doc\n       		/* Feature `dimensions` defines the N-dimensional shape of the Array\n             * The alternative name `shape` (as used in many programming languages) is not used as it would interfere with a geometric shape feature.\n 			 */\n        }\n        feature rank: Natural[1] = size(dimensions);\n        feature flattenedSize: Positive[1] = dimensions->reduce '*' ?? 1;\n        inv { flattenedSize == size(elements) }\n    }\n    \n	datatype Bag :> Collection {\n		doc\n		/*\n		 * Bag is a variable-size, unordered collection of nonunique elements.\n		 */		\n	}\n	\n	datatype Set :> UniqueCollection {\n		doc\n		/*\n		 * Set is a variable-size, unordered collection of unique elements.\n		 */\n	}\n\n	datatype OrderedSet :> OrderedCollection, UniqueCollection \n		intersects OrderedCollection, UniqueCollection {\n		doc\n		/*\n		 * OrderedSet is a variable-size, ordered collection of unique elements.\n		 */	\n		\n		feature elements[0..*] ordered :>> OrderedCollection::elements, UniqueCollection::elements {\n			/* Note: Redefinition of `elements` is unique by default. */\n		}\n	}\n		\n	datatype List :> OrderedCollection {\n		doc\n		/*\n		 * List is a variable-size, ordered collection of nonunique elements.\n		 */\n	}\n\n    datatype KeyValuePair {\n    	doc\n		/*\n		 * KeyValuePair is a tuple of a key and a value for use in Map collections.\n		 * The key must be immutable.\n		 */\n    	\n        feature key: Anything[0..*] ordered nonunique;\n        feature val: Anything[0..*] ordered nonunique;\n    }\n\n    datatype Map :> Collection {\n    	doc\n		/*\n		 * Map is a variable-size, unordered collection of elements that are key-value pairs.\n		 */\n    	\n		feature elements: KeyValuePair[0..*] :>> Collection::elements {\n			/* Note: Redefinition of `elements` is unique by default. \n			 * The `key` of any `KeyValuePair` must be unique over the collection of `KeyValuePair`. \n			 * The `val` does not need to be unique. \n			 */			\n		}\n    }\n\n    datatype OrderedMap :> Map {\n    	doc\n		/*\n		 * OrderedMap is a variable-size, ordered collection of elements that are key-value pairs. \n		 */\n\n		feature elements: KeyValuePair[0..*] ordered :>> Map::elements {\n			/* Note: Redefinition of `elements` is unique by default. */\n		}\n    }\n    \n}", "Kernel Libraries/Kernel Data Type Library/ScalarValues.kerml": "standard library package ScalarValues {\n	doc\n	/*\n	 * This package contains a basic set of primitive scalar (non-collection) data types. \n	 * These include Boolean and String types and a hierarchy of concrete Number types, from \n	 * the most general type of Complex numbers to the most specific type of Positive integers.</p>\n	 */\n\n	private import Base::DataValue;\n	\n	abstract datatype ScalarValue specializes DataValue;\n	datatype Boolean specializes ScalarValue;\n	datatype String specializes ScalarValue;\n	abstract datatype NumericalValue specializes ScalarValue;\n	\n    abstract datatype Number specializes NumericalValue;\n	datatype Complex specializes Number;\n	datatype Real specializes Complex;	\n	datatype Rational specializes Real;\n	datatype Integer specializes Rational;\n	datatype Natural specializes Integer;\n    datatype Positive specializes Natural;	\n}		\n", "Kernel Libraries/Kernel Data Type Library/VectorValues.kerml": "standard library package VectorValues {\n	doc\n	/*\n	 * This package provides a basic model of abstract vectors as well as concrete vectors\n	 * whose components are numerical values. The package VectorFunctions defines the \n	 * corresponding vector-space functions.\n	 */\n\n	private import ScalarValues::NumericalValue;\n	private import ScalarValues::Real;\n	private import Collections::Array;\n	\n	abstract datatype VectorValue {\n		doc\n		/*\n		 * A VectorValue is an abstract data type whose values may be operated on using\n		 * VectorFunctions.\n		 */\n	}\n	\n	datatype NumericalVectorValue :> VectorValue, Array intersects VectorValue, Array {\n		doc\n		/*\n		 * A NumericalVectorValue is a kind of VectorValue that is specifically represented\n		 * as a one-dimensional array of NumericalValues. The dimension is allowed to be empty,\n		 * permitting a NumericalVectorValue of rank 0, which is essentially isomorphic to a\n		 * scalar NumericalValue.\n		 */\n	\n		feature dimension[0..1] :>> dimensions;\n		feature :>> elements : NumericalValue;\n	}\n	\n	datatype CartesianVectorValue :> NumericalVectorValue {\n		doc\n		/*\n		 * CartesianVectorValue is a specialization Numerical VectorValue for which there are \n		 * specific implementations in VectorFunctions of the abstract vector-space functions.\n		 * \n		 * Note: The restriction of the element type to Real is to facilitate\n		 * the complete definition of these functions.\n		 */\n	\n		feature :>> elements : Real;\n	}\n\n	datatype ThreeVectorValue :> NumericalVectorValue {\n		doc\n		/*\n		 * A ThreeVectorValue is a NumericalVectorValue that has dimension 3.\n		 */\n	\n		feature :>> dimension = 3;\n	}\n	\n	datatype CartesianThreeVectorValue :> CartesianVectorValue, ThreeVectorValue \n		intersects CartesianVectorValue, ThreeVectorValue {\n		doc\n		/*\n		 * A CartesianThreeVectorValue is a NumericalVectorValue that is both Cartesian and\n		 * has dimension 3.\n		 */\n	}	\n}", "Kernel Libraries/Kernel Function Library/BaseFunctions.kerml": "standard library package BaseFunctions {\n	doc\n	/*\n	 * This package defines a basic set of functions defined on all kinds of values. \n	 * Most correspond to similarly named operators in the KerML expression syntax.\n	 */\n\n	private import Base::Anything;\n	private import Objects::Object;\n	private import Metaobjects::Metaobject;\n	private import KerML::Metaclass;\n	private import ScalarValues::*;\n	\n	abstract function '=='{ in x: Anything[0..1]; in y: Anything[0..1]; \n		return : Boolean[1];\n	}\n	function '!='{ in x: Anything[0..1]; in y: Anything[0..1]; \n		return : Boolean[1] = not (x == y);\n	}\n	\n	abstract function '==='{ in x: Anything[0..1]; in y: Anything[0..1]; \n		return : Boolean[1];\n	}\n	function '!=='{ in x: Anything[0..1]; in y: Anything[0..1]; \n		return : Boolean[1] = not (x === y);\n	}\n	\n	abstract function ToString{ in x: Anything[0..1]; \n		return : String;\n	}\n	\n	abstract function '['{ in x: Anything[0..*] nonunique; in y: Anything[0..*] nonunique; \n		return : Anything[0..*] nonunique;\n	}\n	abstract function '#'{ in seq: Anything[0..*] ordered nonunique; in index: Positive[1..*] ordered nonunique; \n		return : Anything[0..1];\n	}\n	abstract function ','{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique; \n		return : Anything[0..*] ordered nonunique;\n	}\n	\n    abstract function 'all'{\n     	return : Object[0..*];\n    }\n    \n	abstract function 'istype'{ \n		in seq: Anything[0..*];\n		in 'type': Anything;\n		return : Boolean[1];\n	}\n	\n	abstract function 'hastype'{ \n		in seq: Anything[0..*];\n		in 'type': Anything;\n		return : Boolean;\n	}\n	\n	abstract function '@'{ \n		in seq: Anything[0..*];\n		in 'type': Anything;\n		return : Boolean[1];\n	}\n	\n	abstract function '@@'{ \n		in seq: Metaobject[0..*];\n		in 'type': Metaobject;\n		return : Boolean[1];\n	}\n	\n	abstract function 'as'{ \n		in seq: Anything[0..*] ordered nonunique; \n		return : Anything[0..*] ordered nonunique;\n	}\n	\n	abstract function 'meta'{ \n		in seq: Metaobject[0..*] ordered nonunique; \n		return : Metaobject[0..*] ordered nonunique;\n	}\n	\n}", "Kernel Libraries/Kernel Function Library/BooleanFunctions.kerml": "standard library package BooleanFunctions {\n	doc\n	/*\n	 * This package defines functions on Boolean values, including those corresponding to \n	 * (non-conditional) logical operators in the KerML expression notation.\n	 */\n\n	public import ScalarValues::*;\n	\n	function 'not' specializes ScalarFunctions::'not' { in x: Boolean[1]; return : Boolean[1]; }\n	function 'xor' specializes ScalarFunctions::'xor' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }\n	\n	function '|' specializes ScalarFunctions::'|' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }\n	function '&' specializes ScalarFunctions::'&' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }\n	\n	function '==' specializes DataFunctions::'==' { in x: Boolean[0..1]; in y: Boolean[0..1]; return : Boolean[1]; }\n	\n	function ToString specializes BaseFunctions::ToString { in x: Boolean[1]; return : String[1]; }\n	function ToBoolean { in x: String[1]; return : Boolean[1]; }\n	\n}\n	\n", "Kernel Libraries/Kernel Function Library/CollectionFunctions.kerml": "standard library package CollectionFunctions {\n	doc\n	/*\n	 * This package defines functions on Collections (as defined in the Collections package). \n	 * For functions on general sequences of values, see the SequenceFunctions package.\n	 */\n\n	private import Base::Anything;\n	private import ScalarValues::*;\n	private import SequenceFunctions::equals;\n	private import SequenceFunctions::includes;\n	private import ControlFunctions::exists;\n	public import Collections::*;\n	\n	function '==' specializes BaseFunctions::'==' { in col1: Collection[0..1]; in col2: Collection[0..1];\n		return : Boolean[1] = col1.elements->equals(col2.elements);\n	}\n	\n	function size { in col: Collection[1];\n		return : Natural[1] = SequenceFunctions::size(col.elements);\n	}\n	\n	function isEmpty { in col: Collection[1]; \n		return : Boolean[1] = SequenceFunctions::isEmpty(col.elements);\n	}\n	\n	function notEmpty { in col: Collection[1]; \n		return : Boolean[1] = SequenceFunctions::notEmpty(col.elements);\n	}\n	\n	function contains { in col: Collection[1]; in values: Anything[*];\n		return : Boolean[1] = col.elements->includes(values);\n	}\n	\n	function containsAll { in col1: Collection[1]; in col2: Collection[2]; \n		return : Boolean[1] = contains(col1, col2.elements);\n	}	\n	\n	function head { in col: OrderedCollection[1]; \n		return : Anything[0..1] = SequenceFunctions::head(col.elements);\n	}\n	\n	function tail { in col: OrderedCollection[1]; \n		return : Anything[0..*] ordered nonunique = SequenceFunctions::tail(col.elements);	\n	}\n	\n	function last { in col: OrderedCollection[1]; \n		return : Anything[0..1] = SequenceFunctions::last(col.elements);\n	}\n	\n	function '#' specializes BaseFunctions::'#' { in col: OrderedCollection[1]; in index: Positive[1];\n		// Cast ensures this function is not called recursively if the elements of col are OrderedCollections.\n		return : Anything[0..1] = (col.elements as Anything)#(index);		\n	}\n	\n	function 'array#' specializes BaseFunctions::'#' { in arr: Array[1]; in indexes: Positive[n] ordered nonunique;		\n		private feature n : Natural[1] = arr.rank;\n		\n		// Assumes row-major ordering for elements.\n		private function index { in arr: Array[1]; in i : Natural; in indexes : Positive[1..*];\n			if i <= 1? indexes#(1) else arr.dimensions#(i) * (index(arr, i-1, indexes) - 1) + indexes#(i)\n		}\n		\n		return : Anything[0..1] =\n			if n == 0 or (1..n)->exists {in i; indexes#(i) > arr.dimensions#(i)}? null \n			else arr.elements#(index(arr, n, indexes));\n	}	\n}\n", "Kernel Libraries/Kernel Function Library/ComplexFunctions.kerml": "standard library package ComplexFunctions {\n	doc\n	/*\n	 * This package defines functions on Complex values, including concrete specializations of the \n	 * general arithmetic and comparison operations.\n	 */\n\n	public import ScalarValues::*;\n		\n	feature i: Complex[1] = rect(0.0, 1.0);\n	\n	function rect { in re: Real[1]; in im: Real[1]; return : Complex[1]; }\n	function polar { in abs: Real[1]; in arg: Real[1]; return : Complex[1]; }\n	\n	function re { in x: Complex[1]; return : Real[1]; }\n	function im { in x: Complex[1]; return : Real[1]; }\n	\n	function isZero specializes NumericalFunctions::isZero { in x : Complex[1];\n		return : Boolean[1] = re(x) == 0.0 and im(x) == 0.0;\n	}\n	function isUnit specializes NumericalFunctions::isUnit { in x : Complex[1];\n		return : Boolean[1] = re(x) == 1.0 and im(x) == 0.0;\n	}\n	\n	function abs specializes NumericalFunctions::abs { in x: Complex[1]; return : Real[1]; }\n	function arg { in x: Complex[1]; return : Real[1]; }\n	\n	function '+' specializes NumericalFunctions::'+' { in x: Complex[1]; in y: Complex[0..1]; return : Complex[1]; }\n	function '-' specializes NumericalFunctions::'-' { in x: Complex[1]; in y: Complex[0..1]; return : Complex[1]; }\n	function '*' specializes NumericalFunctions::'*' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }\n	function '/' specializes NumericalFunctions::'/' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }\n	function '**' specializes NumericalFunctions::'**' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }\n	function '^' specializes NumericalFunctions::'^' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }\n	\n	function '==' specializes DataFunctions::'==' { in x: Complex[0..1]; in y: Complex[0..1]; return : Boolean[1]; }\n	\n	function ToString specializes BaseFunctions::ToString { in x: Complex[1]; return : String[1]; }\n	function ToComplex { in x: String[1]; return : Complex[1]; }\n	\n	function sum specializes NumericalFunctions::sum { in collection: Complex[0..*];\n		return : Complex[1] default NumericalFunctions::sum0(collection, rect(0.0, 0.0));\n	}\n	\n	function product specializes NumericalFunctions::product { in collection: Complex[0..*];\n		return : Complex[1] default NumericalFunctions::product1(collection, rect(1.0, 0.0));\n	}	\n}\n", "Kernel Libraries/Kernel Function Library/ControlFunctions.kerml": "standard library package ControlFunctions {\n	doc\n	/*\n	 * This package defines functions that correspond to operators in the KerML expression notation \n	 * for which one or more operands are expressions whose evaluation is determined by another operand.\n	 */\n\n	private import Base::Anything;\n	private import ScalarValues::ScalarValue;\n	private import ScalarValues::Boolean;\n	private import ScalarFunctions::min;\n	private import ScalarFunctions::max;\n	\n	abstract function '.' {\n		in feature source : Anything[0..*] nonunique {\n	  		abstract feature target : Anything[0..*] nonunique;\n	  	}	  	\n	  	private feature chain chains source.target;\n	    chain\n	}\n	\n	abstract function 'if' { \n		in test: Boolean[1];\n		in expr thenValue[0..1] { return : Anything[0..*] ordered nonunique; }\n		in expr elseValue[0..1] { return : Anything[0..*] ordered nonunique; }\n		return : Anything[0..*] ordered nonunique;\n	}\n	\n	abstract function '??' {\n		in firstValue: Anything[0..*] ordered nonunique;\n		in expr secondValue[0..1] { return : Anything[0..*] ordered nonunique; }\n		return : Anything[0..*] ordered nonunique;\n	}\n	\n	function 'and' {\n		in firstValue: Boolean[1];\n		in expr secondValue[0..1] { return : Boolean[1]; }\n		return : Boolean[1];\n	}\n	\n	function 'or'{\n		in firstValue: Boolean[1];\n		in expr secondValue[0..1] { return : Boolean[1]; }\n		return : Boolean[1];\n	}\n	\n	function 'implies'{\n		in firstValue: Boolean[1];\n		in expr secondValue[0..1] { return : Boolean[1]; }\n		return : Boolean[1];\n	}\n	\n	abstract function collect { \n		in collection: Anything[0..*] ordered nonunique;\n		in expr mapper[0..*] { in argument: Anything[1]; return : Anything[0..*] ordered nonunique; }\n		return : Anything[0..*] ordered nonunique;\n	}\n	\n	abstract function select { \n		in collection: Anything[0..*] ordered nonunique; \n		in expr selector[0..*] { in argument: Anything[1]; return : Boolean[1]; }\n		return : Anything[0..*] ordered nonunique;\n	}\n	\n	function selectOne { \n		in collection: Anything[0..*] ordered nonunique;\n		in expr selector1[0..*] { in argument: Anything[1]; return : Boolean[1]; }\n		return : Anything[0..1] = collection->select {in x; selector1(x)}#(1);\n	}\n	\n	abstract function reject{ \n		in collection: Anything[0..*] ordered nonunique; \n		in expr rejector[0..*] { in argument: Anything[1]; return : Boolean[1]; }\n		return : Anything[0..*] ordered nonunique;\n	}\n	\n	abstract function reduce { \n		in collection: Anything[0..*] ordered nonunique; \n		in expr reducer[0..*] { in firstArg: Anything[1]; in secondArg: Anything[1]; return : Anything[1]; }\n		return : Anything[0..*] ordered nonunique;\n	}\n	\n	abstract function forAll { \n		in collection: Anything[0..*] ordered nonunique; \n		in expr test[0..*] { in argument: Anything[1]; return : Boolean[1]; }\n		return : Boolean[1];\n	}\n	\n	abstract function exists { \n		in collection: Anything[0..*] ordered nonunique;\n		in expr test[0..*] { in argument: Anything[1]; return : Boolean[1]; }\n		return : Boolean[1];\n	}\n	\n	function allTrue {\n		in collection: Boolean[0..*]; \n		return : Boolean[1] = collection->forAll {in x; x};\n	}\n	\n	function anyTrue {\n		in collection: Boolean[0..*];\n		return : Boolean[1] = collection->exists {in x; x};\n	}\n	\n	function minimize {\n		in collection: ScalarValue[1..*];\n		in expr fn[0..*] { in argument: ScalarValue[1]; return : ScalarValue[1]; }\n		return : ScalarValue[1] = collection->collect {in x; fn(x)}->reduce min;\n	}\n	\n	function maximize { \n		in collection: ScalarValue[1..*];\n		in expr fn[0..*] { in argument: ScalarValue[1]; return : ScalarValue[1]; }\n		return : ScalarValue = collection->collect {in x; fn(x)}->reduce max;\n	}\n	\n}", "Kernel Libraries/Kernel Function Library/DataFunctions.kerml": "standard library package DataFunctions {\n	doc\n	/*\n	 * This package defines the abstract base functions corresponding to all the unary and binary operators \n	 * in the KerML expression notation that might be defined on various kinds of DataValues.\n	 */\n\n	private import Base::DataValue;\n	private import ScalarValues::Boolean;\n	private import ControlFunctions::reduce;	\n	\n	abstract function '==' specializes BaseFunctions::'==' { in x: DataValue[0..1]; in y: DataValue[0..1]; \n		return : Boolean[1];\n	}\n	function '===' specializes BaseFunctions::'==='{ in x: DataValue[0..1]; in y: DataValue[0..1]; \n		return : Boolean[1] = x == y;\n	}\n	\n	abstract function '+' { in x: DataValue[1]; in y: DataValue[0..1]; return : DataValue[1]; }\n	abstract function '-' { in x: DataValue[1]; in y: DataValue[0..1]; return : DataValue[1]; }\n	abstract function '*' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	abstract function '/' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	abstract function '**' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	abstract function '^' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	abstract function '%' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	\n	abstract function 'not' { in x: DataValue[1]; return : DataValue[1]; }\n	abstract function 'xor' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n\n	abstract function '~' { in x: DataValue[1]; return : DataValue[1]; }\n	abstract function '|' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	abstract function '&' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	\n	abstract function '<' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }\n	abstract function '>' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }\n	abstract function '<=' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }\n	abstract function '>=' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }\n	\n	abstract function max { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	abstract function min { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }\n	\n	abstract function '..' { in lower: DataValue[1]; in upper: DataValue[1]; return : DataValue[0..*] ordered; }	\n}", "Kernel Libraries/Kernel Function Library/IntegerFunctions.kerml": "standard library package IntegerFunctions {\n	doc\n	/*\n	 * This package defines functions on Integer values, including concrete specializations of the \n	 * general arithmetic and comparison operations.\n	 */\n\n	public import ScalarValues::*;\n	\n	function abs specializes RationalFunctions::abs { in x: Integer[1]; return : Natural[1]; }\n	\n	function '+' specializes RationalFunctions::'+' { in x: Integer[1]; in y: Integer[0..1]; return : Integer[1]; }\n	function '-' specializes RationalFunctions::'-' { in x: Integer[1]; in y: Integer[0..1]; return : Integer[1]; }\n	function '*' specializes RationalFunctions::'*' { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }\n	function '/' specializes RationalFunctions::'/' { in x: Integer[1]; in y: Integer[1]; return : Rational[1]; }\n	function '**' specializes RationalFunctions::'**' { in x: Integer[1]; in y: Natural[1]; return : Integer[1]; }\n	function '^' specializes RationalFunctions::'^' { in x: Integer[1]; in y: Natural[1]; return : Integer[1]; }\n	function '%' specializes NumericalFunctions::'%' { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }\n	\n	function '<' specializes RationalFunctions::'<' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }\n	function '>' specializes RationalFunctions::'>' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }\n	function '<=' specializes RationalFunctions::'<=' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }\n	function '>=' specializes RationalFunctions::'>=' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }\n\n	function max specializes RationalFunctions::max { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }\n	function min specializes RationalFunctions::min { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }\n\n	function '==' specializes DataFunctions::'==' { in x: Integer[0..1]; in y: Integer[0..1]; return : Boolean[1]; }\n	\n	function '..' specializes ScalarFunctions::'..' { in lower: Integer[1]; in upper: Integer[1]; return : Integer[0..*]; }\n	\n	function ToString specializes RationalFunctions::ToString { in x: Integer[1]; return : String[1]; }\n	function ToNatural { in x: Integer[1]; return : Natural[1]; }\n	function ToInteger { in x: String[1]; return : Integer[1]; }\n	\n	function sum specializes RationalFunctions::sum { in collection: Integer[0..*]; \n		return : Integer[1] default NumericalFunctions::sum0(collection, 0);\n	}\n	\n	function product specializes RationalFunctions::product { in collection: Integer[0..*];\n		return : Integer[1] default NumericalFunctions::product1(collection, 1);\n	}\n}	\n", "Kernel Libraries/Kernel Function Library/NaturalFunctions.kerml": "standard library package NaturalFunctions {\n	doc\n	/*\n	 * This package defines functions on Natural values, including concrete specialization of the \n	 * general arithmetic and comparison operations.\n	 */\n\n	public import ScalarValues::*;\n	\n	function '+' specializes IntegerFunctions::'+' { in x: Natural[1]; in y: Natural[0..1]; return : Natural[1]; }\n	function '*' specializes IntegerFunctions::'*' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }\n	function '/' specializes IntegerFunctions::'/' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }\n	function '%' specializes IntegerFunctions::'%' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }\n	\n	function '<' specializes IntegerFunctions::'<' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }\n	function '>' specializes IntegerFunctions::'>' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }\n	function '<=' specializes IntegerFunctions::'<=' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }\n	function '>=' specializes IntegerFunctions::'>=' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }	\n\n	function max specializes IntegerFunctions::max { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }\n	function min specializes IntegerFunctions::min { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }\n\n	function '==' specializes IntegerFunctions::'==' { in x: Natural[0..1]; in y: Natural[0..1]; return : Boolean[1]; }\n	\n	function ToString specializes IntegerFunctions::ToString { in x: Natural[1]; return : String[1]; }\n	function ToNatural{ in x: String[1]; return : Natural[1]; }\n}	\n", "Kernel Libraries/Kernel Function Library/NumericalFunctions.kerml": "standard library package NumericalFunctions {\n	doc\n	/*\n	 * This package defines abstract functions on Numerical values for general arithmetic and comparison operations.\n	 */\n\n	public import ScalarValues::*;\n	private import ControlFunctions::reduce;\n	\n	abstract function isZero{ in x: NumericalValue[1]; return : Boolean; }\n	abstract function isUnit{ in x : NumericalValue[1]; return : Boolean; }\n	\n	abstract function abs{ in x: NumericalValue[1]; return : NumericalValue[1]; }\n		\n	abstract function '+' specializes ScalarFunctions::'+' { in x: NumericalValue[1]; in y: NumericalValue[0..1]; return : NumericalValue[1]; }\n	abstract function '-' specializes ScalarFunctions::'-' { in x: NumericalValue[1]; in y: NumericalValue[0..1]; return : NumericalValue[1]; }\n	abstract function '*' specializes ScalarFunctions::'*' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }\n	abstract function '/' specializes ScalarFunctions::'/' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }\n	abstract function '**' specializes ScalarFunctions::'**' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }\n	abstract function '^' specializes ScalarFunctions::'^' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }\n	abstract function '%' specializes ScalarFunctions::'%' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }\n	\n	abstract function '<' specializes ScalarFunctions::'<' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }\n	abstract function '>' specializes ScalarFunctions::'>' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }\n	abstract function '<=' specializes ScalarFunctions::'<=' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }\n	abstract function '>=' specializes ScalarFunctions::'>=' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }\n	\n	abstract function max specializes ScalarFunctions::max { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }\n	abstract function min specializes ScalarFunctions::min { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }\n	\n	abstract function sum { in collection: ScalarValue[0..*]; return : ScalarValue[1]; }	\n	abstract function product { in collection: ScalarValue[0..*]; return : ScalarValue[1]; }\n	\n	function sum0 { in collection: NumericalValue[0..*]; in zero: ScalarValue[1]; \n 		inv { isZero(zero) }		\n        return : ScalarValue = collection->reduce '+' ?? zero;\n	}\n	\n	function product1 { in collection: ScalarValue[0..*]; in one: ScalarValue[1]; \n		inv { isUnit(one) }		\n        return : ScalarValue = collection->reduce '*' ?? one;\n	}\n}", "Kernel Libraries/Kernel Function Library/OccurrenceFunctions.kerml": `standard library package OccurrenceFunctions {
	doc
	/*
	 * This package defines utility functions that operate on occurrences, primarily related to 
	 * time during which those occurrences exist.
	 */
	
	private import Occurrences::Occurrence;
	private import Occurrences::HappensDuring;
	private import ScalarValues::Boolean;
	private import ScalarValues::Positive;
	private import SequenceFunctions::notEmpty;
	private import SequenceFunctions::size;
	private import SequenceFunctions::add;
	private import SequenceFunctions::addAt;
	private import SequenceFunctions::remove;
	private import SequenceFunctions::removeAt;
	private import ControlFunctions::forAll;
	 
	function '==='  specializes BaseFunctions::'===' { 
		doc
		/*
		 * Test whether two occurrences are portions of the same life. That is, whether they 
		 * represent different portions of the same entity (colloquially, whether they have
		 * the same "identity").
		 */
		 
		in x: Occurrence[0..1]; 
		in y: Occurrence[0..1];
		
		return : Boolean[1] = x.portionOfLife == y.portionOfLife;
	}
	
	function isDuring {
		doc
		/*
		 * Test whether a performance of this function happens during the input occurrence.
		 */
		
		in occ: Occurrence[1];
		
		private connector all during: HappensDuring[0..1] from self to occ;
		
		return : Boolean[1] = notEmpty(during);
	}
	
	function create {
		doc
		/*
		 * Ensure that the start of a given occurrence happens during a performance of this
		 * function. The occurrence is also returned from the function.
		 */
		
		inout occ: Occurrence[1];
			
		private connector : HappensDuring from occ.startShot to self;	
		
		return : Occurrence[1] = occ;
	}
	
	function destroy {
		doc
		/*
		 * Ensure that the end of a given occurrence happens during a performance of this
		 * function. The occurrence is also returned from the function.
		 */

		inout occ: Occurrence[0..1];
		
		private connector : HappensDuring from [0..1] occ.endShot to self;
		
		return : Occurrence[0..1] = occ;
	}
	
	function addNew {
		doc
		/*
		 * Add a newly created occurrence to the given group of occurrences and return the
		 * new occurrence.
		 */

		inout group: Occurrence[0..*] nonunique;
		inout occ: Occurrence[1];
		
		private composite step : add {
			inout seq1 = group;
			in seq2 = create(occ);
		}
		
		return : Occurrence[1] = occ;
	}
	
	function addNewAt {
		doc
		/*
		 * Add a newly created occurrence to the given ordered group of occurrences at the given
		 * index and return the new occurrence.
		 */

		inout group: Occurrence[0..*] ordered nonunique;
		inout occ: Occurrence[1];
		in index: Positive[1];
		
		private composite step : addAt {
			inout seq = group;
			in values = create(occ);
			in startIndex = index;
		}
		
		return : Occurrence[1] = occ;
	}
	
	behavior removeOld {
		doc
		/*
		 * Remove a given occurrence from a group of occurrences and destroy it.
		 */

		inout group: Occurrence[0..*] nonunique;
		inout occ: Occurrence[0..1];
		
		private composite step removeStep : remove {
			inout seq = group;
			in values = occ;
		}
		private succession removeStep then destroyStep;
		private composite step destroyStep : destroy {
			inout occ = removeOld::occ;
		}
		
	}
	
	behavior removeOldAt {
		doc
		/*
		 * Removes the occurrence at a given index in an ordered group of occurrences 
		 * and destroy it.
		 */
		inout group: Occurrence[0..*] ordered nonunique;
		in index: Positive[1];
		
		private feature oldOcc = group#(index);
		
		private composite step removeStep : remove {
			inout seq = group;
			in index = removeOldAt::index;
		}
		private succession removeStep then destroyStep;
		private composite step destroyStep : destroy {
			inout occ = oldOcc;
		}
		
	}
}`, "Kernel Libraries/Kernel Function Library/RationalFunctions.kerml": "standard library package RationalFunctions {\n	doc\n	/*\n	 * This package defines Functions on Rational values, including concrete specializations of the \n	 * general arithmetic and comparison operations.\n	 */\n\n	public import ScalarValues::*;\n	\n	function rat { in numer: Integer[1]; in denum: Integer[1]; return : Rational[1]; }\n	function numer { in rat: Rational[1]; return : Integer[1]; }\n	function denom { in rat: Rational[1]; return : Integer[1]; }\n	\n	function abs specializes RealFunctions::abs { in x: Rational[1]; return : Rational[1]; }\n\n	function '+' specializes RealFunctions::'+' { in x: Rational[1]; in y: Rational[0..1]; return : Rational[1]; }\n	function '-' specializes RealFunctions::'-' { in x: Rational[1]; in y: Rational[0..1]; return : Rational[1]; }\n	function '*' specializes RealFunctions::'*' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }\n	function '/' specializes RealFunctions::'/' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }\n	function '**' specializes RealFunctions::'**' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }\n	function '^' specializes RealFunctions::'^' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }\n	\n	function '<' specializes RealFunctions::'<' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }\n	function '>' specializes RealFunctions::'>' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }\n	function '<=' specializes RealFunctions::'<=' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }\n	function '>=' specializes RealFunctions::'>=' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }\n\n	function max specializes RealFunctions::max { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }\n	function min specializes RealFunctions::min { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }\n\n	function '==' specializes RealFunctions::'==' { in x: Rational[0..1]; in y: Rational[0..1]; return : Boolean[1]; }\n	\n	function gcd{ in x: Rational[1]; in y: Rational[1]; return : Integer[1]; }\n		\n	function floor specializes RealFunctions::floor { in x: Rational[1]; return : Integer[1]; }\n	function round specializes RealFunctions::round { in x: Rational[1]; return : Integer[1]; }\n	\n	function ToString specializes RealFunctions::ToString { in x: Rational[1]; return : String[1]; }\n	function ToInteger{ in x: Rational[1]; return : Integer[1]; }\n	function ToRational{ in x: String[1]; return : Rational[1]; }\n	\n	function sum specializes RealFunctions::sum { in collection: Rational[0..*];\n		return : Rational[1] default NumericalFunctions::sum0(collection, rat(0, 1));\n	}\n	\n	function product specializes RealFunctions::product { in collection: Rational[0..*];\n		return : Rational[1] default NumericalFunctions::product1(collection, rat(1, 1));\n	}	\n}\n", "Kernel Libraries/Kernel Function Library/RealFunctions.kerml": "standard library package RealFunctions {\n	doc\n	/*\n	 * This package defines Functions on Real values, including concrete specializations of the \n	 * general arithmetic and comparison operations.\n	 */\n\n	public import ScalarValues::*;\n	\n	function re :> ComplexFunctions::re{ in x: Real[1]; \n        return : Real[1] = x;\n	}\n	function im :> ComplexFunctions::im{ in x: Real[1]; \n        return : Real[1] = 0.0;\n	}\n	\n	function abs specializes ComplexFunctions::abs { in x: Real[1]; return : Real[1]; }\n	function arg specializes ComplexFunctions::arg { in x: Real[1]; \n        return : Real[1] = 0.0;\n	}\n\n	function '+' specializes ComplexFunctions::'+' { in x: Real[1]; in y: Real[0..1]; return : Real[1]; }\n	function '-' specializes ComplexFunctions::'-' { in x: Real[1]; in y: Real[0..1]; return : Real[1]; }\n	function '*' specializes ComplexFunctions::'*' { in x: Real[1]; in y: Real[1]; return : Real[1]; }\n	function '/' specializes ComplexFunctions::'/' { in x: Real[1]; in y: Real[1]; return : Real[1]; }\n	function '**' specializes ComplexFunctions::'**' { in x: Real[1]; in y: Real[1]; return : Real[1]; }\n	function '^' specializes ComplexFunctions::'^' { in x: Real[1]; in y: Real[1]; return : Real[1]; }\n	\n	function '<' specializes NumericalFunctions::'<' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }\n	function '>' specializes NumericalFunctions::'>' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }\n	function '<=' specializes NumericalFunctions::'<=' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }\n	function '>=' specializes NumericalFunctions::'>=' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }\n\n	function max specializes NumericalFunctions::max { in x: Real[1]; in y: Real[1]; return : Real[1]; }\n	function min specializes NumericalFunctions::min { in x: Real[1]; in y: Real[1]; return : Real[1]; }\n\n	function '==' specializes ComplexFunctions::'==' { in x: Real[0..1]; in y: Real[0..1]; return : Boolean[1]; }\n			\n	function sqrt{ in x: Real[1]; return : Real[1]; }\n\n	function floor{ in x: Real[1]; return : Integer[1]; }\n	function round{ in x: Real[1]; return : Integer[1]; }\n	\n	function ToString specializes ComplexFunctions::ToString { in x: Real[1]; return : String[1]; }\n	function ToInteger{ in x: Real[1]; return : Integer[1]; }\n	function ToRational{ in x: Real[1]; return : Rational[1]; }\n	function ToReal{ in x: String[1]; return : Real[1]; }\n	\n	function sum specializes ComplexFunctions::sum { in collection: Real[0..*]; \n        return : Real default NumericalFunctions::sum0(collection, 0.0);\n	}\n	\n	function product specializes ComplexFunctions::product { in collection: Real[0..*]; \n        return : Real default NumericalFunctions::product1(collection, 1.0);\n	}	\n}\n", "Kernel Libraries/Kernel Function Library/ScalarFunctions.kerml": "standard library package ScalarFunctions {\n	doc\n	/*\n	 * This package defines abstract functions that specialize the DataFunctions for use with ScalarValues. \n	 */\n\n	public import ScalarValues::*;\n	\n	abstract function '+' specializes DataFunctions::'+' { in x: ScalarValue[1]; in y: ScalarValue[0..1]; return : ScalarValue[1]; }\n	abstract function '-' specializes DataFunctions::'-' { in x: ScalarValue[1]; in y: ScalarValue[0..1]; return : ScalarValue[1]; }\n	abstract function '*' specializes DataFunctions::'*' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	abstract function '/' specializes DataFunctions::'/' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	abstract function '**' specializes DataFunctions::'**' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	abstract function '^' specializes DataFunctions::'^' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	abstract function '%' specializes DataFunctions::'%' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	\n	abstract function 'not' specializes DataFunctions::'not' { in x: ScalarValue[1]; return : ScalarValue[1]; }\n	abstract function 'xor' specializes DataFunctions::'xor' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n\n	abstract function '~' specializes DataFunctions::'~' { in x: ScalarValue[1]; return : ScalarValue[1]; }	\n	abstract function '|' specializes DataFunctions::'|' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	abstract function '&' specializes DataFunctions::'&' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	\n	abstract function '<' specializes DataFunctions::'<' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }\n	abstract function '>' specializes DataFunctions::'>' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }\n	abstract function '<=' specializes DataFunctions::'<=' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }\n	abstract function '>=' specializes DataFunctions::'>=' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }\n	\n	abstract function max specializes DataFunctions::max { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	abstract function min specializes DataFunctions::min { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }\n	\n	abstract function '..' specializes DataFunctions::'..' { in lower: ScalarValue[1]; in upper: ScalarValue[1]; return : ScalarValue[0..*]; }\n}", "Kernel Libraries/Kernel Function Library/SequenceFunctions.kerml": "standard library package SequenceFunctions {\n	doc\n	/*\n	 * This package defines functions that operate on general sequences of values. (For functions that\n	 * operate on Collection values, see CollectionFunctions.)\n	 */\n\n	private import Base::Anything;\n	private import Occurrences::SelfSameLifeLink;\n	private import ScalarValues::*;\n	private import ControlFunctions::*;\n	\n	function '#' specializes BaseFunctions::'#' { in seq: Anything[0..*] ordered nonunique; in index: Positive[1];\n		return : Anything[0..1];\n	}\n	\n	function equals{ in x: Anything[0..*] ordered nonunique; in y: Anything[0..*] ordered nonunique; \n		return : Boolean[1] =\n			size(x) == size(y) and\n			(1..size(x))->forAll {in i; x#(i) == y#(i)};\n	}\n\n	function same{ in x: Anything[0..*] ordered nonunique; in y: Anything[0..*] ordered nonunique;\n		return : Boolean[1] =\n			size(x) == size(y) and\n			(1..size(x))->forAll {in i; x#(i) === y#(i)};\n	}\n\n	function size{ in seq: Anything[0..*] nonunique;\n		return : Natural[1] = if isEmpty(seq)? 0 else size(tail(seq)) + 1;\n	}\n	function isEmpty{ in seq: Anything[0..*] nonunique;\n		return : Boolean[1] = seq == null;\n	}\n	function notEmpty{ in seq: Anything[0..*] nonunique;\n		return : Boolean[1] = not isEmpty(seq);\n	}\n	function includes{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;\n		return : Boolean[1] = seq2->forAll {in x; seq1->exists{in y; x == y}};\n	}\n	function includesOnly{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;\n		return : Boolean[1] = seq1->includes(seq2) and seq2->includes(seq1);\n	}\n	function excludes{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;\n		return : Boolean[1] = seq2->forAll {in x; seq1->excludes(x)};\n	}\n	\n	function union{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique;\n		return : Anything[0..*] ordered nonunique = (seq1, seq2);\n	}\n	function intersection{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique;\n		return : Anything[0..*] ordered nonunique = seq1->select {in x; seq2->includes(x)};\n	}\n	function including{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;\n		return : Anything[0..*] ordered nonunique = union(seq, values);\n	}\n	function includingAt{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;\n		in index: Positive[1];\n		return : Anything[0..*] ordered nonunique = \n			(seq->subsequence(1, index - 1), values, seq->subsequence(index + 1));\n	}\n	function excluding{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*];\n		return : Anything[0..*] ordered nonunique = seq->reject {in x; values->includes(x)};\n	}\n	function excludingAt{ in seq: Anything[0..*] ordered nonunique;\n		in startIndex: Positive[1]; in endIndex: Positive[1] default startIndex;\n		return : Anything[0..*] ordered nonunique = \n			(seq->subsequence(1, startIndex - 1), seq->subsequence(endIndex + 1));\n	}\n	\n	function subsequence{ in seq: Anything[0..*] ordered nonunique; \n		in startIndex: Positive[1]; in endIndex: Positive[1] default size(seq);\n		return : Anything[0..*] = (startIndex..endIndex)->collect {in i; seq#(i)};\n	}\n	function head{ in seq: Anything[0..*] ordered nonunique;\n		return : Anything[0..1] = seq#(1);\n	}\n	function tail{ in seq: Anything[0..*] ordered nonunique;\n		return : Anything[0..*] ordered nonunique = subsequence(seq, 2);\n	}\n	function last{ in seq: Anything[0..*] ordered nonunique;\n		return : Anything[0..1] = seq#(size(seq));\n	}\n	\n	behavior add { inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;\n		private feature newSeq = seq->including(values);\n		feature redefines endShot: add {\n			binding seq = newSeq;\n		}\n	}	\n	behavior addAt { inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;\n		in index: Positive[1];\n		private feature newSeq = seq->includingAt(values, index);\n		feature redefines endShot: addAt {\n			binding seq = newSeq;\n		}\n	}\n	behavior remove{ inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*];\n		private feature newSeq = seq->excluding(values);\n		feature redefines endShot: remove {\n			binding seq = newSeq;\n		}\n	}\n	behavior removeAt{ inout seq: Anything[0..*] ordered nonunique;\n		in startIndex: Positive[1]; in endIndex: Positive[1] default startIndex;\n		private feature newSeq = seq->excludingAt(startIndex, endIndex);\n		feature redefines endShot: removeAt {\n			binding seq = newSeq;\n		}\n	}\n}", "Kernel Libraries/Kernel Function Library/StringFunctions.kerml": "standard library package StringFunctions {\n	doc\n	/*\n	 * This package defines functions on String values, including those corresponding to string concatenation \n	 * and comparison operators in the KerML expression notation.\n	 */\n\n	public import ScalarValues::*;\n	\n	function '+' specializes ScalarFunctions::'+' { in x: String[1]; in y:String[1]; return : String[1]; }\n	\n	function Length{ in x: String[1]; return : Natural[1]; }\n	function Substring{ in x: String[1]; in lower: Integer[1]; in upper: Integer[1]; return : String[1]; }\n	\n	function '<' specializes ScalarFunctions::'<' { in x: String[1]; in y: String[1]; return : Boolean[1]; }\n	function '>' specializes ScalarFunctions::'>' { in x: String[1]; in y: String[1]; return : Boolean[1]; }\n	function '<=' specializes ScalarFunctions::'<=' { in x: String[1]; in y: String[1]; return : Boolean[1]; }\n	function '>=' specializes ScalarFunctions::'>=' { in x: String[1]; in y: String[1]; return : Boolean[1]; }\n\n	function '==' specializes DataFunctions::'==' { in x: String[0..1]; in y: String[0..1]; return : Boolean[1]; }\n	\n	function ToString specializes BaseFunctions::ToString { in x: String[1];\n		return : String[1] = x;\n	}\n}\n", "Kernel Libraries/Kernel Function Library/TrigFunctions.kerml": "standard library package TrigFunctions {\n	doc\n	/*\n	 * This package defines basic trigonometric functions on real numbers.\n	 */\n\n	public import ScalarValues::Real;\n	\n	feature pi : Real;\n	inv piPrecision { RealFunctions::round(pi * 1E20) == 314159265358979323846.0 }\n	\n	function deg { in theta_rad : Real[1];\n		return : Real[1] = theta_rad * 180 / pi;\n	}\n	function rad { in theta_deg : Real;\n		return : Real[1] = theta_deg * pi / 180;\n	}\n	\n	datatype UnitBoundedReal :> Real {\n		inv unitBound { -1.0 <= that & that <= 1.0 }\n	}\n	\n	function sin { in theta : Real[1]; return : UnitBoundedReal[1]; }\n	function cos { in theta : Real[1]; return : UnitBoundedReal[1]; }\n	function tan { in theta : Real[1]; \n        return : Real = sin(theta) / cos(theta);\n	}\n	function cot { in theta : Real; \n        return : Real = cos(theta) / sin(theta);\n	}\n	\n	function arcsin { in x : UnitBoundedReal[1]; return : Real[1]; }\n	function arccos { in x : UnitBoundedReal[1]; return : Real[1]; }\n	function arctan { in x : Real[1]; return : Real[1]; }\n}", "Kernel Libraries/Kernel Function Library/VectorFunctions.kerml": "standard library package VectorFunctions {\n	doc\n	/*\n	 * This package defines abstract functions on VectorValues corresponding to the algebraic operations\n	 * provided by a vector space with inner product. It also includes concrete implementations of these\n	 * functions specifically for CartesianVectorValues.\n	 */\n\n	private import ScalarValues::NumericalValue;\n	private import ScalarValues::Positive;\n	private import ScalarValues::Real;\n	private import ScalarValues::Boolean;\n	private import NumericalFunctions::*;\n	private import RealFunctions::sqrt;\n	private import TrigFunctions::arccos;\n	private import SequenceFunctions::size;\n	private import ControlFunctions::*;\n	\n	public import VectorValues::*;\n	\n	/* Generic arithmetic functions for all VectorValues. */\n	\n	abstract function isZeroVector {\n		doc\n		/*\n		 * Return whether a VectorValue is a zero vector.\n		 */\n		 \n		in v: VectorValue[1]; \n		return : Boolean[1]; \n	}\n	\n	abstract function '+' specializes DataFunctions::'+' {\n		doc\n		/*\n		 * With two arguments, returns the sum of two VectorValues. With one argument, returns that VectorValue.\n		 */\n		 \n	 	in v: VectorValue[1]; \n	 	in w: VectorValue[0..1]; \n		return u: VectorValue[1];\n		inv zeroAddition { w == null or isZeroVector(w) implies u == w }\n		inv commutivity { w != null implies u == w + v }\n	}\n	\n	abstract function '-' specializes DataFunctions::'-' {\n		doc\n		/*\n		 * With two arguments, returns the difference of two VectorValues. With one arguments, returns the inverse\n		 * of the given VectorValue, that is, the VectorValue that, when added to the original VectorValue, results in\n		 * the zeroVector.\n		 */\n	 \n		in v: VectorValue[1]; \n		in w: VectorValue[0..1]; \n		return u: VectorValue[1];\n		inv negation { w == null implies isZeroVector(v + u) }\n		inv difference { w != null implies v + u == w }\n	}\n	\n	abstract function sum0 {\n		doc\n		/*\n		 * Return the sum of a collection of VectorValues. If the collection is empty, return a given zero vector.\n		 */\n	 \n		in coll: VectorValue[*] nonunique; \n		in zero: VectorValue[1]; \n		inv precondition { isZeroVector(zero) }\n		return s: VectorValue[1] = coll->reduce '+' ?? zero;\n	}\n\n	/* Functions specific to NumericalVectorValues. */\n	\n	function VectorOf {\n		doc\n		/*\n		 * Construct a NumericalVectorValue whose elements are a non-empty list of component NumericalValues.\n		 * The dimension of the NumericalVectorValue is equal to the number of components.\n		 */\n	 \n		in components: NumericalValue[1..*] ordered nonunique; \n		return : NumericalVectorValue[1] {\n			:>> dimension = size(components);\n			:>> elements = components;\n		}\n	}\n	\n	abstract function scalarVectorMult specializes DataFunctions::'*' {\n		doc\n		/*\n		 * Scalar product of a NumericalValue and a NumericalVectorValue.\n		 */\n	 \n		in x: NumericalValue[1]; \n		in v: NumericalVectorValue[1];\n		return w: NumericalVectorValue[1];\n		inv scaling { norm(w) == x * norm(v) }\n		inv zeroLength { isZeroVector(w) implies isZero(norm(w))}\n	}\n	alias '*' for scalarVectorMult;\n	\n	abstract function vectorScalarMult specializes DataFunctions::'*' {\n		doc\n		/*\n		 * Scalar product of a NumericalVectorValue and a NumericalValue, which has the same value as the scalar product of the\n		 * NumericalValue and the NumericalVectorValue.\n		 */\n	 \n		in v: NumericalVectorValue[1]; \n		in x: NumericalValue[1];\n		return w: NumericalVectorValue[1] default scalarVectorMult(x, v);\n	}\n	\n	abstract function vectorScalarDiv specializes DataFunctions::'/' {\n		doc\n		/*\n		 * Scalar quotient of a NumericalVectorValue and a NumericalValue, defined as the scalar product of the inverse of the \n		 * NumericalValue and the NumericalVectorValue.\n		 */\n	 \n		in v: NumericalVectorValue[1]; \n		in x: NumericalValue[1];\n		return w: NumericalVectorValue[1] = scalarVectorMult(1.0 / x, v);\n	}\n\n	abstract function inner specializes DataFunctions::'*' {\n		doc\n		/*\n		 * Inner product of two NumericalVectorValues.\n		 */\n	 \n		in v: NumericalVectorValue[1]; \n		in w: NumericalVectorValue[1];\n		return x: NumericalValue[1];\n		inv commmutivity { x == inner(w, v) }\n		inv zeroInner { isZeroVector(v) or isZeroVector(w) implies isZero(x)}\n	}\n	\n	abstract function norm {\n		doc\n		/*\n		 * The norm (magnitude) of a NumericalVectorValue, as a NumericalValue.\n		 */\n	 \n		in v: NumericalVectorValue[1]; \n		return l : NumericalValue[1];\n		inv squareNorm { l * l == inner(v,v) }\n		inv lengthZero { isZero(l) == isZeroVector(v) }\n	}\n	\n	abstract function angle {\n		doc\n		/*\n		 * The angle between two NumericalVectorValues, as a NumericalValue.\n		 */\n		 \n	 	in v: NumericalVectorValue[1]; \n	 	in w: NumericalVectorValue[1]; \n		return theta: NumericalValue[1];\n		inv commutivity { theta == angle(w, v) }\n		inv lengthInsensitive { theta == angle(w / norm(w), v / norm(v)) }\n	}\n	\n	/* Specialized functions with concrete definitions for CartesianVectorValues. */\n	\n	function CartesianVectorOf {\n		doc\n		/*\n		 * Construct a CartesianVectorValue whose elements are a non-empty list of Real components.\n		 * The dimension of the NumericalVectorValue is equal to the number of components.\n		 */\n	 \n		in components: Real[*] ordered nonunique; \n		return : CartesianVectorValue[1] {\n			:>> dimension = size(components);\n			:>> elements = components;\n		}\n	}\n	function CartesianThreeVectorOf specializes CartesianVectorOf { \n		in components: Real[3] ordered nonunique;\n		return : CartesianThreeVectorValue[1] {\n		    feature :>> CartesianVectorOf::result::dimension, CartesianThreeVectorValue::dimension;\n		}\n	}\n	\n	feature cartesianZeroVector: CartesianVectorValue[3] =\n		(\n			CartesianVectorOf(0.0),\n			CartesianVectorOf((0.0, 0.0)),\n			CartesianThreeVectorOf((0.0, 0.0, 0.0))\n		) {\n		doc\n		/*\n		 * Cartesian zero vectors of 1, 2 and 3 dimensions.\n		 */\n	}\n	feature cartesian3DZeroVector: CartesianThreeVectorValue[1] =\n		cartesianZeroVector#(3);\n	\n	function isCartesianZeroVector specializes isZeroVector {\n		doc\n		/*\n		 * A CartesianVectorValue is a zero vector if all its elements are zero.\n		 */\n	 \n		in v: CartesianVectorValue[1]; \n		return : Boolean[1] = v.elements->forAll{in x; x == 0.0};\n	}\n	\n	function 'cartesian+' specializes '+' { \n		in v: CartesianVectorValue[1]; \n		in w: CartesianVectorValue[0..1];\n		inv precondition { w != null implies v.dimension == w.dimension }\n		return u: CartesianVectorValue[1] =\n			if w == null? v\n			else CartesianVectorOf(\n				(1..w.dimension)->collect{in i : Positive; v#(i) + w#(i)}\n			);\n	}\n	\n	function 'cartesian-' specializes '-' { \n		in v: CartesianVectorValue[1]; \n		in w: CartesianVectorValue[0..1];\n		inv precondition { w != null implies v.dimension == w.dimension }\n		return u: CartesianVectorValue[1] =\n			CartesianVectorOf(\n				if w == null? CartesianVectorOf(v.elements->collect{in x : Real; -x})\n				else CartesianVectorOf(\n					(1..v.dimension)->collect{in i : Positive; v#(i) - w#(i)}\n				)\n			);\n	}\n	\n	function cartesianScalarVectorMult specializes scalarVectorMult { \n		in x: Real[1]; \n		in v: CartesianVectorValue[1];\n		return w: CartesianVectorValue[1] =\n			CartesianVectorOf(\n				v.elements->collect{in y : Real; x * y}\n			);\n	}\n	function cartesianVectorScalarMult specializes vectorScalarMult { \n		in v: CartesianVectorValue[1]; \n		in x: Real[1]; \n		return w: CartesianVectorValue[1] = cartesianScalarVectorMult(x, v);\n	}\n	\n	function cartesianInner specializes inner { \n		in v: CartesianVectorValue[1]; \n		in w : CartesianVectorValue[1];\n		inv precondition { v.dimension == w.dimension }\n		return x: Real[1] =\n			(1..v.dimension)->collect{in i : Positive; v#(i) * w#(i)}->reduce RealFunctions::'+';\n	}\n	\n	function cartesianNorm specializes norm { \n		in v: CartesianVectorValue[1];\n		return l : NumericalValue[1] = sqrt(cartesianInner(v, v));\n	}\n	\n	function cartesianAngle specializes angle { \n		in v: CartesianVectorValue[1]; in w: CartesianVectorValue[1];\n		inv precondition { v.dimension == w.dimension }\n		return theta: Real[1] = arccos(cartesianInner(v, w) / (norm(v) * norm(w)));\n	}\n	\n	function sum { \n		in coll: CartesianThreeVectorValue[*];\n		return : CartesianThreeVectorValue[1] = sum0(coll, cartesian3DZeroVector);\n	}\n	\n}", "Kernel Libraries/Kernel Semantic Library/Base.kerml": 'standard library package Base {\n	doc \n	/*\n	 * This package defines the classifiers and features that provide the bases for the typing\n	 * of all elements in the language.\n	 */\n	 		\n	abstract classifier Anything {\n		doc\n		/*\n	     * Anything is the top level generalized type in the language. \n	     */\n		\n		feature self: Anything[1] subsets things chains things.that {\n			doc\n			/*\n			 * The source of a SelfLink of this thing to itself. self is thus a feature that\n			 * relates everything to itself. It is also the value of the nested "that" feature\n			 * of all other things featured by this thing.\n			 */\n		}\n	}\n	\n	abstract datatype DataValue specializes Anything {\n		doc\n		/*\n		 * Value is the most general classifier of entities that are values that do not change\n		 * over time.\n		 */\n		\n		feature self: DataValue redefines Anything::self;\n	}\n	\n	abstract feature things: Anything [1..*] nonunique {\n		doc\n		/*\n		 * things is the top-level feature in the language.\n		 */\n\n		feature that : Anything[1] {\n			doc\n			/*\n			 * For each value of things, the "featuring instance" of that value. \n			 * This is enforced by declaring Anything::self to be the chaining of things.that, \n			 * restricting it the single value of self.\n			 */			\n		}\n	}\n	\n	abstract feature dataValues: DataValue[0..*] nonunique subsets things {\n		doc\n		/*\n		 * dataValues is a specialization of things restricted to type DataValue.\n		 */\n	}\n		 \n	abstract feature naturals: ScalarValues::Natural[0..*] subsets dataValues {\n		doc\n		/*\n		 * naturals is a specialization of dataValues restricted to type Natural. \n		 * It is the root feature of all multiplicities, which map from a feature to\n		 * the set of Natural numbers representing allowable cardinalities of the feature.\n		 */\n	}\n	\n	multiplicity exactlyOne [1..1] {\n		doc\n		/*\n		 * exactlyOne is a multiplicity range requiring a cardinality of exactly one.\n		 */\n	}\n	\n	multiplicity zeroOrOne [0..1] {\n		doc\n		/*\n		 * zeroOrOne is a multiplicity range requiring a cardinality of zero or one.\n		 */		\n	}\n	\n	multiplicity oneToMany [1..*] {\n		doc\n		/*\n		 * oneToMany is a multiplicity range allowing any cardinality of one or more.\n		 */\n	}\n	\n	multiplicity zeroToMany [0..*] {\n		doc\n		/*\n		 * zeroToMany is a multiplicity range allowing any cardinality of zero or more\n		 * (that is, no restriction).\n		 */\n	}\n	\n}', "Kernel Libraries/Kernel Semantic Library/Clocks.kerml": "standard library package Clocks {\n	doc\n	/*\n	 * This package models Clocks that provide an advancing numerical reference \n	 * usable for quantifying the time of an Occurrence.\n	 */\n\n	private import ScalarValues::NumericalValue;\n	private import ScalarValues::Real;\n	private import Occurrences::Occurrence;\n	private import Occurrences::Life;\n	private import ControlFunctions::forAll;\n	\n	private struct UniversalClockLife[1] :> Clock, Life {\n	    doc\n	    /*\n	     * UniversalClockLife is the classifier of the singleton Life of the universalClock.\n	     */\n	}\n	\n	feature universalClock : UniversalClockLife[1] {\n		doc\n		/*\n		 * universalClock is a single Clock that can be used as a default universal\n		 * time reference.\n		 */\n	}\n	\n	abstract struct Clock {\n		doc\n		/*\n		 * A Clock provides a numerical currentTime that advances montonically\n		 * over its lifetime. Clock is an abstract base Structure that can be\n		 * specialized for different kinds of time quantification (e.g., discrete\n		 * time, continuous time, time with units, etc.).\n		 */\n		 \n		private thisClock : Clock :>> self;\n		\n		var feature currentTime : NumericalValue[1] {\n			doc\n			/*\n			 * A scalar time reference that advances over the lifetime of the Clock. \n			 */\n		}\n						\n		inv timeFlowConstraint {\n			doc\n			/*\n			 * The currentTime of a snapshot of a Clock is equal to\n			 * the TimeOf the snapshot relative to that Clock.\n			 */\n			\n			snapshots->forAll{in s : Clock; \n				TimeOf(s, thisClock) == s.currentTime\n			}\n		}		\n	}\n	\n	abstract function TimeOf {\n		doc\n		/*\n		 * TimeOf returns a numerical timeInstant for a given Occurrence relative to\n		 * a given Clock. The timeInstant is the time of the start of the Occurrence,\n		 * which is considered to be synchronized with the snapshot of the Clock \n		 * with a currentTime equal to the returned timeInstant.\n		 */\n		\n		in o : Occurrence[1];\n		in clock : Clock[1] default localClock;\n		return timeInstant : NumericalValue[1];\n		\n		 inv startTimeConstraint {\n		 	doc\n			/*\n			 * The TimeOf an Occurrence is equal to the time of its start snapshot.\n			 */\n			 \n		 	timeInstant == TimeOf(o.startShot, clock)\n		 }	 \n\n		inv timeOrderingConstraint {\n			doc\n			/*\n			 * If one Occurrence happens before another, then the TimeOf the end\n			 * snapshot of the first Occurrence is no greater than the TimeOf the \n			 * second Occurrence.\n			 */\n			\n			o.predecessors->forAll{in p : Occurrence; \n				TimeOf(p.endShot, clock) <= timeInstant\n			}\n		}\n				\n		inv timeContinuityConstraint {\n			doc\n			/*\n			 * If one Occurrence happens immediately before another, then the TimeOf \n			 * the end snapshot of the first Occurrence equals the TimeOf the second\n			 * Occurrence.\n			 */\n		 \n			o.immediatePredecessors->forAll{in p : Occurrence; \n				TimeOf(p.endShot, clock) == timeInstant\n			}\n		}				\n	}\n	\n	function DurationOf {\n		doc\n		/*\n		 * DurationOf returns the duration of a given Occurrence relative to a\n		 * given Clock, which is equal to the TimeOf the end snapshot of the\n		 * Occurrence minus the TimeOf its start snapshot.\n		 */\n		\n		in o : Occurrence[1]; \n		in clock : Clock[1] default localClock;\n		return duration : NumericalValue =\n			TimeOf(o.endShot, clock) - TimeOf(o.startShot, clock);\n	}\n	\n	struct BasicClock :> Clock {\n		doc\n		/*\n		 * A BasicClock is a Clock whose currentTime is a Real number.\n		 */\n		\n		var feature :>> currentTime : Real;\n	}\n	\n	function BasicTimeOf :> TimeOf {\n		doc\n		/*\n		 * BasicTimeOf returns the TimeOf an Occurrence as a Real number relative\n		 * to a BasicClock.\n		 */\n\n		in o : Occurrence[1];\n		in clock : BasicClock[1];\n		return : Real[1];\n	}\n	\n	function BasicDurationOf :> DurationOf {\n		doc\n		/*\n		 * BasicDurationOf returns the DurationOf an Occurrence as a Real number relative\n		 * to a BasicClock.\n		 */\n		\n		in o : Occurrence[1];\n		in clock : BasicClock[1];\n		return : Real[1];\n	}\n\n}", "Kernel Libraries/Kernel Semantic Library/ControlPerformances.kerml": "standard library package ControlPerformances {\n	doc\n	/*\n	 * This package defines Behaviors to be used to type Steps that control the sequencing of performance\n	 * of other Steps. \n	 */\n\n	private import ScalarValues::Boolean;\n	private import SequenceFunctions::size;\n	private import SequenceFunctions::notEmpty;\n	private import Occurrences::Occurrence;\n	private import Occurrences::HappensBefore;\n	private import Occurrences::SelfSameLifeLink;\n	private import Performances::Performance;\n	private import Performances::BooleanEvaluation;\n	\n	behavior DecisionPerformance specializes Performance {\n		doc\n		/*\n		 * A DecisionPerformance is a Performance that represents the selection of one of the Successions\n		 * that have the DecisionPerforance behavior as their source. All such Successions must subset the \n		 * outgoingHBLink feature of the source DecisionPerformance. For each instance of DecisionPerformance, \n		 * the outgoingHBLink is an instance of exactly one of the Successions, ordering the DecisionPerformance\n		 * as happening before an instance of the target of that Succcession.\n		 */\n		\n		feature outgoingHBLink: HappensBefore[1] {\n			doc\n			/*\n			 * Specializations subset this by all\n			 * successions going out of a decision step.\n			 */\n\n			 end feature redefines earlierOccurrence subsets that;\n		}\n	}\n	\n	behavior MergePerformance specializes Performance {\n		doc\n		/*\n		 * A MergePerformance is a Performance that represents the merging of all Successions that\n		 * target the MergePerforance behavior. All such Successions must subset the incomingHBLink\n		 * feature of the target MergePerformance. For each instance of MergePerformance, the\n		 * incomingHBLink is an instance of exactly one of the Successions, ordering the\n		 * MergePerformance as happening after an instance of the source of that Succession.\n		 */\n\n		feature incomingHBLink: HappensBefore[1] {\n			doc\n			/*\n			 * Specializations subset this by all\n			 * successions coming into a merge step.\n			 */\n\n			 end feature redefines laterOccurrence subsets that;\n		}\n	}\n\n	abstract behavior IfPerformance specializes Performance {\n		doc\n		/*\n		 * An IfPerformance is a Performance that determines whether the ifTest evaluation result is true \n		 * (by whether ifTrue has a value).\n		 */	\n		 \n		in ifTest : BooleanEvaluation[1];\n	}\n	\n	behavior IfThenPerformance specializes IfPerformance {\n		doc\n		/*\n		 * An IfThenPerformance is an IfPerformance where the thenClause occurs after and only after the \n		 * ifTest evaluation result is true.\n		 */\n		\n		in redefines ifTest;\n		in thenClause : Occurrence[0..1];\n		succession [1] ifTest then [0..1] thenClause;\n		inv { ifTest() == thenClause->notEmpty() }\n	}\n	\n	behavior IfElsePerformance specializes IfPerformance {\n		doc\n		/*\n		 * An IfElsePerformance is an IfPerformance where the elseClause occurs after and only \n		 * after the ifTest evaluation result is not true.\n		 */\n\n		in redefines ifTest;\n		in elseClause : Occurrence[0..1];\n		succession [1] ifTest then [0..1] elseClause;\n		inv { not ifTest() == elseClause->notEmpty() }\n	}\n	\n	behavior IfThenElsePerformance specializes IfThenPerformance {\n		doc\n		/*\n		 * An IfThenElsePerformance is an IfThenPerformance with an additional elseClause that\n		 * occurs after and only after the ifTest evaluation is false.\n		 */\n		 \n		in redefines ifTest;\n		in redefines thenClause;\n        in elseClause : Occurrence[0..1];\n        succession [1] ifTest then [0..1] elseClause;\n        inv { not ifTest() == elseClause->notEmpty() }\n	}\n	\n	behavior LoopPerformance specializes Performance {\n		doc\n		/*\n		 * A LoopPerformance is a Performance where the body occurs repeatedly in sequence (iterates) \n		 * as long as the whileTest evaluation result is true before each iteration (and after the \n		 * previous one, except the first time) and the untilTest evaluation result is not true after \n		 * each iteration and before the next one (except the last one).\n		 */\n		 \n		in whileTest : BooleanEvaluation[1..*];\n		in body : Occurrence[0..*];\n        in untilTest : BooleanEvaluation[0..*];\n		\n		step whileDecision : IfThenPerformance[1..*];\n		step untilDecision : IfElsePerformance[0..*];\n		\n		binding [1] whileDecision.ifTest = [1] whileTest;\n		binding [1] whileDecision.thenClause = [1] body;\n		\n		succession body then untilDecision;\n		\n		binding [1] untilDecision.ifTest = [1] untilTest;\n		binding loopBack of [0..1] untilDecision.elseClause = [1] whileDecision;\n		\n		inv { loopBack->size() == whileDecision->size() - 1 }\n	}\n}", "Kernel Libraries/Kernel Semantic Library/FeatureReferencingPerformances.kerml": "standard library package FeatureReferencingPerformances {\n	doc\n	/*\n	 * This package defines Behaviors used to read, write and monitor values of a referenced Feature of an \n	 * Occurrence.\n	 */\n\n	private import Base::Anything;\n	private import Base::things;\n	private import Occurrences::Occurrence;\n	private import Occurrences::HappensWhile;\n	private import Occurrences::HappensBefore;\n	private import Occurrences::HappensJustBefore;\n	private import Occurrences::SelfSameLifeLink;\n	private import Performances::Performance;\n	private import Performances::Evaluation;\n	private import ScalarValues::Boolean;\n	private import SequenceFunctions::isEmpty;\n	private import SequenceFunctions::equals;\n\n	abstract behavior FeatureReferencingPerformance specializes Performance {\n		doc\n		/*\n		 * A FeatureReferencingPerformance is the base Performance for specialized behaviors related \n		 * to values of a referenced Feature of a given Occurrence, as identified in specializations \n		 * of this Behavior.\n		 */\n		\n		in abstract feature onOccurrence : Occurrence [1] {\n			doc\n			/*\n			 * Occurrence with values for the referenced feature in specializations of this behavior.\n			 */\n		}\n		 \n		inout feature values : Anything [*] nonunique {\n			doc\n			/*\n			 * Values of the referenced feature, as specified in specializations of this behavior.\n			 */\n		}	\n	}\n\n    abstract behavior FeatureAccessPerformance specializes FeatureReferencingPerformance {\n    	doc\n		/*\n		 * A FeatureAccessPerformance is a FeatureReferencingPerformance where the result values\n		 * are all the values of a feature of onOccurrence at the time the Performance ends. The\n		 * feature is specified by restricting accessedFeature in specializations or usages.\n		 */\n     	\n		in abstract feature onOccurrence : Occurrence {\n			abstract feature startingAt : Occurrence [1] subsets timeSlices {\n				abstract feature accessedFeature : Anything [*] nonunique;\n			}\n		}\n\n	  	 connector :HappensWhile from onOccurrence.startingAt.startShot to endShot {\n	  	 	doc\n			/*\n			 * Requires some time slice of onOccurrence to start when this performance\n			 * ends (this connector), with particular feature values (following connector).\n			 * The feature is specified by restricting the onOccurrence::accessedFeature \n			 * on usages of this behavior.\n			 */\n	  	 }\n	  	 connector :SelfSameLifeLink from onOccurrence.startingAt.accessedFeature to values;\n	}\n\n	abstract function FeatureReadEvaluation specializes FeatureAccessPerformance, Evaluation { \n		doc\n		/*\n		 * A FeatureReadEvaluation is a FeatureAccessPerformance that is a function providing as\n		 * its result the values of a feature on an occurrence at the time its evaluation ends.\n		 */\n\n		in onOccurrence: Occurrence [1];\n		return resultValues : Anything [*] nonunique redefines result redefines values;\n	}\n\n	abstract behavior FeatureWritePerformance specializes FeatureAccessPerformance {\n		doc\n		/*\n		 * A FeatureWritePerformance is a FeatureAccessPerformance that assigns the values of a \n		 * feature on an occurrence to the given replacementValues at time its performance ends.\n		 */\n		 \n		in feature onOccurrence : Occurrence[1] redefines onOccurrence;\n		inout feature replacementValues : Anything redefines values [*] nonunique;\n	}\n	\n	abstract behavior FeatureMonitorPerformance specializes FeatureReferencingPerformance {\n		doc\n		/*\n		 * A FeatureMonitorPerformance is a FeatureReferencingPerformance that waits for values\n		 * of monitoredFeature to change on onOccurrence from what they were when the performance \n		 * started. The values before and after the change are given by beforeValues and afterValues.\n		 */	\n\n		in feature redefines onOccurrence {\n	    	feature monitoredOccurrence : Occurrence [1] subsets timeSlices {\n	      		abstract feature monitoredFeature : Anything[*] nonunique;\n	      		feature beforeTimeSlice : Occurrence [1] subsets timeSlices {\n	        		feature redefines monitoredFeature;\n	        	}\n	      		feature afterSnapshot : Occurrence [1] subsets snapshots {\n	        		feature redefines monitoredFeature;\n	        	}\n	      		connector :HappensJustBefore from beforeTimeSlice to afterSnapshot;\n	        }\n	  	}\n	  	out feature afterValues redefines values;\n	  	out feature beforeValues : Anything[*] nonunique;\n	  	inv { not beforeValues->equals(afterValues) }\n	\n	  	private connector : HappensWhile \n	  		from [1] onOccurrence.monitoredOccurrence.beforeTimeSlice.startShot to [1] startShot;\n	  	private connector : SelfSameLifeLink \n	  		from [1] onOccurrence.monitoredOccurrence.beforeTimeSlice.monitoredFeature to [1] beforeValues;\n	  	private connector : SelfSameLifeLink \n	  		from [1] onOccurrence.monitoredOccurrence.afterSnapshot.monitoredFeature to [1] afterValues;\n	  	protected connector endWhen : HappensBefore \n	  		from [1] onOccurrence.monitoredOccurrence.afterSnapshot to [1] endShot;\n	}\n		\n	behavior EvaluationResultMonitorPerformance specializes FeatureMonitorPerformance {\n		doc\n		/*\n		 * An EvaluationResultMonitorPerformance is a FeatureMonitorPerformance that waits for changes \n		 * in the result of an Evaluation identified by onOccurrence. The Predicate being evaluated must \n		 * be able to produce multiple results over time, for example by only using BindingConnectors \n		 * between Steps, rather than Successions or Flows, including in its Step behaviors.\n		 */\n		\n		in feature onOccurrence : Evaluation redefines onOccurrence {\n	    	protected expr monitoredOccurrence : Evaluation [1] redefines monitoredOccurrence {\n				return result : Anything[*] redefines result, monitoredFeature; \n			} \n		} \n	}\n	\n	behavior BooleanEvaluationResultMonitorPerformance specializes EvaluationResultMonitorPerformance {\n		doc\n		/*\n		 * A BooleanEvaluationResultMonitorPerformance is a EvaluationResultMonitorPerformance\n		 * that waits for changes in the result of a BooleanEvaluation identified by onOccurrence.\n		 */	\n		\n	  	in bool redefines onOccurrence {\n	    	protected bool redefines monitoredOccurrence[1] {\n	    	    return result : Boolean [1];\n	    	}\n		}\n		out redefines afterValues : Boolean [1]; \n		out redefines beforeValues : Boolean [1];	 \n	}\n	\n	behavior BooleanEvaluationResultToMonitorPerformance specializes FeatureReferencingPerformance {\n		doc\n		/*\n		 * A BooleanEvaluationResultToMonitorPerformance is a FeatureReferencingPerformance that waits \n		 * for the result of a BooleanEvaluation (identified by onOccurrence) to change to either true \n		 * or false, as indicated by isToTrue (defaulting to true). If the result is already true (or false), \n		 * the performance waits for the result to become false (or true) before waiting again for it to \n		 * change back.\n		 */	\n		 \n  		in bool redefines onOccurrence;\n  		feature isToTrue : Boolean [1] default true;\n  		out afterValues: Boolean[1] redefines values  = isToTrue;\n  		private feature monitor1 : BooleanEvaluationResultMonitorPerformance [1] {\n    		feature redefines endWhen : HappensJustBefore {\n    		    end feature earlierOccurrence;\n    		    end feature laterOccurrence;\n    		}\n  		}\n  		private feature monitor2 : BooleanEvaluationResultMonitorPerformance [1] {\n    		feature redefines endWhen : HappensJustBefore {\n                end feature earlierOccurrence;\n                end feature laterOccurrence;\n            }\n  		}\n\n  		private connector : HappensJustBefore from [1] monitor1 to [0..1] monitor2;\n  		inv { isEmpty(monitor2) == (monitor1.afterValues == isToTrue) }\n\n  		private binding [1] monitor1.onOccurrence = [1] onOccurrence;\n  		private binding [1] monitor2.onOccurrence = [1] onOccurrence;\n	}\n}", "Kernel Libraries/Kernel Semantic Library/KerML.kerml": "standard library package KerML {\n	doc \n	/*\n	 * This package contains a reflective KerML model of the KerML abstract syntax.\n	 */\n	 \n	private import ScalarValues::*;\n	public import Kernel::*;\n	\n	package Root {\n		metaclass AnnotatingElement specializes Element {\n			derived var feature annotatedElement : Element[1..*] ordered redefines annotatedElement;\n			derived composite var feature ownedAnnotatingRelationship : Annotation[0..*] ordered subsets annotation, ownedRelationship;\n			derived var feature owningAnnotatingRelationship : Annotation[0..1] subsets owningRelationship, annotation;\n			derived var feature annotation : Annotation[0..*] ordered;\n		}		\n		\n		metaclass Annotation specializes Relationship {\n			var feature annotatedElement : Element[1..1] redefines target, annotatedElement;\n			derived var feature annotatingElement : AnnotatingElement[1..1] redefines source;\n			derived var feature owningAnnotatedElement : Element[0..1] subsets annotatedElement, owningRelatedElement;\n			derived var feature owningAnnotatingElement : AnnotatingElement[0..1] subsets annotatingElement, owningRelatedElement;\n			derived composite var feature ownedAnnotatingElement : AnnotatingElement[0..1] subsets annotatingElement, ownedRelatedElement;\n		}		\n		\n		metaclass Comment specializes AnnotatingElement {\n			var feature 'locale' : String[0..1];\n			var feature body : String[1..1];\n		}		\n		\n		metaclass Dependency specializes Relationship {\n			var feature client : Element[1..*] ordered redefines source;\n			var feature supplier : Element[1..*] ordered redefines target;\n		}		\n		\n		metaclass Documentation specializes Comment {\n			derived var feature documentedElement : Element[1..1] subsets owner redefines annotatedElement;\n		}		\n		\n		abstract metaclass Element {\n			var feature elementId : String[1..1];\n			var feature aliasIds : String[0..*] ordered;\n			var feature declaredShortName : String[0..1];\n			var feature declaredName : String[0..1];\n			var feature isImpliedIncluded : Boolean[1..1];\n			derived var feature shortName : String[0..1];\n			derived var feature name : String[0..1];\n			derived var feature qualifiedName : String[0..1];\n			derived var feature isLibraryElement : Boolean[1..1];\n			\n			var feature owningRelationship : Relationship[0..1];\n			composite var feature ownedRelationship : Relationship[0..*] ordered;\n			derived var feature owningMembership : OwningMembership[0..1] subsets owningRelationship;\n			derived var feature owningNamespace : Namespace[0..1];\n			derived var feature owner : Element[0..1];\n			derived var feature ownedElement : Element[0..*] ordered;\n			derived var feature documentation : Documentation[0..*] ordered subsets ownedElement;\n			derived composite var feature ownedAnnotation : Annotation[0..*] ordered subsets ownedRelationship;\n			derived var feature textualRepresentation : TextualRepresentation[0..*] ordered subsets ownedElement;\n		}		\n		\n		abstract metaclass Import specializes Relationship {\n			var feature visibility : VisibilityKind[1..1];\n			var feature isRecursive : Boolean[1..1];\n			var feature isImportAll : Boolean[1..1];\n			\n			derived var feature importOwningNamespace : Namespace[1..1] subsets owningRelatedElement redefines source;\n			derived var feature importedElement : Element[1..1];\n		}		\n		\n		metaclass Membership specializes Relationship {\n			var feature memberShortName : String[0..1];\n			var feature memberName : String[0..1];\n			var feature visibility : VisibilityKind[1..1];\n			derived var feature memberElementId : String[1..1];\n			\n			var feature memberElement : Element[1..1] redefines target;\n			derived var feature membershipOwningNamespace : Namespace[1..1] subsets owningRelatedElement redefines source;\n		}		\n		\n		metaclass MembershipImport specializes Import {\n			var feature importedMembership : Membership[1..1] redefines target;\n		}		\n		\n		metaclass Namespace specializes Element {\n			derived abstract var feature membership : Membership[0..*] ordered;\n			derived composite var feature ownedImport : Import[0..*] ordered subsets ownedRelationship;\n			derived var feature 'member' : Element[0..*] ordered;\n			derived var feature ownedMember : Element[0..*] ordered subsets 'member';\n			derived composite var feature ownedMembership : Membership[0..*] ordered subsets membership, ownedRelationship;\n			derived var feature importedMembership : Membership[0..*] ordered subsets membership;\n		}		\n		\n		metaclass NamespaceImport specializes Import {\n			var feature importedNamespace : Namespace[1..1] redefines target;\n		}		\n		\n		metaclass OwningMembership specializes Membership {\n			derived var feature ownedMemberElementId : String[1..1] redefines memberElementId;\n			derived var feature ownedMemberShortName : String[0..1] redefines memberShortName;\n			derived var feature ownedMemberName : String[0..1] redefines memberName;\n			\n			derived composite var feature ownedMemberElement : Element[1..1] subsets ownedRelatedElement redefines memberElement;\n		}		\n		\n		abstract metaclass Relationship specializes Element {\n			var feature isImplied : Boolean[1..1];\n			\n			var feature target : Element[0..*] ordered subsets relatedElement;\n			var feature source : Element[0..*] ordered subsets relatedElement;\n			var feature owningRelatedElement : Element[0..1] subsets relatedElement;\n			composite var feature ownedRelatedElement : Element[0..*] ordered subsets relatedElement;\n			derived var feature relatedElement : Element[0..*] ordered nonunique;\n		}		\n		\n		metaclass TextualRepresentation specializes AnnotatingElement {\n			var feature 'language' : String[1..1];\n			var feature body : String[1..1];\n			\n			derived var feature representedElement : Element[1..1] subsets owner redefines annotatedElement;\n		}		\n		\n		datatype VisibilityKind {\n			member feature 'private' : VisibilityKind[1];\n			member feature 'protected' : VisibilityKind[1];\n			member feature 'public' : VisibilityKind[1];\n		}\n		\n	}\n	\n	package Core {\n		public import Root::*;\n		\n		metaclass Classifier specializes Type {\n			derived composite var feature ownedSubclassification : Subclassification[0..*] subsets ownedSpecialization;\n		}		\n		\n		metaclass Conjugation specializes Relationship {\n			var feature originalType : Type[1..1] redefines target;\n			var feature conjugatedType : Type[1..1] redefines source;\n			derived var feature owningType : Type[0..1] subsets conjugatedType, owningRelatedElement;\n		}		\n		\n		metaclass CrossSubsetting specializes Subsetting {\n			var feature crossedFeature : Feature[1..1] redefines subsettedFeature;\n			derived var feature crossingFeature : Feature[1..1] redefines owningFeature, subsettingFeature;\n		}		\n		\n		metaclass Differencing specializes Relationship {\n			var feature differencingType : Type[1..1] redefines target;\n			derived var feature typeDifferenced : Type[1..1] subsets owningRelatedElement redefines source;\n		}		\n		\n		metaclass Disjoining specializes Relationship {\n			var feature typeDisjoined : Type[1..1] redefines source;\n			var feature disjoiningType : Type[1..1] redefines target;\n			derived var feature owningType : Type[0..1] subsets owningRelatedElement, typeDisjoined;\n		}		\n		\n		metaclass EndFeatureMembership specializes FeatureMembership {\n			derived composite var feature ownedMemberFeature : Feature[1..1] redefines ownedMemberFeature;\n		}		\n		\n		metaclass Feature specializes Type {\n			var feature isUnique : Boolean[1..1];\n			var feature isOrdered : Boolean[1..1];\n			var feature isComposite : Boolean[1..1];\n			var feature isEnd : Boolean[1..1];\n			var feature isDerived : Boolean[1..1];\n			var feature isPortion : Boolean[1..1];\n			var feature isVariable : Boolean[1..1];\n			var feature isConstant : Boolean[1..1];\n			var feature direction : FeatureDirectionKind[0..1];\n			\n			derived var feature owningType : Type[0..1] subsets owningNamespace, featuringType;\n			derived var feature 'type' : Type[0..*] ordered;\n			derived composite var feature ownedRedefinition : Redefinition[0..*] subsets ownedSubsetting;\n			derived composite var feature ownedSubsetting : Subsetting[0..*] subsets ownedSpecialization;\n			derived var feature owningFeatureMembership : FeatureMembership[0..1] subsets owningMembership;\n			derived var feature endOwningType : Type[0..1] subsets owningType;\n			derived composite var feature ownedTyping : FeatureTyping[0..*] ordered subsets ownedSpecialization;\n			derived var feature featuringType : Type[0..*] ordered;\n			derived composite var feature ownedTypeFeaturing : TypeFeaturing[0..*] ordered subsets ownedRelationship;\n			derived var feature chainingFeature : Feature[0..*] ordered nonunique;\n			derived composite var feature ownedFeatureInverting : FeatureInverting[0..*] subsets ownedRelationship;\n			derived composite var feature ownedFeatureChaining : FeatureChaining[0..*] ordered subsets ownedRelationship;\n			derived composite var feature ownedReferenceSubsetting : ReferenceSubsetting[0..1] subsets ownedSubsetting;\n			derived var feature featureTarget : Feature[1..1];\n			derived var feature crossFeature : Feature[0..1];\n			derived composite var feature ownedCrossSubsetting : CrossSubsetting[0..1] subsets ownedSubsetting;\n		}		\n		\n		metaclass FeatureChaining specializes Relationship {\n			var feature chainingFeature : Feature[1..1] redefines target;\n			derived var feature featureChained : Feature[1..1] subsets owningRelatedElement redefines source;\n		}		\n		\n		datatype FeatureDirectionKind {\n			member feature 'in' : FeatureDirectionKind[1];\n			member feature 'inout' : FeatureDirectionKind[1];\n			member feature 'out' : FeatureDirectionKind[1];\n		}\n		\n		metaclass FeatureInverting specializes Relationship {\n			var feature featureInverted : Feature[1..1] redefines source;\n			var feature invertingFeature : Feature[1..1] redefines target;\n			derived var feature owningFeature : Feature[0..1] subsets featureInverted, owningRelatedElement;\n		}		\n		\n		metaclass FeatureMembership specializes OwningMembership {\n			derived var feature owningType : Type[1..1] redefines membershipOwningNamespace;\n			derived composite var feature ownedMemberFeature : Feature[1..1] redefines ownedMemberElement;\n		}		\n		\n		metaclass FeatureTyping specializes Specialization {\n			var feature typedFeature : Feature[1..1] redefines specific;\n			var feature 'type' : Type[1..1] redefines general;\n			derived var feature owningFeature : Feature[0..1] subsets typedFeature redefines owningType;\n		}		\n		\n		metaclass Intersecting specializes Relationship {\n			var feature intersectingType : Type[1..1] redefines target;\n			derived var feature typeIntersected : Type[1..1] subsets owningRelatedElement redefines source;\n		}		\n		\n		metaclass Multiplicity specializes Feature;		\n		\n		metaclass Redefinition specializes Subsetting {\n			var feature redefiningFeature : Feature[1..1] redefines subsettingFeature;\n			var feature redefinedFeature : Feature[1..1] redefines subsettedFeature;\n		}		\n		\n		metaclass ReferenceSubsetting specializes Subsetting {\n			var feature referencedFeature : Feature[1..1] redefines subsettedFeature;\n			derived var feature referencingFeature : Feature[1..1] redefines owningFeature, subsettingFeature;\n		}		\n		\n		metaclass Specialization specializes Relationship {\n			var feature general : Type[1..1] redefines target;\n			var feature specific : Type[1..1] redefines source;\n			derived var feature owningType : Type[0..1] subsets owningRelatedElement, specific;\n		}		\n		\n		metaclass Subclassification specializes Specialization {\n			var feature superclassifier : Classifier[1..1] redefines general;\n			var feature 'subclassifier' : Classifier[1..1] redefines specific;\n			derived var feature owningClassifier : Classifier[0..1] redefines owningType;\n		}		\n		\n		metaclass Subsetting specializes Specialization {\n			var feature subsettedFeature : Feature[1..1] redefines general;\n			var feature subsettingFeature : Feature[1..1] redefines specific;\n			derived var feature owningFeature : Feature[0..1] subsets subsettingFeature redefines owningType;\n		}		\n		\n		metaclass Type specializes Namespace {\n			var feature isAbstract : Boolean[1..1];\n			var feature isSufficient : Boolean[1..1];\n			derived var feature isConjugated : Boolean[1..1];\n			\n			derived composite var feature ownedSpecialization : Specialization[0..*] ordered subsets ownedRelationship;\n			derived composite var feature ownedFeatureMembership : FeatureMembership[0..*] ordered subsets ownedMembership, featureMembership;\n			derived var feature 'feature' : Feature[0..*] ordered subsets 'member';\n			derived var feature ownedFeature : Feature[0..*] ordered subsets ownedMember;\n			derived var feature input : Feature[0..*] ordered subsets directedFeature;\n			derived var feature output : Feature[0..*] ordered subsets directedFeature;\n			derived var feature inheritedMembership : Membership[0..*] ordered subsets membership;\n			derived var feature endFeature : Feature[0..*] ordered subsets 'feature';\n			derived var feature ownedEndFeature : Feature[0..*] ordered subsets endFeature, ownedFeature;\n			derived composite var feature ownedConjugator : Conjugation[0..1] subsets ownedRelationship;\n			derived var feature inheritedFeature : Feature[0..*] ordered subsets 'feature';\n			derived var feature 'multiplicity' : Multiplicity[0..1] subsets ownedMember;\n			derived var feature unioningType : Type[0..*] ordered;\n			derived composite var feature ownedIntersecting : Intersecting[0..*] ordered subsets ownedRelationship;\n			derived var feature intersectingType : Type[0..*] ordered;\n			derived composite var feature ownedUnioning : Unioning[0..*] ordered subsets ownedRelationship;\n			derived composite var feature ownedDisjoining : Disjoining[0..*] subsets ownedRelationship;\n			derived var feature featureMembership : FeatureMembership[0..*] ordered;\n			derived var feature differencingType : Type[0..*] ordered;\n			derived composite var feature ownedDifferencing : Differencing[0..*] ordered subsets ownedRelationship;\n			derived var feature directedFeature : Feature[0..*] ordered subsets 'feature';\n		}		\n		\n		metaclass TypeFeaturing specializes Relationship {\n			var feature featureOfType : Feature[1..1] redefines source;\n			var feature featuringType : Type[1..1] redefines target;\n			derived var feature owningFeatureOfType : Feature[0..1] subsets owningRelatedElement, featureOfType;\n		}		\n		\n		metaclass Unioning specializes Relationship {\n			var feature unioningType : Type[1..1] redefines target;\n			derived var feature typeUnioned : Type[1..1] subsets owningRelatedElement redefines source;\n		}		\n		\n	}\n	\n	package Kernel {\n		public import Core::*;\n		\n		metaclass Association specializes Classifier, Relationship {\n			derived var feature relatedType : Type[0..*] ordered nonunique redefines relatedElement;\n			derived var feature sourceType : Type[0..1] subsets relatedType redefines source;\n			derived var feature targetType : Type[0..*] subsets relatedType redefines target;\n			derived var feature associationEnd : Feature[0..*] redefines endFeature;\n		}		\n		\n		metaclass AssociationStructure specializes Association, Structure;		\n		\n		metaclass Behavior specializes Class {\n			derived var feature 'step' : Step[0..*] subsets 'feature';\n			derived var feature parameter : Feature[0..*] ordered redefines directedFeature;\n		}		\n		\n		metaclass BindingConnector specializes Connector;		\n		\n		metaclass BooleanExpression specializes Expression {\n			derived var feature 'predicate' : Predicate[0..1] redefines 'function';\n		}		\n		\n		metaclass Class specializes Classifier;		\n		\n		metaclass CollectExpression specializes OperatorExpression {\n			var feature operator : String[1..1] redefines operator;\n		}		\n		\n		metaclass Connector specializes Feature, Relationship {\n			derived var feature relatedFeature : Feature[0..*] ordered nonunique redefines relatedElement;\n			derived var feature association : Association[0..*] ordered redefines 'type';\n			derived var feature connectorEnd : Feature[0..*] ordered redefines endFeature;\n			derived var feature sourceFeature : Feature[0..1] ordered subsets relatedFeature redefines source;\n			derived var feature targetFeature : Feature[0..*] ordered subsets relatedFeature redefines target;\n			derived var feature defaultFeaturingType : Type[0..1];\n		}		\n		\n		metaclass ConstructorExpression specializes InstantiationExpression;		\n		\n		metaclass DataType specializes Classifier;		\n		\n		metaclass ElementFilterMembership specializes OwningMembership {\n			derived composite var feature condition : Expression[1..1] redefines ownedMemberElement;\n		}		\n		\n		metaclass Expression specializes Step {\n			derived var feature isModelLevelEvaluable : Boolean[1..1];\n			\n			derived var feature 'function' : Function[0..1] redefines 'behavior';\n			derived var feature result : Feature[1..1] subsets output, parameter;\n		}		\n		\n		metaclass FeatureChainExpression specializes OperatorExpression {\n			var feature operator : String[1..1] redefines operator;\n			\n			derived var feature targetFeature : Feature[1..1] subsets 'member';\n		}		\n		\n		metaclass FeatureReferenceExpression specializes Expression {\n			derived var feature referent : Feature[1..1] subsets 'member';\n		}		\n		\n		metaclass FeatureValue specializes OwningMembership {\n			var feature isInitial : Boolean[1..1];\n			var feature isDefault : Boolean[1..1];\n			\n			derived var feature featureWithValue : Feature[1..1] subsets membershipOwningNamespace;\n			derived composite var feature value : Expression[1..1] redefines ownedMemberElement;\n		}		\n		\n		metaclass Flow specializes Connector, Step {\n			derived var feature payloadType : Classifier[0..*] ordered nonunique;\n			derived var feature targetInputFeature : Feature[0..1] ordered nonunique;\n			derived var feature sourceOutputFeature : Feature[0..1] ordered nonunique;\n			derived var feature flowEnd : FlowEnd[0..2] ordered subsets connectorEnd;\n			derived var feature payloadFeature : PayloadFeature[0..1] subsets ownedFeature;\n			derived var feature 'interaction' : Interaction[0..*] ordered redefines association, 'behavior';\n		}		\n		\n		metaclass FlowEnd specializes Feature;		\n		\n		metaclass Function specializes Behavior {\n			derived var feature isModelLevelEvaluable : Boolean[1..1];\n			\n			derived var feature expression : Expression[0..*] subsets 'step';\n			derived var feature result : Feature[1..1] subsets output, parameter;\n		}		\n		\n		metaclass IndexExpression specializes OperatorExpression {\n			var feature operator : String[1..1] redefines operator;\n		}		\n		\n		abstract metaclass InstantiationExpression specializes Expression {\n			derived var feature argument : Expression[0..*] ordered;\n			derived var feature instantiatedType : Type[1..1] subsets 'member';\n		}		\n		\n		metaclass Interaction specializes Association, Behavior;		\n		\n		metaclass Invariant specializes BooleanExpression {\n			var feature isNegated : Boolean[1..1];\n		}		\n		\n		metaclass InvocationExpression specializes InstantiationExpression;		\n		\n		metaclass LibraryPackage specializes Package {\n			var feature isStandard : Boolean[1..1];\n		}		\n		\n		metaclass LiteralBoolean specializes LiteralExpression {\n			var feature value : Boolean[1..1];\n		}		\n		\n		metaclass LiteralExpression specializes Expression;		\n		\n		metaclass LiteralInfinity specializes LiteralExpression;		\n		\n		metaclass LiteralInteger specializes LiteralExpression {\n			var feature value : Integer[1..1];\n		}		\n		\n		metaclass LiteralRational specializes LiteralExpression {\n			var feature value : Rational[1..1];\n		}		\n		\n		metaclass LiteralString specializes LiteralExpression {\n			var feature value : String[1..1];\n		}		\n		\n		metaclass Metaclass specializes Structure;		\n		\n		metaclass MetadataAccessExpression specializes Expression {\n			derived var feature referencedElement : Element[1..1] subsets 'member';\n		}		\n		\n		metaclass MetadataFeature specializes AnnotatingElement, Feature {\n			derived var feature 'metaclass' : Metaclass[0..1] subsets 'type';\n		}		\n		\n		metaclass MultiplicityRange specializes Multiplicity {\n			derived var feature lowerBound : Expression[0..1] subsets bound;\n			derived var feature upperBound : Expression[1..1] subsets bound;\n			derived var feature bound : Expression[1..2] ordered subsets ownedMember;\n		}		\n		\n		metaclass NullExpression specializes Expression;		\n		\n		metaclass OperatorExpression specializes InvocationExpression {\n			var feature operator : String[1..1];\n		}		\n		\n		metaclass Package specializes Namespace {\n			derived var feature filterCondition : Expression[0..*] ordered subsets ownedMember;\n		}		\n		\n		metaclass ParameterMembership specializes FeatureMembership {\n			derived composite var feature ownedMemberParameter : Feature[1..1] redefines ownedMemberFeature;\n		}		\n		\n		metaclass PayloadFeature specializes Feature;		\n		\n		metaclass Predicate specializes Function;		\n		\n		metaclass ResultExpressionMembership specializes FeatureMembership {\n			derived composite var feature ownedResultExpression : Expression[1..1] redefines ownedMemberFeature;\n		}		\n		\n		metaclass ReturnParameterMembership specializes ParameterMembership;		\n		\n		metaclass SelectExpression specializes OperatorExpression {\n			var feature operator : String[1..1] redefines operator;\n		}		\n		\n		metaclass Step specializes Feature {\n			derived var feature 'behavior' : Behavior[0..*] ordered subsets 'type';\n			derived var feature parameter : Feature[0..*] ordered redefines directedFeature;\n		}		\n		\n		metaclass Structure specializes Class;		\n		\n		metaclass Succession specializes Connector;		\n		\n		metaclass SuccessionFlow specializes Succession, Flow;		\n		\n	}\n}\n", "Kernel Libraries/Kernel Semantic Library/Links.kerml": "standard library package Links {\n    doc\n    /*\n     * This package defines associations and features that are related to the typing of links.\n     */\n\n    private import Base::Anything;\n    private import Base::things;\n    \n    abstract assoc Link specializes Anything {\n        doc\n        /*\n         * Link is the most general association between two or more things.\n         */\n\n        feature participant: Anything[2..*] nonunique ordered;\n    }\n    \n    assoc all BinaryLink specializes Link {\n        doc\n        /*\n         * BinaryLink is the most general binary association between exactly two things, \n         * nominally directed from source to target.\n         */\n         \n        feature participant: Anything[2] nonunique ordered redefines Link::participant;\n        \n        end feature source: Anything[1] subsets participant;\n        end feature target: Anything[1] subsets participant;\n    }\n    \n    assoc all SelfLink specializes BinaryLink {\n        doc\n        /*\n         * SelfLink is a binary association in which the things at the two ends are asserted\n         * to be the same.\n         */\n        \n        end feature thisThing: Anything redefines source subsets sameThing crosses sameThing.self;\n        end self2 [1] feature sameThing: Anything redefines target subsets thisThing;\n    }\n        \n    abstract feature links: Link[0..*] nonunique subsets things {\n        doc\n        /*\n         * links is the most general feature of links between individuals.\n         */\n    }\n    \n    abstract feature binaryLinks: BinaryLink[0..*] nonunique subsets links {\n        doc\n        /*\n         * binaryLinks is a specialization of links restricted to type BinaryLink.\n         */\n    }\n    \n    abstract feature selfLinks: SelfLink[0..*] nonunique subsets binaryLinks {\n        doc\n        /*\n         * selfLinks is a specialization of binaryLinks restricted to type SelfLink.\n         */\n\n        end feature thisThing: Anything redefines SelfLink::thisThing, binaryLinks::source;\n        end feature sameThing: Anything redefines SelfLink::sameThing, binaryLinks::target;\n    }\n\n}", "Kernel Libraries/Kernel Semantic Library/Metaobjects.kerml": "standard library package Metaobjects {\n	doc\n	/*\n	 * This package defines Metaclasses and Features that are related to the typing of syntactic and semantic metadata.\n	 */\n\n	private import Objects::Object;\n	private import Objects::objects;\n	private import KerML::Element;\n	private import KerML::Type;\n	\n	abstract metaclass Metaobject specializes Object {\n		doc\n		/*\n		 * A Metaobject contains syntactic or semantic information about one or more annotatedElements. \n		 * It is the most general Metaclass. All other Metaclasses must subclassify it directly or indirectly.\n		 */\n\n		feature redefines self : Metaobject;\n		\n		abstract feature annotatedElement : Element[1..*] {\n			doc\n			/*\n			 * The Elements annotated by this Metaobject. This is set automatically when a Metaobject is\n			 * instantiated as the value of a MetadataFeature.\n			 */\n		}\n	}\n	\n	abstract metaclass SemanticMetadata specializes Metaobject {\n		doc\n		/*\n		 * SemanticMetadata is a Metaobject that requires its single annotatedType to directly or indirectly specialize \n		 * a baseType that models the semantics for the annotatedType.\n		 */\n		\n		abstract feature redefines annotatedElement : Type[1] {\n			doc\n			/*\n			 * The single annotatedElement of this SemanticMetadata, which must be a Type.\n			 */\n		}\n		\n		feature baseType : Type[1] {\n			doc\n			/*\n			 * The required base Type for the annotatedType.\n			 */\n		}\n	}\n	\n	feature metaobjects : Metaobject[0..*] :> objects {\n		/*\n		 * metaobjects is a specialization of objects restricted to type Metadata. It is the most general \n		 * MetadataFeature. All other MetadataFeatures must subset it directly or indirectly.\n		 */\n	}\n}", "Kernel Libraries/Kernel Semantic Library/Objects.kerml": 'standard library package Objects {\n	doc\n	/*\n	 * This package defines classifiers and features that are related to the typing of objects, including link objects.\n	 */\n\n	private import Base::Anything;\n	private import Base::things;\n	private import Links::*;\n	private import Occurrences::Occurrence;\n	private import Occurrences::occurrences;\n	private import Occurrences::HappensLink;\n	private import Occurrences::SelfSameLifeLink;\n	private import Occurrences::WithinBoth;	       \n	private import Performances::Performance;\n	private import Performances::performances;\n	private import SequenceFunctions::isEmpty;\n	private import SequenceFunctions::notEmpty;\n	private import SequenceFunctions::union;\n	private import CollectionFunctions::contains;\n	private import ScalarValues::Integer;\n	private import ScalarValues::Natural;\n	\n	abstract struct Object specializes Occurrence {\n		doc\n		/*\n		 * Object is the most general class of structural occurrences that may change over time.\n		 */\n\n		feature self: Object redefines Occurrence::self;\n		\n		composite feature subobjects: Object[0..*] subsets objects, suboccurrences\n			intersects objects, suboccurrences {\n			doc\n			/*\n			 * The suboccurrences of this Object that are also Objects.\n			 */\n		}\n		\n		feature involvingPerformances: Performance[0..*] subsets performances {\n			doc\n			/*\n			 * Performances in which this object is involved.\n			 */\n		}\n		\n		abstract step enactedPerformances: Performance[0..*] subsets involvingPerformances, timeEnclosedOccurrences\n			intersects involvingPerformances, timeEnclosedOccurrences {\n			doc\n			/*\n			 * Performances that are enacted by this object.\n			 */\n		}\n		\n		composite step ownedPerformances: Performance[0..*] subsets involvingPerformances, timeEnclosedOccurrences, suboccurrences\n			intersects involvingPerformances, timeEnclosedOccurrences, suboccurrences {\n			doc\n			/*\n			 * Performances that are owned by this object.\n			 */\n			 \n			feature redefines this default that {\n				doc\n				/*\n				 * The owning object is the default "this" reference for all ownedPerformances.\n				 */\n			}\n		}\n\n		portion structuredSpaceBoundary : StructuredSpaceObject[0..1] subsets spaceBoundary {\n			doc\n			/*\n			 * A space boundary that is a structured space object.\n			 */\n		}\n	}\n	\n	abstract assoc struct LinkObject specializes Link, Object intersects Link, Object {\n		doc\n		/*\n		 * LinkObject is the most general association structure, being both a Link and an Object.\n		 */\n	}\n	\n	assoc struct BinaryLinkObject specializes BinaryLink, LinkObject intersects BinaryLink, LinkObject {\n		doc\n		/*\n		 * BinaryLinkObject is the most general binary association structure, being both a \n		 * BinaryLink and a LinkObject.\n		 */\n	}\n	\n	abstract feature objects: Object[0..*] nonunique subsets occurrences {\n		doc\n		/*\n		 * objects is a specialization of occurrences restricted to type Object.\n		 */\n	}\n	\n	abstract feature linkObjects: LinkObject[0..*] nonunique subsets links, objects intersects links, objects {\n		doc\n		/*\n		 * linkObjects is a specializations of links and objects restricted to type LinkObjects. \n		 */\n	}\n	\n	abstract feature binaryLinkObjects: BinaryLinkObject[0..*] nonunique subsets binaryLinks, linkObjects\n		intersects binaryLinks, linkObjects {\n		doc\n		/*\n		 * binaryLinkObjects is a specialization of binaryLinks and linkObjects restricted to \n		 * type BinaryLinkObjects.\n		 */\n	}\n	\n\n	struct all Body specializes Object {\n		doc\n		/*\n		 * A Body is an Object of inner space dimension 3.\n		 */\n\n		feature redefines innerSpaceDimension = 3;\n	}\n\n	struct all Surface specializes Object {\n		doc\n		/*\n		 * A Surface is an Object of inner space dimension 2.\n		 */\n		\n		feature redefines innerSpaceDimension = 2;\n		  /* The number of  "holes" in this Surface, assuming it isClosed. */\n		feature genus : Natural[0..1] default 0;\n\n		inv { notEmpty(genus) implies isClosed }\n	}\n\n	struct all Curve specializes Object {\n		doc\n		/*\n		 * A Curve is an Object of inner space dimension 1.\n		 */\n\n		feature redefines innerSpaceDimension = 1;\n	}\n\n	struct all Point specializes Object {\n		doc\n		/*\n		 * A Point is an Object of inner space dimension 0.\n		 */\n		 \n		feature redefines innerSpaceDimension = 0;\n	}\n\n	abstract struct StructuredSpaceObject specializes Object {\n		doc\n		/*\n		 * A StructuredSpaceObject is an Object that is broken up into smaller structured space objects (cells) of\n		 * the same or lower inner space dimension: faces that are surfaces, edges that are curves, and vertices\n		 * that are points, with edges and vertices on the boundary of faces, and vertices on the boundary of\n		 * edges. Cells meet when a structured space object is closed, as required to be a space boundary of\n		 * an object (faces meet at their edges and/or vertices, while edges meet at their vertices). The\n		 * inner space dimension of structured space object is the highest of their cells.\n		 */\n\n        abstract portion feature structuredSpaceObjectCells : StructuredSpaceObject[1..*] subsets Occurrence::spaceSlices { \n            feature cellOrientation : Integer [0..1];\n		    inv { notEmpty(cellOrientation) implies (cellOrientation >= -1 & cellOrientation <= 1) }\n		}\n		\n		comment about StructuredSurface, StructuredCurve, StructuredPoint\n		/*\n		 * The structures StructuredSurface, StructuredCurve and StructuredPoint provide common, necessary redefinitions of\n		 * innerSpaceDimension. They also provide single types for the StructuredSpaceObject features faces, edges and\n		 * vertices, which avoids problems when these features are related by connectors with ends that have owned\n		 * cross features.\n		 */\n		struct StructuredSurface specializes StructuredSpaceObject, Surface {\n            feature redefines StructuredSpaceObject::innerSpaceDimension, Surface::innerSpaceDimension;		    \n		}\n        struct StructuredCurve specializes StructuredSpaceObject, Curve {\n            feature redefines StructuredSpaceObject::innerSpaceDimension, Curve::innerSpaceDimension;         \n        }\n        struct StructuredPoint specializes StructuredSpaceObject, Point {\n            feature redefines StructuredSpaceObject::innerSpaceDimension, Point::innerSpaceDimension;         \n        }\n\n		portion feature faces : StructuredSurface[0..*] ordered subsets structuredSpaceObjectCells {\n		    feature redefines that : StructuredSpaceObject;\n			feature redefines edges subsets that.edges;\n			feature redefines vertices subsets that.vertices;\n			derived feature redefines spaceBoundary; \n			inv { isEmpty(spaceBoundary) == isEmpty(union(edges, vertices)) }\n			inv { notEmpty(spaceBoundary) implies contains(spaceBoundary.unionsOf, union(edges, vertices)) }\n		}\n\n		portion feature edges : StructuredCurve[0..*] ordered subsets structuredSpaceObjectCells {\n            feature redefines that : StructuredSpaceObject;\n			feature redefines vertices subsets that.vertices;\n			derived feature redefines spaceBoundary;\n			inv { isEmpty(spaceBoundary) == isEmpty(vertices) }\n			inv { notEmpty(spaceBoundary) implies contains(spaceBoundary.unionsOf, vertices) }\n		}\n\n		portion feature vertices : StructuredPoint[0..*] ordered subsets structuredSpaceObjectCells;\n		\n		derived feature redefines innerSpaceDimension = \n			if notEmpty(faces) ? 2 else if notEmpty(edges) ? 1 else 0;\n	  }\n}\n', "Kernel Libraries/Kernel Semantic Library/Observation.kerml": "standard library package Observation {\n	doc\n	/*\n	 * This package models a framework for monitoring Boolean conditions and notifying\n	 * registered observers when they change from false to true.\n	 */\n	 \n	private import ScalarValues::Boolean;\n	private import Occurrences::Occurrence;\n	private import Occurrences::Life;\n	private import SequenceFunctions::including;\n	private import SequenceFunctions::excluding;\n	private import ControlFunctions::select;\n	private import ControlPerformances::DecisionPerformance;\n	private import ControlPerformances::IfThenPerformance;\n	private import FeatureReferencingPerformances::FeatureWritePerformance;\n	private import FeatureReferencingPerformances::BooleanEvaluationResultToMonitorPerformance;\n	private import Transfers::TransferBefore;\n\n    private struct DefaultMonitorLife[1] :> ChangeMonitor, Life {\n        doc\n        /*\n         * DefaultMonitorLife is the classifier of the singleton Life of the defaultMonitor.\n         */\n    }\n    \n	feature defaultMonitor[1] : DefaultMonitorLife {\n		doc\n		/*\n		 * defaultMonitor is a single ChangeMonitor that can be used as a default.\n		 */\n	}\n\n	struct ChangeSignal {\n		doc\n		/*\n		 * A ChangeSignal is a signal to be sent when the Boolean result of its\n		 * changeCondition Expression changes from false to true.\n		 */\n\n		bool signalCondition {\n			doc\n			/*\n			 * A BooleanExpression whose result is being monitored.\n			 */\n		}\n		\n		feature signalMonitor : ChangeMonitor {\n			doc\n			/*\n			 * The ChangeMonitor responsible for monitoring the signalCondition.\n			 */\n		}\n	}\n	\n	private behavior ObserveChange {\n		doc\n		/*\n		 * Each Performance of ObserveChange waits for the result of the Boolean \n		 * condition of a given ChangeSignal to change from false to true, and, when \n		 * it does, sends the ChangeSignal to a given observer Occurrence.\n		 */\n\n		in feature changeObserver : Occurrence[1];\n		in feature changeSignal : ChangeSignal[1];\n		\n		composite step wait : IfThenPerformance {\n			doc\n			/*\n			 * If the result of the changeSignal.signalCondition is false, then wait for \n			 * it to become true.\n			 */\n\n			in bool redefines ifTest {\n				not changeSignal.signalCondition()\n			}\n			in step redefines thenClause : BooleanEvaluationResultToMonitorPerformance {\n				in bool onOccurrence = changeSignal.signalCondition;\n			}\n		}		\n		\n		succession wait then transfer;\n		\n	    step transfer : TransferBefore[1] \n	    	redefines outgoingTransfersFromSelf \n	    	subsets changeObserver.incomingTransfers {\n	    	doc\n			/*\n			 * Then send changeSignal to changeObserver.\n			 */\n			 \n	    	end feature source {\n	    		feature redefines sourceOutput = changeSignal;\n	    	}\n	    	end feature target;\n	    }\n	}\n	\n	struct ChangeMonitor {\n		doc\n		/*\n		 * A ChangeMonitor is a collection of ongoing ChangeSignal observations \n		 * for various observer Occurrences. It provides convenient operations for \n		 * starting and canceling the observations it manages.\n		 */\n\n		private thisMonitor : ChangeMonitor redefines self;\n		private composite feature observations[0..*] : ObserveChange;\n		\n		private behavior AssignObservations specializes FeatureWritePerformance {\n			doc\n			/*\n			 * Assign a replacement set of observations as those being managed by a\n			 * given ChangeMonitor.\n			 */\n\n			in feature monitor : ChangeMonitor redefines onOccurrence {\n				feature redefines startingAt {\n					feature redefines accessedFeature, observations;\n				}\n			}\n			inout feature redefines replacementValues[0..*] : ObserveChange;\n		}\n		\n		step startObservation { \n			doc\n			/*\n			 * Start an observation of a given ChangeSignal for a given Occurrence.\n			 */\n\n			in observer : Occurrence[1]; \n			in signal : ChangeSignal[1];\n			private composite step observation : ObserveChange {\n				in changeObserver = observer;\n				in changeSignal = signal;\n			}\n			private composite step addObservation : AssignObservations[1] {\n				in monitor = thisMonitor; \n				inout replacementValues = observations->including(observation);	\n			}\n		}\n		\n		step cancelObservation { \n			doc\n			/*\n			 * Cancel all observations of a given ChangeSignal for a given Occurrence. \n			 */\n\n			in observer : Occurrence[1]; \n			in signal : ChangeSignal[1];\n			private feature observations[0..*] : ObserveChange = \n				observations->select{in observation : ObserveChange; \n					observation.changeObserver == observer and observation.changeSignal == signal\n				};\n			private composite step removeObservation : AssignObservations[1] {\n				in monitor = thisMonitor; \n				inout replacementValues = observations->excluding(observations);\n			}\n		}\n	}	\n}", "Kernel Libraries/Kernel Semantic Library/Occurrences.kerml": 'standard library package Occurrences {\n	doc\n	/*\n	 * This package defines modeling constructs for anything existing or occurring in time and space, with\n	 * associations between them that assert temporal and spatial relationships.\n	 */\n\n	private import Base::Anything;\n	private import Base::things;\n	private import Base::DataValue;\n	private import ScalarValues::Natural;\n	private import ScalarValues::Boolean;\n	private import Links::*;\n	private import Clocks::*;\n	private import Collections::Set;\n	private import Collections::OrderedSet;\n	private import CollectionFunctions::contains;\n	private import SequenceFunctions::isEmpty;\n	private import SequenceFunctions::notEmpty;\n	private import SequenceFunctions::includes;\n	private import SequenceFunctions::union;\n\n	abstract class Occurrence specializes Anything disjoint from DataValue {\n        doc\n        /*\n         * Occurrence is the most general classifier of entities that have identity and\n         * occur over time and space.\n         *\n         * The features of Occurrence specify the semantics of associations between occurrences that\n         * assert complete inclusion and exclusion in time or space, or both, which includes\n         * portions of an occurrence (having the same identity).  Portions include slices and shots\n         * over time and space.\n         */\n        \n		private import SequenceFunctions::*;\n\n		feature portionOfLife: Life[1] subsets portionOf default self;\n\n		feature self: Occurrence[1] redefines Anything::self subsets timeSlices, spaceSlices, spaceTimeCoincidentOccurrences, sameLifeOccurrences;\n		feature sameLifeOccurrences: Occurrence[1..*] subsets things;\n\n		feature this : Occurrence[1] default self {\n			doc\n			/*\n			 * The "context" Occurrence within which this Occurrence takes place. By default, it is this\n			 * Occurrence itself. However, this is overridden for ownedPerformances of Objects and\n			 * subperformances of Performances.\n			 */\n		}\n		connector :HappensDuring from [1] self to [1] this;\n		\n		feature localClock : Clock[1] default universalClock  {\n			doc\n			/*\n			 * A local Clock to be used as the corresponding time reference for this Occurrence\n			 * and, by default, all ownedOccurrences. By default this is the singleton universalClock.\n			 */\n		}\n		\n		composite feature suboccurrences: Occurrence[0..*] subsets occurrences {\n			doc\n			/*\n			 * Composite suboccurrences of this Occurrence.\n			 */\n			 \n			 feature redefines localClock default (that as Occurrence).localClock {\n			 	doc\n			 	/*\n			 	 * The localClock of a suboccurrence defaults to the localClock of its containing\n			 	 * Occurrence.\n			 	 */\n			 }\n			 \n			 feature redefines incomingTransferSort default (that as Occurrence).incomingTransferSort;\n		}\n		\n		/* Occurrences may be suboccurrences of no more than one other occurrence. */		\n		feature superoccurrence: Occurrence[0..1] subsets occurrences inverse of suboccurrences;\n\n		feature withoutOccurrences: Occurrence[0..*] unions successors, predecessors, outsideOfOccurrences\n			inverse of withoutOccurrences {\n			doc\n			/*\n			 * Occurrences that are completely separate either in time or space or both.\n			 */\n\n			/* withoutOccurrences is irreflexive. */\n			inv { (that as Occurrence) != (that.that as Occurrence) }\n		}\n\n		feature predecessors: Occurrence[0..*] subsets withoutOccurrences {\n			doc\n			/*\n			 * Occurrences that end before this occurrence starts.\n			 */\n		}\n\n		feature successors: Occurrence[0..*] subsets withoutOccurrences inverse of predecessors {\n			doc\n			/*\n			 * Occurrences that start after this occurrence ends.\n			 */\n\n			/* successors is transitive. */\n			feature earlierOccurrence: Occurrence[1] subsets that;\n			feature laterOccurrence: Occurrence[1] subsets self;\n			subset laterOccurrence.successors subsets earlierOccurrence.successors;\n		}\n\n		feature immediatePredecessors: Occurrence[0..*] subsets predecessors {\n			doc\n			/*\n			 * Occurrences that end just before this occurrence starts, with no\n			 * possibility of other occurrences happening in the time between them.\n			 */\n		}\n\n		feature immediateSuccessors: Occurrence[0..*] subsets successors inverse of immediatePredecessors {\n			doc\n			/*\n			 * Occurrences that start just after this occurrence ends, with no\n			 * possibility of other occurrences happening in the time between them.\n			 */\n\n			disjoint earlierOccurrence.successors from laterOccurrence.predecessors;\n		}\n\n		feature timeEnclosedOccurrences: Occurrence[1..*] subsets occurrences {\n			doc\n			/*\n			 * Occurrences that start no earlier than and end no later than\n			 * this occurrence, including at least this occurrence.\n			 */\n\n			/*\n			 * timeEnclosedOccurrences and successors constrain each other. All successors of\n			 * (occurrences happening after) time enclosing occurrences (inverse of\n			 * timeEnclosedOccurrences) are also successors of their timeEnclosedOccurrences.\n			 * And predecessors of (occurrences happening before) time enclosing occurrences\n			 * are predecessors of their timeEnclosedOccurrences.\n			 */\n			feature longerOccurrence: Occurrence[1] subsets that;\n			feature shorterOccurrence: Occurrence[1] subsets self;\n			subset longerOccurrence.predecessors subsets shorterOccurrence.predecessors;\n			subset longerOccurrence.successors subsets shorterOccurrence.successors;\n\n			/* timeEnclosedOccurrences is transitive. */\n			subset shorterOccurrence.timeEnclosedOccurrences subsets longerOccurrence.timeEnclosedOccurrences;\n		}\n\n		feature all timeCoincidentOccurrences: Occurrence[1..*] subsets timeEnclosedOccurrences inverse of timeCoincidentOccurrences {\n			doc\n			/*\n			 * Occurrences that start at the same time and end at the same time as this occurrence,\n			 * including at least this occurrence.\n			 */\n\n			feature thatOccurrence: Occurrence[1] subsets longerOccurrence;\n			feature thisOccurrence: Occurrence[1] subsets shorterOccurrence;\n\n			/* timeCoincidentOccurrences occurrences happen during each other. */\n			connector :HappensDuring\n				from [1] shorterOccurrence references thisOccurrence\n				to [1] longerOccurrence references thatOccurrence;\n\n			/* timeCoincidentOccurrences is transitive */\n			subset thatOccurrence.timeCoincidentOccurrences\n				subsets thisOccurrence.timeCoincidentOccurrences;\n		}\n\n		feature spaceEnclosedOccurrences: Occurrence[1..*] subsets occurrences {\n			doc\n			/*\n			 * Occurrences that this one completely includes in space (not necessarily in time),\n			 * including this one.\n			 */\n\n			feature largerSpace: Occurrence[1] subsets that;\n			feature smallerSpace: Occurrence[1] subsets self;\n\n			/* spaceEnclosedOccurrences is transitive. */\n			subset smallerSpace.spaceEnclosedOccurrences subsets largerSpace.spaceEnclosedOccurrences;\n\n			/* smallerSpace are outside occurrences that are outside their largerSpace */\n			subset smallerSpace.outsideOfOccurrences subsets largerSpace.outsideOfOccurrences;\n		}\n\n		feature all spaceTimeEnclosedOccurrences: Occurrence[1..*] subsets timeEnclosedOccurrences, spaceEnclosedOccurrences\n			intersects timeEnclosedOccurrences, spaceEnclosedOccurrences {\n			doc\n			/*\n			 * Occurrences that this one completely includes in both space and time,\n			 * including this one.\n			 */\n\n			/* spaceTimeEnclosedOccurrences is transitive */\n			subset largerSpace.spaceTimeEnclosedOccurrences subsets smallerSpace.spaceTimeEnclosedOccurrences;\n		}\n\n		feature all spaceTimeEnclosedPoints : Occurrence[1..*] subsets spaceTimeEnclosedOccurrences {\n			doc\n			/*\n			 * All space time enclosed occurrences that take up zero time and space.\n			 */\n\n			redefines innerSpaceDimension = 0;\n			binding [1] startShot = [1] endShot;\n		}\n\n		feature spaceTimeCoincidentOccurrences: Occurrence[1..*] \n			subsets timeCoincidentOccurrences, spaceEnclosedOccurrences, spaceTimeEnclosedOccurrences \n			intersects timeCoincidentOccurrences, spaceEnclosedOccurrences inverse of spaceTimeCoincidentOccurrences {\n			doc\n			/*\n			 * Occurrences that this one completely includes in both space and time,\n			 * and vice-versa, including this one.\n			 */\n\n			feature redefines thatOccurrence subsets largerSpace;\n			feature redefines thisOccurrence subsets smallerSpace;\n\n			/* spaceTimeCoincidentOccurrences occurrences are inside of each other. */\n			connector :InsideOf\n				from [1] largerSpace references thatOccurrence\n				to [1] smallerSpace references thisOccurrence;\n\n			/* spaceTimeCoincidentOccurrences is transitive */\n			subset thatOccurrence.spaceTimeCoincidentOccurrences\n				subsets thisOccurrence.spaceTimeCoincidentOccurrences;\n		}\n\n		feature outsideOfOccurrences: Occurrence[0..*] subsets withoutOccurrences inverse of outsideOfOccurrences {\n			doc\n			/*\n			 * Occurrences that do not overlap in space (not necessarily in time, see successors).\n			 */\n		}\n\n		feature justOutsideOfOccurrences: Occurrence[0..*] subsets outsideOfOccurrences inverse of justOutsideOfOccurrences {\n			doc\n			/*\n			 * Occurrences that have no space between some of their space slices and some space slices of this occurrence.\n			 */\n\n			feature separateSpaceToo: Occurrence[1] subsets that;\n			feature separateSpace: Occurrence[1] subsets self;\n\n			connector :MatesWith [1..*]\n				from [0..*] separateSpaceToo references separateSpaceToo.spaceSlices\n				to [0..*] separateSpace references separateSpace.spaceSlices;\n		}\n\n		feature matingOccurrences: Occurrence[1..*] subsets justOutsideOfOccurrences inverse of matingOccurrences {\n			doc\n			/*\n			 * Occurrences that have no space between them and this one.\n			 */\n\n			feature matingSpaceToo: Occurrence[1] subsets that;\n			feature matingSpace: Occurrence[1] subsets self;\n			feature matingOccurrence: Occurrence [1] {\n				portion feature redefines spaceBoundary [1];\n				inv { contains(unionsOf, union(matingSpaceToo, matingSpace)) }\n				portion feature redefines spaceInterior [0];\n			}\n		}\n\n		feature innerSpaceDimension : Natural [1] {\n			doc\n			/*\n			 * The number of variables needed to identify space points in this occurrence, from 0\n			 * to 3, without regard to higher dimensional spaces it might be embedded in.\n			 */\n		}\n\n		inv { innerSpaceDimension <= 3 }\n\n		feature outerSpaceDimension : Natural [0..1] {\n			doc\n			/*\n			 * For occurrences of innerSpaceDimension 1 or 2, the number of variables needed to\n			 * identify their space points in higher dimensions they might be embedded in, from\n			 * the innerSpaceDimension to 3. An outerSpaceDimension equal to innerSpaceDimension\n			 * indicates the occurrence is spatially straight (innerSpaceDimension 1 embedded in\n			 * 2 or 3 dimensions) or flat (innerSpaceDimension 2 embedded in 3 dimensions).\n			 */\n		}\n		inv { notEmpty(outerSpaceDimension) implies\n			 (outerSpaceDimension >= innerSpaceDimension & outerSpaceDimension <= 3) }\n\n		portion feature all portions: Occurrence[1..*] subsets spaceTimeEnclosedOccurrences {\n			doc\n			/*\n			 * All spaceTimeEnclosedOccurrences that have the same portionOfLife (considered the same\n			 * thing occurring).\n			 */\n\n            portion redefines portionOfLife = (that as Occurrence).portionOfLife;\n		}\n\n		feature portionOf : Occurrence[1..*] inverse of portions {\n			doc\n			/*\n			 * Occurrences of which this occurrence is a portion, including at\n			 * least this occurrence.\n			 */\n		}\n\n		portion feature timeSlices: Occurrence[1..*] subsets portions {\n			doc\n			/*\n			 * Portions of an occurrence taking up all of its space over some period of time,\n			 * including at least this occurrence.\n			 */\n		}\n\n		feature timeSliceOf : Occurrence[1..*] subsets portionOf inverse of timeSlices {\n			doc\n			/*\n			 * Occurrences of which this occurrence is a time slice, including at least this\n			 * occurrence.\n			 */\n\n			feature timeSliceOccurrence: Occurrence[1] subsets that;\n			feature timeSlicedOccurrence: Occurrence[1] subsets self;\n\n			/* timeSliceOf is transitive */\n			subset timeSlicedOccurrence.timeSliceOf subsets timeSliceOccurrence.timeSliceOf;\n		}\n\n		portion feature all snapshots: Occurrence[1..*] subsets timeSlices {\n			doc\n			/*\n			 * Time slices of an occurrence that happen at a single instant of time\n			 * (i.e., have no duration).\n			 */\n			binding [1] startShot = [1] endShot;\n		}\n		inv { snapshots == union(startShot, union(middleTimeSlice.snapshots, endShot)) }\n\n		feature snapshotOf : Occurrence[0..*] subsets timeSliceOf inverse of snapshots {\n			doc\n			/*\n			 * Occurrences of which this occurrence is a snapshot.\n			 */\n		}\n\n		portion feature startShot: Occurrence[1] subsets snapshots {\n			doc\n			/*\n			 * The snapshot representing the start of the occurrence in time.\n			 */\n		}\n\n		portion feature middleTimeSlice: Occurrence[0..1] subsets timeSlices {\n			doc\n			/*\n			 * A time slice that takes all the time between the start shot and end shot. There\n			 * is none when the startShot and endShot are the same.\n			 */\n		}\n		inv { isEmpty((that as Occurrence).middleTimeSlice) == ((that as Occurrence).startShot == (that as Occurrence).endShot) }\n\n		connector :HappensJustBefore\n			from [1] earlierOccurrence references startShot\n			to [0..1] laterOccurrence references middleTimeSlice {\n			doc\n			/*\n			 * The startShot happens immediately before the middle time slice.\n			 */\n		}\n\n		portion feature endShot: Occurrence[1] subsets snapshots {\n			doc\n			/*\n			 * The snapshot at the end of the occurrence in time.\n			 */\n\n			/* suboccurrences at the end of an Occurrence must also end. */\n			feature subendshot : Occurrence [0..*] chains self.suboccurrences.endShot {\n				  feature superendshot : Occurrence [1] subsets that;\n				  subset superendshot subsets self.timeCoincidentOccurrences; }\n		}\n\n		 connector :HappensJustBefore\n			from [0..1] earlierOccurrence references middleTimeSlice\n			to [1] laterOccurrence references endShot {\n			doc\n			/*\n			 * The endShot happens after the middle time slice.\n			 */\n		}\n\n		portion feature spaceSlices: Occurrence[1..*] subsets portions {\n			doc\n			/*\n			 * Portions of this occurrence that extend for exactly the same time and some or all\n			 * the space, relative to spatial location of this occurrence, including at least\n			 * this occurrence.\n			 */\n		}\n\n		feature spaceSliceOf: Occurrence[1..*] subsets portionOf inverse of spaceSlices {\n			doc\n			/*\n			 * Occurrences of which this occurrence is a space slice, including at least this\n			 * occurrence.\n			 */\n\n			feature spaceSliceOccurrence: Occurrence[1] subsets that;\n			feature spaceSlicedOccurrence: Occurrence[1] subsets self;\n			inv { spaceSliceOccurrence.innerSpaceDimension <= spaceSlicedOccurrence.innerSpaceDimension }\n\n			/* spaceSliceOf is transitive */\n			subset spaceSlicedOccurrence.spaceSliceOf subsets spaceSliceOccurrence.spaceSliceOf;\n		}\n\n		portion feature spaceShots: Occurrence[1..*] subsets spaceSlices {\n			doc\n			/*\n			 * All spaceSlices of this occurrence that are of a lower inner space dimension than it.\n			 */\n		}\n\n		feature all spaceShotOf: Occurrence[0..*] subsets spaceSliceOf inverse of spaceShots {\n			doc\n			/*\n			 * All occurrences of which this occurrence is a space shot.\n			 */\n\n			feature spaceShotOccurrence: Occurrence[1] subsets that;\n			feature spaceShottedOccurrence: Occurrence[1] subsets self;\n			inv { spaceShotOccurrence.innerSpaceDimension < spaceShottedOccurrence.innerSpaceDimension }\n\n			/* spaceShotOf is transitive */\n			subset spaceShottedOccurrence.spaceShotOf subsets spaceShotOccurrence.spaceShotOf;\n		}\n\n		feature unionsOf: Set[0..*] {\n			doc\n			/*\n			 * Sets of occurrences, where the time and space taken by all the occurrences in each\n			 * set together is the same as taken by this occurrence (all four dimensional points in\n			 * the occurrences of each set are at the same time and space as those of this\n			 * occurrence).\n			 */\n\n			feature redefines elements: Occurrence[0..*];\n			feature union: Occurrence[0..1];\n\n			connector :Within\n				  from [0..*] smallerOccurrence references elements \n				  to [1] largerOccurrence references union;\n			connector :Within\n				  from [0..*] smallerOccurrence references union.spaceTimeEnclosedPoints\n				  to [1..*] largerOccurrence references elements;\n		}\n		binding  [0..1] unionsOf.union = [1] self;\n\n		feature intersectionsOf: Set[0..*] {\n			doc\n			/*\n			 * Sets of occurrences, where the time and space taken in common between the occurrences\n			 * in each set is at the same as taken by this occurrence (all four dimensional points\n			 * common to the occurrences in each set are at the same time and space as those in this\n			 * occurrence).\n			 */\n\n			feature redefines elements: Occurrence[0..*] {\n				feature all notIntersection: Occurrence[0..*] subsets spaceTimeEnclosedPoints;\n			}\n			feature intersection: Occurrence[0..1];\n\n			connector :Within\n				  from [1] smallerOccurrence references intersection\n				  to [0..*] largerOccurrence references elements;\n			connector :Without\n				  from [0..*] separateOccurrenceToo references elements.notIntersection\n				  to [1] separateOccurrence references intersection;\n			connector :Without\n				  from [0..*] separateOccurrenceToo references elements.notIntersection\n				  to [1..*] separateOccurrence references elements;\n		}\n		binding [0..1] intersectionsOf.intersection = [1] self;\n\n		feature differencesOf: OrderedSet[0..*] {\n			doc\n			/*\n			 * Ordered sets of occurrences, where the time and space taken by first occurrence in\n			 * each set that is not in the time and space taken by the remaining occurrences is the\n			 * same as taken by this occurrence (all four dimensional points in the minuend that are\n			 * not in any subtrahend are at the same time and space as those in this occurrence).\n			 */\n			feature redefines elements: Occurrence[0..*];\n			feature difference: Occurrence[0..1];\n			feature minuend: Occurrence [0..1] subsets elements, interdiff.elements = head(elements);\n			feature subtrahend: Occurrence[*] subsets elements = tail(elements);\n			feature interdiff: Set [0..1] {\n				feature redefines elements: Occurrence[1..*];\n				feature all notSubtrahend: Occurrence [0..*] subsets elements;\n			}\n\n			connector :Without\n				  from [0..*] separateOccurrenceToo references interdiff.notSubtrahend \n				  to [1..*] separateOccurrence references subtrahend;\n\n			inv { isEmpty(difference) == isEmpty(interdiff) }\n			inv { notEmpty(difference) implies (difference.intersectionsOf == interdiff) }\n		}\n		binding [0..1] differencesOf.difference = [1] self;\n\n		portion feature spaceInterior: Occurrence[0..1] subsets spaceSlices {\n			doc\n			/*\n			 * A space slice of this occurrence that includes all its space shots except the\n			 * space boundary, which must exist and be outsideOf it.  The space interior must be\n			 * of the same inner space dimension as this occurrence, except if it is zero,\n			 * whereupon there is no space interior.\n			 */\n		}\n\n		feature spaceInteriorOf: Occurrence[0..1] subsets spaceSliceOf inverse of spaceInterior {\n			doc\n			/*\n			 * An Occurrence of which this one is the space interior.\n			 */\n		}\n\n		inv { notEmpty(spaceInterior) implies spaceInterior.innerSpaceDimension == innerSpaceDimension }\n\n		portion feature spaceBoundary: Occurrence[0..1] subsets spaceShots {\n			doc\n			/*\n			 * The space shot of this Occurrence that is not among those of its space interior,\n			 * which must be outside it. It must not have a spaceBoundary.	It can be divided\n			 * into space slices that also have no spaceBoundary, where the outer one surrounds\n			 * the inner ones.\n			 */\n\n			inv { isClosed == true }\n\n			feature spaceBounder: Occurrence [1] subsets self;\n\n			feature outer: Occurrence [0..1] subsets spaceSlices {\n				feature redefines isClosed = true;\n				feature redefines innerSpaceDimension = spaceBounder.innerSpaceDimension;\n			}\n\n			feature inner: Occurrence [0..*] subsets spaceSlices {\n				feature redefines isClosed = true;\n				feature redefines innerSpaceDimension = spaceBounder.innerSpaceDimension;\n			}\n\n			inv { notEmpty(inner) implies notEmpty(outer) }\n			inv { notEmpty(outer) implies\n				contains(unionsOf, union(outer, inner)) }\n		}\n\n		feature spaceBoundaryOf: Occurrence[0..*] subsets spaceShotOf inverse of spaceBoundary {\n			doc\n			/*\n			 * An Occurrence of which this one is the space boundary.\n			 */\n\n			feature spaceBounderOf: Occurrence subsets self;\n			inv { spaceBounderOf.spaceBoundary == that.that }\n		}\n\n		inv { not isClosed implies contains((that as Occurrence).unionsOf, union(spaceBoundary, spaceInterior)) }\n		inv { innerSpaceDimension == 0 implies isEmpty(spaceBoundary) }\n\n		connector :SurroundedBy\n			from [0..*] surroundedSpace references spaceInterior\n			to [1] surroundingSpace references spaceBoundary.outer;\n\n		connector :SurroundedBy\n			from [0..*] surroundedSpace references spaceBoundary.inner\n			to [1] surroundingSpace references spaceInterior;\n\n		feature innerSpaceOccurrences: Occurrence [0..*] subsets outsideOfOccurrences {\n			doc\n			/*\n			 * Occurrences that completely occupy the space surrounded by an inner space boundary of this occurrence.\n			 */\n\n			feature redefines innerSpaceOccurrences [0];\n\n		 	/* innerSpace is the spaceInterior of hOccurrence, which is formed from an inner space boundary of outerSpace. */\n			feature outerSpace: Occurrence[1] subsets that;\n			feature innerSpace: Occurrence[1] subsets self;\n			feature hOccurrence: Occurrence [1];\n			connector hbi: WithinBoth [0..1] from [0..1] hOccurrence.spaceBoundary to [0..1] outerSpace.spaceBoundary.inner;\n			connector hbo: WithinBoth [0..1] from [0..1] hOccurrence.spaceBoundary to [0..1] outerSpace;\n			connector :WithinBoth from [1] hOccurrence.spaceInterior to [1] innerSpace;\n			inv { (isEmpty(hbi) == notEmpty(hbo)) & (notEmpty(hbo) == outerSpace.isClosed) }\n		}\n\n		feature surroundedByOccurrences: Occurrence [0..*] subsets outsideOfOccurrences {\n			doc\n			/*\n			 * Occurrences that have inner spaces that completely include this occurrence.\n			 */\n\n			feature surroundedSpace: Occurrence [1] subsets that;\n			feature surroundingSpace: Occurrence [1] subsets self;\n\n			connector :InsideOf\n				from [0..1] smallerOccurrence references surroundedSpace\n				to [1..*] largerOccurrence references surroundingSpace.innerSpaceOccurrences;\n		}\n\n		feature isClosed : Boolean [1] {\n			doc\n			/*\n			 * Tells whether an occurrence has a spaceBoundary, true if it does, false otherwise.\n			 */\n		}\n		inv { isClosed == isEmpty((that as Occurrence).spaceBoundary) }\n\n		var feature incomingTransfers: Transfers::Transfer[0..*] subsets Transfers::transfers {\n			doc\n			/*\n			 * The incoming transfers received by this occurrence.\n			 */\n\n			end feature redefines source;\n			end feature redefines target;\n		}\n		\n		feature isDispatch : Boolean[1] default false {\n			doc\n			/*\n			 * Determines whether transfers to the dispatch scope might be accepted more than once.\n			 */\n		}\n 		feature dispatchScope: Occurrence [1] default self;\n 		connector :HappensDuring from [1] self to [1] dispatchScope;\n 		\n 		feature isRunToCompletion: Boolean [1] default true {\n			doc\n			/*\n			 * Determines whether transition performances might happen during state entry performances\n			 * within the run to completion scope.\n			 */\n		}\n		feature runToCompletionScope: Occurrence [1] default self;\n		connector :HappensDuring from [1] self to [1] runToCompletionScope;\n \n 		feature incomingTransferSort : IncomingTransferSort [0..*] default earlierFirstIncomingTransferSort {\n			doc\n			/*\n			 * Determines which transfer to accept when multiple are available and which of the unaccepted \n			 * transfers are never to be accepted (dispatched).\n			 */\n		}\n\n		var feature all incomingTransfersToSelf subsets incomingTransfers {\n			doc\n			/*\n			 * The incoming transfers with this occurrence as the target.\n			 */\n\n			end feature redefines source;\n			end feature redefines target = that;\n		}\n\n		var feature outgoingTransfers: Transfers::Transfer[0..*] subsets Transfers::transfers {\n			doc\n			/*\n			 * The outgoing transfers sent from this occurrence.\n			 */\n\n			end feature redefines source;\n			end feature redefines target;\n		}\n\n		var feature all outgoingTransfersFromSelf subsets outgoingTransfers {\n			doc\n			/*\n			 * The outgoing transfers with this occurrence as the source.\n			 */\n\n			end feature redefines source = that;\n			end feature redefines target;\n		}\n	}\n\n	abstract class all Life specializes Occurrence {\n		binding portionOf = self {\n			doc\n			/*\n			 * Lives are only portions of themselves.\n			 */\n			}\n	}\n\n	abstract feature occurrences: Occurrence[0..*] nonunique subsets things;\n	\n	predicate IncomingTransferSort specializes Performances::BooleanEvaluation {    \n		in t1: Transfers::Transfer [1];\n		in t2: Transfers::Transfer [1];  \n		return t1First: Boolean [1]; \n	}\n\n	bool earlierFirstIncomingTransferSort : IncomingTransferSort {\n		return t1First = includes(t1.endShot.successors, t2.endShot);\n	}\n\n	assoc all SelfSameLifeLink specializes BinaryLink {\n		doc\n		/*\n		 * SelfSameLifeLink is a binary association that is equivalent to SelfLink if the\n		 * linked things are DataValues, but asserts that the linked things are portions of\n		 * the same Life if they are Occurrences. \n		 */\n\n		end myselfSameLives [1..*] feature myselfSameLife: Anything redefines source;\n		end selfSameLives [1..*] feature selfSameLife: Anything redefines target;\n\n		feature all sourceOccurrence : Occurrence [0..1] subsets myselfSameLife;\n		feature all targetOccurrence : Occurrence [0..1] subsets selfSameLife, sourceOccurrence.sameLifeOccurrences;\n		binding oSelf of sourceOccurrence.portionOfLife = targetOccurrence.portionOfLife;\n\n		feature all sourceDataValue : DataValue [0..1] subsets myselfSameLife;\n		feature all targetDataValue : DataValue [0..1] subsets selfSameLife;\n		binding dSelf of sourceDataValue = targetDataValue;\n	}\n\n	subclassifier SelfLink specializes SelfSameLifeLink;\n\n	assoc HappensLink specializes BinaryLink disjoint from Occurrence {\n		doc\n		/*\n		 * HappensLink is the most general associations that assert temporal relationships between a\n		 * sourceOccurrence and a targetOccurrence. Because HappensLinks assert temporal\n		 * relationships, they cannot also be Occurrences that happen in time.  Therefore\n		 * HappensLink is disjoint with LinkObject, that is, no HappensLink can also be a\n		 * LinkObject.\n		 */\n		\n		end feature sourceOccurrence: Occurrence redefines BinaryLink::source;\n		end feature targetOccurrence: Occurrence redefines BinaryLink::target;\n	}\n\n	assoc all HappensDuring specializes HappensLink {\n		doc\n		/*\n		 * HappensDuring asserts that the shorterOccurrence happens during the longerOccurrence.\n		 * That is, the time interval of the shorterOccurrence is completely within that of the\n		 * longerOccurrence, or every snapshot of the shorterOccurrence happens while (at the\n		 * same time as) some snapshot of the longerOccurrence. Note that this means every\n		 * Occurrence HappensDuring itself and that HappensDuring is transitive.\n		 */\n		\n		end feature shorterOccurrence: Occurrence redefines sourceOccurrence crosses longerOccurrence.timeEnclosedOccurrences;\n		end happensDuring [1..*] feature longerOccurrence: Occurrence redefines targetOccurrence;\n	}\n\n	assoc all HappensWhile specializes HappensDuring {\n		doc\n		/*\n		 * HappensWhile asserts that two occurrences happen during each other, that is, they\n		 * each start at the same time and end at the same time.\n		 */\n\n		end feature thisOccurrence: Occurrence redefines shorterOccurrence crosses thatOccurrence.timeCoincidentOccurrences;\n		end happensWhile [1..*] subsets timeCoincidentOccurrences feature thatOccurrence: Occurrence redefines longerOccurrence;\n	}\n	\n	assoc SpaceLink specializes BinaryLink disjoint from Occurrence {\n        doc\n        /*\n         * SpaceLink is the most general association that asserts spatial relationships between a\n         * sourceOccurrence and a targetOccurrence. Because SpaceLinks assert spatial\n         * relationships, they cannot also be Occurrences that happen in space.  Therefore\n         * SpaceLink is disjoint with LinkObject, that is, no SpaceLink can also be a\n         * LinkObject.\n         */\n      \n        end feature sourceOccurrence: Occurrence redefines BinaryLink::source;\n        end feature targetOccurrence: Occurrence redefines BinaryLink::target;\n    }\n\n	assoc all InsideOf specializes SpaceLink {\n		doc\n		/*\n		 * InsideOf asserts that its largerSpace completely overlaps its smallerSpace in space (not\n		 * necessarily in time, see HappensDuring). That is, all four dimensional points of the\n		 * smallerSpace are in the spatial extent of the largerSpace. Note that this means every\n		 * Occurrence is InsideOf itself and that InsideOf is transitive.\n		 */\n\n		end feature smallerSpace: Occurrence redefines source crosses largerSpace.spaceEnclosedOccurrences;\n		end insideOf [1..*] feature largerSpace: Occurrence redefines target;\n	}\n\n	assoc all Within specializes HappensDuring, InsideOf intersects HappensDuring, InsideOf {\n		doc\n		/*\n		 * Within asserts that its largerOccurrence completely overlaps its smallerOccurrence in\n		 * time and space. That is, all four dimensional points of the smallerOccurrence happen\n		 * during and are included in the space of the largerOccurrence. This means every occurrence\n		 * is Within itself and Within is transitive.\n		 */\n\n		end feature smallerOccurrence: Occurrence redefines shorterOccurrence, smallerSpace\n		  crosses largerOccurrence.spaceTimeEnclosedOccurrences;\n		end within [1..*] feature largerOccurrence: Occurrence redefines longerOccurrence, largerSpace;\n	 }\n\n	assoc all WithinBoth specializes Within, HappensWhile {\n		doc\n		/*\n		 * WithinBoth asserts that two occurrences are Within each other, that is, they occupy the\n		 * same four dimensional region.  Note that this means every Occurrence is WithinBoth with\n		 * itself and transitive.\n		 */ \n\n		end feature thisOccurrence redefines smallerOccurrence, HappensWhile::thisOccurrence\n		  crosses thatOccurrence.spaceTimeCoincidentOccurrences;\n		end withinBoth subsets spaceTimeCoincidentOccurrences feature thatOccurrence redefines largerOccurrence, HappensWhile::thatOccurrence;\n	}\n\n	assoc all PortionOf specializes Within {\n		doc\n		/*\n		 * PortionOf asserts one occurrence is a portion of another, including at least itself.\n		 */\n\n		end feature portionOccurrence: Occurrence redefines smallerOccurrence crosses portionedOccurrence.portions;\n		end portionWithin subsets portionOf feature portionedOccurrence: Occurrence redefines largerOccurrence;\n	}\n\n	assoc all TimeSliceOf specializes PortionOf {\n		doc\n		/*\n		 * TimeSliceOf asserts one occurrence is a time slice of another, including at least itself.\n		 */\n\n		end feature timeSliceOccurrence: Occurrence redefines portionOccurrence crosses timeSlicedOccurrence.timeSlices;\n		end timeSliceWithin subsets timeSliceOf feature timeSlicedOccurrence: Occurrence redefines portionedOccurrence;\n	}\n\n	assoc all SnapshotOf specializes TimeSliceOf {\n		doc\n		/*\n		 * SnapshotsOf asserts one occurrence is a snapshot of another.\n		 */\n\n		end feature snapshotOccurrence: Occurrence redefines timeSliceOccurrence crosses snapshottedOccurrence.snapshots;\n		end snapshotWithin subsets snapshotOf feature snapshottedOccurrence: Occurrence redefines timeSlicedOccurrence;\n	}\n\n	assoc all SpaceSliceOf specializes PortionOf {\n		doc\n		/*\n		 * SpaceSliceOf asserts that its spaceSliceOccurrence extends for exactly the same time and\n		 * some or all the space of the spaceSlicedOccurrence and that the spaceSliceOccurrence is\n		 * of the same of lower innerSpaceDimension than the spaceSliceOccurrence.  Note that this\n		 * means every occurrence is a SpaceSliceOf itself and SpaceSliceOf is transitive.\n		 */\n\n		end feature spaceSliceOccurrence: Occurrence redefines portionOccurrence crosses spaceSlicedOccurrence.spaceSlices;\n		end spaceSliceWithin subsets spaceSliceOf feature spaceSlicedOccurrence: Occurrence redefines portionedOccurrence;\n	}\n\n	assoc all SpaceShotOf specializes SpaceSliceOf {\n		doc\n		/*\n		 * SpaceShotOf asserts that its spaceShotOccurrence is of a lower inner space dimension than\n		 * it spaceShottedOccurrence.\n		 */\n\n		end feature spaceShotOccurrence: Occurrence redefines spaceSliceOccurrence crosses spaceShottedOccurrence.spaceShots;\n		end spaceShotWithin subsets spaceSliceOf feature spaceShottedOccurrence: Occurrence redefines spaceSlicedOccurrence;\n	}\n\n	assoc all Without specializes BinaryLink unions HappensBefore, OutsideOf {\n		doc\n		/*\n		 * Without is the most general association that asserts complete separation (no overlap) in\n		 * either space or time, or both, between two occurrences.  That is, no four dimensional\n		 * points are in both occurrences. Note that this means no Occurrence is Without itself.\n		 */\n\n		end feature separateOccurrenceToo: Occurrence redefines BinaryLink::source\n		  crosses separateOccurrence.withoutOccurrences;\n		end feature separateOccurrence: Occurrence redefines BinaryLink::target\n		  crosses separateOccurrenceToo.withoutOccurrences;\n	}\n\n	assoc all HappensBefore specializes HappensLink, Without {\n		doc\n		/*\n		 * HappensBefore asserts that the earlierOccurrence is completely separated in time (not\n		 * necessarily in space, see OutsideOf), with the earlierOccurrence happening completely\n		 * before the laterOccurrence.	That is, no snapshot of the earlierOccurrence happens at the\n		 * same time as any snapshot of the laterOccurrence, with all snapshots of earlierOccurrence\n		 * happening before those the laterOccurrence, including the endShot of the earlierOccurrence\n		 * and startShot of the laterOccurrence. Note that this means no Occurrence HappensBefore\n		 * itself.\n		 */\n\n		end feature earlierOccurrence: Occurrence redefines sourceOccurrence, separateOccurrenceToo \n			crosses laterOccurrence.predecessors;\n		end feature laterOccurrence: Occurrence redefines targetOccurrence, separateOccurrence \n			crosses earlierOccurrence.successors;\n	}\n\n	assoc all HappensJustBefore specializes HappensBefore {\n		doc\n		/*\n		 * HappensJustBefore is HappensBefore asserting that there is no possibility of another\n		 * occurrences happening in the time between the earlierOccurrence and laterOccurrence.\n		 */\n\n		end feature redefines earlierOccurrence: Occurrence crosses laterOccurrence.immediatePredecessors;\n		end feature redefines laterOccurrence: Occurrence crosses earlierOccurrence.immediateSuccessors;\n	}\n\n	feature all happensBeforeLinks: HappensBefore[0..*] nonunique subsets binaryLinks {\n		doc\n		/*\n		 * happensBeforeLinks is a specialization of binaryLinks restricted to type HappensBefore.\n		 * It is the default subsetting for succession connectors.\n		 */\n\n		end feature earlierOccurrence: Occurrence redefines HappensBefore::earlierOccurrence, binaryLinks::source;\n		end feature laterOccurrence: Occurrence redefines HappensBefore::laterOccurrence, binaryLinks::target;\n	 }\n\n	assoc all OutsideOf specializes SpaceLink, Without {\n		doc\n		/*\n		 * OutsideOf asserts that two occurrences do not overlap in space (not necessarily in time,\n		 * see HappensBefore).	That is, no four dimensional points of the occurrences are in the\n		 * spatial extent of both of them. This means no Occurrence is OutsideOf itself.\n		 */\n\n		end feature separateSpaceToo: Occurrence redefines sourceOccurrence, separateOccurrenceToo\n			crosses separateSpace.outsideOfOccurrences;\n		end feature separateSpace: Occurrence redefines targetOccurrence, separateOccurrence\n			crosses separateSpaceToo.outsideOfOccurrences;\n	}\n\n	assoc all JustOutsideOf specializes OutsideOf {\n		doc\n		/*\n		 * JustOutsideOf is an OutsideOf asserting that two occurrences have some space slices with\n		 * no space between them.\n		 */\n\n		end feature redefines separateSpaceToo: Occurrence\n			crosses separateSpace.justOutsideOfOccurrences;\n		end feature redefines separateSpace: Occurrence\n		  crosses separateSpaceToo.justOutsideOfOccurrences;\n	}\n\n	assoc all MatesWith specializes JustOutsideOf {\n		doc\n		/*\n		 * MatesWith is an OutsideOf asserting that two occurrences have no space between them.\n		 */\n\n		end feature matingSpaceToo: Occurrence redefines separateSpaceToo\n		  crosses matingSpace.matingOccurrences;\n		end feature matingSpace: Occurrence redefines separateSpace\n		  crosses matingSpaceToo.matingOccurrences;\n	}\n\n	assoc all InnerSpaceOf specializes OutsideOf {\n		doc\n		/*\n		 * InnerSpaceOf is an OutsideOf asserting that the space surrounded by an inner space boundary\n		 * of one occurrence (outer space) is completely occupied by another occurrence (inner space).\n		 */\n\n		end feature outerSpace: Occurrence redefines separateSpaceToo;\n		end feature innerSpace: Occurrence redefines separateSpace crosses outerSpace.innerSpaceOccurrences;\n	}\n\n	assoc all SurroundedBy specializes OutsideOf {\n		doc\n		/*\n		 * SurroundedBy is an OutsideOf asserting that one occurrence (surrounded space) is included\n		 * in space by an inner space occurrence of another (surrounding space).\n		 */\n\n		end feature surroundedSpace: Occurrence redefines separateSpaceToo;\n		end feature surroundingSpace: Occurrence redefines separateSpace crosses surroundedSpace.surroundedByOccurrences;\n	}\n}\n', "Kernel Libraries/Kernel Semantic Library/Performances.kerml": 'standard library package Performances {\n	doc\n	/*\n	 * This package defines classifiers and features that related to the typing of performances and evaluations.\n	 */\n\n	private import Base::Anything;\n	private import Base::things;\n	private import Occurrences::Occurrence;\n	private import Occurrences::occurrences;\n	private import Occurrences::HappensDuring;\n	private import Objects::Object;\n	private import Links::BinaryLink;\n	private import Metaobjects::Metaobject;\n	private import Transfers::Transfer;\n	private import Transfers::transfers;\n	private import Transfers::TransferBefore;\n	private import Transfers::transfersBefore;\n	private import ScalarValues::*;\n	private import SequenceFunctions::includes;\n	\n	abstract behavior Performance specializes Occurrence disjoint from Object {\n		doc\n		/*\n		 * Performance is the most general class of behavioral Occurrences that may be performed over time.\n		 */\n\n		feature self: Performance redefines Occurrence::self;\n		\n		feature involvedObjects: Object[0..*] {\n			doc\n			/*\n			 * Objects that are involved in this Performance.\n			 */\n		}\n		\n		feature performers: Object[0..*] subsets involvedObjects {\n			doc\n			/*\n			 * Objects that enact this Performance.\n			 */\n		}\n		\n		feature redefines isDispatch default true;\n  		feature redefines dispatchScope default thisPerformance;\n  		\n		step enclosedPerformances: Performance[0..*] subsets performances, timeEnclosedOccurrences\n			intersects performances, timeEnclosedOccurrences {\n			doc\n			/*\n			 * timeEnclosedOccurrences of this Performance that are also Performances.\n			 */\n		}\n		\n		feature thisPerformance: Performance [1] default self {\n			doc\n			/*\n			 * Defaults to the root of the subperformance composition tree.\n			 */\n		}\n		connector :HappensDuring from [1] self to [1] thisPerformance; \n		\n		composite step subperformances: Performance[0..*] subsets enclosedPerformances, suboccurrences\n			intersects enclosedPerformances, suboccurrences {\n			doc\n			/*\n			 * enclosedPerformances that are composite. \n			 */\n		\n			feature redefines this default (that as Performance).this {\n				doc\n				/*\n				 * The default "this" context of a subperformance is the same as that of its owning Performance.\n				 * This means that the context for any Performance that is in a composition tree rooted\n				 * in a Performance that is not itself owned by an Object is the root Performance. If the\n				 * root Performance is an ownedPerformance of an Object, then that Object is the context.\n				 */\n			}\n		\n			feature redefines thisPerformance default (that as Performance).thisPerformance;\n		}		\n	}\n	\n	abstract function Evaluation specializes Performance {\n		doc\n		/*\n		 * Evaluation is the most general class of functions that may be evaluated to compute\n		 * a result.\n		 */\n	 \n		return result: Anything[0..*] nonunique;\n	}\n	\n	abstract predicate BooleanEvaluation specializes Evaluation {\n		doc\n		/*\n		 * BooleanEvaluation is a specialization of Evaluation that is the most general class of\n		 * Predicates that may be evaluated to produce a Boolean truth value.\n		 */\n	 \n		return : Boolean[1];\n	}\n	\n	abstract function MetadataAccessEvaluation specializes Evaluation {\n		doc\n		/*\n		 * MetadataAccessEvaluation is a specialization of Evaluation for the case of MetadataAccessExpressions.\n		 */\n		\n		return : Metaobject[1..*];\n	}\n	\n	abstract function LiteralEvaluation specializes Evaluation {\n		doc\n		/*\n		 * LiteralEvaluation is a specialization of Evaluation for the case of LiteralExpressions.\n		 */\n	 \n		return : ScalarValue[1];\n	}\n	\n	abstract predicate LiteralBooleanEvaluation specializes LiteralEvaluation, BooleanEvaluation\n		intersects LiteralEvaluation, BooleanEvaluation {\n		doc\n		/*\n		 * LiteralBooleanEvaluation is a specialization of LiteralEvaluation for the case of LiteralBooleans.\n		 * It is also a predicate and thus a specialization of BooleanEvaluation. \n		 */\n	 \n		return : Boolean[1];\n	}\n	abstract function LiteralIntegerEvaluation specializes LiteralEvaluation {\n		doc\n		/*\n		 * LiteralIntegerEvaluation is a specialization of LiteralEvaluation for the case of LiteralIntegers.\n		 */\n	 \n		return : Integer[1];\n	}\n\n	abstract function LiteralRationalEvaluation specializes LiteralEvaluation {\n		doc\n		/*\n		 * LiteralRationalEvaluation is a specialization of LiteralEvaluation for the case of LiteralRationals.\n		 * (Note: Return type is Real to allow easy type conformance of LiteralRationals when a Real result is expected.)\n		 */\n	 \n		return : Real[1];\n	}\n	\n	abstract function LiteralStringEvaluation specializes LiteralEvaluation {\n		doc\n		/*\n		 * LiteralStringEvaluation is a specialization of LiteralEvaluation for the case of LiteralStrings.\n		 */\n	 \n		return : String[1];\n	}\n	\n	function NullEvaluation specializes Evaluation {\n		doc\n		/*\n		 * NullEvaluation is a specialization of Evaluation for the case of NullExpressions.\n		 */\n	 \n		return : Anything[0..0];\n	}\n\n	assoc all InvolvedIn specializes BinaryLink { \n		doc\n		/*\n		 * InvolvedIn asserts that the involvedObject is involved in the Behavior carried out by the \n		 * involvingPerformance.\n		 */\n		 \n		end feature involvedObject: Object redefines source crosses involvingPerformance.involvedObjects;\n		end feature involvingPerformance: Performance redefines target crosses involvedObject.involvingPerformances;\n	}\n	\n	assoc all Performs specializes InvolvedIn {\n		doc\n		/*\n		 * Performs asserts that the performer enacts the Behavior carried out by the performance.\n		 */\n	\n	 	end feature performerObject: Object redefines involvedObject crosses performance.performers;\n	 	end feature performance: Performance redefines involvingPerformance crosses performerObject.enactedPerformances;\n	 }\n\n	abstract step performances: Performance[0..*] nonunique subsets occurrences {\n		doc\n		/*\n		 * performances is the most general feature for performances of Behaviors.\n		 */\n	}\n	\n	abstract expr evaluations: Evaluation[0..*] nonunique subsets performances {\n		doc\n		/*\n		 * evaluations is a specialization of performances for evaluations of Functions.\n		 */\n	}\n	\n	abstract expr constructorEvaluations [0..*] nonunique subsets evaluations  {\n	    doc\n	    /*\n	     * constructorEvaluations is a specialization of evaluations that restricts the multiplicity \n	     * of its result parameter to 1..1, requiring a constructorEvaluation to result in a single value.\n	     */\n	     \n	     return result [1..1];\n	}\n	\n	abstract expr booleanEvaluations: BooleanEvaluation[0..*] nonunique subsets evaluations {\n		doc\n		/*\n		 * booleanEvaluations is a specialization of evaluations restricted to type BooleanEvaluation.\n		 */\n	}\n	\n	abstract expr trueEvaluations subsets booleanEvaluations {\n		doc\n		/*\n		 * trueEvaluations is a subset of booleanEvaluations that result in true. It is the most general\n		 * feature of invariants that are not negated. \n		 */\n	\n		private feature trueValue = true;\n		binding result = trueValue;\n	}\n	\n	abstract expr falseEvaluations subsets booleanEvaluations {\n		doc\n		/*\n		 * falseEvaluations is a subset of booleanEvaluations that result in false. It is the most general\n		 * feature of invariants that are negated.\n		 */\n	\n        private feature falseValue = false;\n        binding result = falseValue;\n	}\n	\n	abstract expr metadataAccessEvaluations: MetadataAccessEvaluation[0..*] nonunique subsets evaluations {\n		doc\n		/*\n		 * metadataAccessEvaluations is a specialization of evaluations restricted to type MetadataAccessEvaluation. \n		 */\n	}\n	\n	abstract expr literalEvaluations: LiteralEvaluation[0..*] nonunique subsets evaluations {\n		doc\n		/*\n		 * literalEvaluations is a specialization of evaluations restricted to type LiteralEvaluation.\n		 */\n	}\n	\n	abstract expr literalBooleanEvaluations: LiteralBooleanEvaluation[0..*] nonunique subsets literalEvaluations, booleanEvaluations\n		intersects literalEvaluations, booleanEvaluations {\n		doc\n		/*\n		 * literaBooleanlEvaluations is a specialization of literalEvaluations and booleanEvaluations restricted \n		 * to type LiteralBooleanEvaluation.\n		 */\n	}\n	\n	abstract expr literalIntegerEvaluations: LiteralIntegerEvaluation[0..*] nonunique subsets literalEvaluations {\n		doc\n		/*\n		 * literalEvaluations is a specialization of evaluations restricted to type LiteralEvaluation.\n		 */\n	}\n	\n	abstract expr literalRationalEvaluations: LiteralRationalEvaluation[0..*] nonunique subsets literalEvaluations {\n		doc\n		/*\n		 * literalRationalEvaluations is a specialization of literalEvaluations restricted to type LiteralRationalEvaluation.\n		 */\n	}\n	\n	abstract expr literalStringEvaluations: LiteralStringEvaluation[0..*] nonunique subsets literalEvaluations {\n		doc\n		/*\n		 * literalStringEvaluations is a specialization of literalEvaluations restricted to type LiteralStringEvaluation.\n		 */\n	}\n	\n	abstract expr nullEvaluations: NullEvaluation[0..*] nonunique subsets evaluations {\n		doc\n		/*\n		 * nullEvaluations is a specialization of evaluations restricted to type NullEvaluation.\n		 */\n	}\n}', "Kernel Libraries/Kernel Semantic Library/SpatialFrames.kerml": "standard library package SpatialFrames {\n    doc\n    /*\n     * This package models spatial frames of reference for quantifying the position of points \n     * in a three-dimensional space. \n     */\n\n    private import Clocks::*;\n    private import ScalarValues::NumericalValue;\n    private import VectorValues::ThreeVectorValue;\n    private import VectorValues::CartesianThreeVectorValue;\n    private import VectorFunctions::isZeroVector;\n    private import Occurrences::Life;\n    private import Objects::Body;\n    private import Objects::Point;\n    private import ControlFunctions::forAll;\n    private import SequenceFunctions::includes;\n    \n    private struct DefaultFrameLife[1] :> SpatialFrame, Life {\n        doc\n        /*\n         * DefaultFrameLife is the classifier of the singleton Life of the defaultFrame.\n         */\n    }\n    \n    feature defaultFrame : DefaultFrameLife[1] {\n        doc\n        /*\n         * defaultFrame is a fixed SpatialFrame used as a universal default.\n         */\n    }\n    \n    abstract struct SpatialFrame specializes Body {\n        doc\n        /*\n         * A SpatialFrame is a three-dimensional Body that provides a spatial extent that \n         * acts as a frame of reference for defining the physical position and displacement \n         * vectors of Points over time.\n         */\n    }\n    \n    abstract function PositionOf {\n        doc\n        /*\n         * The PositionOf a Point relative to a SpatialFrame, at a specific time relative to a given\n         * Clock, as a positionVector that is a ThreeVectorValue.\n         */\n    \n        in point : Point[1];\n        in time : NumericalValue[1];\n        in frame : SpatialFrame[1] default defaultFrame;\n        in clock : Clock[1] default frame.localClock;\n        return positionVector : ThreeVectorValue[1];\n        \n        inv positionTimePrecondition {\n            doc\n            /*\n             * The given point must exist at the given time.\n             */\n        \n            TimeOf(point.startShot) <= time and\n            time <= TimeOf(point.endShot)\n        }\n        \n        inv spacePositionConstraint {\n            doc\n            /*\n             * The result positionVector is equal to the PositionOf the Point spaceShot of the\n             * frame that encloses the given point, at the given time.\n             */\n        \n            (frame.spaceShots as Point)->forAll{in p : Point;\n                p.spaceTimeEnclosedOccurrences->includes(point) implies\n                    positionVector == PositionOf(p, time, frame)\n            }\n        }\n    }\n    \n    abstract function CurrentPositionOf {\n        doc\n        /*\n         * The CurrentPositionOf a Point relative to a SpatialFrame and a Clock is the PositionOf\n         * the Point relative to the SpatialFrame at the currentTime of the Clock.\n         */\n    \n        in point : Point[1];\n        in frame : SpatialFrame[1] default defaultFrame;\n        in clock : Clock[1] default frame.localClock;\n        return positionVector : ThreeVectorValue[1] =\n            PositionOf(point, clock.currentTime, frame, clock);\n    }\n        \n    function DisplacementOf {\n        doc\n        /*\n         * The DisplacementOf two Points relative to a SpatialFrame, at a specific time relative to a\n         * given Clock, is the displacementVector computed as the difference between the PositionOf the \n         * first Point and PositionOf the second Point, relative to that SpatialFrame, at that time.\n         */\n    \n        in point1 : Point[1];\n        in point2 : Point[1];\n        in time : NumericalValue;\n        in frame : SpatialFrame[1] default defaultFrame;\n        in clock : Clock[1] default frame.localClock;\n        return displacementVector : ThreeVectorValue[1] =\n            PositionOf(point2, time, frame, clock) - PositionOf(point1, time, frame, clock);\n            \n        inv zeroDisplacementConstraint {\n        doc\n        /*\n         * If either point1 or point2 occurs within the other, then the displacementVector is\n         * the zero vector.\n         */\n        \n            (point1.spaceTimeEnclosedOccurrences->includes(point2) or\n            point2.spaceTimeEnclosedOccurrences->includes(point1)) implies\n                isZeroVector(displacementVector)\n        }\n    }\n    \n    function CurrentDisplacementOf {\n        doc\n        /*\n         * The CurrentDisplacementOf two Points relative to a SpatialFrame and Clock is the DisplacementOf\n         * the Points relative to the SpatialFrame at the currentTime of the Clock.\n         */\n    \n        in point1 : Point[1];\n        in point2 : Point[1];\n        in frame : SpatialFrame[1] default defaultFrame;\n        in clock : Clock[1] default frame.localClock;\n        return displacementVector : ThreeVectorValue[1] =\n            DisplacementOf(point1, point2, clock.currentTime, frame, clock);\n    }\n    \n    abstract struct CartesianSpatialFrame :> SpatialFrame {\n        doc\n        /*\n         * A CartesianSpatialFrame is a SpatialFrame relative to which all position and displacement\n         * vectors can be represented as CartesianThreeVectorValues.\n         */\n    }\n    \n    abstract function CartesianPositionOf :> PositionOf {\n        doc\n        /*\n         * The PositionOf a Point relative to a CartesianSpatialFrame is a CartesianThreeVectorValue.\n         */\n    \n        in point : Point[1];\n        in time : NumericalValue[1];\n        in frame : CartesianSpatialFrame[1];\n        in clock : Clock[1] default frame.localClock;\n        return positionVector : CartesianThreeVectorValue[1];\n    }\n    \n    abstract function CartesianCurrentPositionOf :> CurrentPositionOf {\n        doc\n        /*\n         * The CurrentPositionOf a Point relative to a CartesianSpatialFrame is a CartesianThreeVectorValue.\n         */\n    \n        in point : Point[1];\n        in frame : CartesianSpatialFrame[1];\n        in clock : Clock[1] default frame.localClock;\n        return positionVector : CartesianThreeVectorValue[1];\n    }\n    \n    function CartesianDisplacementOf :> DisplacementOf {\n        doc\n        /*\n         * The DisplacementOf two Points relative to a CartesianSpatialFrame is a CartesianThreeVectorValue.\n         */\n    \n        in point1 : Point[1];\n        in point2 : Point[1];\n        in time : NumericalValue[1];\n        in frame : CartesianSpatialFrame[1];\n        in clock : Clock[1] default frame.localClock;\n        return displacementVector : CartesianThreeVectorValue[1];\n    }\n        \n    function CartesianCurrentDisplacementOf :> CurrentDisplacementOf {\n        doc\n        /*\n         * The CurrentDisplacementOf two Points relative to a CartesianSpatialFrame is a CartesianThreeVectorValue.\n         */\n    \n        in point1 : Point[1];\n        in point2 : Point[1];\n        in frame : CartesianSpatialFrame[1];\n        in clock : Clock[1] default frame.localClock;\n        return displacementVector : CartesianThreeVectorValue[1];\n    }\n\n}", "Kernel Libraries/Kernel Semantic Library/StatePerformances.kerml": "standard library package StatePerformances {\n	doc\n	/*\n	 * This package contains a library model of the semantics of state-based behavior,\n	 * including the performance of (behavioral) states and the transitions between them.\n	 */\n\n	private import ScalarValues::Boolean;\n	private import ScalarValues::Natural;\n	private import TransitionPerformances::TransitionPerformance;\n	private import Occurrences::Occurrence;\n	private import Occurrences::HappensDuring;\n	private import Transfers::Transfer;\n	private import Transfers::MessageTransfer;\n	private import Performances::Performance;\n	private import ControlPerformances::DecisionPerformance;\n	private import ControlFunctions::forAll;\n	private import ControlFunctions::select;\n	private import ControlFunctions::collect;\n	private import SequenceFunctions::*;\n	\n	behavior StatePerformance specializes DecisionPerformance {\n		feature isTriggerDuring: Boolean default true;\n\n		abstract step middle[1..*] {\n			doc\n			/*\n			 * All modeler-defined steps must subset this.\n			 */\n		}\n		\n		/* \n		 * Note: All steps are implicitly considered to be enclosedPerformances,\n		 * and hence happening during the state performance.\n		 */\n		\n		step entry[1];\n		step do[1] subsets middle;\n		step exit[1];\n		\n		step nonDoMiddle[*] subsets middle = middle->excluding(do);\n\n		private succession [1] entry then [*] middle;\n		private succession [1] do.startShot then [*] nonDoMiddle.startShot;\n		private succession [*] middle then [1] exit;\n\n\n		feature incomingTransitionTrigger : MessageTransfer [0..1] default null {\n			doc\n			/*\n			 * Transfer that triggered a transition into this state performance. \n			 */\n		}\n\n		private inv { isEmpty(accepted) == isEmpty(acceptable) }\n		feature accepted: Transfer[0..1] subsets acceptable {\n			doc\n			/* A transfer to the trigger target of an outgoing transition performance\n			 * for an outgoing successon that is taken for this state occurrence.\n			 */\n		}\n		feature deferrable: Transfer[0..*] subsets acceptable {\n			doc\n			/* Transfers to trigger targets of outgoing transition performances can be\n			 * considered for acceptance more than once.\n			 */\n		}\n		abstract feature acceptable: Transfer[*] {\n			doc\n			/*\n			 * Transfers that might be accepted. \n			 */\n			feature thatSP : StatePerformance [1] = that as StatePerformance;\n			feature accableT : Transfer redefines self;\n			feature accT : Transfer = thatSP.accepted;\n			inv { accableT == accT | incomingTransferSort(accT, accableT) }  \n			inv { isDispatch implies\n				     allSubstatePerformances(dispatchScope)->forAll{in oSP : StatePerformance;						\n						  oSP == thatSP | isEmpty(oSP.accepted) |\n	   					  includes(thatSP.exit.startShot.successors, oSP.exit.startShot) |\n						  ( oSP.accepted != accableT & \n							( incomingTransferSort(oSP.accepted, accableT) |\n							  includes(oSP.deferrable, accableT) ) ) } }\n		}\n		\n		function allSubstatePerformances {\n			in p : Performance [1];\n			feature substatePerformances: StatePerformance [*] =\n				p.subperformances->select{in subp:Performance; subp istype StatePerformance};\n			return  : StatePerformance [*] =\n				union(substatePerformances,  \n					  substatePerformances->collect{in sp:StatePerformance; allSubstatePerformances(sp) } );\n		}\n		\n		private succession [*] acceptable then [1] exit;\n		\n		feature redefines isRunToCompletion default this.isRunToCompletion;\n		feature redefines runToCompletionScope default this.runToCompletionScope; \n		inv { isRunToCompletion implies\n			     allSubtransitionPerformances(runToCompletionScope)->forAll{in tp : TransitionPerformance;\n				    includes(tp.successors, entry) | includes(tp.predecessors, entry) }\n		}\n		\n		function allSubtransitionPerformances {\n			in p : Performance [1];\n			feature subtransitionPerformances: TransitionPerformance [*] =\n	 			 p.subperformances->select{in subp:Performance;\n		 			   subp istype StateTransitionPerformance };\n			return  : TransitionPerformance [*] =\n				union(subtransitionPerformances,  \n		      		subtransitionPerformances->collect{in sp:TransitionPerformance; \n							 		allSubtransitionPerformances(sp) } ); \n 		}\n	}\n	\n	behavior StateTransitionPerformance specializes TransitionPerformance {\n		feature isTriggerDuring: Boolean[1];\n		inv { not transitionLinkSource.isTriggerDuring | isTriggerDuring  }\n\n		in feature transitionLinkSource: StatePerformance redefines TransitionPerformance::transitionLinkSource {\n			feature redefines accepted;\n			feature redefines StatePerformance::acceptable;\n		}\n		private succession [*] transitionLinkSource.nonDoMiddle then [1] Performance::self;\n\n		private feature transitionLinkTarget [0..1] : Occurrence = transitionLink.laterOccurrence {\n			inv { (that istype StatePerformance) implies\n			      (that as StatePerformance).incomingTransitionTrigger == trigger }\n		}\n		\n		feature acceptable: Transfer [*] subsets transitionLinkSource.acceptable, triggerTarget.incomingTransfersToSelf;\n\n		feature trigger redefines TransitionPerformance::trigger subsets acceptable, transitionLinkSource.accepted {\n			feature redefines endShot;\n		}\n		\n		private feature tdNum: Natural [1] = if not isTriggerDuring ? 0 else size(trigger);\n		private connector linkTriggerDuring: HappensDuring[tdNum] from [*] trigger.endShot to [0..1] transitionLinkSource;\n		\n		private succession all [*] acceptable then [*] guard;\n		private succession [*] guard then [1] transitionLinkSource.exit;\n\n		private succession [accNum] accept then [1] transitionLinkSource.exit;\n	}\n}", "Kernel Libraries/Kernel Semantic Library/Transfers.kerml": "standard library package Transfers {\n    doc\n    /*\n     * This package defines the transfer interactions used to type flows.\n     */\n\n    private import Base::Anything;\n    private import Occurrences::*;\n    private import Links::*;\n    private import Objects::BinaryLinkObject;\n    private import Performances::Performance;\n    private import Performances::performances;\n    private import ScalarValues::Boolean;\n    private import ScalarValues::Natural;\n    private import SequenceFunctions::*;\n    \n    interaction Transfer specializes Performance, BinaryLink {\n        doc\n        /*\n         * A Transfer represents the transfer of a payload from the source of the interaction \n         * to the target of the interaction.\n         */\n    \n        end feature source: Occurrence redefines BinaryLink::source {\n            doc\n            /*\n             * The entity whose output is the source of the payload to be transferred.\n             */\n        \n            feature sourceOutput: Anything[0..*];\n        }\n        \n        end feature target: Occurrence redefines BinaryLink::target {\n            doc\n            /*\n             * The entity whose input is the target of the payload to be transferred.\n             */\n        \n            feature targetInput: Anything[0..*];\n        }\n        \n        feature isInstant: Boolean[1] {\n            doc\n            /*\n             * If isInstance is true, then the transfer is instantaneous.\n             */\n        }\n        \n        feature payload: Anything[1..*] {\n            doc\n            /*\n             * The things that are to be transferred.\n             */\n        }\n        \n        feature payloadNum: Natural [1] = size(payload);\n        \n        private instantNum: Natural[1] = if isInstant? 1 else 0;\n        private binding instant[instantNum] of [0..1] startShot = [0..1] endShot {\n            doc\n            /*\n             * If isInstant is true, then the start and end of the transfer happen at the same time.\n             */\n        }\n    }\n    \n    interaction MessageTransfer specializes Transfer {\n        doc\n        /*\n         * A MessageTransfer is a Transfer that does not specify where the payload is picked\n         * up and dropped off (see FlowTransfer). They are sent by SendPerformances and\n         * accepted by AcceptPerformances.\n         */\n    }\n     \n    interaction FlowTransfer specializes Transfer disjoint from MessageTransfer {\n        doc\n        /*\n         * A FlowTransfer is a Transfer identifying an output feature of the source from which\n         * to pick up a payload and an input feature of the target to which to drop it off. They can\n         * start when the payload is available at the source and move or copy it to the target.\n         */\n         \n        feature isMove: Boolean[1] default true {\n            doc\n            /*\n             * If isMove is true, then the entire payload leaves the source at the start\n             * of the transfer.\n             */\n        }\n        \n        feature isPush: Boolean[1] default true {\n            doc\n            /*\n             * If isPush is true, then the transfer begins when the payload is available\n             * at the source.\n             */\n        }\n        \n        connector sourceOutputLink: BinaryLinkObject[payloadNum] {\n            doc\n            /*\n             * The output of the payloads from the sourceOutput.\n             */\n        \n            end [1] feature transferSource references source;\n            end [payloadNum] feature transferPayload references payload subsets transferSource.sourceOutput;\n        }\n        \n        connector targetInputLink: BinaryLinkObject[payloadNum] {\n            doc\n            /*\n             * The input of the payload to the targetInput.\n             */\n        \n            end [1] feature transferTarget references target;\n            end [payloadNum] feature transferPayload references payload subsets transferTarget.targetInput;\n        }\n        \n        private connector sending: HappensDuring[payloadNum] from [1] startShot to [payloadNum] sourceOutputLink {\n          doc\n            /*\n             * The start of the transfer happens during the output of each of the payloads from the\n             * source. \n             */\n        }\n        \n        private connector moving: HappensWhile[0..*] from [0..*] sourceOutputLink.endShot to [0..1] startShot {\n            doc\n            /*\n             * If isMove is true, then all payloads leave the source at the start\n             * of the transfer.\n             */\n        }\n        private inv { isMove implies size(moving) == size(sourceOutputLink) }\n        \n        private connector pushing: HappensWhile[0..*] from [0..*] sourceOutputLink.startShot to [0..1] startShot {\n            doc\n            /*\n             * If isPush is true, then the transfer begins when the payloads are available\n             * at the source.\n             */\n        }\n        private inv { isPush implies size(pushing) == size(sourceOutputLink) }\n        \n        private connector delivering: HappensWhile[payloadNum] from [payloadNum] targetInputLink.startShot to [1] endShot {\n            doc\n            /*\n             * The input of each of the payloads to the target starts at the end of the transfer.\n             */\n        }\n    }\n    \n    interaction TransferBefore specializes Transfer, HappensBefore intersects Transfer, HappensBefore {\n        doc\n        /*\n         * TransferBefore is a specialization of Transfer in which the source happens before\n         * the transfer, which happens before the target.\n         */\n    \n        end feature source: Occurrence redefines Transfer::source, HappensBefore::earlierOccurrence;\n        end feature target: Occurrence redefines Transfer::target, HappensBefore::laterOccurrence;\n        \n        feature self: TransferBefore redefines Performance::self;\n        \n        private succession source then self;\n        private succession self then target;\n    }\n    \n    interaction FlowTransferBefore specializes TransferBefore, FlowTransfer intersects FlowTransfer, TransferBefore {\n        doc\n        /*\n         * FlowTransferBefore is a FlowTransfer that is also a TransferBefore. \n         */\n         \n        end feature source: Occurrence redefines Transfer::source, TransferBefore::source;\n        end feature target: Occurrence redefines Transfer::target, TransferBefore::target;         \n    }\n    \n    abstract step transfers: Transfer[0..*] nonunique subsets performances, binaryLinks {\n        doc\n        /*\n         * transfers is a specialization of performances and binaryLinks restricted to type \n         * Transfer.\n         */\n    \n        end feature source: Occurrence redefines Transfer::source, binaryLinks::source;\n        end feature target: Occurrence redefines Transfer::target, binaryLinks::target;\n    }\n    \n    abstract step messageTransfers: MessageTransfer[0..*] nonunique subsets transfers {\n        doc\n        /*\n         * messageTransfers is a specialization of transfers restricted to type MessageTransfers.\n         */\n        \n        end feature source: Occurrence redefines MessageTransfer::source, transfers::source;\n        end feature target: Occurrence redefines MessageTransfer::target, transfers::target;      \n    }\n    \n    abstract flow flowTransfers: FlowTransfer[0..*] nonunique subsets transfers {\n        doc\n        /*\n         * flowTransfers is a specialization of transfers restricted to type FlowTransfers.\n         * It is the default subsetting for non-succession flows.\n         */\n         \n        end feature source: Occurrence redefines FlowTransfer::source, transfers::source;\n        end feature target: Occurrence redefines FlowTransfer::target, transfers::target;\n    }\n      \n    abstract flow transfersBefore: TransferBefore[0..*] nonunique subsets transfers, happensBeforeLinks\n        intersects transfers, happensBeforeLinks {\n        doc\n        /*\n         * transfersBefore is a specialization of transfers and happensBeforeLinks restricted to\n         * type TransferBefore.\n         */\n    \n        end feature source: Occurrence redefines TransferBefore::source, transfers::source, happensBeforeLinks::earlierOccurrence;\n        end feature target: Occurrence redefines TransferBefore::target, transfers::target, happensBeforeLinks::laterOccurrence;\n    }\n    \n    abstract flow flowTransfersBefore: FlowTransferBefore[0..*] nonunique subsets flowTransfers, transfersBefore\n        intersects flowTransfers, transfersBefore {\n        doc\n        /*\n         * flowTransfersBefore is a specialization of flowTransfers and transfersBefore that is restricted\n         * to type FlowTransferBefore. IT is the default subsetting for succession flows.\n         */\n    \n        end feature source: Occurrence redefines FlowTransferBefore::source, flowTransfers::source, transfersBefore::source;\n        end feature target: Occurrence redefines FlowTransferBefore::target, flowTransfers::target, transfersBefore::target;\n    }\n\n    behavior SendPerformance specializes Performance  {\n        doc\n        /*\n         * SendPerformances are Performance that require an outgoingTransferFromSelf \n         * from a designated sender Occurrence carrying a given payload, optionally to a designated receiver.\n         */\n    \n        in feature payload [0..*];\n        in feature sender: Occurrence[1] default this;\n        in feature receiver: Occurrence[0..1];\n        feature sentTransfer: MessageTransfer [1] subsets sender.outgoingTransfersFromSelf {\n            feature redefines payload = SendPerformance::payload;\n        }\n        binding [0..1] receiver.incomingTransfersToSelf = [1] sentTransfer;\n\n        succession self then sentTransfer;\n    }\n    \n    behavior AcceptPerformance specializes Performance {\n        doc\n        /*\n         * AcceptPerformance is a performance that requires an incomingTransferToSelf\n         * of a desigated receiver Occurrence, providing its payload as output.\n         */\n        inout feature payload[0..*];\n        in feature receiver: Occurrence[1] default this;\n        feature acceptedTransfer: MessageTransfer[1] subsets receiver.incomingTransfersToSelf;\n        succession acceptedTransfer then self.endShot;\n        \n        binding payload = acceptedTransfer.payload;\n    }\n\n    abstract step sendPerformances: SendPerformance[0..*] nonunique subsets performances {\n        doc\n        /*\n         * sendPerformances is a specialization of performances for SendPerformances.\n         */\n    }\n        \n    abstract step acceptPerformances: AcceptPerformance[0..*] nonunique subsets performances {\n        doc\n        /*\n         * acceptPerformances is a specialization of performances for AcceptPerformances.\n         */\n    }\n}", "Kernel Libraries/Kernel Semantic Library/TransitionPerformances.kerml": "standard library package TransitionPerformances {\n	doc\n	/*\n	 * This package contains a library model of the semantics of conditional transitions between occurrences, \n	 * including the performance of specified Behaviors when the transition occurs.\n	 */\n\n	private import ScalarValues::Boolean;\n	private import ScalarValues::Natural;\n	private import SequenceFunctions::isEmpty;\n	private import Occurrences::Occurrence;\n	private import Occurrences::HappensBefore;\n	private import Performances::Performance;\n	private import Performances::Evaluation;\n	private import Transfers::MessageTransfer;\n	private import Transfers::AcceptPerformance;\n	private import Transfers::acceptPerformances;\n	private import ControlFunctions::allTrue;\n	private import SequenceFunctions::size;\n	\n	abstract behavior TransitionPerformance {\n		in feature transitionLinkSource: Performance[1];\n		\n		feature trigger: MessageTransfer[*];\n		bool guard[*] subsets enclosedPerformances;\n		step effect[*] subsets enclosedPerformances;\n\n		feature triggerTarget : Occurrence [1] default this;\n		feature transitionLink: HappensBefore[0..1];\n		\n		private binding [0..1] transitionLink.earlierOccurrence = [1] transitionLinkSource;\n		private succession [1] transitionLinkSource then [*] effect;\n		private succession [*] effect then [1] transitionLink.laterOccurrence;\n		\n		private connector [0..1] transitionLink to [1..*] trigger;\n		private connector all guardConstraint: TPCGuardConstraint[*] \n			from [0..1] transitionLink to [*] guard;\n			\n		private succession all [*] trigger then [*] guard;\n		private succession all [*] guard then [*] effect;\n\n		feature accNum: Natural [1] = if isEmpty(trigger) ? 0 else 1;\n		step accept: AcceptPerformance[accNum] subsets timeEnclosedOccurrences, acceptPerformances {\n			feature redefines acceptedTransfer = trigger;\n		}\n        binding accept.receiver = triggerTarget;\n\n		private succession [*] guard then [accNum] accept;\n	}\n	\n	behavior NonStateTransitionPerformance specializes TransitionPerformance {\n		feature isTriggerAfter: Boolean default true;\n		private succession [1] transitionLinkSource then [1] Performance::self;\n		private feature taNum: Natural [1] = if isTriggerAfter ? size(trigger) else 0;\n		private succession triggerAfter [taNum] first [0..1] transitionLinkSource then [*] trigger.endShot;\n				\n		private succession all [*] guard then [0..1] transitionLink.laterOccurrence;\n	}\n	\n	assoc struct TPCGuardConstraint {\n		end guardedLink [0..1] feature constrainedHBLink: HappensBefore;\n		end bool constrainedGuard;\n		\n		private inv { allTrue(constrainedGuard()) }\n	}	\n}", "Kernel Libraries/Kernel Semantic Library/Triggers.kerml": "standard library package Triggers {\n	doc\n	/*\n	 * This package contains functions that return ChangeSignals for triggering\n	 * when a Boolean condition changes from false to true, at a specific time\n	 * or after a specific time delay.\n	 */\n\n	private import ScalarValues::Boolean;\n	private import ScalarValues::NumericalValue;\n	private import Occurrences::Occurrence;\n	\n	public import Clocks::*;\n	public import Observation::*;\n	\n	struct TimeSignal :> ChangeSignal {\n		doc\n		/*\n		 * A TimeSignal is a ChangeSignal whose condition is the currentTime\n		 * of a given Clock reaching a specific signalTime.\n		 */\n	\n		feature signalTime : NumericalValue[1] {\n			doc\n			/*\n			 * The time at which the TimeSignal should be sent.\n			 */\n		}\n		\n		feature signalClock : Clock[1] {\n			doc\n			/*\n			 * The Clock whose currentTime is being monitored.\n			 */\n		}\n		\n		private bool :>> signalCondition {\n			doc\n			/*\n			 * The Boolean condition of the currentTime of the signalClock being\n			 * equal to the signalTime.\n			 */\n		\n			signalClock.currentTime == signalTime\n		}\n	}\n	\n	function TriggerWhen {\n		doc\n		/*\n		 * TriggerWhen returns a monitored ChangeSignal for a given condition,\n		 * to be sent to a given receiver when the condition occurs.\n		 */\n	\n		in bool condition[1] {\n			doc\n			/*\n			 * The BooleanExpression to be monitored for changing from \n			 * false to true.\n		 */\n		}\n		\n		in feature receiver : Occurrence [1] {\n			doc\n			/*\n			 * The Occurrence to which the ChangeSignal is to be sent.\n			 */\n		}\n		\n		in feature monitor : ChangeMonitor[1] default defaultMonitor {\n			doc\n			/*\n			 * The ChangeMonitor to be used to monitor the ChangeSignal condition.\n			 * The default is the Observation::defaultMonitor.\n			 */\n		}\n		\n		return feature changeSignal : ChangeSignal[1] = new ChangeSignal(condition, monitor) {\n			doc\n			/*\n			 * The ChangeSignal for the condition, as monitored by the monitor.\n			 */\n		}\n		\n		step :> monitor.startObservation {\n			in observer = receiver;\n			in signal = changeSignal;\n		}		\n	}\n	\n	function TriggerAt {\n		doc\n		/*\n		 * TriggerAt returns a monitored TimeSignal to be sent to a receiver when\n		 * the currentTime of a given Clock reaches a specific timeInstant. \n		 */\n	\n		in feature timeInstant : NumericalValue[1] {\n			doc\n			/*\n			 * The time instant, relative to the clock, at which the TimeSignal should be sent. \n			 */\n		}\n		\n		in feature receiver : Occurrence[1] {\n			doc\n			/*\n			 * The Occurrence to which the TimeSignal is to be sent.\n			 */\n		}\n		\n		in feature clock : Clock[1] default localClock {\n			doc\n			/*\n			 * The Clock to be used as the reference for the timeInstant. The default is\n			 * the localClock, which will be bound when the function is invoked. \n			 */\n		}\n		\n		in feature monitor : ChangeMonitor[1] default defaultMonitor {\n			doc\n			/*\n			 * The ChangeMonitor to be used to monitor the TimeSignal condition.\n			 * The default is the Observation::defaultMonitor.\n			 */\n		}\n		\n		return feature timeSignal : TimeSignal[1] = new TimeSignal(timeInstant, clock, monitor) {\n			doc\n			/*\n			 * The TimeSignal for the given timeInstant, as monitored by the monitor.\n			 */\n		}\n		\n		step :> monitor.startObservation {\n			in observer = receiver;\n			in signal = timeSignal;\n		}\n	}\n	\n	function TriggerAfter {\n		doc\n		/*\n		 * TriggerAfter returns a monitored TimeSignal to be sent to a receiver after\n		 * a certain time delay relative to a given Clock.\n		 */\n	\n		in feature delay : NumericalValue[1] {\n			doc\n			/*\n			 * The time duration, relative to the clock, after which the TimeSignal is sent.\n			 */\n		}\n		\n		in feature receiver : Occurrence[1] {\n			doc\n			/*\n			 * The Occurrence to which the TimeSignal is to be sent.\n			 */\n		}\n		\n		in feature clock : Clock[1] default localClock {\n			doc\n			/*\n			 * The Clock to be used as the reference for the time delay. The default is\n			 * the localClock, which will be bound when the function is invoked. \n			 */\n		}\n		\n		in feature monitor : ChangeMonitor[1] default defaultMonitor {\n			doc\n			/*\n			 * The ChangeMonitor to be used to monitor the TimeSignal condition.\n			 * The default is the Observation::defaultMonitor.\n			 */\n		}\n		\n		return signal : TimeSignal[1] = \n			TriggerAt(clock.currentTime + delay, receiver, clock, monitor) {\n			doc\n			/*\n			 * The TimeSignal for the currentTime of the clock when the function is invoked\n			 * plus the given time delay, as monitored by the monitor.\n			 */\n		}\n	}	\n	\n}", "Systems Library/Actions.sysml": `standard library package Actions {
	doc
	/*
	 * This package defines the base types for actions and related behavioral elements in the
	 * SysML language.
	 */

	private import Base::Anything;
	private import ScalarValues::Positive;
	private import ScalarValues::Natural;
	private import SequenceFunctions::size;
	private import SequenceFunctions::isEmpty;
	private import Occurrences::Occurrence;
	private import Occurrences::HappensWhile;
	private import Performances::Performance;
	private import Performances::performances;
	private import Transfers::SendPerformance;
	private import Transfers::sendPerformances;
	private import Transfers::AcceptPerformance;
	private import Transfers::acceptPerformances;
	private import FeatureReferencingPerformances::FeatureWritePerformance;
	private import ControlPerformances::MergePerformance;
	private import ControlPerformances::DecisionPerformance;
	private import ControlPerformances::IfThenPerformance;
	private import ControlPerformances::IfThenElsePerformance;
	private import ControlPerformances::LoopPerformance;
	private import TransitionPerformances::TransitionPerformance;
	private import TransitionPerformances::NonStateTransitionPerformance;
	private import Transfers::MessageTransfer;
	private import Flows::MessageAction;
	private import OccurrenceFunctions::destroy;
	
	abstract action def Action :> Performance {
		doc
		/*
		 * Action is the most general class of Performances of ActionDefinitions in a system or 
		 * part of a system. Action is the base class of all ActionDefinitions.
		 */
	
		ref action self: Action :>> Performance::self;
		ref action incomingTransfers :>> Performance::incomingTransfers;
		
		action start: Action :>> startShot {
			doc
			/*
			 * The starting snapshot of an Action. 
			 */
		}
		
		action done: Action :>> endShot {
			doc
			/*
			 * The ending snapshot of an Action.
			 */
		}

		action subactions: Action[0..*] :> actions, subperformances {
			doc
			/*
			 * The subperformances of this Action that are Actions. 
			 */
		
			ref occurrence :>> Action::this, actions::this, subperformances::this = (that as Action).this {
				doc
				/*
				 * The "this" reference of a subaction is always the same as that of
				 * its owning Action.
				 */
			}
		}
	
		action sendSubactions: SendAction[0..*] :> subactions, sendActions {
			doc
			/*
			 * The subactions of this Action that are SendActions. 
			 */
		}
	
		action acceptSubactions: AcceptAction[0..*] :> subactions, acceptActions {
			doc
			/*
			 * The subactions of this Action that are AcceptActions. 
			 */
		}
		
		abstract action terminateSubactions : TerminateAction[0..*] :> subactions, terminateActions {
			doc
			/*
			 * The subactions of this Action that are TerminateActions.
			 */
		}
		
		abstract action controls : ControlAction[0..*] :> subactions {
			doc
			/*
			 * The subactions of this Action that are ControlActions.
			 */
		}
		
		abstract action merges : MergeAction[0..*] :> controls {
			doc
			/*
			 * The controls of this Action that are MergeActions.
			 */
		}
		
		abstract action decisions : DecisionAction :> controls {
			doc
			/*
			 * The controls of this Action that are DecisionActions.
			 */
		}
		
		abstract action joins : JoinAction :> controls {
			doc
			/*
			 * The controls of this Action that are JoinActions.
			 */
		}
		
		abstract action forks : ForkAction :> controls {
			doc
			/*
			 * The controls of this Action that are ForkActions.
			 */
		}
		
		abstract action transitions : TransitionAction[0..*] :> subactions, transitionActions {
			doc
			/*
			 * The subactions of this Action that are TransitionActions. 
			 */
		}
		
		abstract action decisionTransitions : DecisionTransitionAction[0..*] :> transitions {
			doc
			/*
			 * The subactions of this Action that are DecisionTransitionActions. 
			 */
		}
		
		abstract action assignments : AssignmentAction[0..*] :> subactions, assignmentActions {
			doc
			/*
			 * The subactions of this Action that are AssignmentActions.
			 */
			 
			 in target;
		}
		
		abstract action ifSubactions : IfThenAction[0..*] :> subactions, ifThenActions {
			doc
			/*
			 * The subactions of this Action that are IfThenActions (including IfThenElseActions).
			 */
		}
		
		abstract action loops : LoopAction[0..*] :> subactions, loopActions {
			doc
			/*
			 * The subactions of this Action that are LoopActions.
			 */
		}
		
		abstract action whileLoops : WhileLoopAction[0..*] :> loops, whileLoopActions {
			doc
			/*
			 * The loops of this Action that are WhileLoopActions.
			 */
		}
		
		abstract action forLoops : ForLoopAction[0..*] :> loops, forLoopActions {
			doc
			/*
			 * The loops of this Action that are ForLoopActions.
			 */
		}
	}
	
	abstract action actions: Action[0..*] nonunique :> performances {
		doc
		/*
		 * actions is the base feature for all ActionUsages.
		 */
	}
	
	action def SendAction :> Action, SendPerformance {
		doc
		/*
		 * A SendAction is an Action used to type SendActionUsages. It initiates an outgoingTransferFromSelf 
		 * from a designated sender Occurrence with a given payload, optionally to a designated receiver.
		 */
	
		in :>> payload [0..*];
	    ref sentMessage :>> sentTransfer: MessageTransfer, MessageAction {
	        in :>> MessageTransfer::payload, MessageAction::payload;
	    }
	}
	
	abstract action sendActions: SendAction[0..*] nonunique :> actions, sendPerformances {
		doc
		/*
		 * sendActions is the base feature for all SendActionUsages.
		 */
	}
	
	action def AcceptMessageAction :> Action, AcceptPerformance {
		doc
		/*
		 * An AcceptMessageAction is an Action that identifies an incomingTransferToSelf
		 * of a designated receiver Occurrence, providing its payload as output.
		 */
		inout :>> payload;
		ref acceptedMessage :>> acceptedTransfer: MessageTransfer, MessageAction {
            in :>> MessageTransfer::payload, MessageAction::payload;
        }
	}
	
	action def AcceptAction :> AcceptMessageAction {
		doc
		/*
		 * An AcceptAction is an AcceptMessageAction used to type AcceptActionUsages that are
		 * not accepters for TransitionActions. It waits for a payload or message of the specified 
		 * kind to be accepted by a nested state transition.
		 */
		ref :>> acceptedMessage = aState.aTransition.accepter.acceptedMessage;
		state aState  {
			transition aTransition first start accept apayload: Anything via receiver then done;
		}
		bind payload = aState.aTransition.apayload;
	}
	
	abstract action acceptActions: AcceptAction[0..*] nonunique :> actions, acceptPerformances {
		doc
		/*
		 * acceptActions is the base feature for standalone AcceptActionUsages.
		 */
	}
	
	abstract action def TerminateAction :> Action {
		doc
		/*
		 * A TerminateAction is an Action that terminates a given Occurrence, meaning 
		 * that the Occurrence ends during the performance of this Action. TerminateAction
		 * is the base type for all TerminateActionUsages.
		 */
		 
		in occurrence terminatedOccurrence[1] {
			doc
			/*
			 * The Occurrence to be terminated.
			 */
		}
		
		action terminateOccurrence : destroy[1] {
			in occ = terminatedOccurrence;
		}
	}
	
	abstract action terminateActions : TerminateAction[0..*] nonunique :> actions {
		doc
		/*
		 * terminateActions is the base feature for all TerminateActionUsages.
		 */
		 
		in occurrence terminatedOccurrence default that as Occurrence {
			doc
			/*
			 * The default terminatedOccurrence for a terminateAction is its
			 * featuring occurrence (which will generally be a containing Action).
			 */
		}
	}
	
	abstract action def ControlAction :> Action {
		doc
		/*
		 * A ControlAction is the Action of a control node, which has no inherent behavior.
		 */
	
		bind start = done {
			doc
			/*
			 * A ControlAction is instantaneous.
			 */
		}
	}
	
	action def MergeAction :> ControlAction, MergePerformance {
		doc
		/*
		 * A MergeAction is the ControlAction for a merge node.
		 * 
		 * Note: Incoming succession connectors to a MergeAction must have source multiplicity 
		 * 0..1 and subset the incomingHBLink feature inherited from MergePerformance.
		 */
	}
	
	action def DecisionAction :> ControlAction, DecisionPerformance {
		doc
		/*
		 * A DecisionAction is the ControlAction for a decision node.
		 * 
		 * Note: Outgoing succession connectors from a DecisionAction must have target multiplicity
		 * 0..1 and subset the outgoingHBLink feature inherited from DecisionPerformance.
		 * If an outgoing succession has a guard, it should have a transitionStep typed by 
		 * DecisionTransition.
		 */
	}
	
	action def JoinAction :> ControlAction {
		doc
		/*
		 * A JoinAction is the ControlAction for a JoinNode.
		 * 
		 * Note: Join behavior results from requiring that the source multiplicity of all
		 * incoming succession connectors be 1..1.
		 */
	}
	
	action def ForkAction :> ControlAction {
		doc
		/*
		 * A ForkAction is the ControlAction for a ForkNode.
		 * 
		 * Note: Fork behavior results from requiring that the target multiplicity of all
		 * outgoing succession connectors be 1..1.
		 */
	}
	
	abstract action def TransitionAction :> Action, TransitionPerformance {
		doc
		/*
		 * A TransitionAction is a TransitionPerformance with an Action as transitionLinkSource.
		 * It is the base type of all TransitionUsages.
		 */
	
		in transitionLinkSource : Action :>> TransitionPerformance::transitionLinkSource;
		ref acceptedMessage : MessageTransfer, MessageAction :>> trigger {
            in :>> MessageTransfer::payload, MessageAction::payload;
        }
		
		ref receiver :>> triggerTarget;

		action accepter : AcceptMessageAction :>> 'accept';
		
		bind receiver = accepter.receiver;
		bind acceptedMessage = accepter.acceptedMessage;
		
		action effect: Action :>> TransitionPerformance::effect;		
	}
	
	action def DecisionTransitionAction :> TransitionAction, NonStateTransitionPerformance {
		doc
		/*
		 * A DecisionTransitionAction is a TransitionAction and NonStateTransitionPerformance that has a 
		 * guard, but no trigger or effects. It is the base type of TransitionUsages used as 
		 * conditional successions in action models.
		 */
	
		ref action :>> accepter[0..0];
		ref action :>> effect[0..0];
	}

	abstract action transitionActions: TransitionAction[0..*] nonunique :> actions {
		doc
		/*
		 * transitionActions is the base feature for all TransitionUsages.
		 */
	}
	
	action def AssignmentAction :> FeatureWritePerformance, Action {
		doc
		/*
		 * An AssignmentAction is an Action, used to type an AssignmentActionUsage. It is also a
		 * FeatureWritePerformance that updates the accessedFeature of its target Occurrence with
		 * the given replacementValues.
		 */
	
		in target : Occurrence[1];
		inout replacementValues : Anything[0..*] nonunique;
	}
	
	abstract action assignmentActions : AssignmentAction[0..*] nonunique :> actions {
		doc
		/*
		 * assignmentActions is the base feature for all AssignmentActionsUsages.
		 */
		 
        in target : Occurrence[1] default that as Occurrence {
            doc
            /*
             * The default target for assignmentActions is its featuring instance (if that is 
             * an Occurrence).
             */
        }
	}
	
	action def IfThenAction :> Action, IfThenPerformance {
		doc
		/*
		 * An IfThenAction is a Kernel IfThenPerformance that is also an Action. 
		 * It is the base type for all IfActionUsages.
		 */
	
		in ifTest[1];
		in action thenClause[0..1];
	}
	
	action def IfThenElseAction :> IfThenAction, IfThenElsePerformance {
		doc
		/*
		 * An IfThenElseAction is a Kernel IfThenElsePeformance that is also an IfThenAction. 
		 * It is the base type for all IfActionUsages that have an elseAction.
		 */
	
		in ifTest[1];
		in action thenClause[0..1];
		in action elseClause[0..1];
	}
	
	abstract action ifThenActions : IfThenAction[0..*] nonunique :> actions {
		doc
		/*
		 * ifThenActions is the base feature for all IfActionUsages.
		 */
	}
	
	abstract action ifThenElseActions : IfThenElseAction[0..*] nonunique :> actions {
		doc
		/*
		 * ifThenElseActions is the base feature for all IfActionUsages that have an elseAction.
		 */
	}
	
	abstract action def LoopAction :> Action {
		doc
		/*
		 * A LoopAction is the base type for all LoopActionUsages.
		 */
	
        in ref iterator;
		
		in action body[0..*] {
			doc
			/*
			 * The action that is performed repeatedly in the loop.
			 */
		}		
	}
	
	action def WhileLoopAction :> LoopAction, LoopPerformance {
		doc
		/*
		 * A WhileLoopAction is a Kernel LoopPerformance that is also a LoopAction.
		 * It is the base type for all WhileLoopActionUsages.
		 */
	
		in whileTest default {true} {
			doc
			/*
			 * A Boolean expression that must be true for the loop to continue.
			 * It is evaluated before the body is performed and is always evaluated at 
			 * least once.
			 */
		}
		
		in action body {
			doc
			/*
			 * The action that is performed while the whileTest is true and the
			 * untilTest is false.
			 */
		}
		
		in untilTest default {false} {
			doc
			/*
			 * A Boolean expression that must be false for the loop to continue.
			 * It is evaluated after the body is performed.
			 */
		}
	}
	
	action def ForLoopAction :> LoopAction {
		doc
		/*
		 * A ForLoopAction is a LoopAction that iterates over an ordered sequence of values.
		 * It is the base type for all ForLoopActionUsages.
		 */
	
		protected ref var[0..1] :> seq {
			doc
			/*
			 * The loop variable that is assigned successive elements of seq on each
			 * iteration of the loop.
			 */
		}
		
		in ref seq {
			doc
			/*
			 * The sequence of values over which the loop iterates.
			 */
		}
		
		in action body {
			doc
			/*
			 * The action that is performed on each iteration of the loop.
			 */
		}
		
		private attribute index : Positive {
			doc
			/*
			 * The index of the element of seq assigned to var on the current iteration
			 * of the loop.
			 */
		}
		
		private action initialization
			assign index := 1;
		then private action whileLoop
			while index <= size(seq) {
				assign var := seq#(index);
				then perform body;
				then assign index := index + 1;
			}
	}
	
	abstract action loopActions : LoopAction[0..*] nonunique :> actions {
		doc
		/*
		 * loopActions is the base feature for all LoopActionUsages.
		 */
	}
	
	abstract action whileLoopActions : WhileLoopAction[0..*] nonunique :> loopActions {
		doc
		/*
		 * whileLoopActions is the base feature for all WhileLoopActionUsages.
		 */
	}
	
	abstract action forLoopActions : ForLoopAction[0..*] nonunique :> loopActions {
		doc
		/*
		 * forLoopActions is the base feature for all ForLoopActionUsages.
		 */
	}
}`, "Systems Library/Allocations.sysml": "standard library package Allocations {\n	doc\n	/*\n	 * This package defines the base types for allocations and related structural elements\n	 * in the SysML language.\n	 */\n\n	private import Base::Anything;\n	private import Connections::*;\n\n	allocation def Allocation :> BinaryConnection {\n		doc\n		/*\n		 * Allocation is the most general class of allocation, represented as a connection \n		 * between the source of the allocation and the target. Allocation is the base type \n		 * of all AllocationDefinitions.\n		 */\n	\n		end source: Anything :>> BinaryConnection::source;\n		end target: Anything :>> BinaryConnection::target;\n	}\n	\n	abstract allocation allocations: Allocation[0..*] nonunique :> binaryConnections {\n		doc\n		/*\n		 * allocations is the base feature of all AllocationUsages.\n		 */\n	}\n}", "Systems Library/AnalysisCases.sysml": "standard library package AnalysisCases {\n	doc\n	/*\n	 * This package defines the base types for analysis cases and related behavioral elements \n	 * in the SysML language.\n	 */\n\n	private import Performances::Evaluation;\n	private import Performances::evaluations;\n	private import Calculations::Calculation;\n	private import Cases::Case;\n	private import Cases::cases;\n	\n	abstract analysis def AnalysisCase :> Case {\n		doc\n		/*\n		 * AnalysisCase is the most general class of performances of AnalysisCaseDefinitions. \n		 * AnalysisCase is the base class of all AnalysisCaseDefinitions.\n		 */\n	\n		ref analysis self : AnalysisCase :>> Case::self;		\n		subject subj :>> Case::subj;\n		\n		abstract analysis subAnalysisCases : AnalysisCase[0..*] :> analysisCases, subcases {\n			doc\n			/*\n			 * Other AnalysisCases carried out as part of the performance of this AnalysisCase.\n			 */\n		}\n	}\n	\n	abstract analysis analysisCases : AnalysisCase[0..*] nonunique :> cases {\n		doc\n		/*\n		 * analysisCases is the base feature of all AnalysisCaseUsages.\n		 */\n	}\n}", "Systems Library/Attributes.sysml": "standard library package Attributes {\ndoc\n/*\n * This package defines the base types for attributes and related structural elements \n * in the SysML language.\n */\n\n	private import Base::DataValue;\n	private import Base::dataValues;\n\n	alias AttributeValue for DataValue {\n		doc\n		/*\n		 * AttributeValue is the most general type of data values that represent qualities or characteristics \n		 * of a system or part of a system. AttributeValue is the base type of all AttributeDefinitions.\n		 */\n	}\n			\n	alias attributeValues for dataValues {\n		doc\n		/*\n		 * attributeValues is the base feature for all AttributeUsages.\n		 */\n	}		\n}", "Systems Library/Calculations.sysml": "standard library package Calculations {\n	doc\n	/*\n	 * This package defines the base types for calculations and related behavioral elements in the\n	 * SysML language.\n	 */\n\n	private import Performances::Evaluation;\n	private import Performances::evaluations;\n	private import Actions::Action;\n	private import Actions::actions;\n	\n	abstract calc def Calculation :> Action, Evaluation {\n		doc\n		/*\n		 * Calculation is the most general class of evaluations of CalculationDefinitions in a\n		 * system or part of a system. Calculation is the base class of all CalculationDefinitions.\n		 */\n	\n		ref calc self: Calculation :>> Action::self, Evaluation::self;\n		\n		abstract calc subcalculations: Calculation :> calculations, subactions {\n			doc\n			/*\n			 * The subactions of this Calculation that are Calculations.\n			 */\n		}\n		\n	}\n	\n	abstract calc calculations: Calculation[0..*] nonunique :> actions, evaluations {\n		doc\n		/*\n		 * calculations is the base Feature for all CalculationUsages.\n		 */\n	}\n}", "Systems Library/Cases.sysml": "standard library package Cases {\n	doc\n	/*\n	 * This package defines the base types for cases and related behavioral elements \n	 * in the SysML language.\n	 */\n\n	private import Base::Anything;\n	private import Requirements::RequirementCheck;\n	private import Calculations::Calculation;\n	private import Calculations::calculations;\n	private import Parts::Part;\n	private import Parts::parts;\n	\n	abstract case def Case :> Calculation {\n		doc\n		/*\n		 * Case is the most general class of performances of CaseDefinitions. \n		 * Case is the base class of all CaseDefinitions.\n		 */\n	\n		ref case self : Case :>> Calculation::self;\n		\n		subject subj : Anything[1] {\n			doc\n			/*\n			 * The subject that was investigated by this Case.\n			 */\n		}\n		\n		ref part actors : Part[0..*] :> parts {\n			doc\n			/*\n			 * The Parts that fill the role of actors for this Case.\n			 * (Note: This is not itself an actor parameter, because specific actor\n			 * parameters will be added for specific Cases.)\n			 */\n		}\n		\n		objective obj : RequirementCheck[1] {\n			doc\n			/*\n			 * A check of whether the objective RequirementUsage was satisfied for this Case.\n			 */\n		\n			subject subj default Case::result;\n		}\n		\n		return ref result[0..*] {\n			doc\n			/*\n			 * The result determined by the case, which should satisfy the case objective.\n			 */\n		}\n		\n		abstract case subcases : Case[0..*] :> cases, subcalculations {\n			doc\n			/*\n			 * Other Cases carried out as part of the performance of this Case.\n			 */\n		}\n	\n	}\n	\n	abstract case cases : Case[0..*] nonunique :> calculations {\n		doc\n		/*\n		 * cases is the base Feature of all CaseUsages.\n		 */\n	}\n}", "Systems Library/Connections.sysml": "standard library package Connections {\n    doc\n    /*\n     * This package defines the base types for connections and related structural elements \n     * in the SysML language.\n     */\n\n    private import Base::Anything;\n    private import Occurrences::Occurrence;\n    private import Occurrences::HappensDuring;\n    private import Objects::LinkObject;\n    private import Objects::linkObjects;\n    private import Objects::BinaryLinkObject;\n    private import Objects::binaryLinkObjects;\n    private import Transfers::Transfer;\n    private import Transfers::transfers;\n    private import Transfers::FlowTransfer;\n    private import Transfers::flowTransfers;\n    private import Transfers::FlowTransferBefore;\n    private import Transfers::flowTransfersBefore;\n    private import ScalarValues::Natural;\n    private import Parts::Part;\n    private import Parts::parts;\n    private import Actions::Action;\n    private import Actions::actions;\n\n    abstract connection def Connection :> LinkObject, Part {\n        doc\n        /*\n         * Connection is the most general class of links between things within some \n         * containing structure. Connection is the base type of all ConnectionDefinitions.\n         */\n    }\n     \n    abstract connection def BinaryConnection :> BinaryLinkObject, Connection {\n        doc\n        /*\n         * BinaryConnection is the most general class of binary links between two things \n         * within some containing structure. BinaryConnection is the base type of all \n         * ConnectionDefinitions with exactly two ends.\n         */\n    \n        end source: Anything :>> BinaryLinkObject::source;\n        end target: Anything :>> BinaryLinkObject::target;\n    }\n    \n    abstract connection connections: Connection[0..*] nonunique :> linkObjects, parts {\n        doc\n        /*\n         * connections is the base feature of all ConnectionUsages.\n         */\n    }\n    \n    abstract connection binaryConnections: Connection[0..*] nonunique :> connections, binaryLinkObjects {\n        doc\n        /*\n         * binaryConnections is the base feature of all binary ConnectionUsages.\n         */\n    }\n}", "Systems Library/Constraints.sysml": "standard library package Constraints {\n	doc\n	/*\n	 * This package defines the base types for constraints and related elements in the\n	 * SysML language.\n	 */\n\n	private import Performances::BooleanEvaluation;\n	private import Performances::booleanEvaluations;\n	private import Performances::trueEvaluations;\n	private import Performances::falseEvaluations;\n	\n	abstract constraint def ConstraintCheck :> BooleanEvaluation {\n		doc\n		/*\n		 * ConstraintCheck is the most general class for constraint checking. ConstraintCheck is the base\n		 * type of all ConstraintDefinitions.\n		 */\n	\n		ref constraint self: ConstraintCheck :>> BooleanEvaluation::self;\n	}\n	\n	abstract constraint constraintChecks: ConstraintCheck[0..*] nonunique :> booleanEvaluations {\n		doc\n		/*\n		 * constraintChecks is the base feature of all ConstraintUsages.\n		 */\n	}\n	\n	abstract constraint assertedConstraintChecks :> constraintChecks, trueEvaluations {\n		doc\n		/*\n		 * assertedConstraintChecks is the subset of constraintChecks for ConstraintChecks asserted to be true.\n		 */\n	}\n		\n	abstract constraint negatedConstraintChecks :> constraintChecks, falseEvaluations {\n		doc\n		/*\n		 * negatedConstraintChecks is the subset of constraintChecks for ConstraintChecks asserted to be false.\n		 */\n	}\n		\n}", "Systems Library/Flows.sysml": "standard library package Flows {\n    doc\n    /*\n     * This package defines the base types for flows and related behavioral elements \n     * in the SysML language.\n     */\n\n    private import Links::Link;\n    private import Occurrences::Occurrence;\n    private import Occurrences::HappensDuring;\n    private import Objects::binaryLinkObjects;\n    private import Transfers::Transfer;\n    private import Transfers::transfers;\n    private import Transfers::FlowTransfer;\n    private import Transfers::flowTransfers;\n    private import Transfers::FlowTransferBefore;\n    private import Transfers::flowTransfersBefore;\n    private import Actions::Action;\n    private import Actions::actions;\n    private import ScalarValues::Natural;\n    \n    abstract flow def MessageAction :> Action, Link {\n        doc\n        /*\n         * MessageAction is the most general class of actions that represent\n         * interactions between linked things. It is the base type of all\n         * FlowDefinitions.\n         */\n         \n         ref payload [0..*] {\n         	doc\n         	/*\n         	 * A payload that may be transferred during the interaction.\n         	 */\n         }\n    }\n\n    abstract flow def Message :> MessageAction, Transfer {\n        doc\n        /*\n         * Message is the subclass of message connections that represent \n         * a transfer of objects or values between two occurrences. It is \n         * the base type of all FlowUsages.\n         */\n        \n        ref payload :>> MessageAction::payload, Transfer::payload;\n        \n        private ref action thisConnection = self;\n        \n        in event occurrence sourceEvent [1] default thisConnection.start {\n            doc\n            /* \n             * An occurrence happening during the source of this message\n             * that is either the start of the mssage or happens before it.\n             */\n        }\n        in event occurrence targetEvent [1] default thisConnection.done {\n            doc\n            /* \n             * An occurrence happening during the target of this message\n             * that is either the end of the message or happens after it.\n             */\n        }\n        \n        connection :HappensDuring connect sourceEvent to [1] source;\n        connection :HappensDuring connect targetEvent to [1] target;\n        \n        private attribute seBeforeNum: Natural[1] = if sourceEvent==thisConnection.start ? 0 else 1;\n        private attribute teAfterNum: Natural[1] = if targetEvent==thisConnection.done ? 0 else 1;\n        succession [seBeforeNum] first [0..1] sourceEvent then [0..1] self;\n        succession [teAfterNum] first [0..1] self then [0..1] targetEvent;\n    }\n    \n    abstract flow def Flow :> Message, FlowTransfer {\n        doc\n        /*\n         * Flow is a subclass of messages that are also flow transfers.\n         * It is the base type for FlowUsages that identify their source output and\n         * target input.\n         */\n         \n        end occurrence source: Occurrence :>> Message::source, FlowTransfer::source;\n        end occurrence target: Occurrence :>> Message::target, FlowTransfer::target;\n    }\n    \n    abstract flow def SuccessionFlow :> Flow, FlowTransferBefore {\n        doc\n        /*\n         * SuccessionFlow is a subclass of flowss that appen after their source and \n         * before their target. It is the base type for all SuccessionFlowUsages.\n         */\n         \n        ref self : SuccessionFlow :>> Flow::self, FlowTransferBefore::self;\n    \n        end occurrence source: Occurrence :>> Flow::source, FlowTransferBefore::source;\n        end occurrence target: Occurrence :>> Flow::target, FlowTransferBefore::target;\n    }\n    \n    abstract message messages: Message[0..*] nonunique :> transfers, actions {\n        doc\n        /*\n         * messages is the base feature of all FlowUsages.\n         */\n    }\n    \n    abstract flow flows: Flow[0..*] nonunique :> messages, flowTransfers {\n        doc\n        /*\n         * flows is the base feature for FlowUsages that identify their source output\n         * and target input.\n         */\n    \n        end occurrence source: Occurrence :>> Flow::source, messages::source, flowTransfers::source;\n        end occurrence target: Occurrence :>> Flow::target, messages::target, flowTransfers::target;\n    }\n    \n    abstract flow successionFlows: SuccessionFlow[0..*] nonunique :> flows, flowTransfersBefore {\n        doc\n        /*\n         * successionFlows is the base feature of all SuccessionFlowUsages.\n         */\n    \n        end occurrence source: Occurrence :>> SuccessionFlow::source, flows::source, flowTransfersBefore::source;\n        end occurrence target: Occurrence :>> SuccessionFlow::target, flows::target, flowTransfersBefore::target;\n    }\n}", "Systems Library/Interfaces.sysml": "standard library package Interfaces {\n    doc\n    /*\n     * This package defines the base types for interfaces and related structural elements in the SysML language.\n     */\n     \n    private import Connections::Connection;\n    private import Connections::connections;\n    private import Connections::BinaryConnection;\n    private import Connections::binaryConnections;\n    private import Ports::Port;\n    \n    private import ScalarValues::Natural;\n    private import SequenceFunctions::size;\n    private import SequenceFunctions::excludingAt;\n    private import ControlFunctions::selectOne;\n    \n    private import SequenceFunctions::notEmpty;\n    \n    private calc def excludingOnce {\n        doc\n        /*\n         * Return a sequence that is the same as the input sequence, but with a single\n         * instance of a given value removed. The given value must be in the input sequence.\n         */\n        in seq[1..*] nonunique ordered; \n        in value[1] :> seq;\n        \n        private attribute position : Natural[1] = (1..size(seq))->selectOne{in i; seq#(i) == value};\n        seq->excludingAt(position)\n    }\n    \n    abstract interface def Interface :> Connection {\n        doc\n        /*\n         * Interface is the most general class of links between Ports on Parts \n         * within some containing structure. Interface is the base type of all\n         * InterfaceDefinitions. \n         * \n         * Transfers outgoing from any one of the participant Ports of an Interface \n         * may be targeted to one of the other participant Ports (depending on any \n         * other Interfaces in which the Port is also participating).\n         */\n         \n        ref port :>> participant : Port [2..*] nonunique ordered {\n            doc\n            /*\n             * The participants of an Interface must be Ports. The interfacingPorts of\n             * each participant Port include all the other participants in the Interface.\n             */\n              \n            protected ref thisParticipant :>> self;\n            protected ref otherParticipants : Port [1..*] nonunique :> interfacingPorts\n                default participant->excludingOnce(thisParticipant);            \n        }\n    }\n    \n    abstract interface def BinaryInterface :> Interface, BinaryConnection {\n        doc\n        /*\n         * BinaryInterface is the most general class of links between two Ports \n         * on Parts within some containing structure. BinaryInterface is the base \n         * type of all binary InterfaceDefinitions which have exactly two ends. \n         * \n         * Transfers outgoing from each participant Port of a BinaryInterface may be \n         * targeted to the other participant Port (depending on any other Interfaces \n         * in which the Port is also participating).\n         */\n        \n        ref port :>> Interface::participant, BinaryConnection::participant[2] nonunique ordered;\n     \n        end port source: Port :>> BinaryConnection::source; \n        end port target: Port :>> BinaryConnection::target;\n    }\n    \n    abstract interface interfaces: Interface[0..*] nonunique :> connections {\n        doc\n        /*\n         * interfaces is the base feature of all InterfaceUsages.\n         */\n    }\n    \n    abstract interface binaryInterfaces: BinaryInterface[0..*] nonunique :> interfaces, binaryConnections {\n        doc\n        /*\n         * interfaces is the base feature of all binary InterfaceUsages.\n         */\n    }\n}", "Systems Library/Items.sysml": "standard library package Items {\n	doc\n	/*\n	 * This package defines the base types for items and related structural elements in the\n	 * SysML language.\n	 */\n\n	private import Objects::Object;\n	private import Objects::objects;\n	private import Parts::Part;\n	private import Parts::parts;\n	private import Occurrences::HappensWhile;\n	private import Occurrences::JustOutsideOf;\n	private import Objects::StructuredSpaceObject;\n	private import Constraints::ConstraintCheck;\n	private import Constraints::constraintChecks;\n	private import CollectionFunctions::contains;\n	private import SequenceFunctions::isEmpty;\n	private import SequenceFunctions::notEmpty;\n	private import SequenceFunctions::includes;\n	private import SequenceFunctions::union;\n	private import ControlFunctions::forAll;\n	\n	abstract item def Item :> Object {\n		doc\n		/*\n		 * Item is the most general class of objects that are part of, exist in or flow through a system. \n		 * Item is the base type of all ItemDefinitions.\n		 */\n	\n		ref self: Item :>> Object::self;\n		\n		item start: Item :>> startShot;\n		item done: Item :>> endShot;\n		\n		item shape : Item :>> spaceBoundary {\n		doc\n			/*\n			 * The shape of an Item is its spatial boundary.\n			 */\n		}\n		\n		item envelopingShapes : Item[0..*] {\n            doc\n			/*\n			 * Each enveloping shape is the shape of an Item that spacially overlaps this Item for its\n			 * entire lifetime.\n			 */\n			 \n			ref item envelopedItem :>> that;	\n\n			assert constraint { \n                doc\n                /* \n                 * Enables two dimensional items to be enveloped by two or three dimensional shapes.\n                 */             \n			    innerSpaceDimension == \n    				(if envelopedItem.innerSpaceDimension == 3  | envelopedItem.outerSpaceDimension == 3? 2 \n    				else envelopedItem.outerSpaceDimension - 1)\n			}\n			assert constraint { (that as Item).innerSpaceDimension < 3 implies notEmpty(outerSpaceDimension) }\n\n			item envelopingItem [1];\n\n			assert constraint {\n				doc\n				/* \n				 * This constraint prevents an envelopingShape from being a portion.\n				 */\n				 \n				envelopingItem.shape.spaceTimeCoincidentOccurrences->includes(that) and\n				envelopingItem.spaceTimeEnclosedOccurrences->includes(that.that) \n			}\n		}\n		\n		item boundingShapes : StructuredSpaceObject [0..*] :> envelopingShapes {\n            doc\n			/*\n			 * envelopingShapes that are structured space objects with every face or every edge\n			 * intersecting this Item.\n			 */		\n            \n			ref item boundingShape: Item :>> self;\n\n			private item :>> faces {\n				ref item face :>> self;\n				item inter [1];\n				assert constraint { contains(inter.intersectionsOf, union(face, boundingShape)) }\n			}\n			private item :>> edges {\n				ref item edge :>> self;\n				item inter [1];\n				assert constraint { isEmpty(faces) implies\n							contains(inter.intersectionsOf, union(edge, boundingShape)) }\n			}\n		}\n\n		item voids :>> innerSpaceOccurrences [0..*] {\n			doc\n			/*\n			 * Voids are inner space occurrences of this Item.\n			 */\n		}\n\n		attribute isSolid = isEmpty(voids) {\n			doc\n			/*\n			 * An Item is solid if it has no voids.\n			 */\n		}\n		\n		abstract item subitems: Item[0..*] :> items, subobjects {\n			doc\n			/*\n			 * The Items that are composite subitems of this Item.\n			 */\n			 \n			private ref redefines Item::incomingTransferSort, subobjects::incomingTransferSort;\n		}\n		\n		abstract part subparts: Part[0..*] :> subitems, parts {\n			doc\n			/*\n			 * The subitems of this Item that are Parts.\n			 */\n		}\n		\n		abstract constraint checkedConstraints: ConstraintCheck[0..*] :> constraintChecks, ownedPerformances {\n			doc\n			/*\n			 * Constraints that have been checked by this Item.\n			 */\n		}\n	}\n	\n	connection def Touches :> JustOutsideOf, HappensWhile {\n		doc\n		/*\n		 * Touching items are just outside each other and happen at the same time.\n		 */\n	\n		end touchesToo [0..*] item touchedItemToo :>> separateSpaceToo, thisOccurrence;\n		end touches [0..*] item touchedItem :>> separateSpace, thatOccurrence;\n	}\n\n	abstract item items : Item[0..*] nonunique :> objects {\n		doc\n		/*\n		 * items is the base feature of all ItemUsages.\n		 */\n	}\n	\n}", "Systems Library/Metadata.sysml": "standard library package Metadata {\ndoc\n/*\n * This package defines the base types for metadata definitions and related \n * metadata annotations in the SysML language.\n */\n\n	private import Metaobjects::Metaobject;\n	private import Metaobjects::metaobjects;\n	private import Items::Item;\n	private import Items::items;\n	\n	abstract metadata def MetadataItem :> Metaobject, Item {\n		doc\n		/*\n		 * MetadataItem is the most general class of Items that represent Metaobjects. \n		 * MetadataItem is the base type of all MetadataDefinitions.\n		 */\n		 \n		 ref self : MetadataItem redefines Metaobject::self, Item::self;\n	}\n	\n	abstract item metadataItems : MetadataItem[0..*] :> metaobjects, items {\n		doc\n		/*\n		 * metadataItems is the base feature of all MetadataUsages.\n		 * \n		 * Note: It is not itself a MetadataUsage, because it is not being used as an\n		 * AnnotatingElement here.\n		 */\n	}\n}", "Systems Library/Parts.sysml": 'standard library package Parts {\ndoc\n/*\n * This package defines the base types for parts and related structural elements in the\n * SysML language.\n */\n\n	private import Objects::Object;\n	private import Objects::objects;\n	private import Items::Item;\n	private import Items::items;\n	private import Ports::Port;\n	private import Ports::ports;\n	private import Actions::Action;\n	private import Actions::actions;\n	private import States::StateAction;\n	private import States::stateActions;\n	\n	abstract part def Part :> Item {\n		doc\n		/*\n		 * Part is the most general class of objects that represent all or a part of a system.\n		 * Part is the base type of all PartDefinitions.\n		 */\n	\n		ref self: Part :>> Item::self;\n		\n		part start: Part :>> Item::start;\n		part done: Part :>> Item::done;\n		\n		abstract port ownedPorts: Port[0..*] :> ports, timeEnclosedOccurrences {\n			doc\n			/*\n			 * Ports that are owned by this Part.\n			 */\n		}\n		\n		abstract ref action performedActions: Action[0..*] :> actions, enactedPerformances {\n			doc\n			/*\n			 * Actions that are performed by this Part.\n			 */\n		}\n		\n		abstract action ownedActions: Action[0..*] :> actions, ownedPerformances {\n			doc\n			/*\n			 * Actions that are owned by this Part.\n			 */\n		\n		 	ref part this : Part :>> Action::this, ownedPerformances::this = that as Part {\n				doc\n				/*\n				 * The "this" reference of an ownedAction is always its owning Part.\n				 */\n			}\n		}\n		\n		abstract ref state exhibitedStates: StateAction[0..*] :> stateActions, performedActions {\n			doc\n			/*\n			 * StateActions that are exhibited by this Part.\n			 */\n		}\n		\n		abstract state ownedStates: StateAction[0..*] :> stateActions, ownedActions {\n			doc\n			/*\n			 * StateActions that are owned by this Part.\n			 */\n		}\n	}\n	\n	abstract part parts: Part[0..*] nonunique :> items {\n		doc\n		/*\n		 * parts is the base feature of all part properties.\n		 */\n	}\n	\n}', "Systems Library/Ports.sysml": "standard library package Ports {\n    doc\n    /*\n     * This package defines the base types for ports and related structural elements \n     * in the SysML language.\n     */\n\n    private import Objects::Object;\n    private import Objects::objects;\n    \n    abstract port def Port :> Object {\n        doc\n        /*\n         * Port is the most general class of objects that represent connection points\n         * for interacting with a Part. Port is the base type of all PortDefinitions.\n         * \n         * Transfers outgoing from a Port are always targeted to a Port connected to\n         * the original Port by an Interface.\n         */\n    \n        ref self: Port :>> Object::self;\n        \n        port subports: Port [0..*] :> ports, timeEnclosedOccurrences {\n            doc\n            /*\n             * The Ports that are subports of this Port.\n             */\n        }\n        \n        abstract ref port interfacingPorts : Port[0..*] nonunique :> ports {\n            doc\n            /*\n             * Ports that are connected to this Port by an Interface.\n             */\n        }\n        \n        ref :>> outgoingTransfersFromSelf :> interfacingPorts.incomingTransfersToSelf {\n            doc\n            /* \n             * The target of each of the outgoingTransfersFromSelf of a Port must be an interfacingPort.\n             */\n             \n             end ref source;\n             end ref target;\n        }\n    }\n    \n    abstract port ports : Port[0..*] nonunique :> objects {\n        doc\n        /*\n         * ports is the base feature of all PortUsages.\n         */\n    }\n}", "Systems Library/Requirements.sysml": "standard library package Requirements {\n	doc\n	/*\n	 * This package defines the base types for requirements and related elements in the SysML language.\n	 */\n\n	private import Base::Anything;\n	private import ScalarValues::String;\n	private import ControlFunctions::allTrue;\n	private import Constraints::constraintChecks;\n	private import Constraints::assertedConstraintChecks;\n	private import Constraints::negatedConstraintChecks;\n	private import Parts::Part;\n	private import Parts::parts;\n	private import Actions::Action;\n	private import Interfaces::Interface;\n	private import Attributes::AttributeValue;\n	\n	private abstract constraint def RequirementConstraintCheck {\n		doc\n		/*\n		 * RequirementConstraintCheck is the base ConstraintCheck for RequirementCheck, defining the\n		 * separate assumptions and required constraints such that, if all the assumptions are true,\n		 * then all the required constraints must be true.\n		 */\n	\n		constraint assumptions[0..*] :> constraintChecks, subperformances {\n			doc\n			/*\n			 * Assumptions that must hold for the required constraints to apply.\n			 */\n		}\n		\n		constraint constraints[0..*] :> constraintChecks, subperformances {\n			doc\n			/*\n			 * The required constraints that are to be checked.\n			 */\n		}\n		\n		return result = allTrue(assumptions()) implies allTrue(constraints()) {\n			doc\n			/*\n			 * If all the assumptions are true, then all the required constraints must hold.\n			 */\n		}\n	}\n	\n	abstract requirement def RequirementCheck :> RequirementConstraintCheck {\n		doc\n		/*\n		 * RequirementCheck is the most general class for requirements checking. RequirementsCheck is the base\n		 * type of all requirement definitions.\n		 */\n	\n		ref requirement :>> self: RequirementCheck;\n		\n		subject subj : Anything[1] {\n			doc\n			/*\n			 * The entity that is being checked for satisfaction of the required constraints.\n			 */\n		}\n		\n		ref part actors : Part[0..*] {\n			doc\n			/*\n			 * The Parts that fill the role of actors for this RequirementCheck.\n			 * (Note: This is not itself an actor parameter, because specific actor\n			 * parameters will be added for specific RequirementChecks.)\n			 */\n		}\n		\n		ref part stakeholders : Part[0..*] {\n			doc\n			/*\n			 * The Parts that represent stakeholders interested in the concern being checked.\n			 * (Note: This is not itself a stakeholder parameter, because specific stakeholder\n			 * parameters will be added for specific RequirementChecks.)\n			 */\n		}\n\n		/* \n		 * Note: assumptions and constraints are redefined here solely to simplify the\n		 * resolution of their qualified names as library elements.\n		 */\n		constraint assumptions :>> RequirementConstraintCheck::assumptions;\n		constraint constraints :>> RequirementConstraintCheck::constraints;\n		\n		abstract requirement subrequirements[0..*] :> requirementChecks, constraints {\n			doc\n			/*\n			 * Nested requirements, which are also required constraints.\n			 */\n		}\n		\n		abstract concern concerns[0..*] :> concernChecks, subrequirements {\n			doc\n			/*\n			 * The checks of any concerns being addressed (as required constraints).\n			 */\n		}\n		\n	}\n	\n	requirement def FunctionalRequirementCheck :> RequirementCheck {\n		doc\n		/*\n		 * A functional requirement specifies an action that a system, or part of a system, must perform.\n		 */\n	\n		subject: Action;\n	}\n	\n	requirement def InterfaceRequirementCheck :> RequirementCheck {\n		doc\n		/*\n		 * An interface requirement specifies an interface for connecting systems and system parts, which\n		 * optionally may include item flows across the interface and/or interface constraints.\n		 */\n	\n		subject: Interface;\n	}\n	\n	requirement def PerformanceRequirementCheck :> RequirementCheck {\n		doc\n		/*\n		 * A performance requirement quantitavely measures the extent to which a system, or a system part, \n		 * satisfies a required capability or condition.\n		 */\n	\n		subject: AttributeValue;\n	}\n	\n	requirement def PhysicalRequirementCheck :> RequirementCheck {\n		doc\n		/*\n		 * A physical requirement specifies physical characteristics and/or physical constraints of the \n		 * system, or a system part.\n		 */\n	\n		subject: Part;\n	}\n	\n	requirement def DesignConstraintCheck :> RequirementCheck {\n		doc\n		/*\n		 * A design constraint specifies a constraint on the implementation of the system or system part, \n		 * such as the system must use a commercial off the shelf component.\n		 */\n	\n		subject: Part;\n	}\n	\n	concern def ConcernCheck :> RequirementCheck {\n		doc\n		/*\n		 * ConcernCheck is the most general class for concern checking. ConcernCheck is the base type of \n		 * all ConcernDefinitions.\n		 */\n	\n		ref concern :>> self: ConcernCheck;\n		\n	}\n	\n	abstract requirement requirementChecks: RequirementCheck[0..*] nonunique :> constraintChecks {\n		doc\n		/*\n		 * requirementChecks is the base feature of all requirement usages.\n		 */\n	}\n	\n	abstract requirement satisfiedRequirementChecks :> requirementChecks, assertedConstraintChecks {\n		doc\n		/*\n		 * satisfiedRequirementChecks is the subset of requirementChecks for Requirements asserted to be satisfied.\n		 */\n	}\n\n	abstract requirement notSatisfiedRequirementChecks: RequirementCheck[0..*] :> requirementChecks, negatedConstraintChecks {\n		doc\n		/*\n		 * notSatisfiedRequirementChecks is the subset of requirementChecks for Requirements asserted to be not satisfied.\n		 */\n	}\n	\n	abstract concern concernChecks: ConcernCheck[0..*] nonunique :> requirementChecks {\n		doc\n		/*\n		 * concernChecks is the base feature of all ConcernUsages.\n		 */\n	}\n	\n}", "Systems Library/StandardViewDefinitions.sysml": "standard library package StandardViewDefinitions {\n    doc /*\n         * This package defines the standard view definitions for the SysML language.\n         */\n    public import SysML::*;\n\n    view def <gv> GeneralView {\n        doc /*\n             * View definition to present any members of exposed model element(s).\n             * This is the most general view, enabling presentation of any model element.\n             * The typical rendering in graphical notation is as a graph of nodes and edges.\n             * Specializations of GeneralView can be specified through appropriate selection of filters, e.g.:\n             * - package view, filtering on Package, Package containment, package Import\n             * - definition and usage view, filtering on Definition, Usage, Specialization, FeatureTyping (covering defined by)\n             * - requirement view, filtering on RequirementDefinition, RequirementUsage, Specialization, FeatureTyping, \n             *   SatisfyRequirementUsage, AllocationDefinition, AllocationUsage,\n             * - view and viewpoint view, filtering on ViewDefinition, ViewUsage, ViewpointDefinition, ViewpointUsage, \n             *   RenderingDefinition, RenderingUsage, ConcernDefinition, ConcernUsage, StakeholderMembership, ...\n             * - language extension view, filtering on Metaclass, MetadataFeature, MetadataAccessExpression, ...\n             * Note: filters are specified by referencing concepts from the KerML.kerml and SysML.sysml standard library packages.\n             */\n    }\n\n    view def <iv> InterconnectionView {\n        doc /*\n             * View definition to present exposed features as nodes, nested features as\n             * nested nodes, and connections between features\n             * as edges between (nested) nodes. Nested nodes may present boundary features\n             * (e.g., ports, parameters).\n             */\n    }\n\n    view def <afv> ActionFlowView specializes InterconnectionView {\n        doc /*\n             * View definition to present connections between actions.\n             * Valid nodes and edges in an ActionFlowView are:\n             * - Actions with nested actions\n             * - Parameters with direction\n             * - Flow connection usages (e.g., kinds of transfers from output to input)\n             * - Binding connections between parameters (e.g., delegate a parameter from\n             *   one level of nesting to another)\n             * - Proxy connection points\n             * - Swim lanes\n             * - Conditional succession\n             * - Control nodes (fork, join, decision, merge)\n             * - Control structures, e.g., if-then-else, until-while-loop, for-loop\n             * - Send and accept actions\n             * - Change and time triggers\n             * - Compartments on actions and parameters\n             */\n    }\n\n    view def <stv> StateTransitionView specializes InterconnectionView {\n        doc /*\n             * View definition to present states and their transitions.\n             * Valid nodes and edges in a StateTransitionView are:\n             * - States with nested states\n             * - Entry, do, and exit actions\n             * - Transition usages with triggers, guards, and actions\n             * - Compartments on states\n             */\n    }\n\n    view def <sv> SequenceView {\n        doc /*\n             * View definition to present time ordering of event occurrences on lifelines\n             * of exposed features.\n             * Valid nodes and edges in a SequenceView are:\n             * - Features such as parts with their lifelines\n             * - Event occurrences on the lifelines\n             * - Messages sent from one part to another with and without a type of flow\n             * - Succession between event occurrences\n             * - Nested sequence view (e.g., a reference to a view)\n             * - Compartments\n             * The typical rendering in graphical notation depicts the exposed features\n             * horizontally along the top, with vertical lifelines. The time axis is\n             * vertical, with time increasing from top to bottom.\n             */\n    }\n\n    view def <gev> GeometryView {\n        doc /*\n             * View definition to present a visualization of exposed spatial items in two\n             * or three dimensions\n             * Valid nodes and edges in a GeometryView are:\n             * - Spatial item, including shape\n             * - Coordinate frame\n             * - Feature related to spatial item, such as a quantity (e.g. temperature)\n             *   of which values are to be rendered on a color scale\n             * The typical rendering in graphical notation would include a number of\n             * visualization parameters, such as:\n             * - 2D or 3D view\n             * - viewing direction\n             * - zoom level\n             * - light sources\n             * - object projection mode, e.g., isometric, perspective, orthographic\n             * - object rendering mode, e.g., shaded, wireframe, hidden line\n             * - object pan (placement) and rotate (orientation) settings\n             * - color maps\n             */\n    }\n\n    view def <grv> GridView {\n        doc /*\n             * View definition to present exposed model elements and their relationships,\n             * arranged in a rectangular grid.\n             * GridView is the generalization of the following more specialized views:\n             * - Tabular view\n             * - Data value tabular view\n             * - Relationship matrix view, e.g. presenting allocation or dependency relationships\n             */\n    }\n\n    view def <bv> BrowserView {\n        doc /*\n             * View definition to present the hierarchical membership structure of model\n             * elements starting from one or more exposed root elements.\n             * The typical rendering in graphical notation is as an indented list of rows,\n             * consisting of dynamically collapsible-expandable nodes that represent\n             * branches and leaves of the tree, as in graphical user interface widgets.\n             */\n    }\n}\n", "Systems Library/States.sysml": `standard library package States {
	doc
	/*
	 * This package defines the base types for states and related behavioral elements in the
	 * SysML language.
	 */

	private import Occurrences::Occurrence;
	private import StatePerformances::StatePerformance;
	private import StatePerformances::StateTransitionPerformance;
	private import Actions::Action;
	private import Actions::TransitionAction;
	private import Actions::transitionActions;
	private import Actions::AcceptAction;
	private import Actions::actions;
	private import SequenceFunctions::notEmpty;
	private import SequenceFunctions::size;
	
	abstract state def StateAction :> Action, StatePerformance {
		doc
		/*
		 * A StateAction is a kind of Action that is also a StatePerformance. It is the base type for all
		 * StateDefinitions.
		 */
	
		entry action entryAction :>> 'entry';
		do action doAction: Action :>> 'do';
		exit action exitAction: Action :>> 'exit';
		
		attribute :>> isTriggerDuring;
		
		ref state self: StateAction :>> Action::self, StatePerformance::self;
		ref state start: StateAction :>> Action::start, StatePerformance::startShot;
		ref state done: StateAction :>> Action::done, StatePerformance::endShot;
		
		action :>> subactions :> middle {
			doc
			/*
			 * The subperformances of this StateAction that are Actions, other than the entry and exit Actions. 
			 * These subactions all take place in the "middle" of the StatePerformance, that is, after the 
			 * entry Action and before the exit Action. 
			 */
		}
		
		action substates: StateAction[0..*] :> stateActions, subactions {
			doc
			/*
			 * The subactions of this state that are states.
			 * 
			 * NOTE: This feature is declared as an ActionUsage, not a StateUsage, so that the constraint 
 			 * checkStateUsageExclusiveStateSpecialization does not apply to it, since this constraint 
			 * would otherwise incorrectly require that "substates" subset "exclusiveStates".
			 */
		}
		
		abstract state exclusiveStates: StateAction[0..*] :> substates {
			doc
			/*
			 * The substates of this state that are mutually exclusive, that is, whose performances do not
			 * overlap in time.
			 */
		}
		
		abstract action stateTransitions: StateTransitionAction[0..*] :> transitions {
			doc
			/*
			 * The transitions of this state that are state transitions.
			 */
		}
		
		succession stateSequencing first [0..1] exclusiveStates then [0..1] exclusiveStates {
			doc
			/*
			 * Exclusive states cannot overlap, so it must be possible to strictly sequence them in time.
			 */
		}
		assert constraint {notEmpty(exclusiveStates) implies size(stateSequencing) == size(exclusiveStates) - 1}
	}
	
	action def StateTransitionAction :> TransitionAction, StateTransitionPerformance {
		doc
		/*
		 * A StateTransitionAction is a TransitionAction and a StateTransitionPerformance whose transitionLinkSource 
		 * is a State. It is the base type of TransitionUsages used transitions in state models.
		 */
	
		in transitionLinkSource[1]: StateAction :>> 
			TransitionAction::transitionLinkSource, StateTransitionPerformance::transitionLinkSource;
			
		inout payload[0..*];
		in :>> receiver;
		
		bind payload = accepter.payload;
		bind receiver = accepter.receiver;
	}
	
	abstract state stateActions: StateAction[0..*] nonunique :> actions {
		doc
		/*
		 * stateActions is the base feature for all StateUsages.
		 */
	}
}`, "Systems Library/SysML.sysml": "standard library package SysML {\n	doc \n	/*\n	 * This package contains a reflective KerML model of the KerML abstract syntax.\n	 */\n	 \n	private import ScalarValues::*;\n	public import Systems::*;\n	\n	package Systems {\n		public import KerML::Kernel::*;\n		\n		metadata def AcceptActionUsage specializes ActionUsage {\n			derived ref item receiverArgument : Expression[0..1] subsets Metadata::metadataItems;\n			derived ref item payloadParameter : ReferenceUsage[1..1] subsets nestedReference, parameter subsets Metadata::metadataItems;\n			derived ref item payloadArgument : Expression[0..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ActionDefinition specializes Behavior, OccurrenceDefinition {\n			derived ref item 'action' : ActionUsage[0..*] ordered subsets step, usage subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ActionUsage specializes Step, OccurrenceUsage {\n			derived ref item actionDefinition : Behavior[0..*] ordered redefines behavior, occurrenceDefinition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ActorMembership specializes ParameterMembership {\n			derived item ownedActorParameter : PartUsage[1..1] redefines ownedMemberParameter subsets Metadata::metadataItems;\n		}		\n		\n		metadata def AllocationDefinition specializes ConnectionDefinition {\n			derived ref item 'allocation' : AllocationUsage[0..*] ordered subsets usage subsets Metadata::metadataItems;\n		}		\n		\n		metadata def AllocationUsage specializes ConnectionUsage {\n			derived ref item allocationDefinition : AllocationDefinition[0..*] ordered redefines connectionDefinition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def AnalysisCaseDefinition specializes CaseDefinition {\n			derived ref item resultExpression : Expression[0..1] subsets expression, ownedFeature subsets Metadata::metadataItems;\n		}		\n		\n		metadata def AnalysisCaseUsage specializes CaseUsage {\n			derived ref item analysisCaseDefinition : AnalysisCaseDefinition[0..1] redefines caseDefinition subsets Metadata::metadataItems;\n			derived ref item resultExpression : Expression[0..1] subsets ownedFeature subsets Metadata::metadataItems;\n		}		\n		\n		metadata def AssertConstraintUsage specializes ConstraintUsage, Invariant {\n			derived ref item assertedConstraint : ConstraintUsage[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def AssignmentActionUsage specializes ActionUsage {\n			derived ref item targetArgument : Expression[0..1] subsets Metadata::metadataItems;\n			derived ref item valueExpression : Expression[0..1] subsets Metadata::metadataItems;\n			derived ref item referent : Feature[1..1] subsets member subsets Metadata::metadataItems;\n		}		\n		\n		metadata def AttributeDefinition specializes DataType, Definition;		\n		\n		metadata def AttributeUsage specializes Usage {\n			derived attribute isReference : Boolean[1..1] redefines isReference;\n			\n			derived ref item attributeDefinition : DataType[0..*] ordered redefines definition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def BindingConnectorAsUsage specializes BindingConnector, ConnectorAsUsage;		\n		\n		metadata def CalculationDefinition specializes Function, ActionDefinition {\n			derived ref item calculation : CalculationUsage[0..*] ordered subsets 'action', expression subsets Metadata::metadataItems;\n		}		\n		\n		metadata def CalculationUsage specializes Expression, ActionUsage {\n			derived ref item calculationDefinition : Function[0..1] ordered redefines function, actionDefinition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def CaseDefinition specializes CalculationDefinition {\n			derived ref item objectiveRequirement : RequirementUsage[0..1] ordered subsets usage subsets Metadata::metadataItems;\n			derived ref item subjectParameter : Usage[1..1] subsets parameter, usage subsets Metadata::metadataItems;\n			derived ref item actorParameter : PartUsage[0..*] ordered subsets parameter, usage subsets Metadata::metadataItems;\n		}		\n		\n		metadata def CaseUsage specializes CalculationUsage {\n			derived ref item objectiveRequirement : RequirementUsage[0..1] ordered subsets usage subsets Metadata::metadataItems;\n			derived ref item caseDefinition : CaseDefinition[0..1] redefines calculationDefinition subsets Metadata::metadataItems;\n			derived ref item subjectParameter : Usage[1..1] subsets parameter, usage subsets Metadata::metadataItems;\n			derived ref item actorParameter : PartUsage[0..*] ordered subsets parameter, usage subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ConcernDefinition specializes RequirementDefinition;		\n		\n		metadata def ConcernUsage specializes RequirementUsage {\n			derived ref item concernDefinition : ConcernDefinition[0..1] redefines requirementDefinition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ConjugatedPortDefinition specializes PortDefinition {\n			derived ref item originalPortDefinition : PortDefinition[1..1] redefines owningNamespace subsets Metadata::metadataItems;\n			derived ref item ownedPortConjugator : PortConjugation[1..1] redefines ownedConjugator subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ConjugatedPortTyping specializes FeatureTyping {\n			ref item conjugatedPortDefinition : ConjugatedPortDefinition[1..1] redefines type subsets Metadata::metadataItems;\n			derived ref item portDefinition : PortDefinition[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ConnectionDefinition specializes AssociationStructure, PartDefinition {\n			attribute isSufficient : Boolean[1..1] redefines isSufficient;\n			\n			derived ref item connectionEnd : Usage[0..*] ordered redefines associationEnd subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ConnectionUsage specializes ConnectorAsUsage, PartUsage {\n			derived ref item connectionDefinition : AssociationStructure[0..*] ordered subsets itemDefinition redefines association subsets Metadata::metadataItems;\n		}		\n		\n		abstract metadata def ConnectorAsUsage specializes Usage, Connector;		\n		\n		metadata def ConstraintDefinition specializes OccurrenceDefinition, Predicate;		\n		\n		metadata def ConstraintUsage specializes BooleanExpression, OccurrenceUsage {\n			derived ref item constraintDefinition : Predicate[0..1] redefines predicate subsets Metadata::metadataItems;\n		}		\n		\n		abstract metadata def ControlNode specializes ActionUsage;		\n		\n		metadata def DecisionNode specializes ControlNode;		\n		\n		metadata def Definition specializes Classifier {\n			attribute isVariation : Boolean[1..1];\n			\n			derived ref item 'variant' : Usage[0..*] subsets ownedMember subsets Metadata::metadataItems;\n			derived item variantMembership : VariantMembership[0..*] subsets ownedMembership subsets Metadata::metadataItems;\n			derived ref item usage : Usage[0..*] ordered subsets feature subsets Metadata::metadataItems;\n			derived ref item directedUsage : Usage[0..*] ordered subsets directedFeature, usage subsets Metadata::metadataItems;\n			derived ref item ownedUsage : Usage[0..*] ordered subsets ownedFeature, usage subsets Metadata::metadataItems;\n			derived ref item ownedReference : ReferenceUsage[0..*] ordered subsets ownedUsage subsets Metadata::metadataItems;\n			derived ref item ownedAttribute : AttributeUsage[0..*] ordered subsets ownedUsage subsets Metadata::metadataItems;\n			derived ref item ownedEnumeration : EnumerationUsage[0..*] ordered subsets ownedAttribute subsets Metadata::metadataItems;\n			derived ref item ownedOccurrence : OccurrenceUsage[0..*] ordered subsets ownedUsage subsets Metadata::metadataItems;\n			derived ref item ownedItem : ItemUsage[0..*] ordered subsets ownedOccurrence subsets Metadata::metadataItems;\n			derived ref item ownedPart : PartUsage[0..*] ordered subsets ownedItem subsets Metadata::metadataItems;\n			derived ref item ownedPort : PortUsage[0..*] ordered subsets ownedUsage subsets Metadata::metadataItems;\n			derived ref item ownedConnection : ConnectorAsUsage[0..*] ordered subsets ownedUsage subsets Metadata::metadataItems;\n			derived ref item ownedFlow : FlowUsage[0..*] subsets ownedConnection subsets Metadata::metadataItems;\n			derived ref item ownedInterface : InterfaceUsage[0..*] ordered subsets ownedConnection subsets Metadata::metadataItems;\n			derived ref item ownedAllocation : AllocationUsage[0..*] ordered subsets ownedConnection subsets Metadata::metadataItems;\n			derived ref item ownedAction : ActionUsage[0..*] ordered subsets ownedOccurrence subsets Metadata::metadataItems;\n			derived ref item ownedState : StateUsage[0..*] ordered subsets ownedAction subsets Metadata::metadataItems;\n			derived ref item ownedTransition : TransitionUsage[0..*] subsets ownedUsage subsets Metadata::metadataItems;\n			derived ref item ownedCalculation : CalculationUsage[0..*] ordered subsets ownedAction subsets Metadata::metadataItems;\n			derived ref item ownedConstraint : ConstraintUsage[0..*] ordered subsets ownedOccurrence subsets Metadata::metadataItems;\n			derived ref item ownedRequirement : RequirementUsage[0..*] ordered subsets ownedConstraint subsets Metadata::metadataItems;\n			derived ref item ownedConcern : ConcernUsage[0..*] subsets ownedRequirement subsets Metadata::metadataItems;\n			derived ref item ownedCase : CaseUsage[0..*] ordered subsets ownedCalculation subsets Metadata::metadataItems;\n			derived ref item ownedAnalysisCase : AnalysisCaseUsage[0..*] ordered subsets ownedCase subsets Metadata::metadataItems;\n			derived ref item ownedVerificationCase : VerificationCaseUsage[0..*] ordered subsets ownedCase subsets Metadata::metadataItems;\n			derived ref item ownedUseCase : UseCaseUsage[0..*] ordered subsets ownedCase subsets Metadata::metadataItems;\n			derived ref item ownedView : ViewUsage[0..*] ordered subsets ownedPart subsets Metadata::metadataItems;\n			derived ref item ownedViewpoint : ViewpointUsage[0..*] ordered subsets ownedRequirement subsets Metadata::metadataItems;\n			derived ref item ownedRendering : RenderingUsage[0..*] ordered subsets ownedPart subsets Metadata::metadataItems;\n			derived ref item ownedMetadata : MetadataUsage[0..*] ordered subsets ownedItem subsets Metadata::metadataItems;\n		}		\n		\n		metadata def EnumerationDefinition specializes AttributeDefinition {\n			attribute isVariation : Boolean[1..1] redefines isVariation;\n			\n			derived ref item enumeratedValue : EnumerationUsage[0..*] ordered redefines 'variant' subsets Metadata::metadataItems;\n		}		\n		\n		metadata def EnumerationUsage specializes AttributeUsage {\n			derived ref item enumerationDefinition : EnumerationDefinition[1..1] redefines attributeDefinition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def EventOccurrenceUsage specializes OccurrenceUsage {\n			derived attribute isReference : Boolean[1..1] redefines isReference;\n			\n			derived ref item eventOccurrence : OccurrenceUsage[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ExhibitStateUsage specializes StateUsage, PerformActionUsage {\n			derived ref item exhibitedState : StateUsage[1..1] redefines performedAction subsets Metadata::metadataItems;\n		}		\n		\n		abstract metadata def Expose specializes Import {\n			attribute visibility : VisibilityKind[1..1] redefines visibility;\n			attribute isImportAll : Boolean[1..1] redefines isImportAll;\n		}		\n		\n		metadata def FlowDefinition specializes Interaction, ActionDefinition {\n			derived ref item flowEnd : Usage[0..*] redefines associationEnd subsets Metadata::metadataItems;\n		}		\n		\n		metadata def FlowUsage specializes ConnectorAsUsage, Flow, ActionUsage {\n			derived ref item flowDefinition : Interaction[0..*] ordered redefines actionDefinition, interaction subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ForLoopActionUsage specializes LoopActionUsage {\n			derived ref item seqArgument : Expression[1..1] subsets Metadata::metadataItems;\n			derived ref item loopVariable : ReferenceUsage[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ForkNode specializes ControlNode;		\n		\n		metadata def FramedConcernMembership specializes RequirementConstraintMembership {\n			attribute kind : RequirementConstraintKind[1..1] redefines kind;\n			\n			derived item ownedConcern : ConcernUsage[1..1] redefines ownedConstraint subsets Metadata::metadataItems;\n			derived ref item referencedConcern : ConcernUsage[1..1] redefines referencedConstraint subsets Metadata::metadataItems;\n		}		\n		\n		metadata def IfActionUsage specializes ActionUsage {\n			derived ref item elseAction : ActionUsage[0..1] subsets Metadata::metadataItems;\n			derived ref item thenAction : ActionUsage[1..1] subsets Metadata::metadataItems;\n			derived ref item ifArgument : Expression[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def IncludeUseCaseUsage specializes UseCaseUsage, PerformActionUsage {\n			derived ref item useCaseIncluded : UseCaseUsage[1..1] redefines performedAction subsets Metadata::metadataItems;\n		}		\n		\n		metadata def InterfaceDefinition specializes ConnectionDefinition {\n			derived ref item interfaceEnd : PortUsage[0..*] ordered redefines connectionEnd subsets Metadata::metadataItems;\n		}		\n		\n		metadata def InterfaceUsage specializes ConnectionUsage {\n			derived ref item interfaceDefinition : InterfaceDefinition[0..*] redefines connectionDefinition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ItemDefinition specializes Structure, OccurrenceDefinition;		\n		\n		metadata def ItemUsage specializes OccurrenceUsage {\n			derived ref item itemDefinition : Structure[0..*] ordered subsets occurrenceDefinition subsets Metadata::metadataItems subsets Metadata::metadataItems;\n		}		\n		\n		metadata def JoinNode specializes ControlNode;		\n		\n		abstract metadata def LoopActionUsage specializes ActionUsage {\n			derived ref item bodyAction : ActionUsage[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def MembershipExpose specializes MembershipImport, Expose;		\n		\n		metadata def MergeNode specializes ControlNode;		\n		\n		metadata def MetadataDefinition specializes ItemDefinition, Metaclass;		\n		\n		metadata def MetadataUsage specializes ItemUsage, MetadataFeature {\n			derived ref item metadataDefinition : Metaclass[0..1] redefines itemDefinition, metaclass subsets Metadata::metadataItems;\n		}		\n		\n		metadata def NamespaceExpose specializes Expose, NamespaceImport;		\n		\n		metadata def ObjectiveMembership specializes FeatureMembership {\n			derived item ownedObjectiveRequirement : RequirementUsage[1..1] redefines ownedMemberFeature subsets Metadata::metadataItems;\n		}		\n		\n		metadata def OccurrenceDefinition specializes Definition, Class {\n			attribute isIndividual : Boolean[1..1];\n		}		\n		\n		metadata def OccurrenceUsage specializes Usage {\n			attribute isIndividual : Boolean[1..1];\n			attribute portionKind : PortionKind[0..1];\n			\n			derived ref item occurrenceDefinition : Class[0..*] ordered redefines definition subsets Metadata::metadataItems;\n			derived ref item individualDefinition : OccurrenceDefinition[0..1] subsets occurrenceDefinition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def PartDefinition specializes ItemDefinition;		\n		\n		metadata def PartUsage specializes ItemUsage {\n			derived ref item partDefinition : PartDefinition[0..*] ordered subsets itemDefinition subsets Metadata::metadataItems;\n		}		\n		\n		metadata def PerformActionUsage specializes ActionUsage, EventOccurrenceUsage {\n			derived ref item performedAction : ActionUsage[1..1] redefines eventOccurrence subsets Metadata::metadataItems;\n		}		\n		\n		metadata def PortConjugation specializes Conjugation {\n			ref item originalPortDefinition : PortDefinition[1..1] redefines originalType subsets Metadata::metadataItems;\n			derived ref item conjugatedPortDefinition : ConjugatedPortDefinition[1..1] redefines owningType subsets Metadata::metadataItems;\n		}		\n		\n		metadata def PortDefinition specializes OccurrenceDefinition, Structure {\n			derived ref item conjugatedPortDefinition : ConjugatedPortDefinition[0..1] subsets ownedMember subsets Metadata::metadataItems;\n		}		\n		\n		metadata def PortUsage specializes OccurrenceUsage {\n			derived ref item portDefinition : PortDefinition[0..*] ordered redefines occurrenceDefinition subsets Metadata::metadataItems;\n		}		\n		\n		enum def PortionKind {\n			enum 'timeslice';\n			enum 'snapshot';\n		}\n		\n		metadata def ReferenceUsage specializes Usage {\n			derived attribute isReference : Boolean[1..1] redefines isReference;\n		}		\n		\n		metadata def RenderingDefinition specializes PartDefinition {\n			derived ref item 'rendering' : RenderingUsage[0..*] ordered subsets usage subsets Metadata::metadataItems;\n		}		\n		\n		metadata def RenderingUsage specializes PartUsage {\n			derived ref item renderingDefinition : RenderingDefinition[0..1] redefines partDefinition subsets Metadata::metadataItems;\n		}		\n		\n		enum def RequirementConstraintKind {\n			enum assumption;\n			enum 'requirement';\n		}\n		\n		metadata def RequirementConstraintMembership specializes FeatureMembership {\n			attribute kind : RequirementConstraintKind[1..1];\n			\n			derived item ownedConstraint : ConstraintUsage[1..1] redefines ownedMemberFeature subsets Metadata::metadataItems;\n			derived ref item referencedConstraint : ConstraintUsage[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def RequirementDefinition specializes ConstraintDefinition {\n			attribute reqId : String[0..1] redefines declaredShortName;\n			derived attribute text : String[0..*];\n			\n			derived ref item subjectParameter : Usage[1..1] subsets parameter, usage subsets Metadata::metadataItems;\n			derived ref item actorParameter : PartUsage[0..*] ordered subsets parameter, usage subsets Metadata::metadataItems;\n			derived ref item stakeholderParameter : PartUsage[0..*] ordered subsets parameter, usage subsets Metadata::metadataItems;\n			derived ref item assumedConstraint : ConstraintUsage[0..*] ordered subsets ownedFeature subsets Metadata::metadataItems;\n			derived ref item requiredConstraint : ConstraintUsage[0..*] ordered subsets ownedFeature subsets Metadata::metadataItems;\n			derived ref item framedConcern : ConcernUsage[0..*] ordered subsets requiredConstraint subsets Metadata::metadataItems;\n		}		\n		\n		metadata def RequirementUsage specializes ConstraintUsage {\n			attribute reqId : String[0..1] redefines declaredShortName;\n			derived attribute text : String[0..*];\n			\n			derived ref item requirementDefinition : RequirementDefinition[0..1] redefines constraintDefinition subsets Metadata::metadataItems;\n			derived ref item requiredConstraint : ConstraintUsage[0..*] ordered subsets ownedFeature subsets Metadata::metadataItems;\n			derived ref item assumedConstraint : ConstraintUsage[0..*] ordered subsets ownedFeature subsets Metadata::metadataItems;\n			derived ref item subjectParameter : Usage[1..1] subsets parameter, usage subsets Metadata::metadataItems;\n			derived ref item framedConcern : ConcernUsage[0..*] ordered subsets requiredConstraint subsets Metadata::metadataItems;\n			derived ref item actorParameter : PartUsage[0..*] ordered subsets parameter, usage subsets Metadata::metadataItems;\n			derived ref item stakeholderParameter : PartUsage[0..*] ordered subsets parameter, usage subsets Metadata::metadataItems;\n		}		\n		\n		metadata def RequirementVerificationMembership specializes RequirementConstraintMembership {\n			attribute kind : RequirementConstraintKind[1..1] redefines kind;\n			\n			derived item ownedRequirement : RequirementUsage[1..1] redefines ownedConstraint subsets Metadata::metadataItems;\n			derived ref item verifiedRequirement : RequirementUsage[1..1] redefines referencedConstraint subsets Metadata::metadataItems;\n		}		\n		\n		metadata def SatisfyRequirementUsage specializes RequirementUsage, AssertConstraintUsage {\n			derived ref item satisfiedRequirement : RequirementUsage[1..1] redefines assertedConstraint subsets Metadata::metadataItems;\n			derived ref item satisfyingFeature : Feature[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def SendActionUsage specializes ActionUsage {\n			derived ref item receiverArgument : Expression[0..1] subsets Metadata::metadataItems;\n			derived ref item payloadArgument : Expression[1..1] subsets Metadata::metadataItems;\n			derived ref item senderArgument : Expression[0..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def StakeholderMembership specializes ParameterMembership {\n			derived item ownedStakeholderParameter : PartUsage[1..1] redefines ownedMemberParameter subsets Metadata::metadataItems;\n		}		\n		\n		metadata def StateDefinition specializes ActionDefinition {\n			attribute isParallel : Boolean[1..1];\n			\n			derived ref item 'state' : StateUsage[0..*] ordered subsets 'action' subsets Metadata::metadataItems;\n			derived ref item entryAction : ActionUsage[0..1] subsets Metadata::metadataItems;\n			derived ref item doAction : ActionUsage[0..1] subsets Metadata::metadataItems;\n			derived ref item exitAction : ActionUsage[0..1] subsets Metadata::metadataItems;\n		}		\n		\n		enum def StateSubactionKind {\n			enum 'entry';\n			enum 'do';\n			enum 'exit';\n		}\n		\n		metadata def StateSubactionMembership specializes FeatureMembership {\n			attribute kind : StateSubactionKind[1..1];\n			\n			derived item 'action' : ActionUsage[1..1] redefines ownedMemberFeature subsets Metadata::metadataItems;\n		}		\n		\n		metadata def StateUsage specializes ActionUsage {\n			attribute isParallel : Boolean[1..1];\n			\n			derived ref item stateDefinition : Behavior[0..*] ordered redefines actionDefinition subsets Metadata::metadataItems;\n			derived ref item entryAction : ActionUsage[0..1] subsets Metadata::metadataItems;\n			derived ref item doAction : ActionUsage[0..1] subsets Metadata::metadataItems;\n			derived ref item exitAction : ActionUsage[0..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def SubjectMembership specializes ParameterMembership {\n			derived item ownedSubjectParameter : Usage[1..1] redefines ownedMemberParameter subsets Metadata::metadataItems;\n		}		\n		\n		metadata def SuccessionAsUsage specializes ConnectorAsUsage, Succession;		\n		\n		metadata def SuccessionFlowUsage specializes SuccessionFlow, FlowUsage;		\n		\n		metadata def TerminateActionUsage specializes ActionUsage {\n			derived ref item terminatedOccurrenceArgument : Expression[0..1] subsets Metadata::metadataItems;\n		}		\n		\n		enum def TransitionFeatureKind {\n			enum trigger;\n			enum guard;\n			enum effect;\n		}\n		\n		metadata def TransitionFeatureMembership specializes FeatureMembership {\n			attribute kind : TransitionFeatureKind[1..1];\n			\n			derived item transitionFeature : Step[1..1] redefines ownedMemberFeature subsets Metadata::metadataItems;\n		}		\n		\n		metadata def TransitionUsage specializes ActionUsage {\n			derived ref item source : ActionUsage[1..1] subsets Metadata::metadataItems;\n			derived ref item target : ActionUsage[1..1] subsets Metadata::metadataItems;\n			derived ref item triggerAction : AcceptActionUsage[0..*] subsets ownedFeature subsets Metadata::metadataItems;\n			derived ref item guardExpression : Expression[0..*] subsets ownedFeature subsets Metadata::metadataItems;\n			derived ref item effectAction : ActionUsage[0..*] subsets feature subsets Metadata::metadataItems;\n			derived ref item 'succession' : Succession[1..1] subsets ownedMember subsets Metadata::metadataItems;\n		}		\n		\n		metadata def TriggerInvocationExpression specializes InvocationExpression {\n			attribute kind : TriggerKind[1..1];\n		}		\n		\n		enum def TriggerKind {\n			enum 'when';\n			enum 'at';\n			enum 'after';\n		}\n		\n		metadata def Usage specializes Feature {\n			attribute isVariation : Boolean[1..1];\n			derived attribute mayTimeVary : Boolean[1..1] redefines isVariable;\n			derived attribute isReference : Boolean[1..1];\n			\n			derived ref item 'variant' : Usage[0..*] subsets ownedMember subsets Metadata::metadataItems;\n			derived item variantMembership : VariantMembership[0..*] subsets ownedMembership subsets Metadata::metadataItems;\n			derived ref item owningDefinition : Definition[0..1] subsets owningType subsets Metadata::metadataItems;\n			derived ref item owningUsage : Usage[0..1] subsets owningType subsets Metadata::metadataItems;\n			derived ref item definition : Classifier[0..*] ordered redefines type subsets Metadata::metadataItems;\n			derived ref item usage : Usage[0..*] ordered subsets feature subsets Metadata::metadataItems;\n			derived ref item directedUsage : Usage[0..*] ordered subsets directedFeature, usage subsets Metadata::metadataItems;\n			derived ref item nestedUsage : Usage[0..*] ordered subsets ownedFeature, usage subsets Metadata::metadataItems;\n			derived ref item nestedReference : ReferenceUsage[0..*] ordered subsets nestedUsage subsets Metadata::metadataItems;\n			derived ref item nestedAttribute : AttributeUsage[0..*] ordered subsets nestedUsage subsets Metadata::metadataItems;\n			derived ref item nestedEnumeration : EnumerationUsage[0..*] ordered subsets nestedAttribute subsets Metadata::metadataItems;\n			derived ref item nestedOccurrence : OccurrenceUsage[0..*] ordered subsets nestedUsage subsets Metadata::metadataItems;\n			derived ref item nestedItem : ItemUsage[0..*] ordered subsets nestedOccurrence subsets Metadata::metadataItems;\n			derived ref item nestedPart : PartUsage[0..*] ordered subsets nestedItem subsets Metadata::metadataItems;\n			derived ref item nestedPort : PortUsage[0..*] ordered subsets nestedUsage subsets Metadata::metadataItems;\n			derived ref item nestedConnection : ConnectorAsUsage[0..*] ordered subsets nestedUsage subsets Metadata::metadataItems;\n			derived ref item nestedFlow : FlowUsage[0..*] subsets nestedConnection subsets Metadata::metadataItems;\n			derived ref item nestedInterface : InterfaceUsage[0..*] ordered subsets nestedConnection subsets Metadata::metadataItems;\n			derived ref item nestedAllocation : AllocationUsage[0..*] ordered subsets nestedConnection subsets Metadata::metadataItems;\n			derived ref item nestedAction : ActionUsage[0..*] ordered subsets nestedOccurrence subsets Metadata::metadataItems;\n			derived ref item nestedState : StateUsage[0..*] ordered subsets nestedAction subsets Metadata::metadataItems;\n			derived ref item nestedTransition : TransitionUsage[0..*] subsets nestedUsage subsets Metadata::metadataItems;\n			derived ref item nestedCalculation : CalculationUsage[0..*] ordered subsets nestedAction subsets Metadata::metadataItems;\n			derived ref item nestedConstraint : ConstraintUsage[0..*] ordered subsets nestedOccurrence subsets Metadata::metadataItems;\n			derived ref item nestedRequirement : RequirementUsage[0..*] ordered subsets nestedConstraint subsets Metadata::metadataItems;\n			derived ref item nestedConcern : ConcernUsage[0..*] subsets nestedRequirement subsets Metadata::metadataItems;\n			derived ref item nestedCase : CaseUsage[0..*] ordered subsets nestedCalculation subsets Metadata::metadataItems;\n			derived ref item nestedAnalysisCase : AnalysisCaseUsage[0..*] ordered subsets nestedCase subsets Metadata::metadataItems;\n			derived ref item nestedVerificationCase : VerificationCaseUsage[0..*] ordered subsets nestedCase subsets Metadata::metadataItems;\n			derived ref item nestedUseCase : UseCaseUsage[0..*] ordered subsets nestedCase subsets Metadata::metadataItems;\n			derived ref item nestedView : ViewUsage[0..*] ordered subsets nestedPart subsets Metadata::metadataItems;\n			derived ref item nestedViewpoint : ViewpointUsage[0..*] ordered subsets nestedRequirement subsets Metadata::metadataItems;\n			derived ref item nestedRendering : RenderingUsage[0..*] ordered subsets nestedPart subsets Metadata::metadataItems;\n			derived ref item nestedMetadata : MetadataUsage[0..*] ordered subsets nestedItem subsets Metadata::metadataItems;\n		}		\n		\n		metadata def UseCaseDefinition specializes CaseDefinition {\n			derived ref item includedUseCase : UseCaseUsage[0..*] ordered subsets Metadata::metadataItems;\n		}		\n		\n		metadata def UseCaseUsage specializes CaseUsage {\n			derived ref item useCaseDefinition : UseCaseDefinition[0..1] redefines caseDefinition subsets Metadata::metadataItems;\n			derived ref item includedUseCase : UseCaseUsage[0..*] ordered subsets Metadata::metadataItems;\n		}		\n		\n		metadata def VariantMembership specializes OwningMembership {\n			derived item ownedVariantUsage : Usage[1..1] redefines ownedMemberElement subsets Metadata::metadataItems;\n		}		\n		\n		metadata def VerificationCaseDefinition specializes CaseDefinition {\n			derived ref item verifiedRequirement : RequirementUsage[0..*] ordered subsets Metadata::metadataItems;\n		}		\n		\n		metadata def VerificationCaseUsage specializes CaseUsage {\n			derived ref item verificationCaseDefinition : VerificationCaseDefinition[0..1] subsets caseDefinition subsets Metadata::metadataItems;\n			derived ref item verifiedRequirement : RequirementUsage[0..*] ordered subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ViewDefinition specializes PartDefinition {\n			derived ref item 'view' : ViewUsage[0..*] ordered subsets usage subsets Metadata::metadataItems;\n			derived ref item satisfiedViewpoint : ViewpointUsage[0..*] ordered subsets ownedRequirement subsets Metadata::metadataItems;\n			derived ref item viewRendering : RenderingUsage[0..1] subsets Metadata::metadataItems;\n			derived ref item viewCondition : Expression[0..*] ordered subsets ownedMember subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ViewRenderingMembership specializes FeatureMembership {\n			derived item ownedRendering : RenderingUsage[1..1] redefines ownedMemberFeature subsets Metadata::metadataItems;\n			derived ref item referencedRendering : RenderingUsage[1..1] subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ViewUsage specializes PartUsage {\n			derived ref item viewDefinition : ViewDefinition[0..1] redefines partDefinition subsets Metadata::metadataItems;\n			derived ref item satisfiedViewpoint : ViewpointUsage[0..*] ordered subsets nestedRequirement subsets Metadata::metadataItems;\n			derived ref item exposedElement : Element[0..*] ordered subsets member subsets Metadata::metadataItems;\n			derived ref item viewRendering : RenderingUsage[0..1] subsets Metadata::metadataItems;\n			derived ref item viewCondition : Expression[0..*] ordered subsets ownedMember subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ViewpointDefinition specializes RequirementDefinition {\n			derived ref item viewpointStakeholder : PartUsage[0..*] ordered subsets Metadata::metadataItems;\n		}		\n		\n		metadata def ViewpointUsage specializes RequirementUsage {\n			derived ref item viewpointDefinition : ViewpointDefinition[0..1] redefines requirementDefinition subsets Metadata::metadataItems;\n			derived ref item viewpointStakeholder : PartUsage[0..*] ordered subsets Metadata::metadataItems;\n		}		\n		\n		metadata def WhileLoopActionUsage specializes LoopActionUsage {\n			derived ref item whileArgument : Expression[1..1] subsets Metadata::metadataItems;\n			derived ref item untilArgument : Expression[0..1] subsets Metadata::metadataItems;\n		}		\n		\n	}\n	\n}\n", "Systems Library/UseCases.sysml": "standard library package UseCases {\n	doc\n	/*\n	 * This package defines the base types for use cases and related behavioral elements in the SysML language.\n	 */\n	 \n	private import Cases::Case;\n	private import Cases::cases;\n	\n	use case def UseCase :> Case {\n		doc\n		/*\n		 * UseCase is the most general class of performances of UseCaseDefinitions. \n		 * UseCase is the base class of all UseCaseDefinitions.\n		 */\n	\n		ref use case self : UseCase :>> Case::self;\n		subject subj :>> Case::subj;\n		objective obj :>> Case::obj;\n		\n		ref use case start: UseCase :>> start {\n			doc\n			/*\n			 * The starting snapshot of a Use Case. \n			 */\n		}\n		\n		ref use case done: UseCase :>> done {\n			doc\n			/*\n			 * The ending snapshot of a Use Case.\n			 */\n		}\n\n		abstract use case subUseCases : UseCase[0..*] :> useCases, subcases {\n			doc\n			/*\n			 * Other UseCases carried out as part of the performance of this UseCase.\n			 */\n		}\n		\n		abstract ref use case includedUseCases : UseCase[0..*] :> useCases, enclosedPerformances {\n			doc\n			/*\n			 * Other UseCases included by this UseCase (i.e., as modeled by an \n			 * IncludeUseCaseUsage).\n			 */\n		}\n	}\n	\n	use case useCases : UseCase[0..*] nonunique :> cases {\n		doc\n		/*\n		 * useCases is the base feature of all UseCaseUsages.\n		 */\n	}\n}", "Systems Library/VerificationCases.sysml": "standard library package VerificationCases {\n	doc\n	/*\n	 * This package defines the base types for verification cases and related behavioral elements \n	 * in the SysML language.\n	 */\n\n	private import Cases::Case;\n	private import Cases::cases;\n	private import Requirements::RequirementCheck;\n	private import ScalarValues::Boolean;\n	\n	abstract verification def VerificationCase :> Case {\n		doc\n		/*\n		 * VerificationCase is the most general class of performances of VerificationCaseDefinitions. \n		 * VericationCase is the base class of all VerificationCaseDefinitions.\n		 */\n	\n		ref verification self : VerificationCase :>> Case::self;		\n		subject subj :>> Case::subj;\n		return verdict : VerdictKind :>> result;\n		\n		objective obj :>> Case::obj {\n			subject subj = VerificationCase::subj;\n			\n			requirement requirementVerifications : RequirementCheck[0..*] :> subrequirements {\n				doc\n				/*\n				 * A record of the evaluations of the RequirementChecks of requirements being verified.\n				 */\n			}\n		}\n		\n		ref requirement requirementVerifications : RequirementCheck[0..*] = obj.requirementVerifications {\n			doc\n			/*\n			 * Checks on whether the verifiedRequirements of the VerificationCase have been satisfied.\n			 */\n		}\n		\n		abstract verification subVerificationCases : VerificationCase[0..*] :> verificationCases, subcases {\n			doc\n			/*\n			 * The subcases of this VerificationCase that are VerificationCaseUsages.\n			 */\n		}\n		\n	}\n	\n	abstract verification verificationCases : VerificationCase[0..*] nonunique  :> cases {\n		doc\n		/*\n		 * verificationCases is the base feature of all VerificationCaseUsages.\n		 */\n	}\n	\n	enum def VerdictKind {\n		doc\n		/*\n		 * VerdictKind is an enumeration of the possible results of a VerificationCase.\n		 */\n	\n		pass;\n		fail;\n		inconclusive;\n		error;\n	}\n	\n	calc def PassIf {\n		doc\n		/*\n		 * PassIf returns a pass or fail VerdictKind depending on whether its argument is\n		 * true or false.\n		 */\n	\n		in attribute isPassing : Boolean;\n		return attribute verdict : VerdictKind = if isPassing? VerdictKind::pass else VerdictKind::fail;\n	}\n	\n	metadata def VerificationMethod {\n		doc\n		/*\n		 * VerificationMethod can be used as metadata annotating a verification case or action.\n		 */\n	\n		attribute kind : VerificationMethodKind[1..*];\n	}\n	\n	enum def VerificationMethodKind {\n		doc\n		/*\n		 * VerificationMethodKind is an enumeration of the standard methods by which verification\n		 * can be carried out.\n		 */\n	\n		inspect;\n		analyze;\n		demo;\n		test;\n	}\n	\n}", "Systems Library/Views.sysml": "standard library package Views {\n	doc\n	/*\n	 * This package defines the base types for views, viewpoints, renderings and related elements \n	 * in the SysML language.\n	 */\n\n	private import Parts::Part;\n	private import Parts::parts;\n	private import Requirements::RequirementCheck;\n	private import Requirements::requirementChecks;\n	\n	abstract view def View :> Part {\n		ref view :>> self : View;\n		\n		abstract ref view subviews : View[0..*] :> views {\n    		doc\n    		/*\n    		 * Other Views that are used in the rendering of this View.\n    		 */\n		}\n		\n		abstract ref rendering viewRendering : Rendering[0..1] {\n            doc\n			/*\n			 * The rendering of this View.\n			 */\n		}\n		\n		viewpoint viewpointSatisfactions : ViewpointCheck[0..*] :> viewpointChecks, checkedConstraints {\n            doc\n			/*\n			 * Checks that the View satisfies all required ViewpointUsages.\n			 */\n		}\n		\n		satisfy requirement viewpointConformance by that {\n			doc\n			/*\n			 * An assertion that all viewpointSatisfactions are true.\n			 */\n			 \n			require viewpointSatisfactions {\n				doc\n				/*\n				 * The required ViewpointChecks.\n				 */\n                ref :>> ownedPerformances::this, subperformances::this default that.that;\n			}\n		}\n	}\n	\n	abstract viewpoint def ViewpointCheck :> RequirementCheck {\n		doc\n		/*\n		 * ViewpointCheck is a RequirementCheck for checking if a View meets the concerns of viewpoint stakeholders. \n		 * It is the base type of all ViewpointDefinitions.\n		 */\n	\n		ref viewpoint :>> self : ViewpointCheck;		\n		subject subj : View[1] :>> RequirementCheck::subj;\n	}\n	\n	abstract rendering def Rendering :> Part {\n		doc\n		/*\n		 * Rendering is the base type of all RenderingDefinitions.\n		 */\n	\n		ref rendering :>> self : Rendering;\n		\n		abstract ref rendering subrenderings : Rendering[0..*] :> renderings {\n			doc\n			/*\n			 * Other Renderings used to carry out this Rendering.\n			 */\n		}\n	}\n	\n	rendering def TextualRendering :> Rendering {\n		doc\n		/*\n		 * A TextualRendering is a Rendering of a View into a textual format.\n		 */\n	}\n\n	rendering def GraphicalRendering :> Rendering {\n		doc\n		/*\n		 * A GraphicalRendering is a Rendering of a View into a Graphical format.\n		 */\n	}\n\n	rendering def TabularRendering :> Rendering {\n		doc\n		/*\n		 * A TabularRendering is a Rendering of a View into a tabular format.\n		 */\n	}\n	\n	abstract view views : View[0..*] nonunique :> parts {\n		doc\n		/*\n		 * views is the base feature of all ViewUsages.\n		 */\n	}\n	\n	abstract viewpoint viewpointChecks : ViewpointCheck[0..*] nonunique :> requirementChecks {\n		doc\n		/*\n		 * viewpointChecks is the base feature of all ViewpointUsages.\n		 */\n	}\n	\n	abstract rendering renderings : Rendering[0..*] nonunique :> parts {\n		doc\n		/*\n		 * renderings is the base feature of all RenderingUsages.\n		 */\n	}\n	\n	rendering asTextualNotation : TextualRendering[1] :> renderings {\n		doc\n		/*\n		 * asTextualNotation renders a View into textual notation as defined in the \n		 * KerML and SysML specifications.\n		 */\n	}\n	\n	rendering asTreeDiagram : GraphicalRendering[1] :> renderings {\n		doc\n		/*\n		 * asTreeDiagram renders a View as a tree diagram, using the \n		 * graphical notation defined in the SysML specification.\n		 */\n	}\n	\n	rendering asInterconnectionDiagram : GraphicalRendering[1] :> renderings {\n		doc\n		/*\n		 * asInterconnectionDiagram renders a View as an interconnection \n		 * diagram, using the graphical notation defined in the SysML specification.\n		 */\n	}\n	\n	rendering asElementTable : TabularRendering[1] :> renderings {\n		doc\n		/*\n		 * asElementTable  renders a View as a table, with one row for each exposed \n		 * Element and columns rendered by applying the columnViews in order to the\n		 * Element in each row.\n		 */\n	\n		view columnView[0..*] ordered {\n			doc\n			/*\n			 * The Views to be rendered in the column cells, in order, of each rows of the table.\n			 */\n		\n			abstract ref rendering :>> viewRendering[0..1];\n		}\n		rendering :>> subrenderings[0..*] = columnView.viewRendering;\n	}\n}" };

  // server/src/platform/libraryFiles.browser.ts
  function libraryUriForPath(relPath) {
    const encoded = relPath.split("/").map(encodeURIComponent).join("/");
    return `sysml-stdlib:///${encoded}`;
  }
  function loadLibraryFiles(_serverDir, _customPath) {
    return Object.entries(BUNDLED_LIBRARY).map(([relPath, content]) => ({
      uri: libraryUriForPath(relPath),
      content
    }));
  }

  // server/src/library/libraryIndex.ts
  function skipSpaces(line, pos) {
    while (pos < line.length && (line[pos] === " " || line[pos] === "	")) pos++;
    return pos;
  }
  function readWord(line, pos) {
    pos = skipSpaces(line, pos);
    const start = pos;
    while (pos < line.length && isIdentPart(line.charCodeAt(pos))) pos++;
    return pos > start ? [line.slice(start, pos), pos] : void 0;
  }
  function readName(line, pos) {
    pos = skipSpaces(line, pos);
    if (pos < line.length && line[pos] === "'") {
      pos++;
      const start = pos;
      while (pos < line.length && isIdentPart(line.charCodeAt(pos))) pos++;
      const name = line.slice(start, pos);
      if (pos < line.length && line[pos] === "'") pos++;
      return name ? [name, pos] : void 0;
    }
    if (pos < line.length && line[pos] === "<") {
      pos++;
      const start = pos;
      while (pos < line.length && line[pos] !== ">") pos++;
      const shortName = line.slice(start, pos).trim();
      if (pos < line.length && line[pos] === ">") pos++;
      pos = skipSpaces(line, pos);
      if (pos < line.length && line[pos] === "'") {
        pos++;
        while (pos < line.length && line[pos] !== "'") pos++;
        if (pos < line.length) pos++;
      } else if (pos < line.length && isIdentPart(line.charCodeAt(pos))) {
        while (pos < line.length && isIdentPart(line.charCodeAt(pos))) pos++;
      }
      return shortName ? [shortName, pos] : void 0;
    }
    return readWord(line, pos);
  }
  function readLongName(line, pos) {
    pos = skipSpaces(line, pos);
    if (pos >= line.length || line[pos] !== "<") return void 0;
    while (pos < line.length && line[pos] !== ">") pos++;
    if (pos < line.length) pos++;
    pos = skipSpaces(line, pos);
    if (pos >= line.length) return void 0;
    if (line[pos] === "'") {
      pos++;
      const start = pos;
      while (pos < line.length && line[pos] !== "'") pos++;
      const longName = line.slice(start, pos).trim();
      if (longName && /^[A-Za-z_]\w*$/.test(longName)) return longName;
      return void 0;
    }
    if (isIdentPart(line.charCodeAt(pos))) {
      const start = pos;
      while (pos < line.length && isIdentPart(line.charCodeAt(pos))) pos++;
      return line.slice(start, pos);
    }
    return void 0;
  }
  function matchWord(line, pos, keyword) {
    if (!line.startsWith(keyword, pos)) return false;
    const after = pos + keyword.length;
    return after >= line.length || !isIdentPart(line.charCodeAt(after));
  }
  var DEF_KEYWORDS = /* @__PURE__ */ new Set([
    "part",
    "attribute",
    "port",
    "action",
    "state",
    "item",
    "connection",
    "interface",
    "requirement",
    "constraint",
    "allocation",
    "usecase",
    "enum",
    "calc",
    "view",
    "viewpoint",
    "metadata",
    "analysis",
    "case",
    "concern",
    "rendering",
    "verification",
    "flow",
    "occurrence",
    "ref"
  ]);
  var STANDALONE_TYPE_KEYWORDS = /* @__PURE__ */ new Set(["datatype", "struct", "metaclass", "alias", "classifier"]);
  var USAGE_KEYWORDS = /* @__PURE__ */ new Set([
    "attribute",
    "part",
    "port",
    "action",
    "state",
    "item",
    "connection",
    "interface",
    "requirement",
    "constraint",
    "allocation",
    "enum",
    "calc",
    "view",
    "viewpoint",
    "occurrence",
    "ref",
    "flow"
  ]);
  function extractPackageNameFromHead(head) {
    const lines = head.split("\n");
    for (const line of lines) {
      let pos = skipSpaces(line, 0);
      if (matchWord(line, pos, "standard")) {
        pos = skipSpaces(line, pos + 8);
      }
      if (matchWord(line, pos, "library")) {
        pos = skipSpaces(line, pos + 7);
      }
      if (!matchWord(line, pos, "package")) continue;
      pos = skipSpaces(line, pos + 7);
      if (pos < line.length && line[pos] === "<") {
        const close = line.indexOf(">", pos);
        if (close < 0) continue;
        pos = skipSpaces(line, close + 1);
      }
      const w = readWord(line, pos);
      if (w) return w[0];
    }
    return void 0;
  }
  function extractTypeNameFromLine(line) {
    let w = readWord(line, 0);
    if (!w) return void 0;
    let [keyword, pos] = w;
    if (keyword === "abstract") {
      w = readWord(line, pos);
      if (!w) return void 0;
      [keyword, pos] = w;
    }
    if (STANDALONE_TYPE_KEYWORDS.has(keyword)) {
    } else if (keyword === "use") {
      w = readWord(line, pos);
      if (!w || w[0] !== "case") return void 0;
      w = readWord(line, w[1]);
      if (!w || w[0] !== "def") return void 0;
      pos = w[1];
    } else if (DEF_KEYWORDS.has(keyword)) {
      w = readWord(line, pos);
      if (!w || w[0] !== "def") return void 0;
      pos = w[1];
    } else {
      return void 0;
    }
    const nameOrAll = readName(line, pos);
    if (!nameOrAll) return void 0;
    if (nameOrAll[0] === "all") {
      return readName(line, nameOrAll[1])?.[0];
    }
    return nameOrAll[0];
  }
  function extractUsageNameFromLine(line) {
    if (line.length < 5 || line[0] !== " " || line[1] !== " " || line[2] !== " " || line[3] !== " ") {
      return void 0;
    }
    let w = readWord(line, 4);
    if (!w) return void 0;
    let [keyword, pos] = w;
    if (keyword === "abstract") {
      w = readWord(line, pos);
      if (!w) return void 0;
      [keyword, pos] = w;
    }
    if (keyword === "use") {
      w = readWord(line, pos);
      if (!w || w[0] !== "case") return void 0;
      pos = w[1];
    } else if (!USAGE_KEYWORDS.has(keyword)) {
      return void 0;
    }
    const name = readName(line, pos);
    if (!name) return void 0;
    const afterPos = skipSpaces(line, name[1]);
    if (afterPos >= line.length) return void 0;
    const ch = line[afterPos];
    if (ch !== ":" && ch !== "[" && ch !== ";" && ch !== "{") return void 0;
    return name[0];
  }
  function extractUsageLongNameFromLine(line) {
    if (line.length < 5 || line[0] !== " " || line[1] !== " " || line[2] !== " " || line[3] !== " ") {
      return void 0;
    }
    let w = readWord(line, 4);
    if (!w) return void 0;
    let [keyword, pos] = w;
    if (keyword === "abstract") {
      w = readWord(line, pos);
      if (!w) return void 0;
      [keyword, pos] = w;
    }
    if (keyword === "use") {
      w = readWord(line, pos);
      if (!w || w[0] !== "case") return void 0;
      pos = w[1];
    } else if (!USAGE_KEYWORDS.has(keyword)) {
      return void 0;
    }
    return readLongName(line, pos);
  }
  function cleanCommentLine(line) {
    let s = 0;
    let e = line.length;
    if (s < e && line[s] === "/") {
      s++;
      while (s < e && line[s] === "*") s++;
      while (s < e && (line[s] === " " || line[s] === "	")) s++;
    } else if (s < e && line[s] === "*") {
      s++;
      if (s < e && line[s] === " ") s++;
    }
    if (e > s && line[e - 1] === "/") {
      let te = e - 1;
      while (te > s && line[te - 1] === "*") te--;
      if (te < e - 1) {
        e = te;
        while (e > s && (line[e - 1] === " " || line[e - 1] === "	")) e--;
      }
    }
    return line.slice(s, e).trim();
  }
  var index;
  var typeIndex;
  function indexLibraryFile(fileUri, content, packages, types) {
    const pkgName = extractPackageNameFromHead(content);
    if (pkgName) {
      packages.set(pkgName, fileUri);
    }
    const lines = content.split("\n");
    for (let i = 0; i < lines.length; i++) {
      const typeName = extractTypeNameFromLine(lines[i]);
      if (typeName) {
        if (!types.has(typeName)) {
          types.set(typeName, { uri: fileUri, line: i });
        }
      }
      const usageName = extractUsageNameFromLine(lines[i]);
      if (usageName) {
        if (!types.has(usageName)) {
          types.set(usageName, { uri: fileUri, line: i });
        }
        if (pkgName) {
          const qualName = `${pkgName}::${usageName}`;
          if (!types.has(qualName)) {
            types.set(qualName, { uri: fileUri, line: i });
          }
        }
        const longName = extractUsageLongNameFromLine(lines[i]);
        if (longName && longName !== usageName) {
          if (!types.has(longName)) {
            types.set(longName, { uri: fileUri, line: i });
          }
          if (pkgName) {
            const qualLong = `${pkgName}::${longName}`;
            if (!types.has(qualLong)) {
              types.set(qualLong, { uri: fileUri, line: i });
            }
          }
        }
      }
    }
  }
  function buildIndexFromFiles(files) {
    const packages = /* @__PURE__ */ new Map();
    const types = /* @__PURE__ */ new Map();
    for (const file of files) {
      rawContentByUri.set(file.uri, file.content);
      rawContentByNormalizedUri.set(normalizeStdlibUri(file.uri), file.content);
      indexLibraryFile(file.uri, file.content, packages, types);
    }
    return { packages, types };
  }
  function initLibraryIndex(serverDir, customPath) {
    rawContentByUri.clear();
    rawContentByNormalizedUri.clear();
    fileContentCache.clear();
    hoverInfoCache.clear();
    const files = loadLibraryFiles(serverDir, customPath);
    const result = buildIndexFromFiles(files);
    index = result.packages;
    typeIndex = result.types;
    return index.size;
  }
  function resolveLibraryPackage(name) {
    if (!index) return void 0;
    const pkg = name.split("::")[0];
    return index.get(pkg);
  }
  function resolveLibraryType(name) {
    if (!typeIndex) return void 0;
    const exact = typeIndex.get(name);
    if (exact) return exact;
    if (name.includes("::")) {
      const member = name.split("::").pop();
      return typeIndex.get(member);
    }
    return void 0;
  }
  function getLibraryPackageNames() {
    return index ? Array.from(index.keys()) : [];
  }
  var rawContentByUri = /* @__PURE__ */ new Map();
  var rawContentByNormalizedUri = /* @__PURE__ */ new Map();
  var fileContentCache = /* @__PURE__ */ new Map();
  var FILE_CACHE_MAX = 50;
  var hoverInfoCache = /* @__PURE__ */ new Map();
  var HOVER_CACHE_MAX = 200;
  function getCachedFileLines(uri) {
    const cached = fileContentCache.get(uri);
    if (cached) return cached;
    const content = rawContentByUri.get(uri);
    if (content === void 0) {
      return void 0;
    }
    const lines = content.split("\n");
    if (fileContentCache.size >= FILE_CACHE_MAX) {
      const firstKey = fileContentCache.keys().next().value;
      if (firstKey !== void 0) fileContentCache.delete(firstKey);
    }
    fileContentCache.set(uri, lines);
    return lines;
  }
  function normalizeStdlibUri(uri) {
    const withoutScheme = uri.replace(/^sysml-stdlib:\/*/i, "");
    try {
      return decodeURIComponent(withoutScheme);
    } catch {
      return withoutScheme;
    }
  }
  function getLibraryFileContent(uri) {
    const exact = rawContentByUri.get(uri);
    if (exact !== void 0) return exact;
    return rawContentByNormalizedUri.get(normalizeStdlibUri(uri));
  }
  function getLibraryHoverInfo(name) {
    if (hoverInfoCache.has(name)) {
      return hoverInfoCache.get(name) ?? void 0;
    }
    const loc = resolveLibraryType(name);
    if (!loc) {
      if (hoverInfoCache.size >= HOVER_CACHE_MAX) {
        const firstKey = hoverInfoCache.keys().next().value;
        if (firstKey !== void 0) hoverInfoCache.delete(firstKey);
      }
      hoverInfoCache.set(name, null);
      return void 0;
    }
    const lines = getCachedFileLines(loc.uri);
    if (!lines) return void 0;
    const declLine = (lines[loc.line] ?? "").trim();
    let packageName;
    if (index) {
      for (const [pkg, uri] of index.entries()) {
        if (uri === loc.uri) {
          packageName = pkg;
          break;
        }
      }
    }
    let documentation;
    const commentLines = [];
    for (let i = loc.line - 1; i >= 0 && i >= loc.line - 30; i--) {
      const l = (lines[i] ?? "").trim();
      if (l.endsWith("*/")) {
        commentLines.unshift(l);
        for (let j = i - 1; j >= 0 && j >= i - 50; j--) {
          const cl = (lines[j] ?? "").trim();
          commentLines.unshift(cl);
          if (cl.startsWith("/*")) break;
        }
        break;
      }
      if (l === "") continue;
      break;
    }
    if (commentLines.length > 0) {
      documentation = commentLines.map((l) => cleanCommentLine(l)).filter((l) => l.length > 0).join("\n");
    }
    const result = {
      declaration: declLine,
      packageName,
      documentation
    };
    if (hoverInfoCache.size >= HOVER_CACHE_MAX) {
      const firstKey = hoverInfoCache.keys().next().value;
      if (firstKey !== void 0) hoverInfoCache.delete(firstKey);
    }
    hoverInfoCache.set(name, result);
    return result;
  }

  // server/src/analysis/complexityAnalyzer.ts
  var WEIGHTS = {
    /** Raw element count contribution (log-scaled) — slightly higher so
     *  large, feature-rich documents score proportionally higher. */
    size: 0.25,
    /** Max nesting depth */
    depth: 0.2,
    /** Coupling / type references per definition */
    coupling: 0.25,
    /** Inverse documentation coverage (less docs = more complex) */
    docDebt: 0.1,
    /** Average fan-out (children per def) */
    fanOut: 0.2
  };
  function analyseComplexity(symbols) {
    if (symbols.length === 0) {
      return emptyReport();
    }
    const defs = symbols.filter((s) => isDefinition(s.kind));
    const usages = symbols.filter((s) => isUsage(s.kind));
    const packages = symbols.filter((s) => s.kind === "package" /* Package */);
    const depthMap = computeDepths(symbols);
    const maxDepth = Math.max(...Array.from(depthMap.values()), 0);
    const byQualifiedName = new Map(symbols.map((s) => [s.qualifiedName, s]));
    const childCounts = /* @__PURE__ */ new Map();
    for (const d of defs) {
      childCounts.set(d.qualifiedName, 0);
    }
    for (const s of symbols) {
      if (s.parentQualifiedName && childCounts.has(s.parentQualifiedName)) {
        childCounts.set(s.parentQualifiedName, (childCounts.get(s.parentQualifiedName) ?? 0) + 1);
      }
    }
    const avgChildrenPerDef = defs.length > 0 ? round(Array.from(childCounts.values()).reduce((a, b) => a + b, 0) / defs.length) : 0;
    const defNames = new Set(defs.map((d) => d.name));
    let couplingCount = 0;
    const typeRefsPerDef = /* @__PURE__ */ new Map();
    for (const d of defs) {
      typeRefsPerDef.set(d.qualifiedName, 0);
    }
    const advanced = computeAdvancedSignals(symbols, defs, byQualifiedName);
    for (const s of usages) {
      for (const tn of s.typeNames) {
        if (defNames.has(tn)) {
          couplingCount++;
          if (s.parentQualifiedName && typeRefsPerDef.has(s.parentQualifiedName)) {
            typeRefsPerDef.set(
              s.parentQualifiedName,
              (typeRefsPerDef.get(s.parentQualifiedName) ?? 0) + 1
            );
          }
        }
      }
    }
    const referencedTypes = new Set(
      usages.flatMap((s) => s.typeNames)
    );
    const unusedDefinitions = defs.filter(
      (d) => d.kind !== "enum def" /* EnumDef */ && !referencedTypes.has(d.name)
    ).length;
    const documentedDefs = defs.filter((d) => d.documentation).length;
    const documentationCoverage = defs.length > 0 ? round(documentedDefs / defs.length * 100) : 100;
    const hotspots = defs.map((d) => {
      const cc = childCounts.get(d.qualifiedName) ?? 0;
      const dp = depthMap.get(d.qualifiedName) ?? 0;
      const tr = typeRefsPerDef.get(d.qualifiedName) ?? 0;
      const hasDoc = !!d.documentation;
      const behaviorSignal = advanced.behaviorByDef.get(d.qualifiedName) ?? 0;
      const score = computeDefScore(cc, dp, tr, hasDoc, behaviorSignal);
      return {
        qualifiedName: d.qualifiedName,
        kind: d.kind,
        childCount: cc,
        depth: dp,
        typeRefs: tr,
        hasDoc,
        score
      };
    }).sort((a, b) => b.score - a.score);
    const enrichedDepth = Math.max(maxDepth, advanced.maxCalcChainDepth + 1);
    const enrichedCoupling = couplingCount + advanced.specializationLinks + Math.round(advanced.performUsages * 0.5) + Math.round(advanced.transitionUsages * 0.5) + Math.round(advanced.stdLibTypeRefs * 0.6);
    const enrichedFanOut = avgChildrenPerDef + advanced.actionComplexityBonus;
    const complexityIndex = computeIndex(
      symbols.length,
      enrichedDepth,
      enrichedCoupling,
      defs.length,
      enrichedFanOut,
      documentationCoverage
    );
    return {
      totalElements: symbols.length,
      definitions: defs.length,
      usages: usages.length,
      packages: packages.length,
      maxDepth,
      avgChildrenPerDef,
      couplingCount,
      unusedDefinitions,
      documentationCoverage,
      complexityIndex,
      rating: indexToRating(complexityIndex),
      hotspots
    };
  }
  function computeAdvancedSignals(symbols, defs, byQualifiedName) {
    const defNames = new Set(defs.map((d) => d.name));
    const behaviorByDef = /* @__PURE__ */ new Map();
    for (const d of defs) {
      behaviorByDef.set(d.qualifiedName, 0);
    }
    let specializationLinks = 0;
    let performUsages = 0;
    let transitionUsages = 0;
    let stdLibTypeRefs = 0;
    let maxCalcChainDepth = 0;
    let actionComplexityBonus = 0;
    const addBehavior = (qualifiedName, amount) => {
      if (!qualifiedName || !behaviorByDef.has(qualifiedName)) return;
      behaviorByDef.set(qualifiedName, (behaviorByDef.get(qualifiedName) ?? 0) + amount);
    };
    for (const d of defs) {
      specializationLinks += d.typeNames.length;
      addBehavior(d.qualifiedName, Math.min(3, d.typeNames.length));
    }
    for (const s of symbols) {
      switch (s.kind) {
        case "perform action" /* PerformActionUsage */:
          performUsages++;
          addBehavior(s.parentQualifiedName, 2);
          break;
        case "calc" /* CalcUsage */:
          addBehavior(s.parentQualifiedName, 2);
          break;
        case "calc def" /* CalcDef */:
          addBehavior(s.parentQualifiedName, 1);
          break;
        case "transition" /* TransitionUsage */:
          transitionUsages++;
          addBehavior(s.parentQualifiedName, 2);
          break;
        case "exhibit state" /* ExhibitStateUsage */:
          addBehavior(s.parentQualifiedName, 1);
          break;
        default:
          break;
      }
      if (s.kind === "action def" /* ActionDef */) {
        const localBehavior = symbols.filter((c) => c.parentQualifiedName === s.qualifiedName).reduce((score, c) => {
          if (c.kind === "perform action" /* PerformActionUsage */) return score + 2;
          if (c.kind === "calc" /* CalcUsage */ || c.kind === "calc def" /* CalcDef */) return score + 2;
          if (c.kind === "action" /* ActionUsage */) return score + 1;
          return score;
        }, 0);
        actionComplexityBonus += Math.min(4, localBehavior / 4);
        addBehavior(s.qualifiedName, Math.min(4, localBehavior));
      }
      if (s.kind === "calc" /* CalcUsage */ || s.kind === "calc def" /* CalcDef */) {
        const chainDepth = calcChainDepth(s, byQualifiedName);
        if (chainDepth > maxCalcChainDepth) {
          maxCalcChainDepth = chainDepth;
        }
        addBehavior(s.parentQualifiedName, Math.min(3, chainDepth));
      }
      for (const typeName of s.typeNames) {
        if (defNames.has(typeName)) continue;
        if (looksLikeStdLibType(typeName)) {
          stdLibTypeRefs++;
          addBehavior(s.parentQualifiedName, 1);
        }
      }
    }
    return {
      specializationLinks,
      performUsages,
      transitionUsages,
      stdLibTypeRefs,
      maxCalcChainDepth,
      actionComplexityBonus,
      behaviorByDef
    };
  }
  function calcChainDepth(symbol, byQualifiedName) {
    let depth = 1;
    let cursor = symbol.parentQualifiedName ? byQualifiedName.get(symbol.parentQualifiedName) : void 0;
    while (cursor && (cursor.kind === "calc" /* CalcUsage */ || cursor.kind === "calc def" /* CalcDef */)) {
      depth++;
      cursor = cursor.parentQualifiedName ? byQualifiedName.get(cursor.parentQualifiedName) : void 0;
    }
    return depth;
  }
  function looksLikeStdLibType(typeName) {
    if (!typeName) return false;
    if (typeName.includes("::")) return true;
    const commonStdLibTypes = /* @__PURE__ */ new Set([
      "String",
      "Boolean",
      "Integer",
      "Natural",
      "Real",
      "Complex",
      "Number",
      "Map",
      "OrderedMap",
      "Set",
      "Sequence",
      "Bag",
      "Vector",
      "KeyValuePair",
      "Duration",
      "Time",
      "DateTime",
      "Mass",
      "Length",
      "Speed",
      "Acceleration"
    ]);
    return commonStdLibTypes.has(typeName);
  }
  function emptyReport() {
    return {
      totalElements: 0,
      definitions: 0,
      usages: 0,
      packages: 0,
      maxDepth: 0,
      avgChildrenPerDef: 0,
      couplingCount: 0,
      unusedDefinitions: 0,
      documentationCoverage: 100,
      complexityIndex: 0,
      rating: "trivial",
      hotspots: []
    };
  }
  function computeDepths(symbols) {
    const result = /* @__PURE__ */ new Map();
    const byQN = new Map(symbols.map((s) => [s.qualifiedName, s]));
    function depth(qn) {
      if (result.has(qn)) return result.get(qn);
      const sym = byQN.get(qn);
      if (!sym || !sym.parentQualifiedName) {
        result.set(qn, 0);
        return 0;
      }
      const d = depth(sym.parentQualifiedName) + 1;
      result.set(qn, d);
      return d;
    }
    for (const s of symbols) {
      depth(s.qualifiedName);
    }
    return result;
  }
  function computeIndex(elementCount, maxDepth, coupling, defCount, avgFanOut, docCoverage) {
    const sizeN = clamp(Math.log2(Math.max(elementCount, 1)) / 10);
    const depthN = clamp(maxDepth / 8);
    const couplingN = defCount > 0 ? clamp(coupling / defCount / 5) : 0;
    const fanOutN = clamp(avgFanOut / 15);
    const docDebtN = clamp(1 - docCoverage / 100);
    const raw = WEIGHTS.size * sizeN + WEIGHTS.depth * depthN + WEIGHTS.coupling * couplingN + WEIGHTS.fanOut * fanOutN + WEIGHTS.docDebt * docDebtN;
    return Math.round(raw * 100);
  }
  function computeDefScore(childCount, depth, typeRefs, hasDoc, behaviorSignal = 0) {
    const cc = clamp(childCount / 15) * 30;
    const dp = clamp(depth / 6) * 20;
    const tr = clamp(typeRefs / 5) * 25;
    const dc = hasDoc ? 0 : 15;
    const bs = clamp(behaviorSignal / 8) * 10;
    return Math.round(Math.min(100, cc + dp + tr + dc + bs));
  }
  function indexToRating(index2) {
    if (index2 <= 10) return "trivial";
    if (index2 <= 25) return "simple";
    if (index2 <= 50) return "moderate";
    if (index2 <= 75) return "complex";
    return "very complex";
  }
  function clamp(value) {
    return Math.max(0, Math.min(1, value));
  }
  function round(value) {
    return Math.round(value * 100) / 100;
  }

  // server/src/model/sysmlModelProvider.ts
  function containsWord(text, word) {
    let idx = 0;
    while ((idx = text.indexOf(word, idx)) !== -1) {
      const before = idx > 0 ? text.charCodeAt(idx - 1) : 32;
      const after = idx + word.length < text.length ? text.charCodeAt(idx + word.length) : 32;
      if (!isIdentPart(before) && !isIdentPart(after)) return true;
      idx += 1;
    }
    return false;
  }
  function findWordPositions(text, word) {
    const results = [];
    let idx = 0;
    while ((idx = text.indexOf(word, idx)) !== -1) {
      const before = idx > 0 ? text.charCodeAt(idx - 1) : 32;
      const afterIdx = idx + word.length;
      const after = afterIdx < text.length ? text.charCodeAt(afterIdx) : 32;
      if (!isIdentPart(before) && !isIdentPart(after)) {
        results.push({ pos: idx, afterPos: afterIdx });
      }
      idx += 1;
    }
    return results;
  }
  function findWordPositionsCI(text, word) {
    const lower = text.toLowerCase();
    const wordLower = word.toLowerCase();
    const results = [];
    let idx = 0;
    while ((idx = lower.indexOf(wordLower, idx)) !== -1) {
      const before = idx > 0 ? lower.charCodeAt(idx - 1) : 32;
      const afterIdx = idx + wordLower.length;
      const after = afterIdx < lower.length ? lower.charCodeAt(afterIdx) : 32;
      if (!isIdentPart(before) && !isIdentPart(after)) {
        results.push({ pos: idx, afterPos: afterIdx });
      }
      idx += 1;
    }
    return results;
  }
  function skipWS(text, pos) {
    while (pos < text.length) {
      const ch = text[pos];
      if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") pos++;
      else break;
    }
    return pos;
  }
  function readIdent(text, pos, allowDots = false) {
    let end = pos;
    while (end < text.length) {
      const ch = text.charCodeAt(end);
      if (isIdentPart(ch)) {
        end++;
      } else if (allowDots && text[end] === ".") {
        end++;
      } else if (text[end] === ":" && end + 1 < text.length && text[end + 1] === ":") {
        end += 2;
      } else {
        break;
      }
    }
    return [text.substring(pos, end), end];
  }
  function readNameOrQuoted(text, pos, allowDots = false) {
    if (pos < text.length && text[pos] === "'") {
      const close = text.indexOf("'", pos + 1);
      if (close >= 0) return [text.substring(pos + 1, close), close + 1];
    }
    return readIdent(text, pos, allowDots);
  }
  function readWordAfterKeyword(text, afterPos, allowDots = false) {
    const start = skipWS(text, afterPos);
    return readIdent(text, start, allowDots);
  }
  function readCommaSeparatedIdents(text, pos) {
    const names = [];
    let p = skipWS(text, pos);
    while (p < text.length) {
      const [name, end] = readIdent(text, p);
      if (!name) break;
      names.push(name);
      p = skipWS(text, end);
      if (p < text.length && text[p] === ",") {
        p = skipWS(text, p + 1);
      } else {
        break;
      }
    }
    return names;
  }
  var SysMLModelProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    /** Cached symbol tables keyed by URI. */
    _stCache = /* @__PURE__ */ new Map();
    /** Remove cached symbol table for a URI (e.g. on document close). */
    removeUri(uri) {
      this._stCache.delete(uri);
    }
    /**
     * Drop **all** cached symbol tables.
     * Returns the number of entries that were evicted.
     */
    clearAll() {
      const count = this._stCache.size;
      this._stCache.clear();
      return count;
    }
    /** Number of cached symbol tables (for diagnostics / stats). */
    get cacheSize() {
      return this._stCache.size;
    }
    /**
     * Return a cached-or-fresh SymbolTable for a URI.
     *
     * The table is rebuilt only when the document version changes.
     */
    _getSymbolTable(uri, parseResult) {
      const version = this.documentManager.getVersion(uri);
      const cached = this._stCache.get(uri);
      if (cached && cached.version === version) {
        return cached.table;
      }
      const table = new SymbolTable();
      table.build(uri, parseResult);
      this._stCache.set(uri, { version, table });
      return table;
    }
    /**
     * Build the model response for a document.
     *
     * @param uri       Document URI
     * @param version   Document version (for staleness detection)
     * @param scopes    Which sections to include (empty/undefined = all)
     */
    getModel(uri, version, scopes) {
      const startTime = Date.now();
      const parseResult = this.documentManager.get(uri);
      if (!parseResult) {
        return { version: -1 };
      }
      const scopeSet = new Set(
        scopes && scopes.length > 0 ? scopes : ["elements", "relationships", "sequenceDiagrams", "activityDiagrams", "resolvedTypes", "diagnostics"]
      );
      const symbolTable = this._getSymbolTable(uri, parseResult);
      const text = this.documentManager.getText(uri) ?? "";
      const lines = text.split("\n");
      const result = { version };
      if (scopeSet.has("elements")) {
        result.elements = this.convertToElementDTOs(symbolTable, uri, lines);
      }
      if (scopeSet.has("relationships")) {
        result.relationships = this.extractRelationships(symbolTable, uri, lines);
      }
      if (scopeSet.has("sequenceDiagrams")) {
        result.sequenceDiagrams = this.extractSequenceDiagrams(symbolTable, uri, lines);
      }
      if (scopeSet.has("activityDiagrams")) {
        result.activityDiagrams = this.extractActivityDiagrams(symbolTable, uri, lines);
      }
      if (scopeSet.has("resolvedTypes")) {
        result.resolvedTypes = this.extractResolvedTypes(symbolTable, uri, lines);
      }
      if (scopeSet.has("diagnostics")) {
        result.diagnostics = this.extractSemanticDiagnostics(symbolTable, uri);
      }
      const allSymbols = symbolTable.getSymbolsForUri(uri);
      const resolved = allSymbols.filter((s) => s.typeNames.length > 0);
      const parseTimeMs = this.documentManager.getParseTimeMs(uri);
      const timingBreakdown = this.documentManager.getTimingBreakdown(uri);
      const modelBuildTimeMs = Date.now() - startTime;
      result.stats = {
        totalElements: allSymbols.length,
        resolvedElements: resolved.length,
        unresolvedElements: allSymbols.length - resolved.length,
        parseTimeMs,
        lexTimeMs: timingBreakdown.lexMs,
        parseOnlyTimeMs: timingBreakdown.parseMs,
        modelBuildTimeMs,
        complexity: analyseComplexity(allSymbols)
      };
      return result;
    }
    // -----------------------------------------------------------------------
    // Element Tree Conversion
    // -----------------------------------------------------------------------
    /**
     * Convert the symbol table into a recursive element tree.
     *
     * The symbol table stores a flat list with `parentQualifiedName` pointers.
     * We rebuild the tree by grouping symbols by parent and recursively
     * attaching children.
     */
    convertToElementDTOs(symbolTable, uri, lines) {
      const symbols = symbolTable.getSymbolsForUri(uri);
      const byQualifiedName = /* @__PURE__ */ new Map();
      for (const sym of symbols) {
        byQualifiedName.set(sym.qualifiedName, sym);
      }
      const childrenOf = /* @__PURE__ */ new Map();
      for (const sym of symbols) {
        if (sym.parentQualifiedName && byQualifiedName.has(sym.parentQualifiedName)) {
          const list = childrenOf.get(sym.parentQualifiedName) ?? [];
          list.push(sym);
          childrenOf.set(sym.parentQualifiedName, list);
        }
      }
      const roots = symbols.filter(
        (s) => !s.parentQualifiedName || !byQualifiedName.has(s.parentQualifiedName)
      );
      return roots.map((s) => this.symbolToElementDTO(s, childrenOf, lines));
    }
    /**
     * Convert a single SysMLSymbol into an SysMLElementDTO, recursively
     * including children.
     */
    symbolToElementDTO(symbol, childrenOf, lines) {
      const childSymbols = (childrenOf.get(symbol.qualifiedName) ?? []).filter((c) => c.qualifiedName !== symbol.qualifiedName);
      const children = childSymbols.map(
        (c) => this.symbolToElementDTO(c, childrenOf, lines)
      );
      const attributes = {};
      if (symbol.typeNames.length > 0) {
        const typeLabel = symbol.typeNames.join(", ");
        if (symbol.kind === "port" /* PortUsage */ || symbol.kind === "port def" /* PortDef */) {
          attributes["portType"] = typeLabel;
        } else {
          attributes["partType"] = typeLabel;
        }
      }
      if (symbol.documentation) {
        attributes["documentation"] = symbol.documentation;
      }
      if (symbol.metadataAnnotations && symbol.metadataAnnotations.length > 0) {
        attributes["metadataAnnotations"] = symbol.metadataAnnotations.join(", ");
      }
      if (symbol.exposeTargets && symbol.exposeTargets.length > 0) {
        attributes["exposeTargets"] = symbol.exposeTargets.join(",");
      }
      if (symbol.viewFilters && symbol.viewFilters.length > 0) {
        attributes["viewFilters"] = symbol.viewFilters.join(",");
      }
      if (symbol.viewRendering) {
        attributes["viewRendering"] = symbol.viewRendering;
      }
      const direction = this.extractDirection(symbol, lines);
      if (direction) {
        attributes["direction"] = direction;
      }
      const multiplicity = this.extractMultiplicity(symbol, lines);
      if (multiplicity) {
        attributes["multiplicity"] = multiplicity;
      }
      const modifier = this.extractModifier(symbol, lines);
      if (modifier) {
        attributes["modifier"] = modifier;
      }
      const visibility = this.extractVisibility(symbol, lines);
      if (visibility) {
        attributes["visibility"] = visibility;
      }
      const value = this.extractValue(symbol, lines);
      if (value) {
        attributes["value"] = value;
      }
      const relationships = [];
      for (const tn of symbol.typeNames) {
        relationships.push({
          type: "typing",
          source: symbol.name,
          target: tn
        });
      }
      const specializations = this.extractSpecializations(symbol, lines);
      for (const spec of specializations) {
        relationships.push({
          type: "specializes",
          source: symbol.name,
          target: spec
        });
      }
      return {
        type: symbol.kind,
        name: symbol.name,
        range: this.rangeToDTO(symbol.range),
        children,
        attributes,
        relationships
      };
    }
    // -----------------------------------------------------------------------
    // Relationship Extraction
    // -----------------------------------------------------------------------
    /**
     * Extract a flat list of relationships from the symbol table.
     * Includes typing, specialization, connections, and more.
     */
    extractRelationships(symbolTable, uri, lines) {
      const symbols = symbolTable.getSymbolsForUri(uri);
      const relationships = [];
      for (const symbol of symbols) {
        if (symbol.kind === "package" /* Package */ || symbol.kind === "import" /* Import */ || symbol.kind === "comment" /* Comment */ || symbol.kind === "doc" /* Doc */) {
          continue;
        }
        if (symbol.typeNames.length > 0 && isUsage(symbol.kind)) {
          for (const tn of symbol.typeNames) {
            relationships.push({
              type: "typing",
              source: symbol.name,
              target: tn
            });
          }
        }
        const specializations = this.extractSpecializations(symbol, lines);
        for (const spec of specializations) {
          relationships.push({
            type: "specializes",
            source: symbol.name,
            target: spec
          });
        }
        if (symbol.kind === "connection" /* ConnectionUsage */) {
          const connectionTargets = this.extractConnectionEndpoints(symbol, lines);
          if (connectionTargets.length === 2) {
            relationships.push({
              type: "connection",
              source: connectionTargets[0],
              target: connectionTargets[1],
              name: symbol.name
            });
          }
        }
        if (symbol.kind === "allocation" /* AllocationUsage */) {
          const allocTargets = this.extractConnectionEndpoints(symbol, lines);
          if (allocTargets.length === 2) {
            relationships.push({
              type: "allocation",
              source: allocTargets[0],
              target: allocTargets[1],
              name: symbol.name
            });
          }
        }
        const elementText = this.getElementText(symbol, lines);
        const additionalRels = this.extractKeywordRelationships(symbol.name, elementText);
        relationships.push(...additionalRels);
      }
      const fullText = lines.join("\n");
      const standaloneSatisfy = this.extractStandaloneSatisfyVerify(stripComments(fullText));
      for (const rel of standaloneSatisfy) {
        const isDup = relationships.some(
          (r) => r.type === rel.type && r.source === rel.source && r.target === rel.target
        );
        if (!isDup) relationships.push(rel);
      }
      return relationships;
    }
    // -----------------------------------------------------------------------
    // Sequence Diagram Extraction
    // -----------------------------------------------------------------------
    /**
     * Extract sequence diagram data from the symbol table.
     *
     * Sequence diagrams are built from:
     * 1. Action definitions/usages with explicit send/accept message patterns
     * 2. Synthesised from action definitions that have first/then/done flows
     *    (flow-to-sequence synthesis — matches ANTLR behaviour)
     */
    extractSequenceDiagrams(symbolTable, uri, lines) {
      const symbols = symbolTable.getSymbolsForUri(uri);
      const diagrams = [];
      const seen = /* @__PURE__ */ new Set();
      for (const symbol of symbols) {
        if (symbol.kind !== "action def" /* ActionDef */ && symbol.kind !== "action" /* ActionUsage */) {
          continue;
        }
        const children = this.getChildSymbols(symbol, symbolTable);
        const participants = [];
        const messages = [];
        for (const child of children) {
          if (child.kind === "part" /* PartUsage */ || child.kind === "item" /* ItemUsage */) {
            participants.push({
              name: child.name,
              type: child.typeNames.join(", ") || child.kind,
              range: this.rangeToDTO(child.range)
            });
          }
        }
        const fullText = this.getFullElementText(symbol, lines);
        let occurrence = 1;
        for (const { afterPos } of findWordPositionsCI(fullText, "send")) {
          const sigStart = skipWS(fullText, afterPos);
          const [signal, afterSig] = readIdent(fullText, sigStart, true);
          if (!signal) continue;
          const kwStart = skipWS(fullText, afterSig);
          const [kw, afterKw] = readIdent(fullText, kwStart);
          if (kw !== "via" && kw !== "to") continue;
          const tgtStart = skipWS(fullText, afterKw);
          const [target] = readIdent(fullText, tgtStart, true);
          if (!target) continue;
          messages.push({
            name: `send_${occurrence}`,
            from: symbol.name,
            to: target,
            payload: signal,
            occurrence: occurrence++,
            range: this.rangeToDTO(symbol.range)
          });
        }
        for (const { afterPos } of findWordPositionsCI(fullText, "accept")) {
          const sigStart = skipWS(fullText, afterPos);
          const [signal, afterSig] = readIdent(fullText, sigStart, true);
          if (!signal) continue;
          const kwStart = skipWS(fullText, afterSig);
          const [kw, afterKw] = readIdent(fullText, kwStart);
          if (kw !== "via" && kw !== "from") continue;
          const srcStart = skipWS(fullText, afterKw);
          const [source] = readIdent(fullText, srcStart, true);
          if (!source) continue;
          messages.push({
            name: `accept_${occurrence}`,
            from: source,
            to: symbol.name,
            payload: signal,
            occurrence: occurrence++,
            range: this.rangeToDTO(symbol.range)
          });
        }
        for (const child of children) {
          if (child.kind === "action" /* ActionUsage */) {
            const childText = this.getFullElementText(child, lines);
            for (const { afterPos } of findWordPositionsCI(childText, "send")) {
              const sigStart = skipWS(childText, afterPos);
              const [signal, afterSig] = readIdent(childText, sigStart, true);
              if (!signal) continue;
              const kwStart = skipWS(childText, afterSig);
              const [kw, afterKw] = readIdent(childText, kwStart);
              if (kw !== "via" && kw !== "to") continue;
              const tgtStart = skipWS(childText, afterKw);
              const [target] = readIdent(childText, tgtStart, true);
              if (!target) continue;
              messages.push({
                name: child.name,
                from: target ?? symbol.name,
                to: signal ?? "",
                payload: signal ?? "",
                occurrence: occurrence++,
                range: this.rangeToDTO(child.range)
              });
            }
            for (const { afterPos } of findWordPositionsCI(childText, "accept")) {
              const sigStart = skipWS(childText, afterPos);
              const [signal, afterSig] = readIdent(childText, sigStart, true);
              if (!signal) continue;
              const kwStart = skipWS(childText, afterSig);
              const [kw, afterKw] = readIdent(childText, kwStart);
              if (kw !== "via" && kw !== "from") continue;
              const srcStart = skipWS(childText, afterKw);
              const [source] = readIdent(childText, srcStart, true);
              if (!source) continue;
              messages.push({
                name: child.name,
                from: source ?? "",
                to: symbol.name,
                payload: signal ?? "",
                occurrence: occurrence++,
                range: this.rangeToDTO(child.range)
              });
            }
          }
        }
        if (participants.length > 0 || messages.length > 0) {
          diagrams.push({
            name: symbol.name,
            participants,
            messages,
            range: this.rangeToDTO(symbol.range)
          });
          if (messages.length > 0) {
            seen.add(symbol.qualifiedName);
          }
        }
      }
      for (const symbol of symbols) {
        if (seen.has(symbol.qualifiedName)) continue;
        if (symbol.kind !== "action def" /* ActionDef */ && symbol.kind !== "action" /* ActionUsage */) {
          continue;
        }
        const children = this.getChildSymbols(symbol, symbolTable);
        const hasChildActions = children.some(
          (c) => c.kind === "action" /* ActionUsage */ || c.kind === "action def" /* ActionDef */
        );
        if (!hasChildActions) continue;
        const flows = this.extractSuccessions(symbol, lines);
        if (flows.length === 0) continue;
        const participants = children.filter((c) => c.kind === "action" /* ActionUsage */ || c.kind === "action def" /* ActionDef */).map((c) => ({
          name: c.name,
          type: c.typeNames.join(", ") || "action",
          range: this.rangeToDTO(c.range)
        }));
        const messages = [];
        let occ = 1;
        for (const flow of flows) {
          if (flow.from === "start" || flow.to === "done") continue;
          const label = flow.guard ?? flow.to;
          messages.push({
            name: label,
            from: flow.from,
            to: flow.to,
            payload: flow.guard ?? "",
            occurrence: occ++,
            range: flow.range
          });
        }
        if (participants.length > 0 || messages.length > 0) {
          const existingIdx = diagrams.findIndex((d) => d.name === symbol.name);
          if (existingIdx >= 0) {
            diagrams.splice(existingIdx, 1);
          }
          diagrams.push({
            name: symbol.name,
            participants,
            messages,
            range: this.rangeToDTO(symbol.range)
          });
        }
      }
      const containerKinds = /* @__PURE__ */ new Set([
        "part def" /* PartDef */,
        "part" /* PartUsage */,
        "item def" /* ItemDef */,
        "item" /* ItemUsage */,
        "interface def" /* InterfaceDef */,
        "interface" /* InterfaceUsage */,
        "connection def" /* ConnectionDef */,
        "connection" /* ConnectionUsage */,
        "occurrence def" /* OccurrenceDef */,
        "occurrence" /* OccurrenceUsage */
      ]);
      const rootName = (qualified) => {
        if (!qualified) return qualified;
        const dotIdx = qualified.indexOf(".");
        const head = dotIdx >= 0 ? qualified.substring(0, dotIdx) : qualified;
        const ccIdx = head.lastIndexOf("::");
        return ccIdx >= 0 ? head.substring(ccIdx + 2) : head;
      };
      for (const symbol of symbols) {
        if (seen.has(symbol.qualifiedName)) continue;
        if (!containerKinds.has(symbol.kind)) continue;
        const children = this.getChildSymbols(symbol, symbolTable);
        const fullText = this.getFullElementText(symbol, lines);
        const parsedMessages = [];
        let occ = 1;
        for (const keyword of ["flow", "message"]) {
          for (const { afterPos } of findWordPositionsCI(fullText, keyword)) {
            const nameStart = skipWS(fullText, afterPos);
            const [name, afterName] = readIdent(fullText, nameStart);
            if (!name || name === "def") continue;
            const fromStart = skipWS(fullText, afterName);
            const [fromKw, afterFromKw] = readIdent(fullText, fromStart);
            if (fromKw !== "from") continue;
            const srcStart = skipWS(fullText, afterFromKw);
            const [srcRaw, afterSrc] = readIdent(fullText, srcStart, true);
            if (!srcRaw) continue;
            const toStart = skipWS(fullText, afterSrc);
            const [toKw, afterToKw] = readIdent(fullText, toStart);
            if (toKw !== "to") continue;
            const tgtStart = skipWS(fullText, afterToKw);
            const [tgtRaw] = readIdent(fullText, tgtStart, true);
            if (!tgtRaw) continue;
            parsedMessages.push({
              name,
              from: rootName(srcRaw),
              to: rootName(tgtRaw),
              payload: name,
              occurrence: occ++,
              range: this.rangeToDTO(symbol.range)
            });
          }
        }
        if (parsedMessages.length === 0) continue;
        const participants = [];
        for (const child of children) {
          if (child.kind === "part" /* PartUsage */ || child.kind === "item" /* ItemUsage */ || child.kind === "part def" /* PartDef */ || child.kind === "item def" /* ItemDef */ || child.kind === "ref" /* RefUsage */) {
            if (!participants.find((p) => p.name === child.name)) {
              participants.push({
                name: child.name,
                type: child.typeNames.join(", ") || child.kind,
                range: this.rangeToDTO(child.range)
              });
            }
          }
        }
        for (const msg of parsedMessages) {
          for (const endpoint of [msg.from, msg.to]) {
            if (endpoint && !participants.find((p) => p.name === endpoint)) {
              participants.push({
                name: endpoint,
                type: "participant",
                range: this.rangeToDTO(symbol.range)
              });
            }
          }
        }
        const existingIdx = diagrams.findIndex((d) => d.name === symbol.name);
        if (existingIdx >= 0) {
          diagrams.splice(existingIdx, 1);
        }
        diagrams.push({
          name: symbol.name,
          participants,
          messages: parsedMessages,
          range: this.rangeToDTO(symbol.range)
        });
        seen.add(symbol.qualifiedName);
      }
      return diagrams;
    }
    // -----------------------------------------------------------------------
    // Activity Diagram Extraction
    // -----------------------------------------------------------------------
    /**
     * Extract activity diagram data from action definitions and usages.
     *
     * D2: Now also includes ActionUsage elements that have child actions
     * (not just ActionDef), to capture perform actions and inline activities.
     */
    extractActivityDiagrams(symbolTable, uri, lines) {
      const symbols = symbolTable.getSymbolsForUri(uri);
      const diagrams = [];
      for (const symbol of symbols) {
        if (symbol.kind !== "action def" /* ActionDef */ && symbol.kind !== "action" /* ActionUsage */) {
          continue;
        }
        const children = this.getChildSymbols(symbol, symbolTable);
        const hasChildActions = children.some(
          (c) => c.kind === "action" /* ActionUsage */ || c.kind === "action def" /* ActionDef */
        );
        if (symbol.kind === "action" /* ActionUsage */ && !hasChildActions) {
          continue;
        }
        const actions = [];
        const decisions = [];
        const flows = [];
        const states = [];
        for (const child of children) {
          const childText = this.getElementText(child, lines);
          if (child.kind === "action" /* ActionUsage */ || child.kind === "action def" /* ActionDef */) {
            let actionType = "action";
            const lowerText = childText.toLowerCase();
            if (lowerText.includes("fork")) actionType = "fork";
            else if (lowerText.includes("join")) actionType = "join";
            else if (lowerText.includes("merge")) actionType = "merge";
            else if (lowerText.includes("decide")) actionType = "decision";
            const subActions = this.getChildSymbols(child, symbolTable).filter((c) => c.kind === "action" /* ActionUsage */ || c.kind === "action def" /* ActionDef */).map((c) => this.symbolToActionDTO(c, symbolTable, lines));
            actions.push({
              name: child.name,
              type: actionType,
              isDefinition: child.kind === "action def" /* ActionDef */,
              range: this.rangeToDTO(child.range),
              parent: symbol.name,
              children: subActions.map((a) => a.name),
              subActions: subActions.length > 0 ? subActions : void 0
            });
            if (actionType === "decision") {
              const branches = this.extractDecisionBranches(child, lines);
              decisions.push({
                name: child.name,
                condition: "",
                branches,
                range: this.rangeToDTO(child.range)
              });
            }
          }
          if (child.kind === "state" /* StateUsage */ || child.kind === "state def" /* StateDef */) {
            const stateType = childText.toLowerCase().includes("initial") ? "initial" : childText.toLowerCase().includes("final") ? "final" : "intermediate";
            states.push({
              name: child.name,
              type: stateType,
              range: this.rangeToDTO(child.range)
            });
          }
        }
        const successionFlows = this.extractSuccessions(symbol, lines);
        flows.push(...successionFlows);
        const fullText = this.getFullElementText(symbol, lines);
        const decideHits = findWordPositions(fullText, "decide");
        const hasDecideStmt = decideHits.some(({ afterPos }) => {
          const p = skipWS(fullText, afterPos);
          return p < fullText.length && fullText[p] === ";";
        });
        if (hasDecideStmt) {
          const branches = [];
          for (const { afterPos: ifAfter } of findWordPositions(fullText, "if")) {
            const thenIdx = fullText.indexOf("then", ifAfter);
            if (thenIdx < 0) continue;
            const bBefore = thenIdx > 0 ? fullText.charCodeAt(thenIdx - 1) : 32;
            const bAfter = thenIdx + 4 < fullText.length ? fullText.charCodeAt(thenIdx + 4) : 32;
            if (isIdentPart(bBefore) || isIdentPart(bAfter)) continue;
            const condition = fullText.substring(ifAfter, thenIdx).trim();
            const [target] = readWordAfterKeyword(fullText, thenIdx + 4);
            if (target) {
              branches.push({ condition, target });
            }
          }
          if (branches.length > 0) {
            decisions.push({
              name: "decide",
              condition: "",
              branches,
              range: this.rangeToDTO(symbol.range)
            });
          }
        }
        if (flows.length > 0) {
          const hasStartFlow = flows.some((f) => f.from === "start");
          const hasDoneFlow = flows.some((f) => f.to === "done");
          if (hasStartFlow) {
            actions.unshift({
              name: "start",
              type: "initial",
              isDefinition: false,
              range: this.rangeToDTO(symbol.range)
            });
          }
          if (hasDoneFlow) {
            actions.push({
              name: "done",
              type: "final",
              isDefinition: false,
              range: this.rangeToDTO(symbol.range)
            });
          }
          if (flows.some((f) => f.from === "decide")) {
            actions.push({
              name: "decide",
              type: "decision",
              isDefinition: false,
              range: this.rangeToDTO(symbol.range)
            });
          }
        }
        if (actions.length > 0 || flows.length > 0 || states.length > 0) {
          diagrams.push({
            name: symbol.name,
            actions,
            decisions,
            flows,
            states,
            range: this.rangeToDTO(symbol.range)
          });
        }
      }
      return diagrams;
    }
    // -----------------------------------------------------------------------
    // Resolved Types Extraction
    // -----------------------------------------------------------------------
    /**
     * Extract resolved type information from the symbol table.
     *
     * This provides specialization chains and feature lists for definitions.
     * Because the LSP server doesn't yet have a full type resolver or library
     * index, we provide what's available from the parse tree.
     */
    extractResolvedTypes(symbolTable, uri, lines) {
      const symbols = symbolTable.getSymbolsForUri(uri);
      const result = {};
      for (const symbol of symbols) {
        if (!isDefinition(symbol.kind) && symbol.typeNames.length === 0) {
          continue;
        }
        const specializes = [];
        const specList = this.extractSpecializations(symbol, lines);
        for (const s of specList) {
          if (!specializes.includes(s)) {
            specializes.push(s);
          }
        }
        for (const tn of symbol.typeNames) {
          if (!specializes.includes(tn)) {
            specializes.push(tn);
          }
        }
        const specializationChain = [...specializes];
        const children = this.getChildSymbols(symbol, symbolTable);
        const features = children.filter((c) => isUsage(c.kind)).map((c) => ({
          name: c.name,
          kind: this.featureKindFromElementKind(c.kind),
          type: c.typeNames.join(", ") || void 0,
          isDerived: false,
          isReadonly: false
        }));
        result[symbol.qualifiedName] = {
          qualifiedName: symbol.qualifiedName,
          simpleName: symbol.name,
          kind: symbol.kind,
          isLibraryType: false,
          specializationChain,
          specializes,
          features
        };
      }
      return result;
    }
    // -----------------------------------------------------------------------
    // Semantic Diagnostics
    // -----------------------------------------------------------------------
    /**
     * Extract semantic diagnostics beyond syntax errors.
     * Includes type resolution warnings, enum keyword validation, etc.
     */
    extractSemanticDiagnostics(symbolTable, uri) {
      const symbols = symbolTable.getSymbolsForUri(uri);
      const diagnostics = [];
      const allSymbolNames = new Set(symbolTable.getAllSymbols().map((s) => s.name));
      for (const symbol of symbols) {
        for (const tn of symbol.typeNames) {
          if (!allSymbolNames.has(tn)) {
            diagnostics.push({
              code: "unresolved-type",
              message: `Type '${tn}' could not be resolved in the current scope`,
              severity: "warning",
              range: this.rangeToDTO(symbol.selectionRange),
              elementName: symbol.name
            });
          }
        }
        if (symbol.kind === "enum def" /* EnumDef */) {
          const children = this.getChildSymbols(symbol, symbolTable);
          const hasEnumValues = children.some(
            (c) => c.kind === "enum" /* EnumUsage */ || c.kind === "attribute" /* AttributeUsage */
          );
          if (!hasEnumValues) {
            diagnostics.push({
              code: "empty-enum",
              message: `Enumeration '${symbol.name}' has no enum values defined`,
              severity: "info",
              range: this.rangeToDTO(symbol.range),
              elementName: symbol.name
            });
          }
        }
      }
      return diagnostics;
    }
    // -----------------------------------------------------------------------
    // Helper Methods
    // -----------------------------------------------------------------------
    /** Convert LSP Range → RangeDTO. */
    rangeToDTO(range) {
      return {
        start: { line: range.start.line, character: range.start.character },
        end: { line: range.end.line, character: range.end.character }
      };
    }
    /** Get child symbols for a given parent symbol. */
    getChildSymbols(parent, symbolTable) {
      const allSymbols = symbolTable.getSymbolsForUri(parent.uri);
      return allSymbols.filter((s) => s.parentQualifiedName === parent.qualifiedName);
    }
    /**
     * Get the source text for an element's declaration line only
     * (not children's text).  This avoids over-matching on parent elements
     * whose range spans child elements.
     */
    getElementText(symbol, lines) {
      const startLine = symbol.range.start.line;
      const endLine = Math.min(startLine + 2, symbol.range.end.line, lines.length - 1);
      return lines.slice(startLine, endLine + 1).join("\n");
    }
    /**
     * Get the full source text for an element's entire range.
     * Used when we need to scan the whole body (e.g., succession flows).
     */
    getFullElementText(symbol, lines) {
      const startLine = symbol.range.start.line;
      const endLine = Math.min(symbol.range.end.line, lines.length - 1);
      return lines.slice(startLine, endLine + 1).join("\n");
    }
    /** Extract port direction (in | out | inout) from source text. */
    extractDirection(symbol, lines) {
      if (symbol.kind !== "port" /* PortUsage */ && symbol.kind !== "port def" /* PortDef */) {
        return void 0;
      }
      const elementText = this.getElementText(symbol, lines);
      if (containsWord(elementText, "inout")) return "inout";
      if (containsWord(elementText, "in")) return "in";
      if (containsWord(elementText, "out")) return "out";
      return void 0;
    }
    /** Extract multiplicity (e.g., [4], [0..*]) from source text. */
    extractMultiplicity(symbol, lines) {
      const elementText = this.getElementText(symbol, lines);
      const open = elementText.indexOf("[");
      if (open < 0) return void 0;
      const close = elementText.indexOf("]", open + 1);
      if (close < 0) return void 0;
      return elementText.substring(open + 1, close);
    }
    /** Extract modifiers (abstract, readonly, derived, etc.) from source text. */
    extractModifier(symbol, lines) {
      const elementText = this.getElementText(symbol, lines);
      const modifiers = [];
      if (containsWord(elementText, "abstract")) modifiers.push("abstract");
      if (containsWord(elementText, "readonly")) modifiers.push("readonly");
      if (containsWord(elementText, "derived")) modifiers.push("derived");
      if (containsWord(elementText, "variation")) modifiers.push("variation");
      if (containsWord(elementText, "individual")) modifiers.push("individual");
      return modifiers.length > 0 ? modifiers.join(", ") : void 0;
    }
    /** Extract visibility (public | private | protected) from source text. */
    extractVisibility(symbol, lines) {
      const elementText = this.getElementText(symbol, lines);
      if (containsWord(elementText, "private")) return "private";
      if (containsWord(elementText, "protected")) return "protected";
      if (containsWord(elementText, "public")) return "public";
      return void 0;
    }
    /** Extract default/assigned value from source text. */
    extractValue(symbol, lines) {
      if (symbol.kind !== "attribute" /* AttributeUsage */) {
        return void 0;
      }
      const elementText = this.getElementText(symbol, lines);
      const eqIdx = elementText.indexOf("=");
      if (eqIdx < 0) return void 0;
      let start = eqIdx + 1;
      if (start < elementText.length && elementText[start] === "=") return void 0;
      start = skipWS(elementText, start);
      let end = start;
      while (end < elementText.length) {
        const ch = elementText[end];
        if (ch === ";" || ch === "{" || ch === "}" || ch === "\n") break;
        end++;
      }
      const val = elementText.substring(start, end).trim();
      if (val && !val.includes("def") && val.length < 100) {
        return val;
      }
      return void 0;
    }
    /** Extract all specialization targets from `:>` or `specializes` syntax. */
    extractSpecializations(symbol, lines) {
      const elementText = this.getElementText(symbol, lines);
      const colonGtIdx = elementText.indexOf(":>");
      if (colonGtIdx >= 0) {
        if (colonGtIdx + 2 < elementText.length && elementText[colonGtIdx + 2] === ">") {
        } else {
          return readCommaSeparatedIdents(elementText, colonGtIdx + 2);
        }
      }
      const specPositions = findWordPositions(elementText, "specializes");
      if (specPositions.length > 0) {
        return readCommaSeparatedIdents(elementText, specPositions[0].afterPos);
      }
      return [];
    }
    /** Extract connection endpoints from `connect` syntax. */
    extractConnectionEndpoints(symbol, lines) {
      const elementText = this.getElementText(symbol, lines);
      const endpoints = [];
      const connectPositions = findWordPositions(elementText, "connect");
      for (const { afterPos } of connectPositions) {
        const [name1, end1] = readWordAfterKeyword(elementText, afterPos, true);
        if (!name1) continue;
        const toPos = skipWS(elementText, end1);
        if (elementText.substring(toPos, toPos + 2) === "to") {
          const afterTo = toPos + 2;
          const [name2] = readWordAfterKeyword(elementText, afterTo, true);
          if (name2) {
            endpoints.push(name1, name2);
            return endpoints;
          }
        }
      }
      const endPositions = findWordPositions(elementText, "end");
      for (const { afterPos } of endPositions) {
        const [name] = readWordAfterKeyword(elementText, afterPos, true);
        if (name) endpoints.push(name);
      }
      return endpoints;
    }
    /**
     * Scan full source text for standalone `satisfy X by Y` and `verify X by Y`
     * statements that aren't nested inside another symbol's declaration.
     */
    extractStandaloneSatisfyVerify(text) {
      const rels = [];
      const keywords = ["satisfy", "verify"];
      for (const kw of keywords) {
        const positions = findWordPositions(text, kw);
        for (const { afterPos } of positions) {
          let pos = skipWS(text, afterPos);
          const [nextWord, afterWord] = readNameOrQuoted(text, pos);
          if (nextWord === "requirement") {
            pos = skipWS(text, afterWord);
          } else {
            pos = skipWS(text, afterPos);
          }
          const [reqName, afterReq] = readNameOrQuoted(text, pos);
          if (!reqName || reqName === "requirement") continue;
          const byPos = skipWS(text, afterReq);
          const [byWord, afterBy] = readIdent(text, byPos);
          let source;
          if (byWord === "by") {
            const [byTarget] = readNameOrQuoted(text, skipWS(text, afterBy));
            if (!byTarget) continue;
            source = byTarget;
          }
          rels.push({ type: kw, source, target: reqName });
        }
      }
      return rels;
    }
    /** Extract relationship keywords from element text. */
    extractKeywordRelationships(elementName, elementText) {
      elementText = stripComments(elementText);
      const rels = [];
      const subsetsPositions = findWordPositions(elementText, "subsets");
      if (subsetsPositions.length > 0) {
        const [target] = readWordAfterKeyword(elementText, subsetsPositions[0].afterPos);
        if (target) rels.push({ type: "subsetting", source: elementName, target });
      }
      const redefPositions = findWordPositions(elementText, "redefines");
      if (redefPositions.length > 0) {
        const [target] = readWordAfterKeyword(elementText, redefPositions[0].afterPos);
        if (target) rels.push({ type: "redefinition", source: elementName, target });
      }
      const satisfyPositions = findWordPositions(elementText, "satisfy");
      if (satisfyPositions.length > 0) {
        let pos = skipWS(elementText, satisfyPositions[0].afterPos);
        const [nextWord, afterWord] = readNameOrQuoted(elementText, pos);
        if (nextWord === "requirement") {
          pos = skipWS(elementText, afterWord);
        }
        const [reqName, afterReq] = readNameOrQuoted(elementText, pos);
        if (reqName && reqName !== "requirement") {
          let satisfier = elementName;
          const byPos = skipWS(elementText, afterReq);
          const [byWord, afterBy] = readIdent(elementText, byPos);
          if (byWord === "by") {
            const [byTarget] = readNameOrQuoted(elementText, skipWS(elementText, afterBy));
            if (byTarget) satisfier = byTarget;
          }
          rels.push({ type: "satisfy", source: satisfier, target: reqName });
        }
      }
      const verifyPositions = findWordPositions(elementText, "verify");
      if (verifyPositions.length > 0) {
        let pos = skipWS(elementText, verifyPositions[0].afterPos);
        const [nextWord, afterWord] = readNameOrQuoted(elementText, pos);
        if (nextWord === "requirement") {
          pos = skipWS(elementText, afterWord);
        }
        const [reqName, afterReq] = readNameOrQuoted(elementText, pos);
        if (reqName && reqName !== "requirement") {
          let verifier = elementName;
          const byPos = skipWS(elementText, afterReq);
          const [byWord, afterBy] = readIdent(elementText, byPos);
          if (byWord === "by") {
            const [byTarget] = readNameOrQuoted(elementText, skipWS(elementText, afterBy));
            if (byTarget) verifier = byTarget;
          }
          rels.push({ type: "verify", source: verifier, target: reqName });
        }
      }
      return rels;
    }
    /** Extract decision branches from decision node text. */
    extractDecisionBranches(symbol, lines) {
      const elementText = this.getElementText(symbol, lines);
      const branches = [];
      const ifPositions = findWordPositions(elementText, "if");
      for (const { afterPos } of ifPositions) {
        const thenIdx = elementText.indexOf("then", afterPos);
        if (thenIdx < 0) continue;
        const beforeThen = thenIdx > 0 ? elementText.charCodeAt(thenIdx - 1) : 32;
        const afterThen = thenIdx + 4 < elementText.length ? elementText.charCodeAt(thenIdx + 4) : 32;
        if (isIdentPart(beforeThen) || isIdentPart(afterThen)) continue;
        const condition = elementText.substring(afterPos, thenIdx).trim();
        const [target] = readWordAfterKeyword(elementText, thenIdx + 4);
        if (target) {
          branches.push({ condition, target });
        }
      }
      const elsePositions = findWordPositions(elementText, "else");
      if (elsePositions.length > 0) {
        const [target] = readWordAfterKeyword(elementText, elsePositions[0].afterPos);
        if (target) {
          branches.push({ condition: "else", target });
        }
      }
      return branches;
    }
    /**
     * Extract succession (control flow) relationships from action body text.
     *
     * Handles multi-line succession chains, inline patterns, and
     * decision/merge control flow patterns:
     *   - Multi-line: `first X;` / `then Y;` / `then Z;`
     *   - Inline:     `first X then Y;`
     *   - Explicit:   `succession first X then Y;`
     *   - Decision:   `decide; if <cond> then X; merge Y;`
     *   - Quoted:     `then 'My Action';`
     */
    extractSuccessions(parent, lines) {
      const elementText = this.getFullElementText(parent, lines);
      const flows = [];
      const seen = /* @__PURE__ */ new Set();
      const range = this.rangeToDTO(parent.range);
      const addFlow = (from, to, guard) => {
        if (from === to) return;
        const key = `${from}->${to}`;
        if (seen.has(key)) return;
        seen.add(key);
        const f = { from, to, range };
        if (guard) f.guard = guard;
        flows.push(f);
      };
      function braceDepthAt(text, pos) {
        let depth = 0;
        for (let i = 0; i < pos && i < text.length; i++) {
          if (text[i] === "{") depth++;
          else if (text[i] === "}") depth--;
        }
        return depth;
      }
      const firstBrace = elementText.indexOf("{");
      const topDepth = firstBrace >= 0 ? braceDepthAt(elementText, firstBrace + 1) : 1;
      const stripQualifier = (name) => {
        const idx = name.lastIndexOf("::");
        return idx >= 0 ? name.substring(idx + 2) : name;
      };
      const tokens = [];
      for (const { pos, afterPos } of findWordPositions(elementText, "first")) {
        if (braceDepthAt(elementText, pos) !== topDepth) continue;
        const nameStart = skipWS(elementText, afterPos);
        const [name] = readNameOrQuoted(elementText, nameStart);
        if (name) {
          tokens.push({ type: "first", name: stripQualifier(name), index: pos });
        }
      }
      for (const { pos, afterPos } of findWordPositions(elementText, "then")) {
        if (braceDepthAt(elementText, pos) !== topDepth) continue;
        const lookbackStart = Math.max(0, pos - 100);
        const preceding = elementText.substring(lookbackStart, pos);
        if (containsWord(preceding, "if") && !preceding.includes(";")) continue;
        let nameStart = skipWS(elementText, afterPos);
        const [maybeAction, afterAction] = readIdent(elementText, nameStart);
        if (maybeAction === "action") {
          nameStart = skipWS(elementText, afterAction);
        }
        const [name] = readNameOrQuoted(elementText, nameStart);
        if (!name || name === "if") continue;
        tokens.push({ type: "then", name: stripQualifier(name), index: pos });
      }
      tokens.sort((a, b) => a.index - b.index);
      const coveredIndices = /* @__PURE__ */ new Set();
      for (let i = 0; i < tokens.length; i++) {
        if (tokens[i].type === "first") {
          const chain = [tokens[i].name];
          coveredIndices.add(i);
          for (let j = i + 1; j < tokens.length; j++) {
            if (tokens[j].type === "then") {
              chain.push(tokens[j].name);
              coveredIndices.add(j);
            } else {
              break;
            }
          }
          for (let k = 0; k < chain.length - 1; k++) {
            addFlow(chain[k], chain[k + 1]);
          }
        }
      }
      const uncoveredThens = tokens.filter(
        (t, i) => !coveredIndices.has(i) && t.type === "then"
      );
      if (uncoveredThens.length > 0) {
        for (let i = 0; i < uncoveredThens.length - 1; i++) {
          addFlow(uncoveredThens[i].name, uncoveredThens[i + 1].name);
        }
      }
      if (flows.length > 0) {
        const allTargets = new Set(flows.map((f) => f.to));
        const allSources = new Set(flows.map((f) => f.from));
        const entryActions = flows.map((f) => f.from).filter((name) => name !== "start" && name !== "done" && !allTargets.has(name));
        const exitActions = flows.map((f) => f.to).filter((name) => name !== "start" && name !== "done" && !allSources.has(name));
        if (entryActions.length > 0) {
          addFlow("start", entryActions[0]);
        }
        if (exitActions.length > 0) {
          addFlow(exitActions[exitActions.length - 1], "done");
        }
      }
      for (const { afterPos } of findWordPositions(elementText, "succession")) {
        let p = skipWS(elementText, afterPos);
        const [word1, afterWord1] = readIdent(elementText, p);
        if (word1 === "flow") {
          p = skipWS(elementText, afterWord1);
          const [fromKw, afterFrom] = readIdent(elementText, p);
          if (fromKw === "from") {
            p = skipWS(elementText, afterFrom);
            const [srcFull, afterSrc] = readIdent(elementText, p, true);
            const src = srcFull.includes(".") ? srcFull.substring(0, srcFull.indexOf(".")) : srcFull;
            p = skipWS(elementText, afterSrc);
            const [toKw, afterTo] = readIdent(elementText, p);
            if (toKw === "to") {
              p = skipWS(elementText, afterTo);
              const [dstFull] = readIdent(elementText, p, true);
              const dst = dstFull.includes(".") ? dstFull.substring(0, dstFull.indexOf(".")) : dstFull;
              if (src && dst) addFlow(src, dst);
            }
          }
          continue;
        }
        let nameStart = p;
        if (word1 === "first") {
          nameStart = skipWS(elementText, afterWord1);
        }
        const [name1] = readNameOrQuoted(elementText, nameStart);
        if (!name1) continue;
        const afterName1 = nameStart + name1.length + (elementText[nameStart] === "'" ? 2 : 0);
        const thenCheck = skipWS(elementText, afterName1);
        const [thenKw, afterThen] = readIdent(elementText, thenCheck);
        if (thenKw === "then") {
          const name2Start = skipWS(elementText, afterThen);
          const [name2] = readNameOrQuoted(elementText, name2Start);
          if (name2) addFlow(stripQualifier(name1), stripQualifier(name2));
        }
      }
      const decidePositions = findWordPositions(elementText, "decide");
      const hasDecide = decidePositions.some(({ afterPos }) => {
        const p = skipWS(elementText, afterPos);
        return p < elementText.length && elementText[p] === ";";
      });
      if (hasDecide) {
        for (let fi = flows.length - 1; fi >= 0; fi--) {
          if (flows[fi].from === "decide") {
            seen.delete(`decide->${flows[fi].to}`);
            flows.splice(fi, 1);
          }
        }
        const branchTargets = [];
        for (const { afterPos: ifAfter } of findWordPositions(elementText, "if")) {
          const thenIdx = elementText.indexOf("then", ifAfter);
          if (thenIdx < 0) continue;
          const bBefore = thenIdx > 0 ? elementText.charCodeAt(thenIdx - 1) : 32;
          const bAfter = thenIdx + 4 < elementText.length ? elementText.charCodeAt(thenIdx + 4) : 32;
          if (isIdentPart(bBefore) || isIdentPart(bAfter)) continue;
          const condition = elementText.substring(ifAfter, thenIdx).trim();
          const targetStart = skipWS(elementText, thenIdx + 4);
          const [target] = readNameOrQuoted(elementText, targetStart);
          if (target) {
            const afterTarget = targetStart + target.length + (elementText[targetStart] === "'" ? 2 : 0);
            const semi = skipWS(elementText, afterTarget);
            if (semi < elementText.length && elementText[semi] === ";") {
              addFlow("decide", target, condition);
              branchTargets.push(target);
            }
          }
        }
        for (const { pos: mergePos, afterPos: mergeAfter } of findWordPositions(elementText, "merge")) {
          const mStart = skipWS(elementText, mergeAfter);
          const [mergeTarget] = readNameOrQuoted(elementText, mStart);
          if (!mergeTarget) continue;
          const afterMT = mStart + mergeTarget.length + (elementText[mStart] === "'" ? 2 : 0);
          const semiP = skipWS(elementText, afterMT);
          if (semiP >= elementText.length || elementText[semiP] !== ";") continue;
          for (const branch of branchTargets) {
            addFlow(branch, mergeTarget);
          }
          const afterMerge = tokens.filter(
            (t) => t.type === "then" && t.index > mergePos
          );
          if (afterMerge.length > 0) {
            addFlow(mergeTarget, afterMerge[0].name);
          } else if (mergeTarget !== "done") {
            addFlow(mergeTarget, "done");
          }
        }
      }
      return flows;
    }
    /** Convert element kind to feature kind string. */
    featureKindFromElementKind(kind) {
      switch (kind) {
        case "attribute" /* AttributeUsage */:
        case "attribute def" /* AttributeDef */:
          return "attribute";
        case "port" /* PortUsage */:
        case "port def" /* PortDef */:
          return "port";
        case "action" /* ActionUsage */:
        case "action def" /* ActionDef */:
          return "action";
        case "state" /* StateUsage */:
        case "state def" /* StateDef */:
          return "state";
        default:
          return "reference";
      }
    }
    /** Convert an action symbol to an ActivityActionDTO. */
    symbolToActionDTO(symbol, symbolTable, lines) {
      const childText = this.getElementText(symbol, lines);
      let actionType = "action";
      const lowerText = childText.toLowerCase();
      if (lowerText.includes("fork")) actionType = "fork";
      else if (lowerText.includes("join")) actionType = "join";
      else if (lowerText.includes("merge")) actionType = "merge";
      else if (lowerText.includes("decide")) actionType = "decision";
      return {
        name: symbol.name,
        type: actionType,
        isDefinition: symbol.kind === "action def" /* ActionDef */,
        range: this.rangeToDTO(symbol.range)
      };
    }
  };

  // server/src/platform/connection.browser.ts
  var import_browser = __toESM(require_browser3());
  function createServerConnection() {
    const workerScope = globalThis;
    const reader = new import_browser.BrowserMessageReader(workerScope);
    const writer = new import_browser.BrowserMessageWriter(workerScope);
    return (0, import_browser.createConnection)(import_browser.ProposedFeatures.all, reader, writer);
  }

  // server/src/providers/codeActionProvider.ts
  var import_node = __toESM(require_main3());
  var CodeActionProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    /**
     * Return code actions for the given range, typically in response to
     * a lightbulb appearing on a diagnostic.
     */
    provideCodeActions(params) {
      const actions = [];
      const uri = params.textDocument.uri;
      for (const diagnostic of params.context.diagnostics) {
        const typoFix = this.tryKeywordTypoFix(uri, diagnostic);
        if (typoFix) {
          actions.push(typoFix);
        }
        const namingFix = this.tryNamingConventionFix(uri, diagnostic);
        if (namingFix) {
          actions.push(namingFix);
        }
        const docFix = this.tryMissingDocFix(uri, diagnostic);
        if (docFix) {
          actions.push(docFix);
        }
        const enumFix = this.tryEmptyEnumFix(uri, diagnostic);
        if (enumFix) {
          actions.push(enumFix);
        }
        const unusedFix = this.tryUnusedDefinitionFix(uri, diagnostic);
        if (unusedFix) {
          actions.push(unusedFix);
        }
        const redefMultFix = this.tryRedefinitionMultiplicityFix(uri, diagnostic);
        if (redefMultFix) {
          actions.push(redefMultFix);
        }
        const portCompatFix = this.tryPortCompatibilityFix(uri, diagnostic);
        if (portCompatFix) {
          actions.push(portCompatFix);
        }
        const constraintRefFix = this.tryConstraintReferenceFix(uri, diagnostic);
        if (constraintRefFix) {
          actions.push(constraintRefFix);
        }
        const unresolvedTypeFixes = this.tryUnresolvedTypeFixes(uri, diagnostic);
        if (unresolvedTypeFixes.length > 0) {
          actions.push(...unresolvedTypeFixes);
        }
      }
      return actions;
    }
    // ── Unresolved type fixes ──────────────────────────────────────
    /**
     * For unresolved type diagnostics, offer:
     *  1) Import package quick-fix if the type exists in another workspace package.
        *  2) Create a local type definition stub in current package.
     */
    tryUnresolvedTypeFixes(uri, diagnostic) {
      if (diagnostic.code !== "unresolved-type") return [];
      const text = this.documentManager.getText(uri);
      if (!text) return [];
      const data = diagnostic.data;
      const unresolvedType = data?.typeName ?? extractQuotedString(diagnostic.message, "Type '");
      if (!unresolvedType) return [];
      const actions = [];
      const symbolTable = this.documentManager.getWorkspaceSymbolTable();
      const allSymbols = symbolTable.getAllSymbols();
      const packageNames = /* @__PURE__ */ new Set();
      for (const s of allSymbols) {
        if (!isDefinition(s.kind)) continue;
        if (s.name !== unresolvedType) continue;
        if (s.uri === uri) continue;
        const parentQn = s.parentQualifiedName || "";
        const qn = s.qualifiedName || "";
        const pkg = (parentQn.split("::")[0] || qn.split("::")[0] || "").trim();
        if (!pkg || pkg === unresolvedType) continue;
        if (pkg) packageNames.add(pkg);
      }
      for (const pkg of packageNames) {
        if (this.hasImportForPackage(text, pkg)) {
          continue;
        }
        const insertPos = this.findImportInsertPosition(text);
        const childIndent = this.getChildIndentForPackageLine(text, insertPos.line);
        const importText = `${childIndent}public import ${pkg}::*;
`;
        const edit = {
          changes: {
            [uri]: [
              import_node.TextEdit.insert(insertPos, importText)
            ]
          }
        };
        actions.push({
          title: `Import '${pkg}::*' to resolve '${unresolvedType}'`,
          kind: import_node.CodeActionKind.QuickFix,
          diagnostics: [diagnostic],
          isPreferred: actions.length === 0,
          edit
        });
      }
      const stubPos = this.findPackageBodyInsertPosition(text);
      if (stubPos) {
        const childIndent = this.getChildIndentForPackageLine(text, stubPos.line);
        const localTypeStub = this.buildLocalTypeStub(text, diagnostic, unresolvedType, childIndent);
        const edit = {
          changes: {
            [uri]: [
              import_node.TextEdit.insert(stubPos, localTypeStub.stubText)
            ]
          }
        };
        actions.push({
          title: localTypeStub.title,
          kind: import_node.CodeActionKind.QuickFix,
          diagnostics: [diagnostic],
          isPreferred: actions.length === 0,
          edit
        });
      }
      return actions;
    }
    // ── Keyword typo ────────────────────────────────────────────────
    /**
     * If the diagnostic is a keyword typo ("Did you mean 'X'?"), offer
     * a quick fix that replaces the misspelled word with the suggestion.
     */
    tryKeywordTypoFix(uri, diagnostic) {
      const data = diagnostic.data;
      let typo;
      let suggestion;
      if (data?.typo && data?.suggestion) {
        typo = data.typo;
        suggestion = data.suggestion;
      } else {
        const msg = diagnostic.message;
        typo = extractQuotedString(msg, "Unknown keyword '");
        suggestion = extractQuotedString(msg, "Did you mean '");
      }
      if (!typo || !suggestion) return void 0;
      const edit = {
        changes: {
          [uri]: [
            import_node.TextEdit.replace(diagnostic.range, suggestion)
          ]
        }
      };
      return {
        title: `Fix typo: '${typo}' \u2192 '${suggestion}'`,
        kind: import_node.CodeActionKind.QuickFix,
        diagnostics: [diagnostic],
        isPreferred: true,
        edit
      };
    }
    // ── Naming convention ───────────────────────────────────────────
    /**
     * Offer to rename an identifier to PascalCase or camelCase.
     */
    tryNamingConventionFix(uri, diagnostic) {
      if (diagnostic.code !== "naming-convention") return void 0;
      const data = diagnostic.data;
      let name;
      let isPascal;
      let isCamel;
      if (data?.name && data?.convention) {
        name = data.name;
        isPascal = data.convention === "PascalCase";
        isCamel = data.convention === "camelCase";
      } else {
        isPascal = diagnostic.message.includes("PascalCase");
        isCamel = diagnostic.message.includes("camelCase");
        name = extractQuotedString(diagnostic.message, "Definition '") ?? extractQuotedString(diagnostic.message, "Usage '");
      }
      if (!isPascal && !isCamel) return void 0;
      if (!name) return void 0;
      let newName;
      if (isPascal) {
        newName = name.charAt(0).toUpperCase() + name.slice(1);
      } else {
        newName = name.charAt(0).toLowerCase() + name.slice(1);
      }
      const edit = {
        changes: {
          [uri]: [
            import_node.TextEdit.replace(diagnostic.range, newName)
          ]
        }
      };
      return {
        title: `Rename to '${newName}'`,
        kind: import_node.CodeActionKind.QuickFix,
        diagnostics: [diagnostic],
        isPreferred: true,
        edit
      };
    }
    // ── Missing documentation ───────────────────────────────────────
    /**
     * Insert a `doc` comment inside the definition body, right after
     * the opening brace.  Per the SysML v2 spec, `doc` is an owned
     * member of the definition — not a preceding annotation.
     */
    tryMissingDocFix(uri, diagnostic) {
      if (diagnostic.code !== "missing-doc") return void 0;
      const data = diagnostic.data;
      const name = data?.name ?? extractQuotedString(diagnostic.message, "Definition '");
      if (!name) return void 0;
      const text = this.documentManager.getText(uri);
      if (!text) return void 0;
      const lines = text.split("\n");
      const startLine = diagnostic.range.start.line;
      let bracePos;
      for (let i = startLine; i < Math.min(startLine + 5, lines.length); i++) {
        const braceIdx = lines[i].indexOf("{");
        if (braceIdx >= 0) {
          bracePos = import_node.Position.create(i, braceIdx + 1);
          break;
        }
      }
      if (!bracePos) return void 0;
      const defIndent = this.getLineIndent(text, startLine);
      const childIndent = defIndent + "    ";
      const docComment = `
${childIndent}doc /* TODO: Describe ${name} */`;
      const edit = {
        changes: {
          [uri]: [
            import_node.TextEdit.insert(bracePos, docComment)
          ]
        }
      };
      return {
        title: `Add documentation for '${name}'`,
        kind: import_node.CodeActionKind.QuickFix,
        diagnostics: [diagnostic],
        isPreferred: false,
        edit
      };
    }
    // ── Empty enumeration ───────────────────────────────────────────
    /**
     * Add a placeholder `enum value` inside an empty enum definition.
     */
    tryEmptyEnumFix(uri, diagnostic) {
      if (diagnostic.code !== "empty-enum") return void 0;
      const text = this.documentManager.getText(uri);
      if (!text) return void 0;
      const lines = text.split("\n");
      const startLine = diagnostic.range.start.line;
      let bracePos;
      for (let i = startLine; i < Math.min(startLine + 5, lines.length); i++) {
        const braceIdx = lines[i].indexOf("{");
        if (braceIdx >= 0) {
          bracePos = import_node.Position.create(i, braceIdx + 1);
          break;
        }
      }
      if (!bracePos) return void 0;
      const defIndent = this.getLineIndent(text, startLine);
      const childIndent = defIndent + "    ";
      const insertText = `
${childIndent}enum value1;
${childIndent}enum value2;`;
      const edit = {
        changes: {
          [uri]: [
            import_node.TextEdit.insert(bracePos, insertText)
          ]
        }
      };
      return {
        title: "Add placeholder enum values",
        kind: import_node.CodeActionKind.QuickFix,
        diagnostics: [diagnostic],
        isPreferred: false,
        edit
      };
    }
    // ── Unused definition ───────────────────────────────────────────
    /**
     * Prefix the definition name with an underscore to mark as intentionally
     * unused (conventional suppression).
     */
    tryUnusedDefinitionFix(uri, diagnostic) {
      if (diagnostic.code !== "unused-definition") return void 0;
      const data = diagnostic.data;
      const name = data?.name ?? extractQuotedString(diagnostic.message, "Definition '");
      if (!name) return void 0;
      if (name.startsWith("_")) return void 0;
      const newName = `_${name}`;
      const edit = {
        changes: {
          [uri]: [
            import_node.TextEdit.replace(diagnostic.range, newName)
          ]
        }
      };
      return {
        title: `Prefix with underscore: '_${name}'`,
        kind: import_node.CodeActionKind.QuickFix,
        diagnostics: [diagnostic],
        isPreferred: false,
        edit
      };
    }
    // ── Redefinition multiplicity ──────────────────────────────────
    /**
     * Align an incompatible redefinition multiplicity with the base multiplicity
     * when both are available in the diagnostic message.
     */
    tryRedefinitionMultiplicityFix(uri, diagnostic) {
      if (diagnostic.code !== "invalid-redefinition-multiplicity") return void 0;
      const msg = diagnostic.message;
      const baseMatch = msg.match(/base\s+'[^']+'\s+multiplicity\s+\[([^\]]+)\]/);
      if (!baseMatch) return void 0;
      const baseMultiplicity = baseMatch[1];
      const text = this.documentManager.getText(uri);
      if (!text) return void 0;
      const line = diagnostic.range.start.line;
      const lineText = text.split("\n")[line] ?? "";
      const multMatch = lineText.match(/\[[^\]]+\]/);
      if (!multMatch) return void 0;
      const startChar = multMatch.index ?? 0;
      const endChar = startChar + multMatch[0].length;
      const edit = {
        changes: {
          [uri]: [
            import_node.TextEdit.replace(
              {
                start: import_node.Position.create(line, startChar),
                end: import_node.Position.create(line, endChar)
              },
              `[${baseMultiplicity}]`
            )
          ]
        }
      };
      return {
        title: `Align multiplicity with base: [${baseMultiplicity}]`,
        kind: import_node.CodeActionKind.QuickFix,
        diagnostics: [diagnostic],
        isPreferred: true,
        edit
      };
    }
    // ── Port compatibility ──────────────────────────────────────────
    /**
     * Suggest replacing the right endpoint with a local compatible port
     * when a suitable candidate exists.
     */
    tryPortCompatibilityFix(uri, diagnostic) {
      if (diagnostic.code !== "incompatible-port-types") return void 0;
      const msg = diagnostic.message;
      const m2 = msg.match(/'([^']+)'\s+\(([^)]+)\)\s+is connected to\s+'([^']+)'\s+\(([^)]+)\)/);
      if (!m2) return void 0;
      const left = m2[1];
      const leftType = m2[2];
      const right = m2[3];
      const symbolTable = this.documentManager.getWorkspaceSymbolTable();
      const symbolsInUri = symbolTable.getSymbolsForUri(uri);
      const compatible = symbolsInUri.find(
        (s) => s.kind === "port" /* PortUsage */ && s.name !== left && s.name !== right && (s.typeNames[0] ?? s.typeName) === leftType
      );
      if (!compatible) return void 0;
      const text = this.documentManager.getText(uri);
      if (!text) return void 0;
      const start = diagnostic.range.start;
      const end = diagnostic.range.end;
      const lines = text.split("\n");
      if (start.line !== end.line) return void 0;
      const segment = (lines[start.line] ?? "").slice(start.character, end.character);
      if (!segment) return void 0;
      const replaced = segment.replace(new RegExp(`\\b${right}\\b`), compatible.name);
      if (replaced === segment) return void 0;
      const edit = {
        changes: {
          [uri]: [
            import_node.TextEdit.replace(diagnostic.range, replaced)
          ]
        }
      };
      return {
        title: `Replace '${right}' with compatible port '${compatible.name}'`,
        kind: import_node.CodeActionKind.QuickFix,
        diagnostics: [diagnostic],
        isPreferred: false,
        edit
      };
    }
    // ── Constraint reference typo ───────────────────────────────────
    /**
     * Suggest nearest member-name replacement for unresolved `a.b` references.
     */
    tryConstraintReferenceFix(uri, diagnostic) {
      if (diagnostic.code !== "unresolved-constraint-reference") return void 0;
      const msg = diagnostic.message;
      const text = this.documentManager.getText(uri);
      if (!text) return void 0;
      const lines = text.split("\n");
      const sameLine = diagnostic.range.start.line === diagnostic.range.end.line;
      const lineText = sameLine ? lines[diagnostic.range.start.line] ?? "" : "";
      const rangeExpr = sameLine ? lineText.slice(diagnostic.range.start.character, diagnostic.range.end.character) : "";
      const tokenExpr = sameLine ? extractDottedTokenAtRange(
        lineText,
        diagnostic.range.start.character,
        diagnostic.range.end.character
      ) : "";
      const m2 = msg.match(/Unresolved constraint reference\s+'([^']+)'(?:\s+in scope\s+'([^']+)')?/);
      const expr = rangeExpr && rangeExpr.includes(".") ? rangeExpr : tokenExpr && tokenExpr.includes(".") ? tokenExpr : m2?.[1] ?? "";
      const scopeName = m2?.[2];
      if (!expr) return void 0;
      if (!expr.includes(".")) return void 0;
      const parts = expr.split(".");
      if (parts.length < 2) return void 0;
      const root = parts[0];
      const unresolvedLeaf = parts[parts.length - 1];
      const symbolTable = this.documentManager.getWorkspaceSymbolTable();
      const symbolsInUri = symbolTable.getSymbolsForUri(uri);
      const allSymbols = symbolTable.getAllSymbols();
      const scope = scopeName ? symbolsInUri.find((s) => s.name === scopeName) : void 0;
      const scopeMembers = scope ? allSymbols.filter((s) => s.parentQualifiedName === scope.qualifiedName) : [];
      const rootUsage = scopeMembers.find((s) => s.name === root) ?? symbolsInUri.find((s) => s.name === root && !!(s.typeNames[0] ?? s.typeName));
      const rootType = rootUsage ? rootUsage.typeNames[0] ?? rootUsage.typeName : void 0;
      let memberNames = [];
      if (rootType) {
        const typeDef = allSymbols.find((s) => s.name === rootType && s.kind.endsWith(" def"));
        if (typeDef) {
          memberNames = allSymbols.filter((s) => s.parentQualifiedName === typeDef.qualifiedName).map((s) => s.name);
        }
      }
      if (memberNames.length === 0) {
        memberNames = symbolsInUri.map((s) => s.name).filter((n2) => n2 !== root);
      }
      if (memberNames.length === 0) {
        memberNames = allSymbols.filter((s) => s.uri === uri).map((s) => s.name).filter((n2) => n2 !== root);
      }
      if (memberNames.length === 0) return void 0;
      const suggestion = memberNames.map((name) => ({ name, dist: levenshtein(unresolvedLeaf, name) })).sort((a, b) => a.dist - b.dist)[0];
      let best = suggestion;
      if (!best || best.dist > 3 || best.name === unresolvedLeaf) {
        const textCandidates = extractLikelyMemberNames(text, root);
        const fallback = textCandidates.map((name) => ({ name, dist: levenshtein(unresolvedLeaf, name) })).sort((a, b) => a.dist - b.dist)[0];
        if (fallback && fallback.name !== unresolvedLeaf) {
          best = fallback;
        }
      }
      if (!best || best.dist > 4 || best.name === unresolvedLeaf) return void 0;
      const fixedExpr = `${root}.${best.name}`;
      const edit = {
        changes: {
          [uri]: [
            import_node.TextEdit.replace(diagnostic.range, fixedExpr)
          ]
        }
      };
      return {
        title: `Replace '${expr}' with '${fixedExpr}'`,
        kind: import_node.CodeActionKind.QuickFix,
        diagnostics: [diagnostic],
        isPreferred: true,
        edit
      };
    }
    // ── Helpers ──────────────────────────────────────────────────────
    /**
     * Return the leading whitespace of a given line number.
     */
    getLineIndent(text, line) {
      if (!text) return "";
      const lines = text.split("\n");
      if (line < 0 || line >= lines.length) return "";
      const ln = lines[line];
      let end = 0;
      while (end < ln.length && (ln[end] === " " || ln[end] === "	")) end++;
      return ln.substring(0, end);
    }
    hasImportForPackage(text, pkg) {
      const escaped = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
      const re = new RegExp(`^\\s*(?:public\\s+)?import\\s+${escaped}::\\*\\s*;\\s*$`, "m");
      return re.test(text);
    }
    findImportInsertPosition(text) {
      const lines = text.split("\n");
      let packageLine = -1;
      let firstImport = -1;
      let lastImport = -1;
      for (let i = 0; i < lines.length; i++) {
        const ln = lines[i];
        if (packageLine < 0 && /^\s*(?:standard\s+library\s+)?package\b/.test(ln)) {
          packageLine = i;
        }
        if (/^\s*(?:public\s+)?import\b/.test(ln)) {
          if (firstImport < 0) firstImport = i;
          lastImport = i;
        }
      }
      if (lastImport >= 0) {
        return import_node.Position.create(lastImport + 1, 0);
      }
      if (packageLine >= 0) {
        return import_node.Position.create(packageLine + 1, 0);
      }
      return import_node.Position.create(0, 0);
    }
    findPackageBodyInsertPosition(text) {
      const lines = text.split("\n");
      let lastClosingBraceLine = -1;
      for (let i = lines.length - 1; i >= 0; i--) {
        if (/^\s*}\s*;?\s*$/.test(lines[i])) {
          lastClosingBraceLine = i;
          break;
        }
      }
      if (lastClosingBraceLine < 0) return void 0;
      return import_node.Position.create(lastClosingBraceLine, 0);
    }
    getChildIndentForPackageLine(text, line) {
      const base = this.getLineIndent(text, Math.max(0, line));
      return `${base}    `;
    }
    isAttributeTypeContext(text, diagnostic, unresolvedType) {
      const lines = text.split("\n");
      const line = lines[diagnostic.range.start.line] ?? "";
      const beforeRange = line.slice(0, diagnostic.range.start.character);
      const unresolvedInLine = line.slice(diagnostic.range.start.character, diagnostic.range.end.character);
      const escapedType = unresolvedType.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
      if (/^\s*attribute\s+[A-Za-z_][A-Za-z0-9_]*\s*:/.test(line) && new RegExp(`:\\s*${escapedType}\\b`).test(line)) {
        return true;
      }
      if (/\battribute\s+[A-Za-z_][A-Za-z0-9_]*\s*:\s*$/.test(beforeRange)) {
        return true;
      }
      return /\battribute\s+[A-Za-z_][A-Za-z0-9_]*\s*:\s*[A-Za-z_][A-Za-z0-9_]*\b/.test(beforeRange + unresolvedInLine);
    }
    buildLocalTypeStub(text, diagnostic, unresolvedType, childIndent) {
      if (this.isAttributeTypeContext(text, diagnostic, unresolvedType)) {
        return {
          title: `Create local 'attribute def ${unresolvedType};'`,
          stubText: `
${childIndent}attribute def ${unresolvedType};
`
        };
      }
      return {
        title: `Create local 'item def ${unresolvedType};'`,
        stubText: `
${childIndent}item def ${unresolvedType};
`
      };
    }
  };
  function levenshtein(a, b) {
    if (a === b) return 0;
    if (!a.length) return b.length;
    if (!b.length) return a.length;
    const prev = new Array(b.length + 1);
    const curr = new Array(b.length + 1);
    for (let j = 0; j <= b.length; j++) prev[j] = j;
    for (let i = 1; i <= a.length; i++) {
      curr[0] = i;
      for (let j = 1; j <= b.length; j++) {
        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
        curr[j] = Math.min(
          prev[j] + 1,
          curr[j - 1] + 1,
          prev[j - 1] + cost
        );
      }
      for (let j = 0; j <= b.length; j++) prev[j] = curr[j];
    }
    return prev[b.length];
  }
  function extractQuotedString(text, prefixWithQuote) {
    const idx = text.indexOf(prefixWithQuote);
    if (idx < 0) return void 0;
    const start = idx + prefixWithQuote.length;
    const end = text.indexOf("'", start);
    if (end < 0) return void 0;
    return text.substring(start, end);
  }
  function extractDottedTokenAtRange(line, start, end) {
    if (!line || start < 0 || end < 0 || start > line.length || end > line.length) return "";
    const isTokenChar = (ch) => ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === ".";
    let left = Math.max(0, start);
    while (left > 0 && isTokenChar(line[left - 1])) left--;
    let right = Math.min(line.length, end);
    while (right < line.length && isTokenChar(line[right])) right++;
    const token = line.slice(left, right).trim();
    return token.includes(".") ? token : "";
  }
  function extractLikelyMemberNames(text, excludeName) {
    const names = /* @__PURE__ */ new Set();
    const addMatches = (re) => {
      let m2;
      while ((m2 = re.exec(text)) !== null) {
        const n2 = m2[1];
        if (n2 && n2 !== excludeName) {
          names.add(n2);
        }
      }
    };
    addMatches(/\battribute\s+([A-Za-z_][A-Za-z0-9_]*)\b/g);
    addMatches(/\bpart\s+([A-Za-z_][A-Za-z0-9_]*)\b/g);
    addMatches(/\bport\s+([A-Za-z_][A-Za-z0-9_]*)\b/g);
    addMatches(/\bitem\s+([A-Za-z_][A-Za-z0-9_]*)\b/g);
    addMatches(/\bsubject\s+([A-Za-z_][A-Za-z0-9_]*)\b/g);
    return [...names];
  }

  // server/src/providers/completionProvider.ts
  var import_node2 = __toESM(require_main3());
  var SYSML_KEYWORDS2 = [
    // Definitions
    { label: "part def", kind: import_node2.CompletionItemKind.Class, detail: "Part definition", documentation: "Defines a type of part that can be instantiated", insertText: "part def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "action def", kind: import_node2.CompletionItemKind.Function, detail: "Action definition", documentation: "Defines a type of action/behavior", insertText: "action def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "state def", kind: import_node2.CompletionItemKind.Enum, detail: "State definition", documentation: "Defines a state machine", insertText: "state def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "requirement def", kind: import_node2.CompletionItemKind.Interface, detail: "Requirement definition", documentation: "Defines a type of requirement", insertText: "requirement def ${1:Name} {\n	doc /* ${2:description} */\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "constraint def", kind: import_node2.CompletionItemKind.Constant, detail: "Constraint definition", documentation: "Defines a reusable constraint", insertText: "constraint def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "attribute def", kind: import_node2.CompletionItemKind.Property, detail: "Attribute definition", documentation: "Defines a type of attribute/value", insertText: "attribute def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "item def", kind: import_node2.CompletionItemKind.Class, detail: "Item definition", documentation: "Defines a type of item that can flow", insertText: "item def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "port def", kind: import_node2.CompletionItemKind.Interface, detail: "Port definition", documentation: "Defines a type of port for connections", insertText: "port def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "interface def", kind: import_node2.CompletionItemKind.Interface, detail: "Interface definition", documentation: "Defines an interface contract", insertText: "interface def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "connection def", kind: import_node2.CompletionItemKind.Interface, detail: "Connection definition", documentation: "Defines a type of connection", insertText: "connection def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "allocation def", kind: import_node2.CompletionItemKind.Interface, detail: "Allocation definition", documentation: "Defines a type of allocation", insertText: "allocation def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "use case def", kind: import_node2.CompletionItemKind.Event, detail: "Use case definition", documentation: "Defines a use case", insertText: "use case def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "view def", kind: import_node2.CompletionItemKind.Struct, detail: "View definition", documentation: "Defines a view of the model", insertText: "view def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "viewpoint def", kind: import_node2.CompletionItemKind.Struct, detail: "Viewpoint definition", documentation: "Defines a viewpoint for stakeholders", insertText: "viewpoint def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "enum def", kind: import_node2.CompletionItemKind.Enum, detail: "Enumeration definition", documentation: "Defines an enumeration type", insertText: "enum def ${1:Name} {\n	${2:value1};\n	${3:value2};\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "calc def", kind: import_node2.CompletionItemKind.Function, detail: "Calculation definition", documentation: "Defines a calculation/function", insertText: "calc def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "metadata def", kind: import_node2.CompletionItemKind.TypeParameter, detail: "Metadata definition", documentation: "Defines custom metadata/stereotypes", insertText: "metadata def ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    // Usages
    { label: "part", kind: import_node2.CompletionItemKind.Variable, detail: "Part usage", documentation: "Creates a part instance", insertText: "part ${1:name} : ${2:Type};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "action", kind: import_node2.CompletionItemKind.Function, detail: "Action usage", documentation: "Creates an action/behavior instance", insertText: "action ${1:name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "state", kind: import_node2.CompletionItemKind.Enum, detail: "State usage", documentation: "Creates a state instance", insertText: "state ${1:name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "attribute", kind: import_node2.CompletionItemKind.Property, detail: "Attribute usage", documentation: "Creates an attribute/value", insertText: "attribute ${1:name} : ${2:Type};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "port", kind: import_node2.CompletionItemKind.Interface, detail: "Port usage", documentation: "Creates a port", insertText: "port ${1:name} : ${2:PortType};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "item", kind: import_node2.CompletionItemKind.Variable, detail: "Item usage", documentation: "Creates an item instance", insertText: "item ${1:name} : ${2:Type};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "requirement", kind: import_node2.CompletionItemKind.Interface, detail: "Requirement usage", documentation: "Creates a requirement instance", insertText: "requirement ${1:name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "connection", kind: import_node2.CompletionItemKind.Reference, detail: "Connection usage", documentation: "Creates a connection between parts", insertText: "connection ${1:name} connect ${2:source} to ${3:target};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "ref", kind: import_node2.CompletionItemKind.Reference, detail: "Reference usage", documentation: "Creates a reference to another element", insertText: "ref ${1:name} : ${2:Type};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    // Structure
    { label: "package", kind: import_node2.CompletionItemKind.Module, detail: "Package", documentation: "Creates a namespace container", insertText: "package ${1:Name} {\n	$0\n}", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "import", kind: import_node2.CompletionItemKind.Module, detail: "Import", documentation: "Imports elements from another namespace", insertText: "import ${1:namespace}::*;", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "alias", kind: import_node2.CompletionItemKind.Reference, detail: "Alias", documentation: "Creates an alias for an element", insertText: "alias ${1:newName} for ${2:existingElement};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    // Relationships
    { label: "connect", kind: import_node2.CompletionItemKind.Operator, detail: "Connection", documentation: "Connects two endpoints", insertText: "connect ${1:source} to ${2:target};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "bind", kind: import_node2.CompletionItemKind.Operator, detail: "Binding", documentation: "Binds two features together", insertText: "bind ${1:source} = ${2:target};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "flow", kind: import_node2.CompletionItemKind.Operator, detail: "Flow", documentation: "Defines item flow between parts", insertText: "flow of ${1:ItemType} from ${2:source} to ${3:target};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "satisfy", kind: import_node2.CompletionItemKind.Operator, detail: "Satisfaction", documentation: "Indicates requirement satisfaction", insertText: "satisfy ${1:requirement} by ${2:element};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    // Modifiers
    { label: "abstract", kind: import_node2.CompletionItemKind.Keyword, detail: "Abstract modifier", documentation: "Makes element abstract" },
    { label: "readonly", kind: import_node2.CompletionItemKind.Keyword, detail: "Readonly modifier", documentation: "Makes attribute readonly" },
    { label: "derived", kind: import_node2.CompletionItemKind.Keyword, detail: "Derived modifier", documentation: "Indicates value is derived/calculated" },
    { label: "in", kind: import_node2.CompletionItemKind.Keyword, detail: "Input direction", documentation: "Port/parameter receives input" },
    { label: "out", kind: import_node2.CompletionItemKind.Keyword, detail: "Output direction", documentation: "Port/parameter provides output" },
    { label: "inout", kind: import_node2.CompletionItemKind.Keyword, detail: "Bidirectional direction", documentation: "Port/parameter is bidirectional" },
    // Documentation
    { label: "doc", kind: import_node2.CompletionItemKind.Text, detail: "Documentation", documentation: "Creates a documentation comment", insertText: "doc /* ${1:description} */", insertTextFormat: import_node2.InsertTextFormat.Snippet },
    { label: "comment", kind: import_node2.CompletionItemKind.Text, detail: "Comment", documentation: "Creates a comment element", insertText: "comment /* ${1:text} */", insertTextFormat: import_node2.InsertTextFormat.Snippet }
  ];
  var CompletionProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    /** Cached definition completions, invalidated when symbol table changes. */
    _defCache;
    provideCompletions(params) {
      const items = [];
      const uri = params.textDocument.uri;
      const context = this.detectContext(uri, params.position.line, params.position.character);
      for (const kw of SYSML_KEYWORDS2) {
        const item = {
          label: kw.label,
          kind: kw.kind,
          detail: kw.detail,
          documentation: kw.documentation,
          data: kw.label,
          // used for resolve
          sortText: `2_${kw.label}`
        };
        if (kw.insertText) {
          item.insertText = kw.insertText;
          item.insertTextFormat = kw.insertTextFormat;
        }
        items.push(item);
      }
      const workspaceTable = this.documentManager.getWorkspaceSymbolTable();
      const allSymbols = workspaceTable.getAllSymbols();
      if (this._defCache && this._defCache.symbols === allSymbols) {
        items.push(...this._defCache.items);
      } else {
        const definitionSymbols = allSymbols.filter((s) => isDefinition(s.kind));
        const seen = /* @__PURE__ */ new Set();
        const defItems = [];
        for (const sym of definitionSymbols) {
          if (!sym.name || seen.has(sym.name)) continue;
          seen.add(sym.name);
          defItems.push({
            label: sym.name,
            kind: this.mapSymbolKindToCompletionKind(sym.kind),
            detail: `${sym.kind}${sym.qualifiedName !== sym.name ? ` (${sym.qualifiedName})` : ""}`,
            documentation: sym.documentation,
            data: sym.qualifiedName,
            sortText: `1_${sym.name}`
          });
        }
        this._defCache = { symbols: allSymbols, items: defItems };
        items.push(...defItems);
      }
      if (context === "connect-endpoint") {
        const portSymbols = allSymbols.filter(
          (s) => s.kind === "port" /* PortUsage */ || s.kind === "port def" /* PortDef */
        );
        const seenPorts = /* @__PURE__ */ new Set();
        for (const sym of portSymbols) {
          if (!sym.name || seenPorts.has(sym.name)) continue;
          seenPorts.add(sym.name);
          items.push({
            label: sym.name,
            kind: import_node2.CompletionItemKind.Interface,
            detail: `${sym.kind}${sym.typeNames[0] ? ` : ${sym.typeNames[0]}` : ""}`,
            data: sym.qualifiedName,
            sortText: `0_${sym.name}`
          });
        }
      }
      if (context === "type-annotation") {
        return items.filter((i) => this.isTypeOrDefinitionCompletion(i));
      }
      if (context === "connect-endpoint") {
        return items.filter((i) => this.isConnectContextCompletion(i));
      }
      return items;
    }
    resolveCompletion(item) {
      return item;
    }
    mapSymbolKindToCompletionKind(kind) {
      if (kind === "part def" /* PartDef */ || kind === "item def" /* ItemDef */) {
        return import_node2.CompletionItemKind.Class;
      }
      if (kind === "action def" /* ActionDef */ || kind === "calc def" /* CalcDef */) {
        return import_node2.CompletionItemKind.Function;
      }
      if (kind === "port def" /* PortDef */ || kind === "interface def" /* InterfaceDef */) {
        return import_node2.CompletionItemKind.Interface;
      }
      if (kind === "enum def" /* EnumDef */) {
        return import_node2.CompletionItemKind.Enum;
      }
      if (kind === "attribute def" /* AttributeDef */) {
        return import_node2.CompletionItemKind.Property;
      }
      return import_node2.CompletionItemKind.Text;
    }
    detectContext(uri, line, character) {
      const text = this.documentManager.getText(uri);
      if (!text) return "general";
      const lines = text.split("\n");
      if (line < 0 || line >= lines.length) return "general";
      const lineText = lines[line] ?? "";
      const beforeCursor = lineText.slice(0, Math.max(0, Math.min(character, lineText.length)));
      const beforeTrim = beforeCursor.trimEnd();
      if (/\bconnect\b/.test(beforeCursor) && !beforeCursor.includes(";")) {
        return "connect-endpoint";
      }
      if (/\bconnect\b/.test(beforeCursor) && /\b(to|from)$/.test(beforeTrim) || /\bconnect\s*$/.test(beforeTrim) || /\bconnect\s+[A-Za-z_][\w.]*\s*$/.test(beforeTrim)) {
        return "connect-endpoint";
      }
      if (/:\s*[A-Za-z_\d]*$/.test(beforeCursor)) {
        return "type-annotation";
      }
      return "general";
    }
    isTypeOrDefinitionCompletion(item) {
      if (typeof item.detail === "string" && item.detail.includes(" def")) return true;
      if (typeof item.data === "string" && item.data.includes("::")) return true;
      return [
        "part def",
        "action def",
        "state def",
        "requirement def",
        "constraint def",
        "attribute def",
        "item def",
        "port def",
        "interface def",
        "connection def",
        "allocation def",
        "use case def",
        "view def",
        "viewpoint def",
        "enum def",
        "calc def",
        "metadata def"
      ].includes(item.label);
    }
    isConnectContextCompletion(item) {
      if (typeof item.detail === "string" && (item.detail.startsWith("port") || item.detail.includes(" port"))) {
        return true;
      }
      return item.label === "connect" || item.label === "port" || item.label === "port def";
    }
  };

  // server/src/providers/definitionProvider.ts
  var DefinitionProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    provideDefinition(params) {
      const symbolTable = this.documentManager.getSymbolTable(params.textDocument.uri);
      if (!symbolTable) {
        return null;
      }
      const wsSymbolTable = this.documentManager.getWorkspaceSymbolTable();
      const symbol = symbolTable.findSymbolAtPosition(
        params.textDocument.uri,
        params.position.line,
        params.position.character
      );
      if (!symbol) {
        const text = this.documentManager.getText(params.textDocument.uri);
        if (!text) return null;
        const word = this.getWordAtPosition(text, params.position.line, params.position.character);
        if (!word) return null;
        if (word.includes("::")) {
          const libLoc = this.resolveFromLibrary(word);
          if (libLoc) return libLoc;
          const member = word.split("::").pop();
          const memberMatches = symbolTable.findByName(member);
          if (memberMatches.length > 0) {
            return {
              uri: memberMatches[0].uri,
              range: memberMatches[0].selectionRange
            };
          }
          const wsMemberMatches = wsSymbolTable.findByName(member);
          if (wsMemberMatches.length > 0) {
            return {
              uri: wsMemberMatches[0].uri,
              range: wsMemberMatches[0].selectionRange
            };
          }
          return null;
        }
        const matches = symbolTable.findByName(word);
        if (matches.length > 0) {
          return {
            uri: matches[0].uri,
            range: matches[0].selectionRange
          };
        }
        const wsMatches = wsSymbolTable.findByName(word);
        if (wsMatches.length > 0) {
          return {
            uri: wsMatches[0].uri,
            range: wsMatches[0].selectionRange
          };
        }
        return this.resolveFromLibrary(word);
      }
      if (symbol.typeName) {
        const typeMatches = symbolTable.findByName(symbol.typeName);
        if (typeMatches.length > 0) {
          return {
            uri: typeMatches[0].uri,
            range: typeMatches[0].selectionRange
          };
        }
        const wsTypeMatches = wsSymbolTable.findByName(symbol.typeName);
        if (wsTypeMatches.length > 0) {
          return {
            uri: wsTypeMatches[0].uri,
            range: wsTypeMatches[0].selectionRange
          };
        }
        const libLoc = this.resolveFromLibrary(symbol.typeName);
        if (libLoc) return libLoc;
      }
      return {
        uri: symbol.uri,
        range: symbol.selectionRange
      };
    }
    /**
     * Resolve a name against the bundled SysML standard library.
     * Returns a Location pointing to the `.kerml` / `.sysml` file
     * and line where the type is declared, or `null`.
     */
    resolveFromLibrary(name) {
      const loc = resolveLibraryType(name);
      if (loc) {
        return {
          uri: loc.uri,
          range: {
            start: { line: loc.line, character: 0 },
            end: { line: loc.line, character: 0 }
          }
        };
      }
      const pkgUri = resolveLibraryPackage(name);
      if (pkgUri) {
        return {
          uri: pkgUri,
          range: {
            start: { line: 0, character: 0 },
            end: { line: 0, character: 0 }
          }
        };
      }
      return null;
    }
    getWordAtPosition(text, line, character) {
      const lines = text.split("\n");
      if (line >= lines.length) return void 0;
      const lineText = lines[line];
      if (character >= lineText.length) return void 0;
      return extractQualifiedNameAt(lineText, character);
    }
  };

  // server/src/providers/diagnosticsProvider.ts
  var import_node3 = __toESM(require_main3());
  var EXPRESSION_OPERATOR_RE = /(\w\s*[+\-*/^]\s*\w)|(\w\s*\*\*\s*\w)|->|\.(?:\?)|:=|;\s*doc\b|#\w+\s+dependency/;
  var DiagnosticsProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    /** Cached grammar limitation ranges per URI, keyed by document version. */
    grammarRangeCache = /* @__PURE__ */ new Map();
    /**
     * Get diagnostics for a parsed document.
     */
    getDiagnostics(uri) {
      const result = this.documentManager.get(uri);
      if (!result) {
        return [];
      }
      const text = this.documentManager.getText(uri);
      const version = this.documentManager.getVersion(uri);
      let suppressedRanges;
      const cached = this.grammarRangeCache.get(uri);
      if (cached && cached.version === version) {
        suppressedRanges = cached.ranges;
      } else if (text) {
        suppressedRanges = this.findGrammarLimitationRanges(text);
        this.grammarRangeCache.set(uri, { version, ranges: suppressedRanges });
      } else {
        suppressedRanges = [];
      }
      const diagnostics = [];
      for (const error of result.errors) {
        if (suppressedRanges.length > 0) {
          if (this.isLineInRanges(error.line, suppressedRanges)) {
            continue;
          }
          if (error.message.startsWith("extraneous input '}' expecting") && this.isLineAtEndOfRanges(error.line, suppressedRanges)) {
            continue;
          }
        }
        diagnostics.push(this.syntaxErrorToDiagnostic(error));
      }
      return diagnostics;
    }
    syntaxErrorToDiagnostic(error) {
      let message = error.message;
      const token = error.offendingSymbol;
      if (token && token.type !== SysMLv2Lexer.IDENTIFIER && token.text && /^[a-z]+$/.test(token.text)) {
        const word = token.text;
        const suggestion = "my" + word.charAt(0).toUpperCase() + word.slice(1);
        message = `'${word}' is a reserved SysML keyword and cannot be used as a name. Consider renaming it (e.g., '${suggestion}').`;
      }
      return {
        severity: import_node3.DiagnosticSeverity.Error,
        range: {
          start: { line: error.line, character: error.column },
          end: { line: error.line, character: error.column + error.length }
        },
        message,
        source: "sysml"
      };
    }
    /**
     * Find 0-based line ranges of blocks where the ANTLR grammar has
     * known limitations and syntax errors should be suppressed.
     *
     * Only suppress errors in blocks whose body text actually contains
     * expression-level operators that the grammar cannot handle
     * (arithmetic, unit, collection, or assignment operators).  Blocks
     * without such operators will correctly report all syntax errors.
     */
    findGrammarLimitationRanges(text) {
      const ranges = [];
      const re = /\b(part|attribute|item|port|action|state|constraint|requirement|analysis|calc|occurrence|interface|connection|allocation|flow|use|verification|individual|exhibit|view|viewpoint|concern|rendering|metadata)\b([^;{]*)\{/g;
      let m2;
      let lineOffsets;
      while ((m2 = re.exec(text)) !== null) {
        const open = m2.index + m2[0].length - 1;
        let depth = 1;
        let i = open + 1;
        while (i < text.length && depth > 0) {
          if (text[i] === "{") depth++;
          if (text[i] === "}") depth--;
          i++;
        }
        if (depth !== 0) continue;
        const bodyText = stripComments(text.slice(open + 1, i - 1));
        if (!EXPRESSION_OPERATOR_RE.test(bodyText)) {
          continue;
        }
        if (!lineOffsets) {
          lineOffsets = [0];
          for (let j = 0; j < text.length; j++) {
            if (text[j] === "\n") lineOffsets.push(j + 1);
          }
        }
        ranges.push({
          startLine: this.offsetToLine(lineOffsets, open),
          endLine: this.offsetToLine(lineOffsets, i - 1)
        });
      }
      return ranges;
    }
    offsetToLine(lineOffsets, offset) {
      let lo = 0;
      let hi = lineOffsets.length - 1;
      while (lo < hi) {
        const mid = lo + hi + 1 >>> 1;
        if (lineOffsets[mid] <= offset) lo = mid;
        else hi = mid - 1;
      }
      return lo;
    }
    isLineInRanges(line, ranges) {
      return ranges.some((r) => line >= r.startLine && line <= r.endLine);
    }
    isLineAtEndOfRanges(line, ranges) {
      return ranges.some((r) => line === r.endLine);
    }
  };

  // server/src/providers/symbolKindMapping.ts
  var import_node4 = __toESM(require_main3());
  function toSysMLSymbolKind(kind) {
    switch (kind) {
      // Structural definitions → Class (they *are* types)
      case "part def" /* PartDef */:
      case "occurrence def" /* OccurrenceDef */:
        return import_node4.SymbolKind.Class;
      // Structural usages → Field (instances / typed features)
      case "part" /* PartUsage */:
      case "occurrence" /* OccurrenceUsage */:
      case "ref" /* RefUsage */:
        return import_node4.SymbolKind.Field;
      // Attributes
      case "attribute def" /* AttributeDef */:
      case "attribute" /* AttributeUsage */:
        return import_node4.SymbolKind.Property;
      // Ports & Interfaces → Interface
      case "port def" /* PortDef */:
      case "port" /* PortUsage */:
      case "interface def" /* InterfaceDef */:
      case "interface" /* InterfaceUsage */:
        return import_node4.SymbolKind.Interface;
      // Connections
      case "connection def" /* ConnectionDef */:
      case "connection" /* ConnectionUsage */:
        return import_node4.SymbolKind.Interface;
      // Behavioral: actions → Method
      case "action def" /* ActionDef */:
      case "action" /* ActionUsage */:
      case "perform action" /* PerformActionUsage */:
        return import_node4.SymbolKind.Method;
      // Behavioral: states → Event (better semantic fit than Enum)
      case "state def" /* StateDef */:
      case "state" /* StateUsage */:
      case "exhibit state" /* ExhibitStateUsage */:
        return import_node4.SymbolKind.Event;
      // Transitions → Event
      case "transition" /* TransitionUsage */:
        return import_node4.SymbolKind.Event;
      // Requirements → Object
      case "requirement def" /* RequirementDef */:
      case "requirement" /* RequirementUsage */:
      case "actor" /* ActorUsage */:
      case "subject" /* SubjectUsage */:
      case "stakeholder" /* StakeholderUsage */:
        return import_node4.SymbolKind.Object;
      // Constraints → Constant (boolean-valued)
      case "constraint def" /* ConstraintDef */:
      case "constraint" /* ConstraintUsage */:
        return import_node4.SymbolKind.Constant;
      // Items → Struct (physical things, data)
      case "item def" /* ItemDef */:
      case "item" /* ItemUsage */:
        return import_node4.SymbolKind.Struct;
      // Allocations → TypeParameter (cross-concern mapping)
      case "allocation def" /* AllocationDef */:
      case "allocation" /* AllocationUsage */:
        return import_node4.SymbolKind.TypeParameter;
      // Enumerations
      case "enum def" /* EnumDef */:
        return import_node4.SymbolKind.Enum;
      case "enum" /* EnumUsage */:
        return import_node4.SymbolKind.EnumMember;
      // Calculations → Function
      case "calc def" /* CalcDef */:
      case "calc" /* CalcUsage */:
      case "analysis case def" /* AnalysisCaseDef */:
      case "verification case def" /* VerificationCaseDef */:
        return import_node4.SymbolKind.Function;
      // Use cases → Event
      case "use case def" /* UseCaseDef */:
      case "use case" /* UseCaseUsage */:
      case "include use case" /* IncludeUseCaseUsage */:
        return import_node4.SymbolKind.Event;
      // Views → Namespace
      case "view def" /* ViewDef */:
      case "view" /* ViewUsage */:
      case "viewpoint def" /* ViewpointDef */:
      case "viewpoint" /* ViewpointUsage */:
      case "rendering def" /* RenderingDef */:
        return import_node4.SymbolKind.Namespace;
      // Metadata → TypeParameter
      case "metadata def" /* MetadataDef */:
        return import_node4.SymbolKind.TypeParameter;
      // Package
      case "package" /* Package */:
        return import_node4.SymbolKind.Package;
      // Comments / docs
      case "comment" /* Comment */:
      case "doc" /* Doc */:
        return import_node4.SymbolKind.String;
      // Import / Alias
      case "import" /* Import */:
      case "alias" /* Alias */:
        return import_node4.SymbolKind.Module;
      default:
        return import_node4.SymbolKind.Variable;
    }
  }

  // server/src/providers/documentSymbolProvider.ts
  var DocumentSymbolProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    provideDocumentSymbols(params) {
      const symbolTable = this.documentManager.getSymbolTable(params.textDocument.uri);
      if (!symbolTable) {
        return [];
      }
      const symbols = symbolTable.getSymbolsForUri(params.textDocument.uri);
      return this.buildHierarchy(symbols);
    }
    buildHierarchy(symbols) {
      const topLevel = [];
      const byQualifiedName = /* @__PURE__ */ new Map();
      const childrenOf = /* @__PURE__ */ new Map();
      for (const sym of symbols) {
        byQualifiedName.set(sym.qualifiedName, sym);
        if (!sym.parentQualifiedName) {
          topLevel.push(sym);
        } else {
          const siblings = childrenOf.get(sym.parentQualifiedName) ?? [];
          siblings.push(sym);
          childrenOf.set(sym.parentQualifiedName, siblings);
        }
      }
      const buildSymbol = (sym) => {
        const children = childrenOf.get(sym.qualifiedName) ?? [];
        return {
          name: sym.name,
          detail: toMetaclassName(sym.kind),
          kind: toSysMLSymbolKind(sym.kind),
          range: sym.range,
          selectionRange: sym.selectionRange,
          children: children.map(buildSymbol)
        };
      };
      return topLevel.map(buildSymbol);
    }
  };

  // server/src/providers/foldingRangeProvider.ts
  var import_node5 = __toESM(require_main3());
  var FoldingRangeProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    provideFoldingRanges(params) {
      const text = this.documentManager.getText(params.textDocument.uri);
      if (!text) {
        return [];
      }
      const ranges = [];
      const lines = text.split("\n");
      const braceStack = [];
      let commentStart;
      for (let i = 0; i < lines.length; i++) {
        const line = lines[i];
        if (line.includes("/*") && !line.includes("*/")) {
          commentStart = i;
        } else if (commentStart !== void 0 && line.includes("*/")) {
          ranges.push({
            startLine: commentStart,
            endLine: i,
            kind: import_node5.FoldingRangeKind.Comment
          });
          commentStart = void 0;
        }
        for (const ch of line) {
          if (ch === "{") {
            braceStack.push(i);
          } else if (ch === "}") {
            const startLine = braceStack.pop();
            if (startLine !== void 0 && i > startLine) {
              ranges.push({
                startLine,
                endLine: i,
                kind: import_node5.FoldingRangeKind.Region
              });
            }
          }
        }
      }
      return ranges;
    }
  };

  // server/src/providers/formattingProvider.ts
  var import_node6 = __toESM(require_main3());
  var FormattingProvider = class {
    constructor(documents2) {
      this.documents = documents2;
    }
    documents;
    provideDocumentFormatting(params) {
      const doc = this.documents.get(params.textDocument.uri);
      if (!doc) return [];
      const tabSize = params.options.tabSize ?? 4;
      const insertSpaces = params.options.insertSpaces ?? true;
      const indent = insertSpaces ? " ".repeat(tabSize) : "	";
      const text = doc.getText();
      const formatted = this.formatSysML(text, indent);
      if (formatted === text) return [];
      return [
        import_node6.TextEdit.replace(
          import_node6.Range.create(0, 0, doc.lineCount, 0),
          formatted
        )
      ];
    }
    provideRangeFormatting(params) {
      const doc = this.documents.get(params.textDocument.uri);
      if (!doc) return [];
      const tabSize = params.options.tabSize ?? 4;
      const insertSpaces = params.options.insertSpaces ?? true;
      const indent = insertSpaces ? " ".repeat(tabSize) : "	";
      const rangeText = doc.getText(params.range);
      const formatted = this.formatSysML(rangeText, indent);
      if (formatted === rangeText) return [];
      return [import_node6.TextEdit.replace(params.range, formatted)];
    }
    formatSysML(text, indent) {
      const lines = text.split("\n");
      const result = [];
      let depth = 0;
      let prevBlank = false;
      for (let i = 0; i < lines.length; i++) {
        let line = lines[i];
        line = line.trimEnd();
        if (line.trim() === "") {
          if (!prevBlank && result.length > 0) {
            result.push("");
            prevBlank = true;
          }
          continue;
        }
        prevBlank = false;
        const trimmed = line.trim();
        let leadingCloses = 0;
        for (let c = 0; c < trimmed.length; c++) {
          const ch = trimmed[c];
          if (ch === "}" || ch === "]") leadingCloses++;
          else break;
        }
        if (leadingCloses > 0) {
          depth = Math.max(0, depth - leadingCloses);
        }
        const isLineComment = trimmed.startsWith("//");
        const isBlockCommentContinuation = !trimmed.startsWith("/*") && (trimmed.startsWith("*") || trimmed.startsWith("*/"));
        let indented;
        if (isBlockCommentContinuation) {
          indented = indent.repeat(depth) + " " + trimmed;
        } else if (isLineComment) {
          indented = indent.repeat(depth) + trimmed;
        } else {
          const normalized = this.normalizeSpacing(trimmed);
          indented = indent.repeat(depth) + normalized;
        }
        result.push(indented);
        if (!isLineComment) {
          const opens = this.countOutsideStrings(trimmed, "{") + this.countOutsideStrings(trimmed, "[");
          const closes = this.countOutsideStrings(trimmed, "}") + this.countOutsideStrings(trimmed, "]");
          depth += opens - closes + leadingCloses;
          depth = Math.max(0, depth);
        }
      }
      while (result.length > 0 && result[result.length - 1] === "") {
        result.pop();
      }
      result.push("");
      return result.join("\n");
    }
    /**
     * Normalize spacing around common SysML operators.
     * Preserves spacing inside strings. No regex.
     */
    normalizeSpacing(line) {
      if (line.startsWith('"') || line.startsWith("'")) return line;
      const len = line.length;
      let result = "";
      let inString = false;
      let stringChar = "";
      for (let i = 0; i < len; i++) {
        const ch = line[i];
        if (inString) {
          result += ch;
          if (ch === stringChar && (i === 0 || line[i - 1] !== "\\")) {
            inString = false;
          }
          continue;
        }
        if (ch === '"' || ch === "'") {
          inString = true;
          stringChar = ch;
          result += ch;
          continue;
        }
        if (ch === "{") {
          let end = result.length;
          while (end > 0 && (result[end - 1] === " " || result[end - 1] === "	")) end--;
          result = result.substring(0, end) + " {";
          continue;
        }
        if (ch === ";" && i + 1 < len) {
          result += ";";
          let j = i + 1;
          while (j < len && (line[j] === " " || line[j] === "	")) j++;
          if (j < len) {
            result += " ";
            i = j - 1;
          }
          continue;
        }
        if (ch === " " || ch === "	") {
          let j = i + 1;
          while (j < len && (line[j] === " " || line[j] === "	")) j++;
          result += " ";
          i = j - 1;
          continue;
        }
        result += ch;
      }
      return result;
    }
    /**
     * Count occurrences of a character outside of string literals.
     */
    countOutsideStrings(line, char) {
      let count = 0;
      let inString = false;
      let stringChar = "";
      for (let i = 0; i < line.length; i++) {
        const c = line[i];
        if (inString) {
          if (c === stringChar && line[i - 1] !== "\\") {
            inString = false;
          }
        } else if (c === '"' || c === "'") {
          inString = true;
          stringChar = c;
        } else if (c === "/" && i + 1 < line.length) {
          if (line[i + 1] === "/") break;
          if (line[i + 1] === "*") break;
        } else if (c === char) {
          count++;
        }
      }
      return count;
    }
  };

  // server/src/providers/hoverProvider.ts
  var import_node7 = __toESM(require_main3());
  var HoverProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    _semanticValidator;
    /** Inject the server-level SemanticValidator so hover reuses cached data. */
    setSemanticValidator(validator) {
      this._semanticValidator = validator;
    }
    provideHover(params) {
      const symbolTable = this.documentManager.getSymbolTable(params.textDocument.uri);
      if (!symbolTable) {
        return null;
      }
      const text = this.documentManager.getText(params.textDocument.uri);
      const word = text ? this.getWordAtPosition(text, params.position.line, params.position.character) : void 0;
      if (word && word.includes("::")) {
        const libHover = this.buildLibraryHover(word);
        if (libHover) return libHover;
      }
      const symbol = symbolTable.findSymbolAtPosition(
        params.textDocument.uri,
        params.position.line,
        params.position.character
      );
      if (!symbol) {
        if (word) {
          const libHover = this.buildLibraryHover(word);
          if (libHover) return libHover;
        }
        return null;
      }
      const lines = [];
      const metaclass = toMetaclassName(symbol.kind);
      lines.push(`**${metaclass}** \`${symbol.name}\``);
      if (symbol.qualifiedName !== symbol.name) {
        lines.push(`
Fully qualified: \`${symbol.qualifiedName}\``);
      }
      if (symbol.typeName) {
        lines.push(`
Type: \`${symbol.typeName}\``);
        const libInfo = getLibraryHoverInfo(symbol.typeName);
        if (libInfo) {
          if (libInfo.packageName) {
            lines.push(`
From: \`${libInfo.packageName}\``);
          }
          lines.push(`
\`\`\`sysml
${libInfo.declaration}
\`\`\``);
          if (libInfo.documentation) {
            lines.push(`
${libInfo.documentation}`);
          }
        }
      }
      if (symbol.documentation) {
        lines.push(`
---
${symbol.documentation}`);
      }
      const semanticDiags = this.documentManager.getSemanticDiagnostics(params.textDocument.uri);
      const hoverDiags = (semanticDiags ?? []).filter(
        (d) => this.rangeContainsPosition(d.range, params.position)
      );
      if (hoverDiags.length > 0) {
        lines.push("\n---\n**Semantic Feedback**");
        for (const d of hoverDiags.slice(0, 3)) {
          const sev = d.severity === import_node7.DiagnosticSeverity.Error ? "Error" : d.severity === import_node7.DiagnosticSeverity.Warning ? "Warning" : "Hint";
          lines.push(`- **${sev}**: ${d.message}`);
          const hint = this.getRepairHint(String(d.code ?? ""));
          if (hint) {
            lines.push(`  - Suggestion: ${hint}`);
          }
        }
      }
      const content = {
        kind: import_node7.MarkupKind.Markdown,
        value: lines.join("\n")
      };
      return {
        contents: content,
        range: symbol.selectionRange
      };
    }
    /**
     * Build a hover result from the standard library for a name.
     */
    buildLibraryHover(name) {
      const info = getLibraryHoverInfo(name);
      if (!info) return null;
      const lines = [];
      const displayName = name.includes("::") ? name : info.packageName ? `${info.packageName}::${name}` : name;
      lines.push(`**Standard Library** \`${displayName}\``);
      lines.push(`
\`\`\`sysml
${info.declaration}
\`\`\``);
      if (info.packageName) {
        lines.push(`
Package: \`${info.packageName}\``);
      }
      if (info.documentation) {
        lines.push(`
---
${info.documentation}`);
      }
      return {
        contents: {
          kind: import_node7.MarkupKind.Markdown,
          value: lines.join("\n")
        }
      };
    }
    /**
     * Extract the word (simple or qualified) at a text position.
     * Scans for identifier segments separated by '::' without regex.
     */
    getWordAtPosition(text, line, character) {
      const lines = text.split("\n");
      if (line >= lines.length) return void 0;
      const lineText = lines[line];
      if (character >= lineText.length) return void 0;
      return extractQualifiedNameAt(lineText, character);
    }
    rangeContainsPosition(range, position) {
      const afterStart = position.line > range.start.line || position.line === range.start.line && position.character >= range.start.character;
      const beforeEnd = position.line < range.end.line || position.line === range.end.line && position.character <= range.end.character;
      return afterStart && beforeEnd;
    }
    getRepairHint(code) {
      switch (code) {
        case "invalid-redefinition-multiplicity":
          return "Align the redefined feature multiplicity with its base feature bounds.";
        case "incompatible-port-types":
          return "Connect endpoints with matching port types, or update one endpoint type.";
        case "unresolved-constraint-reference":
          return "Fix the reference path or add the missing feature in the referenced type.";
        case "unresolved-type":
          return "Define/import the missing type or correct the type name.";
        case "invalid-multiplicity":
          return "Use a valid bound where lower <= upper and lower is non-negative.";
        default:
          return void 0;
      }
    }
  };

  // server/src/providers/keywordValidator.ts
  var import_node8 = __toESM(require_main3());
  var DEFINITION_KEYWORDS = /* @__PURE__ */ new Set([
    "about",
    "abstract",
    "accept",
    "action",
    "actor",
    "after",
    "alias",
    "all",
    "allocate",
    "allocation",
    "analysis",
    "assert",
    "assign",
    "assume",
    "attribute",
    "bind",
    "binding",
    "calc",
    "case",
    "comment",
    "concern",
    "connect",
    "connection",
    "constraint",
    "decide",
    "def",
    "default",
    "defined",
    "dependency",
    "derived",
    "do",
    "doc",
    "else",
    "end",
    "entry",
    "enum",
    "event",
    "exhibit",
    "exit",
    "expose",
    "feature",
    "filter",
    "first",
    "flow",
    "for",
    "fork",
    "frame",
    "from",
    "if",
    "import",
    "in",
    "include",
    "individual",
    "inout",
    "interface",
    "item",
    "join",
    "language",
    "library",
    "locale",
    "merge",
    "message",
    "meta",
    "metadata",
    "multiplicity",
    "namespace",
    "nonunique",
    "not",
    "null",
    "objective",
    "occurrence",
    "of",
    "ordered",
    "out",
    "package",
    "parallel",
    "part",
    "perform",
    "port",
    "private",
    "protected",
    "public",
    "readonly",
    "redefines",
    "ref",
    "references",
    "render",
    "rendering",
    "rep",
    "require",
    "requirement",
    "return",
    "satisfy",
    "send",
    "snapshot",
    "specializes",
    "stakeholder",
    "state",
    "subject",
    "subsets",
    "succession",
    "then",
    "timeslice",
    "to",
    "transition",
    "type",
    "use",
    "variant",
    "variation",
    "verification",
    "verify",
    "view",
    "viewpoint",
    "when",
    "while",
    "datatype"
  ]);
  function levenshtein2(a, b) {
    if (a.length < b.length) {
      const t = a;
      a = b;
      b = t;
    }
    const m2 = a.length;
    const n2 = b.length;
    let prev = new Uint16Array(n2 + 1);
    let curr = new Uint16Array(n2 + 1);
    for (let j = 0; j <= n2; j++) prev[j] = j;
    for (let i = 1; i <= m2; i++) {
      curr[0] = i;
      for (let j = 1; j <= n2; j++) {
        const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
        curr[j] = Math.min(
          prev[j] + 1,
          // deletion
          curr[j - 1] + 1,
          // insertion
          prev[j - 1] + cost
          // substitution
        );
      }
      [prev, curr] = [curr, prev];
    }
    return prev[n2];
  }
  function findClosestKeyword(identifier, maxDistance = 2) {
    const lower = identifier.toLowerCase();
    if (lower.length < 4) return void 0;
    if (DEFINITION_KEYWORDS.has(lower)) return void 0;
    const effectiveMax = lower.length <= 5 ? 1 : maxDistance;
    let bestMatch;
    let bestDist = effectiveMax + 1;
    for (const keyword of DEFINITION_KEYWORDS) {
      if (Math.abs(keyword.length - lower.length) > maxDistance) continue;
      const dist = levenshtein2(lower, keyword);
      if (dist > 0 && dist < bestDist) {
        bestDist = dist;
        bestMatch = keyword;
      }
    }
    return bestMatch;
  }
  var KEYWORD_CONTINUATIONS = /* @__PURE__ */ new Set([
    SysMLv2Lexer.IDENTIFIER,
    // e.g. "attributedd power" — followed by a name
    SysMLv2Lexer.COLON,
    // e.g. "attributedd : Type"
    SysMLv2Lexer.DEF,
    // e.g. "party def Foo"
    SysMLv2Lexer.LBRACE,
    // e.g. "packge { ... }"
    SysMLv2Lexer.LBRACK,
    // e.g. "attributedd [2]"
    SysMLv2Lexer.ABOUT
    // e.g. keyword misuse
  ]);
  var NAME_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
    // ── SysML definition/usage element keywords ──
    SysMLv2Lexer.PART,
    SysMLv2Lexer.PORT,
    SysMLv2Lexer.ITEM,
    SysMLv2Lexer.ATTRIBUTE,
    SysMLv2Lexer.ACTION,
    SysMLv2Lexer.CALC,
    SysMLv2Lexer.STATE,
    SysMLv2Lexer.CONSTRAINT,
    SysMLv2Lexer.REQUIREMENT,
    SysMLv2Lexer.CONCERN,
    SysMLv2Lexer.CASE,
    SysMLv2Lexer.ANALYSIS,
    SysMLv2Lexer.VERIFICATION,
    SysMLv2Lexer.VIEW,
    SysMLv2Lexer.VIEWPOINT,
    SysMLv2Lexer.RENDERING,
    SysMLv2Lexer.METADATA,
    SysMLv2Lexer.PACKAGE,
    SysMLv2Lexer.NAMESPACE,
    SysMLv2Lexer.ENUM,
    SysMLv2Lexer.ALLOCATION,
    SysMLv2Lexer.CONNECTION,
    SysMLv2Lexer.INTERFACE,
    SysMLv2Lexer.OCCURRENCE,
    SysMLv2Lexer.INDIVIDUAL,
    SysMLv2Lexer.FLOW,
    SysMLv2Lexer.SUCCESSION,
    SysMLv2Lexer.BINDING,
    SysMLv2Lexer.MESSAGE,
    SysMLv2Lexer.TRANSITION,
    // ── KerML element keywords ──
    SysMLv2Lexer.TYPE,
    SysMLv2Lexer.CLASSIFIER,
    SysMLv2Lexer.DATATYPE,
    SysMLv2Lexer.CLASS,
    SysMLv2Lexer.STRUCT,
    SysMLv2Lexer.ASSOC,
    SysMLv2Lexer.METACLASS,
    SysMLv2Lexer.INTERACTION,
    SysMLv2Lexer.BEHAVIOR,
    SysMLv2Lexer.FUNCTION,
    SysMLv2Lexer.PREDICATE,
    SysMLv2Lexer.FEATURE,
    SysMLv2Lexer.CONNECTOR,
    SysMLv2Lexer.STEP,
    SysMLv2Lexer.EXPR,
    SysMLv2Lexer.BOOL,
    SysMLv2Lexer.INV,
    SysMLv2Lexer.MULTIPLICITY,
    // ── Annotation / membership keywords ──
    SysMLv2Lexer.ALIAS,
    SysMLv2Lexer.COMMENT,
    SysMLv2Lexer.DOC,
    SysMLv2Lexer.REP,
    SysMLv2Lexer.DEPENDENCY,
    SysMLv2Lexer.IMPORT,
    // ── Keyword + DEF / keyword modifiers ──
    SysMLv2Lexer.DEF,
    SysMLv2Lexer.REF,
    SysMLv2Lexer.ALL,
    // ── Feature prefix / visibility modifiers ──
    SysMLv2Lexer.ABSTRACT,
    SysMLv2Lexer.VARIATION,
    SysMLv2Lexer.DERIVED,
    SysMLv2Lexer.COMPOSITE,
    SysMLv2Lexer.CONST,
    SysMLv2Lexer.CONSTANT,
    SysMLv2Lexer.VAR,
    SysMLv2Lexer.MEMBER,
    SysMLv2Lexer.RETURN,
    SysMLv2Lexer.PUBLIC,
    SysMLv2Lexer.PRIVATE,
    SysMLv2Lexer.PROTECTED,
    // ── Directionality ──
    SysMLv2Lexer.IN,
    SysMLv2Lexer.OUT,
    SysMLv2Lexer.INOUT,
    SysMLv2Lexer.END,
    // ── Actor / role keywords ──
    SysMLv2Lexer.ACTOR,
    SysMLv2Lexer.STAKEHOLDER,
    SysMLv2Lexer.SUBJECT,
    SysMLv2Lexer.VARIANT,
    SysMLv2Lexer.SNAPSHOT,
    SysMLv2Lexer.TIMESLICE,
    // ── Action control node keywords ──
    SysMLv2Lexer.FORK,
    SysMLv2Lexer.JOIN,
    SysMLv2Lexer.MERGE,
    SysMLv2Lexer.DECIDE,
    // ── Reference-preceding keywords (perform x, exhibit x, …) ──
    SysMLv2Lexer.PERFORM,
    SysMLv2Lexer.EXHIBIT,
    SysMLv2Lexer.INCLUDE,
    SysMLv2Lexer.SATISFY,
    SysMLv2Lexer.ASSERT,
    SysMLv2Lexer.VERIFY,
    SysMLv2Lexer.RENDER,
    SysMLv2Lexer.CONNECT,
    SysMLv2Lexer.ALLOCATE,
    SysMLv2Lexer.BIND,
    SysMLv2Lexer.EXPOSE,
    SysMLv2Lexer.EVENT,
    // ── Succession / flow keywords ──
    SysMLv2Lexer.FIRST,
    SysMLv2Lexer.THEN,
    SysMLv2Lexer.TO,
    SysMLv2Lexer.FROM,
    // ── Relationship keywords ──
    SysMLv2Lexer.REDEFINES,
    SysMLv2Lexer.SUBSETS,
    SysMLv2Lexer.SPECIALIZES,
    SysMLv2Lexer.REFERENCES,
    SysMLv2Lexer.CONJUGATES,
    SysMLv2Lexer.CHAINS,
    SysMLv2Lexer.CROSSES,
    SysMLv2Lexer.UNIONS,
    SysMLv2Lexer.INTERSECTS,
    SysMLv2Lexer.DIFFERENCES,
    // ── KerML relationship element keywords ──
    SysMLv2Lexer.SPECIALIZATION,
    SysMLv2Lexer.CONJUGATION,
    SysMLv2Lexer.DISJOINING,
    SysMLv2Lexer.INVERTING,
    SysMLv2Lexer.FEATURING,
    SysMLv2Lexer.TYPING,
    SysMLv2Lexer.REDEFINITION,
    SysMLv2Lexer.SUBTYPE,
    SysMLv2Lexer.SUBCLASSIFIER,
    SysMLv2Lexer.SUBSET,
    SysMLv2Lexer.CONJUGATE,
    SysMLv2Lexer.DISJOINT,
    SysMLv2Lexer.INVERSE,
    // ── Requirement / state body keywords ──
    SysMLv2Lexer.ASSUME,
    SysMLv2Lexer.REQUIRE,
    SysMLv2Lexer.FRAME,
    SysMLv2Lexer.OBJECTIVE,
    SysMLv2Lexer.ENTRY,
    SysMLv2Lexer.DO,
    SysMLv2Lexer.EXIT,
    // ── Misc keywords preceding a name or qualified name ──
    SysMLv2Lexer.ACCEPT,
    SysMLv2Lexer.SEND,
    SysMLv2Lexer.ASSIGN,
    SysMLv2Lexer.TERMINATE,
    SysMLv2Lexer.FOR,
    SysMLv2Lexer.ABOUT,
    SysMLv2Lexer.BY,
    SysMLv2Lexer.FILTER,
    SysMLv2Lexer.NEW,
    SysMLv2Lexer.META,
    SysMLv2Lexer.OF,
    // ── Punctuation that precedes names ──
    SysMLv2Lexer.COLON,
    SysMLv2Lexer.COLON_GT,
    SysMLv2Lexer.COLON_GT_GT,
    SysMLv2Lexer.COLON_COLON,
    SysMLv2Lexer.COLON_COLON_GT,
    SysMLv2Lexer.GT,
    // closing angle bracket: <'shortName'> name
    SysMLv2Lexer.FAT_ARROW,
    // => target (crosses)
    SysMLv2Lexer.TILDE,
    // ~ conjugatedType
    SysMLv2Lexer.COMMA,
    // list separator in specializations
    SysMLv2Lexer.HASH,
    // # prefixMetadataFeature
    SysMLv2Lexer.AT
    // @ metadata annotation
  ]);
  function looksLikeKeywordPosition(visibleTokens, index2) {
    if (index2 > 0) {
      const prev = visibleTokens[index2 - 1];
      if (NAME_PRECEDING_KEYWORDS.has(prev.type)) {
        return false;
      }
      if (prev.type === SysMLv2Lexer.DOT || prev.type === SysMLv2Lexer.EQ || prev.type === SysMLv2Lexer.COLON_EQ) {
        return false;
      }
      if (prev.text === "->") {
        return false;
      }
    }
    if (index2 + 1 < visibleTokens.length) {
      const next = visibleTokens[index2 + 1];
      if (KEYWORD_CONTINUATIONS.has(next.type)) {
        return true;
      }
    }
    if (index2 === 0) return true;
    return false;
  }
  function validateKeywords(result) {
    const diagnostics = [];
    result.tokenStream.fill();
    const allTokens = result.tokenStream.getTokens();
    const visibleTokens = [];
    for (let j = 0; j < allTokens.length; j++) {
      const t = allTokens[j];
      if (t.channel === 0 && t.type !== Token.EOF) {
        visibleTokens.push(t);
      }
    }
    for (let i = 0; i < visibleTokens.length; i++) {
      const token = visibleTokens[i];
      if (token.type !== SysMLv2Lexer.IDENTIFIER) continue;
      const text = token.text;
      if (!text) continue;
      if (!looksLikeKeywordPosition(visibleTokens, i)) continue;
      const suggestion = findClosestKeyword(text);
      if (!suggestion) continue;
      const line = (token.line ?? 1) - 1;
      const char = token.column ?? 0;
      const message = `Unknown keyword '${text}'. Did you mean '${suggestion}'?`;
      diagnostics.push({
        severity: import_node8.DiagnosticSeverity.Error,
        range: {
          start: { line, character: char },
          end: { line, character: char + text.length }
        },
        message,
        source: "sysml",
        data: { typo: text, suggestion }
      });
    }
    return diagnostics;
  }

  // server/src/providers/referencesProvider.ts
  var ReferencesProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    provideReferences(params) {
      const result = this.documentManager.get(params.textDocument.uri);
      if (!result) {
        return [];
      }
      const symbolTable = this.documentManager.getWorkspaceSymbolTable();
      const symbol = symbolTable.findSymbolAtPosition(
        params.textDocument.uri,
        params.position.line,
        params.position.character
      );
      if (!symbol) {
        return [];
      }
      const references = symbolTable.findReferences(symbol.name);
      const locations = [];
      for (const ref of references) {
        locations.push({
          uri: ref.uri,
          range: ref.selectionRange
        });
      }
      if (params.context.includeDeclaration) {
      }
      return locations;
    }
  };

  // server/src/providers/renameProvider.ts
  function findWordOccurrences(line, word) {
    const positions = [];
    let from = 0;
    while (from <= line.length - word.length) {
      const idx = line.indexOf(word, from);
      if (idx < 0) break;
      if ((idx === 0 || !isIdentPart(line.charCodeAt(idx - 1))) && (idx + word.length >= line.length || !isIdentPart(line.charCodeAt(idx + word.length)))) {
        positions.push(idx);
      }
      from = idx + 1;
    }
    return positions;
  }
  var RenameProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    /**
     * Check if the token at position is renameable and return its range.
     */
    prepareRename(params) {
      const symbolTable = this.documentManager.getSymbolTable(params.textDocument.uri);
      if (!symbolTable) return null;
      const symbol = symbolTable.findSymbolAtPosition(
        params.textDocument.uri,
        params.position.line,
        params.position.character
      );
      if (!symbol) return null;
      return symbol.selectionRange;
    }
    /**
     * Perform the rename — update the symbol and all references.
     */
    provideRename(params) {
      const symbolTable = this.documentManager.getSymbolTable(params.textDocument.uri);
      if (!symbolTable) return null;
      const symbol = symbolTable.findSymbolAtPosition(
        params.textDocument.uri,
        params.position.line,
        params.position.character
      );
      if (!symbol) return null;
      const text = this.documentManager.getText(params.textDocument.uri);
      if (!text) return null;
      const edits = [];
      const oldName = symbol.name;
      const newName = params.newName;
      const references = symbolTable.findReferences(oldName);
      for (const ref of references) {
        if (ref.uri === params.textDocument.uri) {
          edits.push({
            range: ref.selectionRange,
            newText: newName
          });
        }
      }
      const lines = text.split("\n");
      for (let i = 0; i < lines.length; i++) {
        for (const col of findWordOccurrences(lines[i], oldName)) {
          const range = {
            start: { line: i, character: col },
            end: { line: i, character: col + oldName.length }
          };
          if (!edits.some((e) => e.range.start.line === i && e.range.start.character === col)) {
            edits.push({ range, newText: newName });
          }
        }
      }
      if (edits.length === 0) return null;
      return {
        changes: {
          [params.textDocument.uri]: edits
        }
      };
    }
  };

  // server/src/providers/semanticTokensProvider.ts
  var import_node9 = __toESM(require_main3());
  var OPERATOR_TOKENS = /* @__PURE__ */ new Set([
    SysMLv2Lexer.BANG_EQ_EQ,
    // !==
    SysMLv2Lexer.STAR_STAR,
    // **
    SysMLv2Lexer.COLON_GT,
    // :>
    SysMLv2Lexer.COLON_GT_GT,
    // :>>
    SysMLv2Lexer.AMP,
    // &
    SysMLv2Lexer.COLON_COLON,
    // ::
    SysMLv2Lexer.STAR,
    // *
    SysMLv2Lexer.PIPE,
    // |
    SysMLv2Lexer.EQ_EQ,
    // ==
    SysMLv2Lexer.BANG_EQ,
    // !=
    SysMLv2Lexer.PLUS,
    // +
    SysMLv2Lexer.MINUS,
    // -
    SysMLv2Lexer.ARROW,
    // ->
    SysMLv2Lexer.SLASH,
    // /
    SysMLv2Lexer.LT,
    // <
    SysMLv2Lexer.EQ,
    // =
    SysMLv2Lexer.GT,
    // >
    SysMLv2Lexer.CARET,
    // ^
    SysMLv2Lexer.TILDE
    // ~
  ]);
  var PUNCTUATION_TOKENS = /* @__PURE__ */ new Set([
    SysMLv2Lexer.LBRACE,
    // {
    SysMLv2Lexer.RBRACE,
    // }
    SysMLv2Lexer.LPAREN,
    // (
    SysMLv2Lexer.RPAREN,
    // )
    SysMLv2Lexer.SEMI,
    // ;
    SysMLv2Lexer.COMMA,
    // ,
    SysMLv2Lexer.DOT,
    // .
    SysMLv2Lexer.LBRACK,
    // [
    SysMLv2Lexer.RBRACK,
    // ]
    SysMLv2Lexer.COLON
    // :
  ]);
  var STRUCTURAL_KEYWORDS = /* @__PURE__ */ new Set([
    "part",
    "port",
    "item",
    "state",
    "constraint",
    "requirement",
    "concern",
    "case",
    "view",
    "viewpoint",
    "rendering",
    "allocation",
    "connection",
    "interface",
    "occurrence",
    "individual",
    "flow",
    "binding",
    "succession",
    "metadata",
    "enum",
    "actor",
    "subject",
    "ref",
    "use"
  ]);
  var tokenTypes = [
    "namespace",
    // 0 — packages
    "type",
    // 1 — type references
    "class",
    // 2 — definitions
    "variable",
    // 3 — usages
    "property",
    // 4 — attributes
    "function",
    // 5 — actions, calcs
    "keyword",
    // 6 — SysML keywords
    "comment",
    // 7 — comments
    "string",
    // 8 — string literals
    "number",
    // 9 — numeric literals
    "operator",
    // 10 — operators
    "enum",
    // 11 — enumerations, states
    "interface"
    // 12 — ports, interfaces
  ];
  var tokenModifiers = [
    "declaration",
    // 0
    "definition",
    // 1
    "readonly",
    // 2
    "abstract"
    // 3
  ];
  var SemanticTokensProvider = class {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
    }
    documentManager;
    /** Cached semantic tokens keyed by URI + version. */
    tokenCache;
    provideSemanticTokens(params) {
      const uri = params.textDocument.uri;
      const version = this.documentManager.getVersion(uri);
      if (this.tokenCache && this.tokenCache.uri === uri && this.tokenCache.version === version) {
        return this.tokenCache.tokens;
      }
      const builder = new import_node9.SemanticTokensBuilder();
      const result = this.documentManager.get(uri);
      if (!result) {
        return builder.build();
      }
      result.tokenStream.fill();
      const tokens = result.tokenStream.getTokens();
      let prevMeaningful;
      for (const token of tokens) {
        if (!token.text || token.channel !== 0) {
          continue;
        }
        const text = token.text;
        const tokenType = this.classifyTokenInContext(text, prevMeaningful, token.type);
        prevMeaningful = text;
        if (tokenType === void 0) {
          continue;
        }
        const line = (token.line ?? 1) - 1;
        const char = token.column ?? 0;
        const length = text.length;
        builder.push(line, char, length, tokenType, 0);
      }
      const built = builder.build();
      this.tokenCache = { uri, version, tokens: built };
      return built;
    }
    /**
     * Classify a token using surrounding context to match tmLanguage scopes.
     */
    classifyTokenInContext(text, prev, lexerType) {
      if (lexerType === SysMLv2Lexer.REGULAR_COMMENT || lexerType === SysMLv2Lexer.SINGLE_LINE_NOTE) {
        return 7;
      }
      if (lexerType === SysMLv2Lexer.STRING || lexerType === SysMLv2Lexer.DOUBLE_STRING) {
        return 8;
      }
      if (lexerType === SysMLv2Lexer.INTEGER || lexerType === SysMLv2Lexer.REAL) {
        return 9;
      }
      if (OPERATOR_TOKENS.has(lexerType)) {
        return 10;
      }
      if (PUNCTUATION_TOKENS.has(lexerType)) {
        return void 0;
      }
      if (this.isKeyword(text)) {
        return 6;
      }
      if (lexerType === SysMLv2Lexer.IDENTIFIER) {
        return this.classifyIdentifier(prev);
      }
      return void 0;
    }
    /**
     * Classify an identifier based on the previous meaningful token,
     * mirroring the tmLanguage patterns for consistent highlighting.
     */
    classifyIdentifier(prev) {
      if (!prev) return 3;
      if (prev === "def") return 2;
      if (prev === "package" || prev === "namespace" || prev === "library") return 0;
      if (prev === "action" || prev === "calc" || prev === "analysis" || prev === "verification") return 5;
      if (prev === ":" || prev === ":>" || prev === ":>>") return 1;
      if (prev === "attribute") return 4;
      if (this.isStructuralKeyword(prev)) return 3;
      return 3;
    }
    /**
     * Keywords that precede member/instance names in usage declarations.
     */
    isStructuralKeyword(text) {
      return STRUCTURAL_KEYWORDS.has(text);
    }
    isKeyword(text) {
      return SYSML_KEYWORDS.has(text);
    }
  };

  // server/src/providers/semanticValidator.ts
  var import_node10 = __toESM(require_main3());
  var STANDARD_LIBRARY_TYPES = /* @__PURE__ */ new Set([
    // Kernel Data Types
    "Boolean",
    "String",
    "Integer",
    "Real",
    "Natural",
    "Positive",
    "Complex",
    "Number",
    "Rational",
    "ScalarValues",
    "DataFunctions",
    // Kernel Semantic Library
    "Anything",
    "Nothing",
    "Object",
    "Occurrence",
    "Base",
    "Objects",
    "Occurrences",
    "Items",
    "Parts",
    "Ports",
    "Actions",
    "States",
    "Connections",
    "Interfaces",
    "Allocations",
    "Requirements",
    "Constraints",
    "Calculations",
    "Cases",
    "Flows",
    "Transfers",
    "Performances",
    "TransitionPerformances",
    // Common library packages
    "ISQ",
    "SI",
    "USCustomaryUnits",
    "Quantities",
    "MeasurementReferences",
    "ScalarValues",
    // StandardViewDefinitions (SysML v2 standard library)
    "GeneralView",
    "InterconnectionView",
    "ActionFlowView",
    "StateTransitionView",
    "SequenceView",
    "GeometryView",
    "GridView",
    "BrowserView",
    "StandardViewDefinitions",
    // Views library (rendering types)
    "View",
    "ViewpointCheck",
    "Rendering",
    "TextualRendering",
    "GraphicalRendering",
    "TabularRendering",
    "Views",
    // ISQ Base quantities (ISO 80000)
    "LengthValue",
    "MassValue",
    "DurationValue",
    "TimeValue",
    "ElectricCurrentValue",
    "ThermodynamicTemperatureValue",
    "TemperatureValue",
    "AmountOfSubstanceValue",
    "LuminousIntensityValue",
    // ISQ Derived quantities (commonly used)
    "AreaValue",
    "VolumeValue",
    "SpeedValue",
    "VelocityValue",
    "AccelerationValue",
    "ForceValue",
    "EnergyValue",
    "PowerValue",
    "PressureValue",
    "TorqueValue",
    "MomentOfForceValue",
    "AngularVelocityValue",
    "FrequencyValue",
    "DensityValue",
    "MassFlowRateValue",
    "VolumeFlowRateValue",
    // ISQ units
    "LengthUnit",
    "MassUnit",
    "DurationUnit",
    "TimeUnit"
  ]);
  var CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
    "and",
    "or",
    "not",
    "xor",
    "implies",
    "if",
    "then",
    "else",
    "true",
    "false",
    "null",
    "require",
    "constraint",
    "subject",
    "return",
    "doc",
    "comment",
    "assert",
    "assume"
  ]);
  function isISQValueType(name) {
    if (!name.endsWith("Value") || name.length < 6) return false;
    const ch0 = name.charCodeAt(0);
    if (ch0 < 65 || ch0 > 90) return false;
    for (let i = 1; i < name.length; i++) {
      const c = name.charCodeAt(i);
      if (!(c >= 65 && c <= 90 || c >= 97 && c <= 122)) return false;
    }
    return true;
  }
  var SemanticValidator = class _SemanticValidator {
    constructor(documentManager2) {
      this.documentManager = documentManager2;
      this.modelProvider = new SysMLModelProvider(documentManager2);
    }
    documentManager;
    modelProvider;
    /** Cached workspace-wide satisfy data, invalidated when any document version changes. */
    satisfyCache;
    /** Cached workspace-wide verify data, invalidated when any document version changes. */
    verifyCache;
    /** Cached symbol indexes, invalidated when workspace symbol table changes. */
    indexCache;
    /** Cached allSymbolNames set, keyed on allSymbols array identity. */
    symbolNamesCache;
    /** Cached library package names — never changes after init. */
    libraryNamesCache;
    addRequirementNameVariants(out, ref) {
      if (!ref) return;
      const trimmed = ref.trim();
      if (!trimmed) return;
      out.add(trimmed);
      const lastSeg = trimmed.includes("::") ? trimmed.split("::").pop() : trimmed;
      out.add(lastSeg);
    }
    collectWorkspaceRequirementRelationshipNames() {
      const satisfiedNames = /* @__PURE__ */ new Set();
      const verifiedNames = /* @__PURE__ */ new Set();
      const uris = this.documentManager.getUris();
      for (const uri of uris) {
        const version = this.documentManager.getVersion(uri);
        if (version < 0) continue;
        const model = this.modelProvider.getModel(uri, version, ["relationships"]);
        const rels = model.relationships ?? [];
        for (const rel of rels) {
          if (rel.type === "satisfy") {
            this.addRequirementNameVariants(satisfiedNames, rel.target);
          } else if (rel.type === "verify") {
            this.addRequirementNameVariants(verifiedNames, rel.target);
          }
        }
      }
      return { satisfiedNames, verifiedNames };
    }
    /**
     * Run all semantic validation rules and return LSP Diagnostic objects.
     */
    validate(uri) {
      const symbolTable = this.documentManager.getWorkspaceSymbolTable();
      const symbols = symbolTable.getSymbolsForUri(uri);
      if (symbols.length === 0) return [];
      const allSymbols = symbolTable.getAllSymbols();
      let allSymbolNames;
      if (this.symbolNamesCache && this.symbolNamesCache.symbols === allSymbols) {
        allSymbolNames = this.symbolNamesCache.names;
      } else {
        allSymbolNames = new Set(allSymbols.map((s) => s.name));
        this.symbolNamesCache = { symbols: allSymbols, names: allSymbolNames };
      }
      if (!this.libraryNamesCache) {
        this.libraryNamesCache = new Set(getLibraryPackageNames());
      }
      const libraryNames = this.libraryNamesCache;
      const text = this.documentManager.getText(uri) ?? "";
      const indexes = this.getOrBuildIndexes(allSymbols);
      const diagnostics = [];
      for (const symbol of symbols) {
        diagnostics.push(
          ...this.checkUnresolvedType(symbol, allSymbolNames, libraryNames),
          ...this.checkInvalidMultiplicity(symbol),
          ...this.checkEmptyEnum(symbol, symbols),
          ...this.checkNamingConvention(symbol),
          ...this.checkMissingDocumentation(symbol)
        );
      }
      diagnostics.push(...this.checkDuplicateDefinitions(symbols));
      diagnostics.push(...this.checkUnusedDefinitions(allSymbols, uri));
      diagnostics.push(...this.checkRedefinitionMultiplicity(symbols, indexes, text));
      diagnostics.push(...this.checkPortCompatibility(text, uri, indexes));
      diagnostics.push(...this.checkConstraintBodyReferences(text, uri, symbols, indexes));
      diagnostics.push(...this.checkCircularSpecialization(symbols, indexes));
      diagnostics.push(...this.checkCircularContainment(symbols, indexes));
      diagnostics.push(...this.checkUnsatisfiedRequirements(symbols, indexes));
      diagnostics.push(...this.checkUnverifiedRequirements(symbols, indexes));
      diagnostics.push(...this.checkViewpointSatisfaction(symbols, indexes));
      return this.dedupeDiagnostics(diagnostics);
    }
    /**
     * Rule: Unresolved type reference.
     *
     * When a feature (part, attribute, port, etc.) references a type name
     * that doesn't exist in the document's symbol table or the standard
     * library, flag it as a warning. If the feature has a mandatory
     * multiplicity (lower >= 1), escalate to error with extra context.
     */
    checkUnresolvedType(symbol, allSymbolNames, libraryNames) {
      if (!symbol.typeName) return [];
      let typeName = symbol.typeName;
      const kwMatch = typeName.match(/^([A-Z][A-Za-z_0-9]*?)(redefines|subsets|references|connect|bind|default|via|accept|send|flow|allocate|assign|decide|merge|join|fork)([A-Z])/);
      if (kwMatch) {
        typeName = kwMatch[1];
      }
      const rootSegment = typeName.split("::")[0];
      if (allSymbolNames.has(typeName) || allSymbolNames.has(rootSegment) || STANDARD_LIBRARY_TYPES.has(typeName) || STANDARD_LIBRARY_TYPES.has(rootSegment) || libraryNames.has(rootSegment) || // Pattern match for ISQ quantity value types (e.g., LengthValue, TorqueValue)
      isISQValueType(typeName) || // Check the scanned library type index (covers all ISQ/SI types including
      // those with digits like CartesianSpatial3dCoordinateFrame)
      resolveLibraryType(typeName) !== void 0 || resolveLibraryType(rootSegment) !== void 0 || // Names starting with lowercase are feature references (subsettings
      // via :>), not type references — don't flag them as unresolved types.
      // e.g. "attribute x :> distancePerVolume" references a feature, not a type.
      typeName.charCodeAt(0) >= 97 && typeName.charCodeAt(0) <= 122) {
        return [];
      }
      const isMandatory = symbol.multiplicityRange && symbol.multiplicityRange.lower >= 1;
      const severity = isMandatory ? import_node10.DiagnosticSeverity.Error : import_node10.DiagnosticSeverity.Warning;
      let message = `Type '${typeName}' is not defined in the current document or standard library`;
      if (isMandatory) {
        const multStr = symbol.multiplicity ?? "1";
        message += ` (feature '${symbol.name}' requires multiplicity [${multStr}])`;
      }
      return [{
        severity,
        range: symbol.selectionRange,
        message,
        source: "sysml",
        code: "unresolved-type",
        data: { typeName }
      }];
    }
    /**
     * Rule: Invalid multiplicity bounds.
     *
     * Checks that lower bound ≤ upper bound when both are numeric.
     * Examples of invalid: [5..2], [10..1]
     */
    checkInvalidMultiplicity(symbol) {
      if (!symbol.multiplicityRange || !symbol.multiplicity) return [];
      const { lower, upper } = symbol.multiplicityRange;
      if (typeof upper === "number" && lower > upper) {
        return [{
          severity: import_node10.DiagnosticSeverity.Error,
          range: symbol.selectionRange,
          message: `Invalid multiplicity [${symbol.multiplicity}]: lower bound (${lower}) exceeds upper bound (${upper})`,
          source: "sysml",
          code: "invalid-multiplicity"
        }];
      }
      if (lower < 0) {
        return [{
          severity: import_node10.DiagnosticSeverity.Error,
          range: symbol.selectionRange,
          message: `Invalid multiplicity [${symbol.multiplicity}]: lower bound cannot be negative`,
          source: "sysml",
          code: "invalid-multiplicity"
        }];
      }
      return [];
    }
    /**
     * Rule: Empty enumeration definition.
     *
     * An enum def with no enum values is likely incomplete.
     */
    checkEmptyEnum(symbol, allSymbols) {
      if (symbol.kind !== "enum def" /* EnumDef */) return [];
      const children = allSymbols.filter(
        (s) => s.parentQualifiedName === symbol.qualifiedName
      );
      const hasEnumValues = children.some(
        (c) => c.kind === "enum" /* EnumUsage */ || c.kind === "attribute" /* AttributeUsage */
      );
      if (!hasEnumValues) {
        return [{
          severity: import_node10.DiagnosticSeverity.Information,
          range: symbol.selectionRange,
          message: `Enumeration '${symbol.name}' has no enum values defined`,
          source: "sysml",
          code: "empty-enum"
        }];
      }
      return [];
    }
    /**
     * Rule: Naming convention.
     * Definitions should use PascalCase, usages should use camelCase.
     */
    checkNamingConvention(symbol) {
      if (!symbol.name) return [];
      if (symbol.kind === "package" /* Package */ || symbol.kind === "import" /* Import */ || symbol.kind === "comment" /* Comment */ || symbol.kind === "doc" /* Doc */ || symbol.kind === "alias" /* Alias */ || symbol.kind === "unknown" /* Unknown */) return [];
      if (isDefinition(symbol.kind)) {
        const ch = symbol.name[0];
        if (ch === ch.toLowerCase() && ch !== ch.toUpperCase()) {
          return [{
            severity: import_node10.DiagnosticSeverity.Hint,
            range: symbol.selectionRange,
            message: `Definition '${symbol.name}' should use PascalCase`,
            source: "sysml",
            code: "naming-convention",
            data: { name: symbol.name, convention: "PascalCase" }
          }];
        }
      } else {
        const ch = symbol.name[0];
        if (ch === ch.toUpperCase() && ch !== ch.toLowerCase()) {
          return [{
            severity: import_node10.DiagnosticSeverity.Hint,
            range: symbol.selectionRange,
            message: `Usage '${symbol.name}' should use camelCase`,
            source: "sysml",
            code: "naming-convention",
            data: { name: symbol.name, convention: "camelCase" }
          }];
        }
      }
      return [];
    }
    /**
     * Rule: Missing documentation.
     * Definitions without a doc comment get a hint.
     */
    checkMissingDocumentation(symbol) {
      if (!isDefinition(symbol.kind)) return [];
      if (symbol.documentation) return [];
      return [{
        severity: import_node10.DiagnosticSeverity.Information,
        range: symbol.selectionRange,
        message: `Definition '${symbol.name}' has no documentation`,
        source: "sysml",
        code: "missing-doc",
        data: { name: symbol.name }
      }];
    }
    /**
     * Rule: Unused definitions.
     * Definitions not referenced by any symbol typeNames and that do not
     * themselves specialize/redefine another type.
     */
    checkUnusedDefinitions(symbols, targetUri) {
      const defs = symbols.filter(
        (s) => s.kind === "part def" /* PartDef */ || s.kind === "action def" /* ActionDef */
      );
      const defsInScope = targetUri ? defs.filter((def) => def.uri === targetUri) : defs;
      const referencedTypes = new Set(
        symbols.filter((s) => s.kind !== "package" /* Package */).flatMap((s) => s.typeNames)
      );
      for (const s of symbols) {
        if (s.exposeTargets) {
          for (const target of s.exposeTargets) {
            const simpleName = target.replace(/::\*{1,2}$/, "").split("::").pop();
            if (simpleName) referencedTypes.add(simpleName);
          }
        }
      }
      const diagnostics = [];
      for (const def of defsInScope) {
        const isReferenced = referencedTypes.has(def.name);
        const hasBaseType = (def.typeNames?.length ?? 0) > 0;
        if (!isReferenced && !hasBaseType) {
          diagnostics.push({
            severity: import_node10.DiagnosticSeverity.Warning,
            range: def.selectionRange,
            message: `Definition '${def.name}' is not referenced by any usage in the workspace`,
            source: "sysml",
            code: "unused-definition",
            data: { name: def.name }
          });
        }
      }
      return diagnostics;
    }
    /**
     * Rule: Duplicate definition names in the same scope.
     *
     * Two definitions (part def, port def, etc.) with the same name
     * in the same parent scope indicate a conflict.
     */
    /**
     * Static helper: run semantic validation rules without a DocumentManager.
     * Used by the MCP layer which works directly with SysMLSymbol arrays.
     */
    static validateSymbols(symbolsInUri, allNames, opts) {
      const diagnostics = [];
      const instance = Object.create(_SemanticValidator.prototype);
      const allSymbols = opts?.allSymbols ?? symbolsInUri;
      const includeStyleRules = opts?.includeStyleRules ?? true;
      const indexes = instance.buildSymbolIndexes(allSymbols);
      for (const symbol of symbolsInUri) {
        diagnostics.push(
          ...instance.checkUnresolvedType(symbol, allNames, /* @__PURE__ */ new Set()),
          ...instance.checkInvalidMultiplicity(symbol),
          ...instance.checkEmptyEnum(symbol, symbolsInUri)
        );
        if (includeStyleRules) {
          diagnostics.push(
            ...instance.checkNamingConvention(symbol),
            ...instance.checkMissingDocumentation(symbol)
          );
        }
      }
      diagnostics.push(...instance.checkDuplicateDefinitions(symbolsInUri));
      diagnostics.push(...instance.checkUnusedDefinitions(allSymbols));
      diagnostics.push(...instance.checkRedefinitionMultiplicity(symbolsInUri, indexes, opts?.text));
      diagnostics.push(...instance.checkCircularSpecialization(symbolsInUri, indexes));
      diagnostics.push(...instance.checkCircularContainment(symbolsInUri, indexes));
      diagnostics.push(...instance.checkUnsatisfiedRequirements(
        allSymbols,
        indexes,
        opts?.text ? [opts.text] : []
      ));
      diagnostics.push(...instance.checkUnverifiedRequirements(
        allSymbols,
        indexes,
        opts?.text ? [opts.text] : []
      ));
      if (opts?.text && opts.uri) {
        diagnostics.push(...instance.checkPortCompatibility(opts.text, opts.uri, indexes));
        diagnostics.push(...instance.checkConstraintBodyReferences(opts.text, opts.uri, symbolsInUri, indexes));
      }
      return instance.dedupeDiagnostics(diagnostics);
    }
    /**
     * Rule: Circular specialization chain.
     *
     * Detects cycles in definition specialization hierarchies.
     * For example: A :> B, B :> C, C :> A forms a cycle.
     */
    checkCircularSpecialization(symbolsInUri, indexes) {
      const diagnostics = [];
      const defsInFile = symbolsInUri.filter((s) => isDefinition(s.kind) && s.typeNames.length > 0);
      for (const def of defsInFile) {
        const visited = /* @__PURE__ */ new Set();
        visited.add(def.name);
        const cycle = this.followSpecializationChain(def.name, def.typeNames, visited, indexes);
        if (cycle) {
          diagnostics.push({
            severity: import_node10.DiagnosticSeverity.Error,
            range: def.selectionRange,
            message: `Circular specialization: ${cycle.join(" :> ")} :> ${cycle[0]}`,
            source: "sysml",
            code: "circular-specialization"
          });
        }
      }
      return diagnostics;
    }
    /**
     * Walk the specialization chain from a set of type names and detect if any
     * path leads back to a name already in the visited set.
     */
    followSpecializationChain(originName, typeNames, visited, indexes) {
      for (const tn of typeNames) {
        if (visited.has(tn)) {
          return [...visited];
        }
        const candidates = indexes.definitionsByName.get(tn);
        if (!candidates || candidates.length === 0) continue;
        const target = candidates[0];
        if (target.typeNames.length === 0) continue;
        visited.add(tn);
        const cycle = this.followSpecializationChain(originName, target.typeNames, visited, indexes);
        if (cycle) return cycle;
        visited.delete(tn);
      }
      return void 0;
    }
    /**
     * Rule: Circular containment.
     *
     * Detects cycles where definition A contains a feature typed by B and
     * definition B contains a feature typed by A (or longer transitive chains).
     */
    checkCircularContainment(symbolsInUri, indexes) {
      const diagnostics = [];
      const defsInFile = symbolsInUri.filter((s) => isDefinition(s.kind));
      for (const def of defsInFile) {
        const children = indexes.byParent.get(def.qualifiedName) ?? [];
        const childTypeNames = children.flatMap((c) => c.typeNames).filter((t) => t.length > 0);
        if (childTypeNames.length === 0) continue;
        for (const childTypeName of childTypeNames) {
          if (childTypeName === def.name) continue;
          const visited = /* @__PURE__ */ new Set();
          visited.add(def.name);
          const cycle = this.followContainmentChain(childTypeName, visited, indexes);
          if (cycle) {
            const offendingChild = children.find((c) => c.typeNames.includes(childTypeName));
            const range = offendingChild?.selectionRange ?? def.selectionRange;
            diagnostics.push({
              severity: import_node10.DiagnosticSeverity.Error,
              range,
              message: `Circular containment: ${cycle.join(" -> ")} -> ${cycle[0]}`,
              source: "sysml",
              code: "circular-containment"
            });
            break;
          }
        }
      }
      return diagnostics;
    }
    /**
     * Walk the containment chain: for a type name, find its definition,
     * check its children's types, and see if any loops back.
     */
    followContainmentChain(typeName, visited, indexes) {
      if (visited.has(typeName)) {
        return [...visited];
      }
      const candidates = indexes.definitionsByName.get(typeName);
      if (!candidates || candidates.length === 0) return void 0;
      const target = candidates[0];
      const children = indexes.byParent.get(target.qualifiedName) ?? [];
      const childTypeNames = children.flatMap((c) => c.typeNames).filter((t) => t.length > 0);
      if (childTypeNames.length === 0) return void 0;
      visited.add(typeName);
      for (const tn of childTypeNames) {
        const cycle = this.followContainmentChain(tn, visited, indexes);
        if (cycle) return cycle;
      }
      visited.delete(typeName);
      return void 0;
    }
    /**
     * Rule: unsatisfied requirements.
     *
     * Requirement usages that are not referenced by any `satisfy` statement
     * anywhere in the workspace receive a warning. Only top-level requirement
     * usages are checked — nested requirements inside a satisfy block or
     * requirement definitions are skipped.
     */
    checkUnsatisfiedRequirements(allSymbols, indexes, workspaceTexts) {
      const diagnostics = [];
      let satisfiedNames;
      let satisfyBlockRanges;
      if (workspaceTexts) {
        satisfiedNames = /* @__PURE__ */ new Set();
        satisfyBlockRanges = /* @__PURE__ */ new Map();
        for (const text of workspaceTexts) {
          this.extractSatisfyReferences(text, satisfiedNames);
          satisfyBlockRanges.set("__static__", this.extractSatisfyBlockRanges(text));
        }
      } else if (this.documentManager) {
        const uris = this.documentManager.getUris();
        const versionKey = uris.map((u) => u + ":" + this.documentManager.getVersion(u)).join("|");
        if (this.satisfyCache && this.satisfyCache.versionKey === versionKey) {
          satisfiedNames = this.satisfyCache.satisfiedNames;
          satisfyBlockRanges = this.satisfyCache.satisfyBlockRanges;
        } else {
          const relNames = this.collectWorkspaceRequirementRelationshipNames();
          satisfiedNames = relNames.satisfiedNames;
          satisfyBlockRanges = /* @__PURE__ */ new Map();
          for (const uri of uris) {
            const text = this.documentManager.getText(uri);
            if (text) {
              satisfyBlockRanges.set(uri, this.extractSatisfyBlockRanges(text));
            }
          }
          this.satisfyCache = { versionKey, satisfiedNames, satisfyBlockRanges };
          if (!this.verifyCache || this.verifyCache.versionKey !== versionKey) {
            this.verifyCache = { versionKey, verifiedNames: relNames.verifiedNames };
          }
        }
      } else {
        satisfiedNames = /* @__PURE__ */ new Set();
        satisfyBlockRanges = /* @__PURE__ */ new Map();
      }
      const requirementUsages = allSymbols.filter(
        (s) => s.kind === "requirement" /* RequirementUsage */
      );
      for (const req of requirementUsages) {
        if (req.parentQualifiedName) {
          const parent = indexes.byQualifiedName.get(req.parentQualifiedName);
          if (parent?.kind === "requirement" /* RequirementUsage */) continue;
        }
        const uriRanges = satisfyBlockRanges.get(req.uri) ?? satisfyBlockRanges.get("__static__") ?? [];
        const reqLine = req.selectionRange.start.line;
        if (uriRanges.some((r) => reqLine >= r.startLine && reqLine <= r.endLine)) continue;
        const isSatisfied = satisfiedNames.has(req.name) || satisfiedNames.has(req.qualifiedName);
        if (!isSatisfied) {
          diagnostics.push({
            severity: import_node10.DiagnosticSeverity.Warning,
            range: req.selectionRange,
            message: `Requirement '${req.name}' is not satisfied by any element`,
            source: "sysml",
            code: "unsatisfied-requirement",
            data: { name: req.name, qualifiedName: req.qualifiedName }
          });
        }
      }
      return diagnostics;
    }
    /**
     * Extract requirement references from `satisfy` statements in a text.
     * Adds both the full qualified name and the simple (last segment) name.
     *
     * Patterns matched:
     *   satisfy QualifiedName by ...
     *   satisfy QualifiedName;
     */
    extractSatisfyReferences(text, out) {
      const stripped = stripComments(text);
      const re = /\bsatisfy\s+(?:requirement\s+)?([\w]+(?:::[\w]+)*)\s+(?:by\b|;|:)/g;
      let m2;
      while ((m2 = re.exec(stripped)) !== null) {
        const ref = m2[1];
        out.add(ref);
        const lastSeg = ref.includes("::") ? ref.split("::").pop() : ref;
        out.add(lastSeg);
      }
    }
    /**
     * Extract the line ranges of satisfy block bodies from text.
     * Returns an array of { startLine, endLine } for each satisfy { ... } block.
     */
    extractSatisfyBlockRanges(text) {
      const ranges = [];
      const stripped = stripComments(text);
      const re = /\bsatisfy\b[^;{]*\{/g;
      let m2;
      let lineOffsets;
      while ((m2 = re.exec(stripped)) !== null) {
        const open = m2.index + m2[0].length - 1;
        let depth = 1;
        let i = open + 1;
        while (i < stripped.length && depth > 0) {
          if (stripped[i] === "{") depth++;
          if (stripped[i] === "}") depth--;
          i++;
        }
        if (depth !== 0) continue;
        if (!lineOffsets) {
          lineOffsets = [0];
          for (let j = 0; j < text.length; j++) {
            if (text[j] === "\n") lineOffsets.push(j + 1);
          }
        }
        ranges.push({
          startLine: this.offsetToLine(lineOffsets, open),
          endLine: this.offsetToLine(lineOffsets, i - 1)
        });
      }
      return ranges;
    }
    /**
     * Rule: unverified requirements.
     *
     * In SysML v2, `satisfy` declares that a design element fulfills a
     * requirement, while `verify` declares that a verification case (test)
     * checks whether a requirement is met.  Good practice requires both.
     *
     * This rule warns when a requirement usage has no `verify` statement
     * anywhere in the workspace, regardless of satisfaction status.
     *
     * SysML v2 verify patterns detected:
     *   verify <requirement> by <verificationCase>;
     *   verify <qualifiedName>;
     *   verification case def X { verify <requirement>; }
     */
    checkUnverifiedRequirements(allSymbols, indexes, workspaceTexts) {
      const diagnostics = [];
      let satisfiedNames;
      let verifiedNames;
      let satisfyBlockRanges;
      if (workspaceTexts) {
        satisfiedNames = /* @__PURE__ */ new Set();
        verifiedNames = /* @__PURE__ */ new Set();
        satisfyBlockRanges = /* @__PURE__ */ new Map();
        for (const text of workspaceTexts) {
          this.extractSatisfyReferences(text, satisfiedNames);
          this.extractVerifyReferences(text, verifiedNames);
          satisfyBlockRanges.set("__static__", this.extractSatisfyBlockRanges(text));
        }
      } else if (this.documentManager) {
        const uris = this.documentManager.getUris();
        const versionKey = uris.map((u) => u + ":" + this.documentManager.getVersion(u)).join("|");
        const satisfyCacheValid = this.satisfyCache && this.satisfyCache.versionKey === versionKey;
        const verifyCacheValid = this.verifyCache && this.verifyCache.versionKey === versionKey;
        if (!satisfyCacheValid || !verifyCacheValid) {
          const relNames = this.collectWorkspaceRequirementRelationshipNames();
          if (!satisfyCacheValid) {
            satisfyBlockRanges = /* @__PURE__ */ new Map();
            for (const uri of uris) {
              const text = this.documentManager.getText(uri);
              if (text) {
                satisfyBlockRanges.set(uri, this.extractSatisfyBlockRanges(text));
              }
            }
            this.satisfyCache = { versionKey, satisfiedNames: relNames.satisfiedNames, satisfyBlockRanges };
          }
          if (!verifyCacheValid) {
            this.verifyCache = { versionKey, verifiedNames: relNames.verifiedNames };
          }
        }
        satisfiedNames = this.satisfyCache.satisfiedNames;
        satisfyBlockRanges = this.satisfyCache.satisfyBlockRanges;
        verifiedNames = this.verifyCache.verifiedNames;
      } else {
        satisfiedNames = /* @__PURE__ */ new Set();
        verifiedNames = /* @__PURE__ */ new Set();
        satisfyBlockRanges = /* @__PURE__ */ new Map();
      }
      const requirementUsages = allSymbols.filter(
        (s) => s.kind === "requirement" /* RequirementUsage */
      );
      for (const req of requirementUsages) {
        if (req.parentQualifiedName) {
          const parent = indexes.byQualifiedName.get(req.parentQualifiedName);
          if (parent?.kind === "requirement" /* RequirementUsage */) continue;
        }
        const uriRanges = satisfyBlockRanges.get(req.uri) ?? satisfyBlockRanges.get("__static__") ?? [];
        const reqLine = req.selectionRange.start.line;
        if (uriRanges.some((r) => reqLine >= r.startLine && reqLine <= r.endLine)) continue;
        const isSatisfied = satisfiedNames.has(req.name) || satisfiedNames.has(req.qualifiedName);
        const isVerified = verifiedNames.has(req.name) || verifiedNames.has(req.qualifiedName);
        if (!isVerified) {
          const message = isSatisfied ? `Requirement '${req.name}' is satisfied but has no verification case \u2014 consider adding: verify ${req.name} by <VerificationCase>;` : `Requirement '${req.name}' has no verification case \u2014 consider adding: verify ${req.name} by <VerificationCase>;`;
          diagnostics.push({
            severity: import_node10.DiagnosticSeverity.Warning,
            range: req.selectionRange,
            message,
            source: "sysml",
            code: "unverified-requirement",
            data: { name: req.name, qualifiedName: req.qualifiedName }
          });
        }
      }
      return diagnostics;
    }
    /**
     * Extract requirement references from `verify` statements in text.
     * Adds both the full qualified name and the simple (last segment) name.
     *
     * Patterns matched:
     *   verify QualifiedName by ...
     *   verify QualifiedName;
     *   verify requirement QualifiedName by ...
     */
    extractVerifyReferences(text, out) {
      const stripped = stripComments(text);
      const re = /\bverify\s+(?:requirement\s+)?([\w]+(?:::[\w]+)*)\s*(?:by\b|;|:|\{)/g;
      let m2;
      while ((m2 = re.exec(stripped)) !== null) {
        const ref = m2[1];
        out.add(ref);
        const lastSeg = ref.includes("::") ? ref.split("::").pop() : ref;
        out.add(lastSeg);
      }
    }
    /** Binary-search a sorted line-offset table to find the 0-based line for a character offset. */
    offsetToLine(lineOffsets, offset) {
      let lo = 0;
      let hi = lineOffsets.length - 1;
      while (lo < hi) {
        const mid = lo + hi + 1 >>> 1;
        if (lineOffsets[mid] <= offset) lo = mid;
        else hi = mid - 1;
      }
      return lo;
    }
    /**
     * Rule: viewpoint satisfaction checking.
     *
     * Warns when:
     * - A view satisfies a viewpoint but has no expose directives
     * - A view references an undefined viewpoint
     */
    checkViewpointSatisfaction(symbols, _indexes) {
      const diagnostics = [];
      const views = symbols.filter((s) => s.kind === "view" /* ViewUsage */);
      const _viewpointNames = new Set(
        symbols.filter((s) => s.kind === "viewpoint def" /* ViewpointDef */ || s.kind === "viewpoint" /* ViewpointUsage */).map((s) => s.name)
      );
      for (const view of views) {
        const hasExpose = view.exposeTargets && view.exposeTargets.length > 0;
        const hasFilter = view.viewFilters && view.viewFilters.length > 0;
        if (!hasExpose && !hasFilter) {
          diagnostics.push({
            severity: import_node10.DiagnosticSeverity.Information,
            range: view.selectionRange,
            message: `View '${view.name}' has no expose or filter directives \u2014 it will show all elements`,
            source: "sysml",
            code: "view-no-scope"
          });
        }
      }
      return diagnostics;
    }
    /**
     * Rule: redefinition multiplicity must conform to base feature multiplicity.
     *
     * For `:>>` / `redefines`, this checks only the lower/upper numeric relation:
     *   base.lower <= redefined.lower <= redefined.upper <= base.upper (if bounded)
     */
    checkRedefinitionMultiplicity(symbolsInUri, indexes, text) {
      const diagnostics = [];
      const lines = text?.split("\n");
      for (const s of symbolsInUri) {
        if (!s.typeName || !s.multiplicityRange) continue;
        const c0 = s.typeName.charCodeAt(0);
        const isLikelyRedef = c0 >= 97 && c0 <= 122;
        if (!isLikelyRedef) continue;
        if (lines) {
          const lineIdx = s.selectionRange.start.line;
          const line = lines[lineIdx] || "";
          if (!/:>>/.test(line) && !/\bredefines\b/.test(line)) continue;
        }
        const candidates = indexes.byName.get(s.typeName) ?? [];
        const base = candidates.find((c) => !!c.multiplicityRange);
        if (!base?.multiplicityRange) continue;
        const baseLower = base.multiplicityRange.lower;
        const baseUpper = base.multiplicityRange.upper;
        const curLower = s.multiplicityRange.lower;
        const curUpper = s.multiplicityRange.upper;
        const lowerOk = curLower >= baseLower;
        const upperOk = baseUpper === "*" || curUpper !== "*" && curUpper <= baseUpper;
        if (lowerOk && upperOk) continue;
        diagnostics.push({
          severity: import_node10.DiagnosticSeverity.Error,
          range: s.selectionRange,
          message: `Redefinition multiplicity [${s.multiplicity ?? "?"}] is incompatible with base '${base.name}' multiplicity [${base.multiplicity ?? "?"}]`,
          source: "sysml",
          code: "invalid-redefinition-multiplicity"
        });
      }
      return diagnostics;
    }
    /**
     * Rule: both ends of a `connect a to b` relation should resolve to ports with compatible types.
     *
     * Flags connections where ports have different types, unless:
     * - One port is a conjugate (~) of the other
     * - The connection is inside an interface definition
     * - The connection is within an interface usage
     * - Both ports are untyped (empty port defs with no features)
     */
    checkPortCompatibility(text, uri, indexes) {
      if (!text) return [];
      const diagnostics = [];
      const lines = text.split("\n");
      const re = /\bconnect\s+([A-Za-z_][\w.]*)\s+to\s+([A-Za-z_][\w.]*)/g;
      let m2;
      while ((m2 = re.exec(text)) !== null) {
        const left = m2[1].split(".").pop();
        const right = m2[2].split(".").pop();
        const lSym = (indexes.portsByName.get(left) ?? [])[0];
        const rSym = (indexes.portsByName.get(right) ?? [])[0];
        if (!lSym || !rSym) continue;
        const lType = lSym.typeNames[0] ?? lSym.typeName;
        const rType = rSym.typeNames[0] ?? rSym.typeName;
        if (!lType || !rType || lType === rType) continue;
        if (lType === "~" + rType || rType === "~" + lType) continue;
        if (lType.startsWith("~") && lType.slice(1) === rType) continue;
        if (rType.startsWith("~") && rType.slice(1) === lType) continue;
        const matchLine = text.substring(0, m2.index).split("\n").length - 1;
        let insideInterfaceDef = false;
        for (let i = matchLine; i >= 0 && i >= matchLine - 30; i--) {
          const line = (lines[i] || "").trim();
          if (/\binterface\s+def\b/.test(line)) {
            insideInterfaceDef = true;
            break;
          }
          if (/^\s*package\b/.test(line)) break;
        }
        if (insideInterfaceDef) continue;
        const precedingText = text.substring(Math.max(0, m2.index - 300), m2.index);
        if (/\binterface\s+\w[\w']*(:\w[\w']*)?\s*$/m.test(precedingText)) continue;
        const lDefSyms = indexes.byName.get(lType) ?? [];
        const rDefSyms = indexes.byName.get(rType) ?? [];
        const lDef = lDefSyms.find((s) => s.kind.includes("def"));
        const rDef = rDefSyms.find((s) => s.kind.includes("def"));
        const lChildren = lDef ? indexes.byParent.get(lDef.qualifiedName) ?? [] : [];
        const rChildren = rDef ? indexes.byParent.get(rDef.qualifiedName) ?? [] : [];
        if (lChildren.length === 0 && rChildren.length === 0) continue;
        if (lDef && rDef) {
          const lHierarchy = this.resolveTypeHierarchy(lType, indexes);
          const rHierarchy = this.resolveTypeHierarchy(rType, indexes);
          if (lHierarchy.has(rType) || rHierarchy.has(lType)) continue;
          const hasCommonAncestor = [...lHierarchy].some((t) => rHierarchy.has(t));
          if (hasCommonAncestor) continue;
          const lChildNames = new Set(lChildren.map((c) => c.name));
          const hasSharedFeature = rChildren.some((c) => lChildNames.has(c.name));
          if (hasSharedFeature) continue;
        }
        const range = this.indexToRange(text, m2.index, m2[0].length);
        diagnostics.push({
          severity: import_node10.DiagnosticSeverity.Warning,
          range,
          message: `Port compatibility issue: '${left}' (${lType}) is connected to '${right}' (${rType})`,
          source: "sysml",
          code: "incompatible-port-types",
          data: { uri }
        });
      }
      return diagnostics;
    }
    /**
     * Resolve the full type hierarchy for a type name by following
     * specialization chains transitively (max depth 10).
     * Returns a Set of all ancestor type names including the type itself.
     */
    resolveTypeHierarchy(typeName, indexes) {
      const hierarchy = /* @__PURE__ */ new Set();
      const queue = [typeName];
      while (queue.length > 0 && hierarchy.size < 50) {
        const current = queue.shift();
        if (hierarchy.has(current)) continue;
        hierarchy.add(current);
        const defs = indexes.byName.get(current) ?? [];
        for (const def of defs) {
          if (!def.kind.includes("def")) continue;
          for (const parent of def.typeNames) {
            if (!hierarchy.has(parent)) queue.push(parent);
          }
        }
      }
      return hierarchy;
    }
    /**
     * Rule: identifiers used in constraint bodies must resolve from parent-feature scope.
     */
    checkConstraintBodyReferences(text, uri, symbolsInUri, indexes) {
      if (!text) return [];
      const diagnostics = [];
      const blocks = this.extractConstraintBlocks(text);
      for (const b of blocks) {
        if (this.hasDocumentationOnlyConstraintBody(b.body)) {
          if (b.isRequire && this.isInsideViewpoint(text, b.bodyOffset)) continue;
          const trimStart = b.body.search(/\S/);
          const startInBody = trimStart >= 0 ? trimStart : 0;
          const trimmedLen = Math.max(1, b.body.trim().length);
          diagnostics.push({
            severity: import_node10.DiagnosticSeverity.Warning,
            range: this.indexToRange(text, b.bodyOffset + startInBody, trimmedLen),
            message: "Invalid constraint body: expected expression, found documentation text",
            source: "sysml",
            code: "invalid-constraint-body",
            data: { uri }
          });
          continue;
        }
        const parent = this.findConstraintScopeSymbol(symbolsInUri, indexes, b.startLine);
        if (!parent) continue;
        const parentMembers = indexes.byParent.get(parent.qualifiedName) ?? [];
        if (parentMembers.length === 0) continue;
        const ignoredRanges = this.getIgnoredBodyRanges(b.body);
        const idRe = /\b([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*)\b/g;
        let im;
        while ((im = idRe.exec(b.body)) !== null) {
          if (this.isIndexInRanges(im.index, ignoredRanges)) continue;
          const expr = im[1];
          if (this.isConstraintKeyword(expr)) continue;
          if (/^\d/.test(expr)) continue;
          const path = expr.split(".");
          const ok = this.resolvePathFromParent(path, parentMembers, indexes);
          if (ok) continue;
          if (path.length === 1) {
            const root = path[0];
            if (indexes.byName.has(root) || resolveLibraryType(root) !== void 0) {
              continue;
            }
          }
          const absoluteStart = b.bodyOffset + im.index;
          diagnostics.push({
            severity: import_node10.DiagnosticSeverity.Warning,
            range: this.indexToRange(text, absoluteStart, expr.length),
            message: `Unresolved constraint reference '${expr}' in scope '${parent.name}'`,
            source: "sysml",
            code: "unresolved-constraint-reference",
            data: { uri }
          });
        }
      }
      return diagnostics;
    }
    extractConstraintBlocks(text) {
      const out = [];
      const re = /\b(require\s+)?constraint\s*\{/g;
      let m2;
      while ((m2 = re.exec(text)) !== null) {
        const open = m2.index + m2[0].length - 1;
        let depth = 1;
        let i = open + 1;
        while (i < text.length && depth > 0) {
          const ch = text[i];
          if (ch === "{") depth++;
          if (ch === "}") depth--;
          i++;
        }
        if (depth !== 0) continue;
        const bodyStart = open + 1;
        const bodyEnd = i - 1;
        const body = text.slice(bodyStart, bodyEnd);
        const startLine = text.slice(0, bodyStart).split("\n").length - 1;
        out.push({ body, bodyOffset: bodyStart, startLine, isRequire: !!m2[1] });
      }
      return out;
    }
    resolvePathFromParent(path, parentMembers, indexes) {
      const root = parentMembers.find((s) => s.name === path[0]);
      if (!root) return false;
      if (path.length === 1) return true;
      let typeName = root.typeNames[0] ?? root.typeName;
      for (let i = 1; i < path.length; i++) {
        if (!typeName) return false;
        const typeDefs = indexes.definitionsByName.get(typeName) ?? [];
        const typeDef = typeDefs[0];
        if (!typeDef) return false;
        const member = (indexes.byParent.get(typeDef.qualifiedName) ?? []).find((s) => s.name === path[i]);
        if (!member) return false;
        typeName = member.typeNames[0] ?? member.typeName;
      }
      return true;
    }
    findContainingSymbolByLine(symbols, line) {
      return symbols.filter((s) => s.range.start.line <= line && s.range.end.line >= line).sort((a, b) => {
        const ar = (a.range.end.line - a.range.start.line) * 1e3 + (a.range.end.character - a.range.start.character);
        const br = (b.range.end.line - b.range.start.line) * 1e3 + (b.range.end.character - b.range.start.character);
        return ar - br;
      })[0];
    }
    findConstraintScopeSymbol(symbolsInUri, indexes, line) {
      let scope = this.findContainingSymbolByLine(symbolsInUri, line);
      while (scope) {
        const members = indexes.byParent.get(scope.qualifiedName) ?? [];
        if (members.length > 0) return scope;
        if (!scope.parentQualifiedName) return scope;
        scope = indexes.byQualifiedName.get(scope.parentQualifiedName);
      }
      return void 0;
    }
    /**
     * Return cached indexes if the workspace symbol table hasn't changed,
     * otherwise rebuild and cache.
     */
    getOrBuildIndexes(allSymbols) {
      if (this.indexCache && this.indexCache.symbols === allSymbols) {
        return this.indexCache.indexes;
      }
      const indexes = this.buildSymbolIndexes(allSymbols);
      this.indexCache = { symbols: allSymbols, indexes };
      return indexes;
    }
    buildSymbolIndexes(allSymbols) {
      const byName = /* @__PURE__ */ new Map();
      const byParent = /* @__PURE__ */ new Map();
      const byQualifiedName = /* @__PURE__ */ new Map();
      const definitionsByName = /* @__PURE__ */ new Map();
      const portsByName = /* @__PURE__ */ new Map();
      for (const s of allSymbols) {
        const nameList = byName.get(s.name) ?? [];
        nameList.push(s);
        byName.set(s.name, nameList);
        byQualifiedName.set(s.qualifiedName, s);
        if (s.parentQualifiedName) {
          const children = byParent.get(s.parentQualifiedName) ?? [];
          children.push(s);
          byParent.set(s.parentQualifiedName, children);
        }
        if (isDefinition(s.kind)) {
          const defs = definitionsByName.get(s.name) ?? [];
          defs.push(s);
          definitionsByName.set(s.name, defs);
        }
        if (s.kind === "port" /* PortUsage */ || s.kind === "port def" /* PortDef */) {
          const ports = portsByName.get(s.name) ?? [];
          ports.push(s);
          portsByName.set(s.name, ports);
        }
      }
      return { byName, byParent, byQualifiedName, definitionsByName, portsByName };
    }
    isConstraintKeyword(value) {
      return CONSTRAINT_KEYWORDS.has(value);
    }
    getIgnoredBodyRanges(body) {
      const ranges = [];
      const blockRe = /\/\*[\s\S]*?\*\//g;
      let m2;
      while ((m2 = blockRe.exec(body)) !== null) {
        ranges.push({ start: m2.index, end: m2.index + m2[0].length });
      }
      const lineRe = /\/\/[^\n\r]*/g;
      while ((m2 = lineRe.exec(body)) !== null) {
        ranges.push({ start: m2.index, end: m2.index + m2[0].length });
      }
      return ranges;
    }
    isIndexInRanges(index2, ranges) {
      for (const r of ranges) {
        if (index2 >= r.start && index2 < r.end) return true;
      }
      return false;
    }
    hasDocumentationOnlyConstraintBody(body) {
      const trimmed = body.trim();
      if (!trimmed) return false;
      const withoutComments = trimmed.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n\r]*/g, " ").trim();
      if (withoutComments === "doc" || withoutComments === "comment") {
        return true;
      }
      const hasExprSignal = /[<>=!+\-*/%()[\].,:]|\b(and|or|not)\b/.test(withoutComments);
      const proseOnly = /^[A-Za-z_\s]+$/.test(withoutComments);
      return proseOnly && !hasExprSignal;
    }
    isInsideViewpoint(text, offset) {
      const preceding = text.slice(0, offset);
      let depth = 0;
      for (let i = preceding.length - 1; i >= 0; i--) {
        const ch = preceding[i];
        if (ch === "}") depth++;
        if (ch === "{") {
          if (depth > 0) {
            depth--;
            continue;
          }
          const before = preceding.slice(0, i).trimEnd();
          return /\bviewpoint\b/.test(before.slice(-40));
        }
      }
      return false;
    }
    /** Cached line-offset table for indexToRange — avoids O(n) text.slice().split() per call */
    lineOffsetCache;
    indexToRange(text, start, length) {
      let offsets;
      if (this.lineOffsetCache && this.lineOffsetCache.text === text) {
        offsets = this.lineOffsetCache.offsets;
      } else {
        offsets = [0];
        for (let i = 0; i < text.length; i++) {
          if (text[i] === "\n") offsets.push(i + 1);
        }
        this.lineOffsetCache = { text, offsets };
      }
      let lo = 0;
      let hi = offsets.length - 1;
      while (lo < hi) {
        const mid = lo + hi + 1 >>> 1;
        if (offsets[mid] <= start) lo = mid;
        else hi = mid - 1;
      }
      const startLine = lo;
      const startChar = start - offsets[startLine];
      return {
        start: { line: startLine, character: startChar },
        end: { line: startLine, character: startChar + length }
      };
    }
    dedupeDiagnostics(diags) {
      const seen = /* @__PURE__ */ new Set();
      const out = [];
      for (const d of diags) {
        const key = [
          d.code ?? "no-code",
          d.range.start.line,
          d.range.start.character,
          d.range.end.line,
          d.range.end.character,
          d.message
        ].join("|");
        if (seen.has(key)) continue;
        seen.add(key);
        out.push(d);
      }
      return out;
    }
    checkDuplicateDefinitions(symbols) {
      const diagnostics = [];
      const definitionsByScope = /* @__PURE__ */ new Map();
      for (const symbol of symbols) {
        if (!isDefinition(symbol.kind)) continue;
        const scope = symbol.parentQualifiedName ?? "__root__";
        let scopeMap = definitionsByScope.get(scope);
        if (!scopeMap) {
          scopeMap = /* @__PURE__ */ new Map();
          definitionsByScope.set(scope, scopeMap);
        }
        let defs = scopeMap.get(symbol.name);
        if (!defs) {
          defs = [];
          scopeMap.set(symbol.name, defs);
        }
        defs.push(symbol);
      }
      for (const scopeMap of definitionsByScope.values()) {
        for (const [name, defs] of scopeMap) {
          if (defs.length > 1) {
            for (const def of defs) {
              diagnostics.push({
                severity: import_node10.DiagnosticSeverity.Warning,
                range: def.selectionRange,
                message: `Duplicate definition: '${name}' is defined ${defs.length} times in the same scope`,
                source: "sysml",
                code: "duplicate-definition"
              });
            }
          }
        }
      }
      return diagnostics;
    }
  };

  // server/src/platform/shims/fs-promises.ts
  async function readFile(_path, _enc) {
    throw new Error("fs/promises.readFile is not available in the browser");
  }
  async function readdir(_path, _opts) {
    return [];
  }

  // server/src/utils/fileDiscovery.ts
  var DEFAULT_SKIP_DIRS = [
    "node_modules",
    ".git",
    ".settings",
    "temp",
    "test",
    "tests",
    "out",
    "dist",
    "build",
    "coverage",
    ".venv",
    "__pycache__"
  ];
  var SYSML_EXTENSIONS = [".sysml", ".kerml"];
  function isSysMLFile(name) {
    return SYSML_EXTENSIONS.some((ext) => name.endsWith(ext));
  }
  async function findSysMLFilesAsync(dir, skipDirs2) {
    const skip = skipDirs2 ?? new Set(DEFAULT_SKIP_DIRS);
    const results = [];
    let entries;
    try {
      entries = await readdir(dir, { withFileTypes: true });
    } catch {
      return results;
    }
    const childDirPromises = [];
    for (const entry of entries) {
      const fullPath = join(dir, entry.name);
      if (entry.isDirectory()) {
        if (skip.has(entry.name)) continue;
        childDirPromises.push(findSysMLFilesAsync(fullPath, skip));
      } else if (entry.isFile() && isSysMLFile(entry.name)) {
        results.push(fullPath);
      }
    }
    if (childDirPromises.length > 0) {
      const childResults = await Promise.all(childDirPromises);
      for (const arr of childResults) results.push(...arr);
    }
    return results;
  }
  async function readFilesBatch(filePaths, batchSize = 32) {
    const contents = /* @__PURE__ */ new Map();
    for (let i = 0; i < filePaths.length; i += batchSize) {
      const batch = filePaths.slice(i, i + batchSize);
      const settled = await Promise.allSettled(
        batch.map(async (fp) => {
          const text = await readFile(fp, "utf-8");
          return { fp, text };
        })
      );
      for (const result of settled) {
        if (result.status === "fulfilled") {
          contents.set(result.value.fp, result.value.text);
        }
      }
    }
    return contents;
  }

  // server/src/server.ts
  function toFsPath(uri) {
    try {
      if (uri.startsWith("file://")) return fileURLToPath(uri);
    } catch {
    }
    return void 0;
  }
  var connection = createServerConnection();
  var documents = new import_node11.TextDocuments(TextDocument2);
  var serverStartTime = Date.now();
  var documentManager = new DocumentManager();
  var modelProvider = new SysMLModelProvider(documentManager);
  var diagnosticsProvider = new DiagnosticsProvider(documentManager);
  var completionProvider = new CompletionProvider(documentManager);
  var hoverProvider = new HoverProvider(documentManager);
  var definitionProvider = new DefinitionProvider(documentManager);
  var referencesProvider = new ReferencesProvider(documentManager);
  var documentSymbolProvider = new DocumentSymbolProvider(documentManager);
  var semanticTokensProvider = new SemanticTokensProvider(documentManager);
  var foldingRangeProvider = new FoldingRangeProvider(documentManager);
  var renameProvider = new RenameProvider(documentManager);
  var codeActionProvider = new CodeActionProvider(documentManager);
  var formattingProvider = new FormattingProvider(documents);
  var semanticValidator = new SemanticValidator(documentManager);
  hoverProvider.setSemanticValidator(semanticValidator);
  var hasConfigurationCapability = false;
  var hasWorkspaceFolderCapability = false;
  var workspaceRoots = [];
  var isWorkspaceFile = false;
  var skipDirs = new Set(DEFAULT_SKIP_DIRS);
  var serverReady = false;
  var earlyOpenUris = /* @__PURE__ */ new Set();
  var workerRequestId = 0;
  var isBrowserServer = true;
  var parseWorker;
  var workerReady = false;
  function spawnParseWorker() {
    if (isBrowserServer) {
      connection.console.log("Parse worker disabled in browser; parsing runs inline");
      return;
    }
    const workerPath = join("/", "parseWorker.js");
    try {
      parseWorker = new Worker(workerPath);
      parseWorker.on("message", handleWorkerMessage);
      parseWorker.on("error", (err) => {
        connection.console.log(`Parse worker error: ${err.message}`);
        workerReady = false;
      });
      parseWorker.on("exit", (code) => {
        connection.console.log(`Parse worker exited with code ${code}`);
        workerReady = false;
        parseWorker = void 0;
      });
      workerReady = true;
      connection.console.log("Parse worker spawned");
    } catch (err) {
      connection.console.log(`Failed to spawn parse worker: ${err}`);
    }
  }
  function handleWorkerMessage(msg) {
    if (msg.warmup) {
      connection.console.log(
        `Worker DFA warm-up: ${msg.elapsed} ms, ${msg.chunksCompleted}/${msg.totalChunks} chunks` + (msg.interrupted ? " (interrupted by real parse)" : "")
      );
      return;
    }
    const { uri, version, errors, keywordDiagnostics } = msg;
    const doc = documents.get(uri);
    if (!doc || doc.version !== version) return;
    const diagnostics = [];
    for (const e of errors) {
      const line = Math.max(0, e.line);
      diagnostics.push({
        severity: 1,
        // Error
        range: {
          start: { line, character: e.column },
          end: { line, character: e.column + (e.length || 1) }
        },
        message: e.message,
        source: "sysml"
      });
    }
    for (const kd of keywordDiagnostics) {
      diagnostics.push({
        severity: kd.severity,
        range: kd.range,
        message: kd.message,
        source: "sysml",
        code: kd.code
      });
    }
    connection.sendDiagnostics({ uri, diagnostics });
    setImmediate(() => {
      const currentDoc = documents.get(uri);
      if (!currentDoc || currentDoc.version !== version) return;
      documentManager.parse(currentDoc);
      const correctedDiags = diagnosticsProvider.getDiagnostics(uri);
      const parseResult = documentManager.get(uri);
      if (parseResult) {
        correctedDiags.push(...validateKeywords(parseResult));
      }
      connection.sendDiagnostics({ uri, diagnostics: correctedDiags });
      connection.sendNotification("sysml/status", {
        state: "end",
        message: `Parsed ${uri.split("/").pop()} (worker + main)`,
        fileName: uri.split("/").pop(),
        uri
      });
      const existingSemantic = semanticTimers.get(uri);
      if (existingSemantic) clearTimeout(existingSemantic);
      semanticTimers.set(uri, setTimeout(() => {
        semanticTimers.delete(uri);
        if (documentManager.getVersion(uri) !== version) return;
        if (!documents.get(uri)) return;
        const semanticDiags = semanticValidator.validate(uri);
        documentManager.setSemanticDiagnostics(uri, semanticDiags);
        const allDiags = [...correctedDiags, ...semanticDiags];
        connection.sendDiagnostics({ uri, diagnostics: allDiags });
      }, 50));
    });
  }
  function requestWorkerParse(document) {
    if (!workerReady || !parseWorker) return false;
    const id = ++workerRequestId;
    parseWorker.postMessage({
      id,
      text: document.getText(),
      uri: document.uri,
      version: document.version
    });
    return true;
  }
  connection.onInitialize((params) => {
    const capabilities = params.capabilities;
    hasConfigurationCapability = !!(capabilities.workspace && !!capabilities.workspace.configuration);
    hasWorkspaceFolderCapability = !!(capabilities.workspace && !!capabilities.workspace.workspaceFolders);
    const initOpts = params.initializationOptions;
    isWorkspaceFile = initOpts?.isWorkspaceFile ?? false;
    if (params.workspaceFolders) {
      workspaceRoots = params.workspaceFolders.map((f) => toFsPath(f.uri)).filter((p) => p !== void 0);
    } else if (params.rootUri) {
      const root = toFsPath(params.rootUri);
      if (root) workspaceRoots = [root];
    }
    const legend = {
      tokenTypes,
      tokenModifiers
    };
    const result = {
      capabilities: {
        textDocumentSync: import_node11.TextDocumentSyncKind.Incremental,
        // Completion
        completionProvider: {
          resolveProvider: true,
          triggerCharacters: [".", ":", " "]
        },
        // Hover
        hoverProvider: true,
        // Go to definition
        definitionProvider: true,
        // Find references
        referencesProvider: true,
        // Document symbols (outline)
        documentSymbolProvider: true,
        // Semantic tokens
        semanticTokensProvider: {
          full: true,
          legend
        },
        // Folding ranges
        foldingRangeProvider: true,
        // Rename
        renameProvider: {
          prepareProvider: true
        },
        // Code actions (quick fixes)
        codeActionProvider: {
          codeActionKinds: [
            import_node11.CodeActionKind.QuickFix
          ]
        },
        // Document formatting
        documentFormattingProvider: true,
        documentRangeFormattingProvider: true
      }
    };
    if (hasWorkspaceFolderCapability) {
      result.capabilities.workspace = {
        workspaceFolders: {
          supported: true
        }
      };
    }
    return result;
  });
  connection.onInitialized(() => {
    if (hasConfigurationCapability) {
      connection.client.register(
        import_node11.DidChangeConfigurationNotification.type,
        void 0
      );
      pullSettings().catch(() => {
      });
    }
    const libCount = initLibraryIndex("/");
    connection.console.log(`SysML v2 Language Server initialized (${libCount} library packages indexed)`);
    const dfaT0 = Date.now();
    try {
      const dfaStates = loadDFASnapshot();
      connection.console.log(
        `DFA snapshot loaded: ${dfaStates} states in ${Date.now() - dfaT0} ms`
      );
    } catch (e) {
      connection.console.log(
        `DFA snapshot load failed (will use cold DFA): ${e}`
      );
    }
    serverReady = true;
    spawnParseWorker();
    if (isWorkspaceFile && workspaceRoots.length > 0) {
      scanWorkspaceFoldersAsync(workspaceRoots).then(({ fileCount, scanMs }) => {
        connection.console.log(
          `Workspace scan: pre-parsed ${fileCount} .sysml files in ${scanMs} ms`
        );
        revalidateOpenDocuments();
      });
    }
    serverReady = true;
    if (earlyOpenUris.size > 0) {
      connection.console.log(
        `Re-validating ${earlyOpenUris.size} document(s) opened before server was ready`
      );
      for (const uri of earlyOpenUris) {
        const doc = documents.get(uri);
        if (doc) validateDocument(doc);
      }
      earlyOpenUris.clear();
    }
  });
  async function pullSettings() {
    if (!hasConfigurationCapability) return;
    const config = await connection.workspace.getConfiguration("sysml.scan");
    applySettings(config);
  }
  function applySettings(config) {
    if (!config) return;
    const raw = config.skipDirectories;
    if (Array.isArray(raw) && raw.every((v) => typeof v === "string")) {
      skipDirs = new Set(raw);
    }
  }
  connection.onDidChangeConfiguration((_change) => {
    pullSettings().catch(() => {
    });
  });
  function parseWorkspaceFile(filePath) {
    const uri = pathToFileURL(filePath).toString();
    if (documents.get(uri)) return false;
    let content;
    try {
      content = readFileSync(filePath, "utf-8");
    } catch {
      return false;
    }
    const doc = TextDocument2.create(uri, "sysml", 0, content);
    documentManager.parse(doc);
    return true;
  }
  async function scanWorkspaceFoldersAsync(roots) {
    const scanT0 = Date.now();
    const fileArrays = await Promise.all(roots.map((r) => findSysMLFilesAsync(r, skipDirs)));
    const allFiles = [];
    for (const arr of fileArrays) allFiles.push(...arr);
    const fileContents = await readFilesBatch(allFiles, 32);
    let fileCount = 0;
    for (let i = 0; i < allFiles.length; i++) {
      const filePath = allFiles[i];
      const uri = pathToFileURL(filePath).toString();
      if (documents.get(uri)) continue;
      const content = fileContents.get(filePath);
      if (content === void 0) continue;
      documentManager.parseBatch(uri, 0, content);
      fileCount++;
      if ((i + 1) % 4 === 0) {
        await new Promise((resolve) => setImmediate(resolve));
      }
    }
    return { fileCount, scanMs: Date.now() - scanT0 };
  }
  function revalidateOpenDocuments() {
    for (const doc of documents.all()) {
      validateDocument(doc);
    }
  }
  var crossFileRevalidateTimer;
  documents.onDidOpen((event) => {
    if (!serverReady) {
      earlyOpenUris.add(event.document.uri);
      documentManager.parse(event.document);
      return;
    }
    validateDocument(event.document);
    if (crossFileRevalidateTimer) clearTimeout(crossFileRevalidateTimer);
    crossFileRevalidateTimer = setTimeout(() => {
      crossFileRevalidateTimer = void 0;
      revalidateOpenDocuments();
    }, 500);
  });
  var debounceTimers = /* @__PURE__ */ new Map();
  var semanticTimers = /* @__PURE__ */ new Map();
  var DEBOUNCE_MS = 200;
  documents.onDidChangeContent((event) => {
    const uri = event.document.uri;
    const existing = debounceTimers.get(uri);
    if (existing) clearTimeout(existing);
    debounceTimers.set(uri, setTimeout(() => {
      debounceTimers.delete(uri);
      if (!documents.get(uri)) {
        return;
      }
      validateDocument(event.document);
    }, DEBOUNCE_MS));
  });
  documents.onDidClose((event) => {
    const uri = event.document.uri;
    const debounceTimer = debounceTimers.get(uri);
    if (debounceTimer) {
      clearTimeout(debounceTimer);
      debounceTimers.delete(uri);
    }
    const semanticTimer = semanticTimers.get(uri);
    if (semanticTimer) {
      clearTimeout(semanticTimer);
      semanticTimers.delete(uri);
    }
    documentManager.remove(event.document.uri);
    modelProvider.removeUri(event.document.uri);
    connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
    const fsPath = toFsPath(event.document.uri);
    if (fsPath && (fsPath.endsWith(".sysml") || fsPath.endsWith(".kerml"))) {
      parseWorkspaceFile(fsPath);
    }
  });
  connection.onDidChangeWatchedFiles((params) => {
    let changed = false;
    for (const change of params.changes) {
      const fsPath = toFsPath(change.uri);
      if (!fsPath) continue;
      if (change.type === 3) {
        if (documentManager.get(change.uri)) {
          documentManager.remove(change.uri);
          changed = true;
        }
      } else {
        if (!documents.get(change.uri) && (fsPath.endsWith(".sysml") || fsPath.endsWith(".kerml"))) {
          if (parseWorkspaceFile(fsPath)) {
            changed = true;
          }
        }
      }
    }
    if (changed) {
      revalidateOpenDocuments();
    }
  });
  async function validateDocument(document) {
    if (!documents.get(document.uri)) {
      return;
    }
    const fileName = document.uri.split("/").pop() ?? document.uri;
    connection.sendNotification("sysml/status", {
      state: "begin",
      message: `Parsing ${fileName}`,
      fileName,
      uri: document.uri
    });
    if (requestWorkerParse(document)) {
      documentManager.cacheTextOnly(
        document.uri,
        document.version,
        document.getText()
      );
      return;
    }
    const parseT0 = Date.now();
    documentManager.parse(document);
    const parseMs = Date.now() - parseT0;
    const diagnostics = diagnosticsProvider.getDiagnostics(document.uri);
    const parseResult = documentManager.get(document.uri);
    if (parseResult) {
      diagnostics.push(...validateKeywords(parseResult));
    }
    connection.sendDiagnostics({ uri: document.uri, diagnostics });
    connection.sendNotification("sysml/status", {
      state: "end",
      message: `Parsed ${fileName} (${parseMs} ms)`,
      fileName,
      uri: document.uri
    });
    const version = document.version;
    const existingSemantic = semanticTimers.get(document.uri);
    if (existingSemantic) {
      clearTimeout(existingSemantic);
    }
    const semanticTimer = setTimeout(() => {
      semanticTimers.delete(document.uri);
      if (documentManager.getVersion(document.uri) !== version) return;
      if (!documents.get(document.uri)) return;
      const semanticDiags = semanticValidator.validate(document.uri);
      documentManager.setSemanticDiagnostics(document.uri, semanticDiags);
      if (semanticDiags.length === 0) return;
      diagnostics.push(...semanticDiags);
      connection.sendDiagnostics({ uri: document.uri, diagnostics });
    }, 50);
    semanticTimers.set(document.uri, semanticTimer);
  }
  connection.onCompletion(
    (params) => {
      return completionProvider.provideCompletions(params);
    }
  );
  connection.onCompletionResolve(
    (item) => {
      return completionProvider.resolveCompletion(item);
    }
  );
  connection.onHover(
    (params) => {
      return hoverProvider.provideHover(params);
    }
  );
  connection.onDefinition(
    (params) => {
      return definitionProvider.provideDefinition(params);
    }
  );
  connection.onReferences(
    (params) => {
      return referencesProvider.provideReferences(params);
    }
  );
  connection.onDocumentSymbol(
    (params) => {
      return documentSymbolProvider.provideDocumentSymbols(params);
    }
  );
  connection.languages.semanticTokens.on(
    (params) => {
      return semanticTokensProvider.provideSemanticTokens(params);
    }
  );
  connection.onFoldingRanges(
    (params) => {
      return foldingRangeProvider.provideFoldingRanges(params);
    }
  );
  connection.onPrepareRename(
    (params) => {
      return renameProvider.prepareRename(params);
    }
  );
  connection.onRenameRequest(
    (params) => {
      return renameProvider.provideRename(params);
    }
  );
  connection.onCodeAction(
    (params) => {
      return codeActionProvider.provideCodeActions(params);
    }
  );
  connection.onDocumentFormatting(
    (params) => {
      return formattingProvider.provideDocumentFormatting(params);
    }
  );
  connection.onDocumentRangeFormatting(
    (params) => {
      return formattingProvider.provideRangeFormatting(params);
    }
  );
  connection.onRequest("sysml/model", (params) => {
    return modelProvider.getModel(
      params.textDocument.uri,
      1,
      params.scope
    );
  });
  connection.onRequest("sysml/serverStats", () => {
    const mem = typeof process !== "undefined" && typeof process.memoryUsage === "function" ? process.memoryUsage() : { heapUsed: 0, heapTotal: 0, rss: 0, external: 0 };
    const toMB = (bytes) => Math.round(bytes / 1024 / 1024);
    return {
      uptime: Math.round((Date.now() - serverStartTime) / 1e3),
      memory: {
        heapUsed: toMB(mem.heapUsed),
        heapTotal: toMB(mem.heapTotal),
        rss: toMB(mem.rss),
        external: toMB(mem.external)
      },
      caches: {
        documents: documentManager.getUris().length,
        symbolTables: modelProvider.cacheSize,
        semanticTokens: 0
      }
    };
  });
  connection.onRequest("sysml/clearCache", () => {
    const docCount = documentManager.getUris().length;
    const stCount = modelProvider.clearAll();
    for (const uri of documentManager.getUris()) {
      documentManager.remove(uri);
    }
    return {
      documents: docCount,
      symbolTables: stCount,
      semanticTokens: 0
    };
  });
  connection.onRequest("sysml/libraryContent", (params) => {
    return getLibraryFileContent(params?.uri) ?? null;
  });
  documents.listen(connection);
  connection.listen();
})();
//# sourceMappingURL=browserServerMain.js.map
