From 62d634932cccb1116e84779862b7de9e06ff4889 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Sat, 4 Mar 2023 20:22:55 +0100 Subject: [PATCH 01/54] saves on-going work --- src/main/scala/viper/gobra/Gobra.scala | 28 +- .../scala/viper/gobra/frontend/Config.scala | 25 +- .../scala/viper/gobra/frontend/Desugar.scala | 10 +- .../scala/viper/gobra/frontend/Parser.scala | 10 +- .../viper/gobra/frontend/TaskManager.scala | 76 +++ .../viper/gobra/frontend/info/Info.scala | 502 ++++++++++++++++-- .../resolution/MemberResolution.scala | 18 +- 7 files changed, 614 insertions(+), 55 deletions(-) create mode 100644 src/main/scala/viper/gobra/frontend/TaskManager.scala diff --git a/src/main/scala/viper/gobra/Gobra.scala b/src/main/scala/viper/gobra/Gobra.scala index cb9e18620..a391465f8 100644 --- a/src/main/scala/viper/gobra/Gobra.scala +++ b/src/main/scala/viper/gobra/Gobra.scala @@ -16,6 +16,7 @@ import viper.gobra.ast.frontend.PPackage import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.{CGEdgesTerminationTransform, ConstantPropagation, InternalTransform, OverflowChecksTransform} import viper.gobra.backend.BackendVerifier +import viper.gobra.frontend.info.Info.Context import viper.gobra.frontend.info.{Info, TypeInfo} import viper.gobra.frontend.{Config, Desugar, PackageInfo, Parser, ScallopGobraConfig} import viper.gobra.reporting._ @@ -158,7 +159,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { finalConfig <- getAndMergeInFileConfig(config, pkgInfo) _ = setLogLevel(finalConfig) parsedPackage <- performParsing(pkgInfo, finalConfig) - typeInfo <- performTypeChecking(parsedPackage, finalConfig) + typeInfo <- performTypeChecking(parsedPackage, executor, finalConfig) program <- performDesugaring(parsedPackage, typeInfo, finalConfig) program <- performInternalTransformations(program, finalConfig, pkgInfo) viperTask <- performViperEncoding(program, finalConfig, pkgInfo) @@ -243,16 +244,20 @@ class Gobra extends GoVerifier with GoIdeVerifier { private def performParsing(pkgInfo: PackageInfo, config: Config): Either[Vector[VerifierError], PPackage] = { if (config.shouldParse) { + val startMs = System.currentTimeMillis() val sourcesToParse = config.packageInfoInputMap(pkgInfo) - Parser.parse(sourcesToParse, pkgInfo)(config) + val res = Parser.parse(sourcesToParse, pkgInfo)(config) + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + println(s"parser phase done, took ${durationS}s") + res } else { Left(Vector()) } } - private def performTypeChecking(parsedPackage: PPackage, config: Config): Either[Vector[VerifierError], TypeInfo] = { + private def performTypeChecking(parsedPackage: PPackage, executionContext: GobraExecutionContext, config: Config): Either[Vector[VerifierError], TypeInfo] = { if (config.shouldTypeCheck) { - Info.check(parsedPackage, config.packageInfoInputMap(parsedPackage.info), isMainContext = true)(config) + Info.check(parsedPackage, config.packageInfoInputMap(parsedPackage.info), isMainContext = true, context = new Context(executionContext, config))(config) } else { Left(Vector()) } @@ -260,7 +265,11 @@ class Gobra extends GoVerifier with GoIdeVerifier { private def performDesugaring(parsedPackage: PPackage, typeInfo: TypeInfo, config: Config): Either[Vector[VerifierError], Program] = { if (config.shouldDesugar) { - Right(Desugar.desugar(parsedPackage, typeInfo)(config)) + val startMs = System.currentTimeMillis() + val res = Right(Desugar.desugar(parsedPackage, typeInfo)(config)) + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + println(s"desugaring done, took ${durationS}s") + res } else { Left(Vector()) } @@ -282,18 +291,25 @@ class Gobra extends GoVerifier with GoIdeVerifier { // constant propagation does not cause duplication of verification errors caused // by overflow checks (if enabled) because all overflows in constant declarations // can be found by the well-formedness checks. + val startMs = System.currentTimeMillis() var transformations: Vector[InternalTransform] = Vector(CGEdgesTerminationTransform, ConstantPropagation) if (config.checkOverflows) { transformations :+= OverflowChecksTransform } val result = transformations.foldLeft(program)((prog, transf) => transf.transform(prog)) config.reporter.report(AppliedInternalTransformsMessage(config.packageInfoInputMap(pkgInfo).map(_.name), () => result)) + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + println(s"internal transformations done, took ${durationS}s") Right(result) } private def performViperEncoding(program: Program, config: Config, pkgInfo: PackageInfo): Either[Vector[VerifierError], BackendVerifier.Task] = { if (config.shouldViperEncode) { - Right(Translator.translate(program, pkgInfo)(config)) + val startMs = System.currentTimeMillis() + val res = Right(Translator.translate(program, pkgInfo)(config)) + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + println(s"Viper encoding done, took ${durationS}s") + res } else { Left(Vector()) } diff --git a/src/main/scala/viper/gobra/frontend/Config.scala b/src/main/scala/viper/gobra/frontend/Config.scala index 51da14019..f9a1c9c59 100644 --- a/src/main/scala/viper/gobra/frontend/Config.scala +++ b/src/main/scala/viper/gobra/frontend/Config.scala @@ -16,6 +16,8 @@ import viper.gobra.backend.{ViperBackend, ViperBackends} import viper.gobra.GoVerifier import viper.gobra.frontend.PackageResolver.FileResource import viper.gobra.frontend.Source.getPackageInfo +import viper.gobra.frontend.info.Info.TypeCheckMode +import viper.gobra.frontend.info.Info.TypeCheckMode.TypeCheckMode import viper.gobra.reporting.{FileWriterReporter, GobraReporter, StdIOReporter} import viper.gobra.util.{TypeBounds, Violation} import viper.silver.ast.SourcePosition @@ -68,6 +70,7 @@ object ConfigDefaults { lazy val DefaultEnableLazyImports: Boolean = false lazy val DefaultNoVerify: Boolean = false lazy val DefaultNoStreamErrors: Boolean = false + lazy val DefaultTypeCheckMode: TypeCheckMode = TypeCheckMode.Parallel } case class Config( @@ -118,7 +121,8 @@ case class Config( disableMoreCompleteExhale: Boolean = ConfigDefaults.DefaultDisableMoreCompleteExhale, enableLazyImports: Boolean = ConfigDefaults.DefaultEnableLazyImports, noVerify: Boolean = ConfigDefaults.DefaultNoVerify, - noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors + noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors, + typeCheckMode: TypeCheckMode = ConfigDefaults.DefaultTypeCheckMode, ) { def merge(other: Config): Config = { @@ -163,7 +167,8 @@ case class Config( disableMoreCompleteExhale = disableMoreCompleteExhale, enableLazyImports = enableLazyImports || other.enableLazyImports, noVerify = noVerify || other.noVerify, - noStreamErrors = noStreamErrors || other.noStreamErrors + noStreamErrors = noStreamErrors || other.noStreamErrors, + typeCheckMode = typeCheckMode ) } @@ -214,6 +219,7 @@ case class BaseConfig(gobraDirectory: Path = ConfigDefaults.DefaultGobraDirector enableLazyImports: Boolean = ConfigDefaults.DefaultEnableLazyImports, noVerify: Boolean = ConfigDefaults.DefaultNoVerify, noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors, + typeCheckMode: TypeCheckMode = ConfigDefaults.DefaultTypeCheckMode, ) { def shouldParse: Boolean = true def shouldTypeCheck: Boolean = !shouldParseOnly @@ -268,6 +274,7 @@ trait RawConfig { enableLazyImports = baseConfig.enableLazyImports, noVerify = baseConfig.noVerify, noStreamErrors = baseConfig.noStreamErrors, + typeCheckMode = baseConfig.typeCheckMode, ) } @@ -639,6 +646,19 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals noshort = true, ) + val typeCheckMode: ScallopOption[TypeCheckMode] = choice( + name = "typeCheckMode", + choices = Seq("LAZY", "SEQUENTIAL", "PARALLEL"), + descr = "Specifies the mode in which type-checking is performed.", + default = Some("PARALLEL"), + noshort = true + ).map { + case "LAZY" => TypeCheckMode.Lazy + case "SEQUENTIAL" => TypeCheckMode.Sequential + case "PARALLEL" => TypeCheckMode.Parallel + case _ => ConfigDefaults.DefaultTypeCheckMode + } + /** * Exception handling */ @@ -785,5 +805,6 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals enableLazyImports = enableLazyImports(), noVerify = noVerify(), noStreamErrors = noStreamErrors(), + typeCheckMode = typeCheckMode(), ) } diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index cc107c5d7..96a372934 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -31,6 +31,7 @@ object Desugar { def desugar(pkg: PPackage, info: viper.gobra.frontend.info.TypeInfo)(config: Config): in.Program = { val importsCollector = new PackageInitSpecCollector // independently desugar each imported package. + val importedDesugaringStartMs = System.currentTimeMillis() val importedPrograms = info.context.getContexts map { tI => { val typeInfo: TypeInfo = tI.getTypeInfo val importedPackage = typeInfo.tree.originalRoot @@ -39,12 +40,18 @@ object Desugar { d.registerPackage(importedPackage, importsCollector)(config) (d, d.packageD(importedPackage)) }} + val importedDurationS = f"${(System.currentTimeMillis() - importedDesugaringStartMs) / 1000f}%.1f" + println(s"desugaring imported packages done, took ${importedDurationS}s") + + val desugaringStartMs = System.currentTimeMillis() // desugar the main package, i.e. the package on which verification is performed: val mainDesugarer = new Desugarer(pkg.positions, info) // registers main package to generate proof obligations for its init code mainDesugarer.registerMainPackage(pkg, importsCollector)(config) // combine all desugared results into one Viper program: val internalProgram = combine(mainDesugarer, mainDesugarer.packageD(pkg), importedPrograms) + val durationS = f"${(System.currentTimeMillis() - desugaringStartMs) / 1000f}%.1f" + println(s"desugaring main package done, took ${durationS}s") config.reporter report DesugaredMessage(config.packageInfoInputMap(pkg.info).map(_.name), () => internalProgram) internalProgram } @@ -3455,7 +3462,8 @@ object Desugar { // Collect and register all import-preconditions pkg.imports.foreach{ imp => info.context.getTypeInfo(RegularImport(imp.importPath))(config) match { - case Some(Right(tI)) => + // case Some(Right(tI)) => + case Right(tI) => val desugaredPre = imp.importPres.map(specificationD(FunctionContext.empty(), info)) Violation.violation(!config.enableLazyImports || desugaredPre.isEmpty, s"Import precondition found despite running with ${Config.enableLazyImportOptionPrettyPrinted}") specCollector.addImportPres(tI.getTypeInfo.tree.originalRoot, desugaredPre) diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index bc80f19e5..947840d11 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -22,6 +22,7 @@ import viper.silver.ast.SourcePosition import scala.collection.mutable.ListBuffer import java.security.MessageDigest +import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} object Parser { @@ -59,7 +60,7 @@ object Parser { type SourceCacheKey = String // cache maps a key (obtained by hasing file path and file content) to the parse result - private var sourceCache: Map[SourceCacheKey, (Either[Vector[ParserError], PProgram], Positions)] = Map.empty + private var sourceCache: ConcurrentMap[SourceCacheKey, (Either[Vector[ParserError], PProgram], Positions)] = new ConcurrentHashMap() /** computes the key for caching a particular source. This takes the name, the specOnly flag, and the file's contents into account */ private def getCacheKey(source: Source, specOnly: Boolean): SourceCacheKey = { @@ -70,7 +71,7 @@ object Parser { } def flushCache(): Unit = { - sourceCache = Map.empty + sourceCache.clear() } private def parseSources(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { @@ -100,10 +101,11 @@ object Parser { def parseAndStore(): (Either[Vector[ParserError], PProgram], Positions) = { cacheHit = false val res = parseSource(source) - sourceCache += getCacheKey(source, specOnly) -> (res, positions) + // sourceCache.put(getCacheKey(source, specOnly), (res, positions)) (res, positions) } - val (res, pos) = sourceCache.getOrElse(getCacheKey(source, specOnly), parseAndStore()) + // val (res, pos) = sourceCache.getOrElse(getCacheKey(source, specOnly), parseAndStore()) + val (res, pos) = sourceCache.computeIfAbsent(getCacheKey(source, specOnly), _ => parseAndStore()) if (cacheHit) { // a cached AST has been found in the cache. The position manager does not yet have any positions for nodes in // this AST. Therefore, the following strategy iterates over the entire AST and copies positional information diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala new file mode 100644 index 000000000..8413d396b --- /dev/null +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -0,0 +1,76 @@ +package viper.gobra.frontend + +import viper.gobra.frontend.info.Info.TypeCheckMode +import viper.gobra.util.{GobraExecutionContext, Violation} + +import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} +import scala.concurrent.duration.Duration +import scala.concurrent.{Await, Future, Promise} +import scala.util.{Failure, Success} +import scala.jdk.CollectionConverters._ + +trait Job[R] { + private var compututationStarted = false + private val promise: Promise[R] = Promise() + def getFuture: Future[R] = promise.future + protected def compute(): R + + def call(): R = { + getFuture.value match { + case Some(Success(res)) => return res // return already computed type-checker result + case Some(Failure(exception)) => Violation.violation(s"Job resulted in exception: $exception") + case _ => + } + Violation.violation(!compututationStarted, s"Job is already on-going") + compututationStarted = true + val res = compute() + promise.success(res) + res + } +} + +class TaskManager[K, R](config: Config) { + private val jobs: ConcurrentMap[K, Job[R]] = new ConcurrentHashMap() + + /** + * returns true if job has been inserted and thus was previously absent + */ + def addIfAbsent(id: K, job: Job[R], insertOnly: Boolean = false)(executionContext: GobraExecutionContext): Boolean = { + var isAbsent = false + // first insert job, then run it (if necessary) + jobs.computeIfAbsent(id, _ => { + isAbsent = true + job + }) + // now run it but only if it's a new job: + if (isAbsent && !insertOnly) { + config.typeCheckMode match { + case TypeCheckMode.Lazy => // don't do anything as of now + case TypeCheckMode.Sequential => job.call() + case TypeCheckMode.Parallel => Future{ job.call() }(executionContext) + } + } + isAbsent + } + + def getResult(id: K): R = { + val job = jobs.get(id) + Violation.violation(job != null, s"Task $id not found") + getResultFromJob(job) + } + + def getAllResults: Iterable[R] = + jobs.values().asScala.map(getResultFromJob) + + def getAllResultsWithKeys: Iterable[(K, R)] = + jobs.asScala.toVector.map { case (key, job) => (key, getResultFromJob(job)) } + + private def getResultFromJob(job: Job[R]): R = config.typeCheckMode match { + case TypeCheckMode.Lazy => job.call() // we perform the computation now that we need the result + case TypeCheckMode.Sequential => + // note that we cannot await the future here as type-checking of this package might not have started yet. + // Thus, we use `.call()` that either returns a previously calculated type-checking result or will calculate it. + job.call() + case TypeCheckMode.Parallel => Await.result(job.getFuture, Duration.Inf) + } +} diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 234b591fb..9c0ef6a77 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -7,81 +7,507 @@ package viper.gobra.frontend.info import org.bitbucket.inkytonik.kiama.relation.Tree -import org.bitbucket.inkytonik.kiama.util.Source -import viper.gobra.ast.frontend.{PNode, PPackage} -import viper.gobra.frontend.Config -import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage} +import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, message, noMessages} +import org.bitbucket.inkytonik.kiama.util.{Position, Source} +import viper.gobra.ast.frontend.{PImport, PNode, PPackage} +import viper.gobra.frontend.{Config, Job, PackageResolver, Parser, Source, TaskManager} +import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} +import viper.gobra.frontend.info.Info.TypeCheckMode.TypeCheckMode import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.{GhostLessPrinter, GoifyingPrinter} -import viper.gobra.reporting.{CyclicImportError, TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} +import viper.gobra.reporting.{CyclicImportError, NotFoundError, TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} +import viper.gobra.util.{GobraExecutionContext, Violation} +import java.util.concurrent.Callable import scala.collection.immutable.ListMap +import scala.concurrent.duration.Duration +import scala.concurrent.{Await, Future, Promise} +import scala.util.{Failure, Success} object Info { type GoTree = Tree[PNode, PPackage] + /** + * ImportCycle describes a cyclic import. `importClosingCycle` is the AST node that closes the cycle and + * `cyclicPackages` stores the packages involved in the cycle. + */ + case class ImportCycle(importNodeCausingCycle: PImport, importNodeStart: Option[Position], cyclicPackages: Vector[AbstractImport]) + + object TypeCheckMode extends Enumeration { + type TypeCheckMode = Value + val Lazy, Sequential, Parallel = Value + } + /** * All TypeInfo instances share a single context instance. * Therefore, package management is centralized. */ - class Context { - /** stores the results of all imported packages that have been parsed and type checked so far */ - private var contextMap: Map[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]] = ListMap[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]]() + class Context(executionContext: GobraExecutionContext, config: Config) { + /** stores the results of all imported packages that have been parsed so far */ + private var parserContextMap: Map[AbstractPackage, Either[Vector[VerifierError], (Vector[Source], PPackage)]] = ListMap() /** keeps track of the package dependencies that are currently resolved. This information is used to detect cycles */ - private var pendingPackages: Vector[AbstractImport] = Vector() + private var parserPendingPackages: Vector[AbstractImport] = Vector() /** stores all cycles that have been discovered so far */ - private var knownImportCycles: Set[Vector[AbstractImport]] = Set() + var parserKnownImportCycles: Set[ImportCycle] = Set() - def addPackage(importTarget: AbstractImport, typeInfo: ExternalTypeInfo)(config: Config): Unit = { + /* + def parseRecursively(importTarget: AbstractImport)(config: Config): Either[Vector[VerifierError], PPackage] = { val packageTarget = AbstractPackage(importTarget)(config) - pendingPackages = pendingPackages.filterNot(_ == importTarget) - contextMap = contextMap + (packageTarget -> Right(typeInfo)) + parserPendingPackages = parserPendingPackages :+ importTarget + val pkgSources = PackageResolver.resolveSources(importTarget)(config) + .getOrElse(Vector()) + .map(_.source) + val res = for { + nonEmptyPkgSources <- if (pkgSources.isEmpty) + Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) + else Right(pkgSources) + parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) + directImportTargets = parsedProgram.imports.map(i => RegularImport(i.importPath)) + errorsInTransitivePackages = directImportTargets + .map(directImportTarget => { + if (parserPendingPackages.contains(directImportTarget)) { + // package cycle detected + parserKnownImportCycles += parserPendingPackages + Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'"))) + } else { + parseRecursively(directImportTarget)(config) + } + }) + .flatMap(_.left.getOrElse(Vector.empty)) + res <- if (errorsInTransitivePackages.isEmpty) Right(parsedProgram) else Left(errorsInTransitivePackages) + } yield res + parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) + parserContextMap = parserContextMap + (packageTarget -> res) + res } - - def addErrenousPackage(importTarget: AbstractImport, errors: Vector[VerifierError])(config: Config): Unit = { + */ + def parseRecursively(importTarget: AbstractImport)(config: Config): Either[Vector[VerifierError], PPackage] = { val packageTarget = AbstractPackage(importTarget)(config) - pendingPackages = pendingPackages.filterNot(_ == importTarget) - contextMap = contextMap + (packageTarget -> Left(errors)) - } - def getTypeInfo(importTarget: AbstractImport)(config: Config): Option[Either[Vector[VerifierError], ExternalTypeInfo]] = { - val packageTarget = AbstractPackage(importTarget)(config) - contextMap.get(packageTarget) match { - case s@Some(_) => s - case _ => { - // there is no entry yet and package resolution might need to resolve multiple depending packages - // keep track of these packages in pendingPackages until either type information or an error is added to contextMap - if (pendingPackages.contains(importTarget)) { - // package cycle detected - knownImportCycles += pendingPackages - Some(Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'")))) - } else { - pendingPackages = pendingPackages :+ importTarget - None - } + // skip packages that we have already parsed: + if (parserContextMap.contains(packageTarget)) { + return parserContextMap(packageTarget) match { + case Right((_, pkg)) => Right(pkg) + case Left(errs) => Left(errs) } } + + println(s"parsing $importTarget") + parserPendingPackages = parserPendingPackages :+ importTarget + val pkgSources = PackageResolver.resolveSources(importTarget)(config) + .getOrElse(Vector()) + .map(_.source) + + val res = for { + nonEmptyPkgSources <- if (pkgSources.isEmpty) + Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) + // Left(message(importNode, s"No source files for package '$importTarget' found")) + else Right(pkgSources) + parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) + errorsInTransitivePackages = parsedProgram.imports + .map(importNode => { + val directImportTarget = RegularImport(importNode.importPath) + if (parserPendingPackages.contains(directImportTarget)) { + // package cycle detected + val importNodeStart = parsedProgram.positions.positions.getStart(importNode) + parserKnownImportCycles += ImportCycle(importNode, importNodeStart, parserPendingPackages) + println(s"cycle detected: ${importTarget} has import ${directImportTarget} that occurs in ${parserKnownImportCycles}") + Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'"))) + // val cycle = parserPendingPackages + // Left(message(importNode, s"Package '$importTarget' is part of this import cycle: ${cycle.mkString("[", ", ", "]")}")) + } else { + parseRecursively(directImportTarget)(config) + } + }) + .flatMap(_.left.getOrElse(Vector.empty)) + res <- if (errorsInTransitivePackages.isEmpty) Right(parsedProgram) else Left(errorsInTransitivePackages) + } yield res + /* + val res: Either[Messages, PPackage] = for { + nonEmptyPkgSources <- if (pkgSources.isEmpty) + // Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) + Left(message(importNode, s"No source files for package '$importTarget' found")) + else Right(pkgSources) + parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) + directImportTargets = parsedProgram.imports // .map(i => RegularImport(i.importPath)) + errorsInTransitivePackages: Messages = directImportTargets + .map(directImportTarget => { + if (parserPendingPackages.contains(directImportTarget)) { + // package cycle detected + parserKnownImportCycles += parserPendingPackages + // Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'"))) + val cycle = parserPendingPackages + Left(message(importNode, s"Package '$importTarget' is part of this import cycle: ${cycle.mkString("[", ", ", "]")}")) + } else { + parseRecursively(directImportTarget)(config) + } + }) + .flatMap(_.left.getOrElse(noMessages)) + res <- if (errorsInTransitivePackages.isEmpty) Right(parsedProgram) else Left(errorsInTransitivePackages) + } yield res + */ + parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) + parserContextMap = parserContextMap + (packageTarget -> res.map(pkg => (pkgSources, pkg))) + res + } + + /** + * returns all parser errors and cyclic errors transitively found in imported packages + */ + def computeCycles(importTarget: AbstractImport): Vector[VerifierError] = { + parserPendingPackages = parserPendingPackages :+ importTarget + val abstractPackage = AbstractPackage(importTarget)(config) + val res = for { + res <- parseManager.getResult(abstractPackage) + (_, ast) = res + directImportTargets = ast.imports + errorsInTransitivePackages = directImportTargets + .flatMap(importNode => { + val directImportTarget = RegularImport(importNode.importPath) + if (parserPendingPackages.contains(directImportTarget)) { + // package cycle detected + val importNodeStart = ast.positions.positions.getStart(importNode) + parserKnownImportCycles += ImportCycle(importNode, importNodeStart, parserPendingPackages) + Vector(CyclicImportError(s"Cyclic package import detected starting with package '$directImportTarget'")) + // val cycle = parserPendingPackages + // message(importNode, s"Package '$importTarget' is part of this import cycle: ${cycle.mkString("[", ", ", "]")}") + } else { + computeCycles(directImportTarget) + } + }) + res <- if (errorsInTransitivePackages.isEmpty) Right(ast) else Left(errorsInTransitivePackages) + } yield res + parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) + res.left.getOrElse(Vector.empty) } + /* + def parseRecursively(pkg: PPackage)(config: Config): Either[Vector[VerifierError], PPackage] = { + val imports = Seq(BuiltInImport) ++ + pkg.imports.map(i => RegularImport(i.importPath)) + imports.map(importTarget => { + parserPendingPackages = parserPendingPackages :+ importTarget + val pkgSources = PackageResolver.resolveSources(importTarget)(config) + .getOrElse(Vector()) + .map(_.source) + val res = for { + nonEmptyPkgSources <- if (pkgSources.isEmpty) + Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) + else Right(pkgSources) + parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) + }) + + } + */ /** * Returns all package names that lie on the cycle of imports or none if no cycle was found */ - def getImportCycle(importTarget: AbstractImport): Option[Vector[AbstractImport]] = knownImportCycles.find(_.contains(importTarget)) + def getParserImportCycle(importTarget: AbstractImport): Option[ImportCycle] = + parserKnownImportCycles.find(_.cyclicPackages.contains(importTarget)) - def getContexts: Iterable[ExternalTypeInfo] = contextMap.values.collect { case Right(info) => info } + case class ParseJob(importTarget: AbstractImport) extends Job[Either[Vector[VerifierError], (Vector[Source], PPackage)]] { + def compute(): Either[Vector[VerifierError], (Vector[Source], PPackage)] = { + println(s"start parsing $importTarget") + val startMs = System.currentTimeMillis() + val pkgSources = PackageResolver.resolveSources(importTarget)(config) + .getOrElse(Vector()) + .map(_.source) + for { + nonEmptyPkgSources <- if (pkgSources.isEmpty) + Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) + // Left(message(importNode, s"No source files for package '$importTarget' found")) + else Right(pkgSources) + parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) + durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + _ = println(s"parsing $importTarget done (took ${durationS}s)") + // submit jobs to parse dependent packages: + _ = parsedProgram.imports.foreach(importNode => { + val directImportTarget = RegularImport(importNode.importPath) + val directImportPackage = AbstractPackage(directImportTarget)(config) + parseManager.addIfAbsent(directImportPackage, ParseJob(directImportTarget))(executionContext) + }) + } yield (pkgSources, parsedProgram) + } + } + + val parseManager = new TaskManager[AbstractPackage, Either[Vector[VerifierError], (Vector[Source], PPackage)]](config) + def parse(importTarget: AbstractImport): Unit = { + val abstractPackage = AbstractPackage(importTarget)(config) + val parseJob = ParseJob(importTarget) + parseManager.addIfAbsent(abstractPackage, parseJob)(executionContext) + } + + case class TypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] { + def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { + println(s"start type-checking ${pkg.info.id}") + val startMs = System.currentTimeMillis() + val res = Info.check(pkg, pkgSources, context)(config) + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + println(s"type-checking ${pkg.info.id} done (took ${durationS}s)") + res + } + } + + case class FailureJob(errs: Vector[VerifierError]) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] { + def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = Left(errs) + } + + /* + lazy val typeContextMap: Map[AbstractPackage, Future[Either[Vector[VerifierError], ExternalTypeInfo]]] = + parserContextMap.map{ case (abstractPackage, value) => (abstractPackage, value match { + case Right((pkgSources, pkg)) => + if (parallelizeTypechecking) Future { typeCheck(pkgSources, pkg) }(executionContext) + else { + val res = typeCheck(pkgSources, pkg) + if (res.isLeft) { + println(s"type-checking ${abstractPackage} failed: ${res.left.get}") + } + Future.successful(res) + } + case Left(errs) => Future.successful(Left(errs)) + })} + */ + private val typeCheckManager = new TaskManager[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]](config) + def typeCheck(): Unit = { + /*parserContextMap.foreach { case (abstractPackage, parseResult) => + val typeCheckJob = parseResult match { + case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) + case Left(errs) => FailureJob(errs) + } + println(s"adding task $abstractPackage") + typeCheckManager.addIfAbsent(abstractPackage, typeCheckJob)(executionContext) + } + */ + parseManager.getAllResultsWithKeys.foreach { case (abstractPackage, parseResult) => + val typeCheckJob = parseResult match { + case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) + case Left(errs) => FailureJob(errs) + } + println(s"adding task $abstractPackage") + // since we're adding the packages in arbitrary order, we cannot directly run the task in SEQUENTIAL mode because + // depending packages might not have been inserted yet + typeCheckManager.addIfAbsent(abstractPackage, typeCheckJob, insertOnly = config.typeCheckMode == TypeCheckMode.Sequential)(executionContext) + } + } + /* + lazy val jobMap: Map[AbstractPackage, Job] = + parserContextMap.transform { case (_, value) => value match { + case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) + case Left(errs) => FailureJob(errs) + }} + */ - def getExternalErrors: Vector[VerifierError] = contextMap.values.collect { case Left(errs) => errs }.flatten.toVector + def typeCheckSequentially(): Unit = { + /* + val jobs = jobMap.toVector.sorted(Ordering.by[(AbstractPackage, Job), Int](_._1.hashCode())) + println(s"typeCheckSequentially: ${jobs.map(_._1)}") + jobs.foreach { case (abstractPackage, job) => + // println(s"typeCheckSequentially: $abstractPackage") + job.call() } + */ + // NOP + } + + def typeCheckInParallel(): Unit = { + // NOP + // jobMap.foreach { case (_, job) => Future{ job.call() }(executionContext) } + } + /* + lazy val typeContextMap: Map[AbstractPackage, Future[Either[Vector[VerifierError], ExternalTypeInfo]]] = + jobMap.transform { case (_, job) => job.getFuture } + */ +// /** stores the results of all imported packages that have been parsed and type checked so far */ +// private var contextMap: Map[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]] = ListMap[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]]() +// /** keeps track of the package dependencies that are currently resolved. This information is used to detect cycles */ +// private var pendingPackages: Vector[AbstractImport] = Vector() +// /** stores all cycles that have been discovered so far */ +// private var knownImportCycles: Set[Vector[AbstractImport]] = Set() +// +// def addPackage(importTarget: AbstractImport, typeInfo: ExternalTypeInfo)(config: Config): Unit = { +// val packageTarget = AbstractPackage(importTarget)(config) +// pendingPackages = pendingPackages.filterNot(_ == importTarget) +// contextMap = contextMap + (packageTarget -> Right(typeInfo)) +// } +// +// def addErrenousPackage(importTarget: AbstractImport, errors: Vector[VerifierError])(config: Config): Unit = { +// val packageTarget = AbstractPackage(importTarget)(config) +// pendingPackages = pendingPackages.filterNot(_ == importTarget) +// contextMap = contextMap + (packageTarget -> Left(errors)) +// } +// +// def getTypeInfo(importTarget: AbstractImport)(config: Config): Option[Either[Vector[VerifierError], ExternalTypeInfo]] = { +// val packageTarget = AbstractPackage(importTarget)(config) +// contextMap.get(packageTarget) match { +// case s@Some(_) => s +// case _ => { +// // there is no entry yet and package resolution might need to resolve multiple depending packages +// // keep track of these packages in pendingPackages until either type information or an error is added to contextMap +// if (pendingPackages.contains(importTarget)) { +// // package cycle detected +// knownImportCycles += pendingPackages +// Some(Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'")))) +// } else { +// pendingPackages = pendingPackages :+ importTarget +// None +// } +// } +// } +// } +// +// /** +// * Returns all package names that lie on the cycle of imports or none if no cycle was found +// */ +// def getImportCycle(importTarget: AbstractImport): Option[Vector[AbstractImport]] = knownImportCycles.find(_.contains(importTarget)) +// +// def getContexts: Iterable[ExternalTypeInfo] = contextMap.values.collect { case Right(info) => info } +// +// def getExternalErrors: Vector[VerifierError] = contextMap.values.collect { case Left(errs) => errs }.flatten.toVector + + def getContexts: Iterable[ExternalTypeInfo] = + // typeContextMap.values.map(fut => Await.result(fut, Duration.Inf)).collect { case Right(info) => info } + typeCheckManager.getAllResults.collect { case Right(info) => info } + /* + def getTypeInfoNonBlocking(importTarget: AbstractImport)(config: Config): Option[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] = { + val packageTarget = AbstractPackage(importTarget)(config) + typeContextMap.get(packageTarget) + } + + def getTypeInfo(importTarget: AbstractImport)(config: Config): Option[Either[Vector[VerifierError], ExternalTypeInfo]] = + getTypeInfoNonBlocking(importTarget)(config).map(Await.result(_, Duration.Inf)) + + */ + + /* + def startTypeChecking(): Unit = { + config.typeCheckMode match { + case TypeCheckMode.Parallel => typeCheckInParallel() + case TypeCheckMode.Sequential => typeCheckSequentially() + case TypeCheckMode.Lazy => // don't do anything yet + } + } + */ + + def getTypeInfo(importTarget: AbstractImport)(config: Config): Either[Vector[VerifierError], ExternalTypeInfo] = { + val packageTarget = AbstractPackage(importTarget)(config) + /* + Violation.violation(typeContextMap.contains(packageTarget), s"expected that a job for ${packageTarget} but found none") + val fut = typeContextMap(packageTarget) + Await.result(fut, Duration.Inf) + */ + /* + Violation.violation(jobMap.contains(packageTarget), s"expected that a job for ${packageTarget} but found none") + val job = jobMap(packageTarget) + config.typeCheckMode match { + case TypeCheckMode.Lazy => job.call() + case TypeCheckMode.Sequential => + // note that we cannot await the future here as type-checking of this package might not have started yet. + // Thus, we use `.call()` that either returns a previously calculated type-checking result or will calculate it. + job.call() + case TypeCheckMode.Parallel => Await.result(job.getFuture, Duration.Inf) + } + */ + typeCheckManager.getResult(packageTarget) + } } - def check(pkg: PPackage, sources: Vector[Source], context: Context = new Context, isMainContext: Boolean = false)(config: Config): Either[Vector[VerifierError], TypeInfo with ExternalTypeInfo] = { + + def check(pkg: PPackage, sources: Vector[Source], context: Context /*= new Context()*/, isMainContext: Boolean = false)(config: Config): Either[Vector[VerifierError], TypeInfo with ExternalTypeInfo] = { val tree = new GoTree(pkg) // println(program.declarations.head) // println("-------------------") // println(tree) val info = new TypeInfoImpl(tree, context, isMainContext)(config: Config) - val errors = info.errors + def createImportError(importNode: PImport, errs: Vector[VerifierError]): Messages = { + val importTarget = RegularImport(importNode.importPath) + // create an error message located at the import statement to indicate errors in the imported package + // we distinguish between parse and type errors, cyclic imports, and packages whose source files could not be found + val notFoundErr = errs.collectFirst { case e: NotFoundError => e } + // alternativeErr is a function to compute the message only when needed + val alternativeErr = () => context.getParserImportCycle(importTarget) match { + case Some(cycle) => + val positionalInfo = cycle.importNodeStart.map(pos => s" at ${pos.format}").getOrElse("") + message(importNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}${positionalInfo}: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") + case _ => message(importNode, s"Package '$importTarget' contains errors: $errs") + } + notFoundErr.map(e => message(importNode, e.message)) + .getOrElse(alternativeErr()) + } + + //val parserMessages = noMessages + val parserMessages = if (isMainContext) { + val sequential = false + val parsingStartMs = System.currentTimeMillis() + val messages = if (sequential) { + // parse BuiltInImport + val builtInParseResult = context.parseRecursively(BuiltInImport)(config) + val builtInMessages = if (builtInParseResult.isRight) noMessages else message(pkg, s"Parsing package with Gobra's built-in definitions failed. This is an internal bug.") + + val importedPackagesMessages = pkg.imports.flatMap(importNode => { + val importTarget = RegularImport(importNode.importPath) + val parseResult = context.parseRecursively(importTarget)(config) + parseResult.left.map(errs => createImportError(importNode, errs)).left.getOrElse(noMessages) + }) + + builtInMessages ++ importedPackagesMessages + } else { + // parse BuiltInImport + context.parse(BuiltInImport) + + pkg.imports.foreach(importNode => { + val importTarget = RegularImport(importNode.importPath) + context.parse(importTarget) + }) + + // collect parse errors and cyclic import errors: + val builtInParseErrors = context.computeCycles(BuiltInImport) + val builtInMessages = if (builtInParseErrors.isEmpty) noMessages else message(pkg, s"Parsing package with Gobra's built-in definitions failed. This is an internal bug.") + + val importedPackagesMessages = pkg.imports.flatMap(importNode => { + val importTarget = RegularImport(importNode.importPath) + val parseErrors = context.computeCycles(importTarget) + if (parseErrors.isEmpty) noMessages else createImportError(importNode, parseErrors) + }) + + builtInMessages ++ importedPackagesMessages + } + val durationS = f"${(System.currentTimeMillis() - parsingStartMs) / 1000f}%.1f" + println(s"parsing done, took ${durationS}s, ${messages.length} errors found") + /* + val imports = Vector(BuiltInImport) ++ + pkg.imports.map(i => RegularImport(i.importPath)) + val parseResult = imports.map(importTarget => { + context.parseRecursively(importTarget)(config) + }) + val transitiveParseErrors = parseResult.flatMap(res => res.left.getOrElse(Vector.empty)) + if (transitiveParseErrors.nonEmpty) { + println(s"parse error encountered") + println(transitiveParseErrors) + return Left(transitiveParseErrors) + } + println(s"parsing was fine") + */ + + messages + } else { + noMessages + } + + val typeCheckingStartMs = System.currentTimeMillis() + if (isMainContext && parserMessages.isEmpty) { + // context.startTypeChecking() + context.typeCheck() + } + + // val errors = info.errors + val errors = if (parserMessages.nonEmpty) parserMessages else { + info.errors + } + if (isMainContext && errors.isEmpty) { + val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" + println(s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})") + } val sourceNames = sources.map(_.name) // use `sources` instead of `context.inputs` for reporting such that the message is correctly attributed in case of imports diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala index 896553697..4dc0f9bc9 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala @@ -405,6 +405,7 @@ trait MemberResolution { this: TypeInfoImpl => // TODO: move this method to another file def getTypeChecker(importTarget: AbstractImport, errNode: PNode): Either[Messages, ExternalTypeInfo] = { + /* def parseAndTypeCheck(importTarget: AbstractImport): Either[Vector[VerifierError], ExternalTypeInfo] = { val pkgSources = PackageResolver.resolveSources(importTarget)(config) .getOrElse(Vector()) @@ -425,14 +426,15 @@ trait MemberResolution { this: TypeInfoImpl => ) res } - + */ def createImportError(errs: Vector[VerifierError]): Messages = { // create an error message located at the import statement to indicate errors in the imported package // we distinguish between parse and type errors, cyclic imports, and packages whose source files could not be found val notFoundErr = errs.collectFirst { case e: NotFoundError => e } // alternativeErr is a function to compute the message only when needed - val alternativeErr = () => context.getImportCycle(importTarget) match { - case Some(cycle) => message(errNode, s"Package '$importTarget' is part of this import cycle: ${cycle.mkString("[", ", ", "]")}") + val alternativeErr = () => context.getParserImportCycle(importTarget) match { + case Some(cycle) => + message(errNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") case _ => message(errNode, s"Package '$importTarget' contains errors: $errs") } notFoundErr.map(e => message(errNode, e.message)) @@ -440,7 +442,15 @@ trait MemberResolution { this: TypeInfoImpl => } // check if package was already parsed, otherwise do parsing and type checking: + /* val cachedInfo = context.getTypeInfo(importTarget)(config) - cachedInfo.getOrElse(parseAndTypeCheck(importTarget)).left.map(createImportError) + if (cachedInfo.isEmpty) { + println(s"package $importTarget is not contained in context") + } + Violation.violation(cachedInfo.nonEmpty, s"package $importTarget is not contained in context") + cachedInfo.get.left.map(createImportError) + // cachedInfo.getOrElse(parseAndTypeCheck(importTarget)).left.map(createImportError) + */ + context.getTypeInfo(importTarget)(config).left.map(createImportError) } } From 8039bcf97a77a5b5e2f529948345275ae0f01ac9 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 9 Mar 2023 09:32:22 +0100 Subject: [PATCH 02/54] updates ANTLR Go lexer and parser --- build.sbt | 2 +- src/main/antlr4/GoLexer.g4 | 24 +++++++++++--- src/main/antlr4/GoParser.g4 | 62 +++++++++++++++++-------------------- 3 files changed, 49 insertions(+), 39 deletions(-) diff --git a/build.sbt b/build.sbt index d2dfacf37..dca34e1c5 100644 --- a/build.sbt +++ b/build.sbt @@ -34,7 +34,7 @@ lazy val gobra = (project in file(".")) libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.9", // for SystemUtils libraryDependencies += "org.apache.commons" % "commons-text" % "1.9", // for escaping strings in parser preprocessor libraryDependencies += "commons-codec" % "commons-codec" % "1.15", // for obtaining the hex encoding of a string - libraryDependencies += "org.antlr" % "antlr4-runtime" % "4.9.2", + libraryDependencies += "org.antlr" % "antlr4-runtime" % "4.12.0", scalacOptions ++= Seq( "-encoding", "UTF-8", // Enforce UTF-8, instead of relying on properly set locales diff --git a/src/main/antlr4/GoLexer.g4 b/src/main/antlr4/GoLexer.g4 index efcba1f79..871541ca1 100644 --- a/src/main/antlr4/GoLexer.g4 +++ b/src/main/antlr4/GoLexer.g4 @@ -34,8 +34,7 @@ * https://golang.org/ref/spec */ -// Imported to Gobra from https://github.com/antlr/grammars-v4/blob/4c06ad8cc8130931c75ca0b17cbc1453f3830cd2/golang - +// Imported to Gobra from https://github.com/antlr/grammars-v4/blob/fae6a8500e9c6a1ec895fca1495b0384b9144091/golang lexer grammar GoLexer; @@ -145,7 +144,7 @@ HEX_FLOAT_LIT : '0' [xX] HEX_MANTISSA HEX_EXPONENT fragment HEX_MANTISSA : ('_'? HEX_DIGIT)+ ('.' ( '_'? HEX_DIGIT )*)? | '.' HEX_DIGIT ('_'? HEX_DIGIT)*; -fragment HEX_EXPONENT : [pP] [+-] DECIMALS; +fragment HEX_EXPONENT : [pP] [+-]? DECIMALS; IMAGINARY_LIT : (DECIMAL_LIT | BINARY_LIT | OCTAL_LIT | HEX_LIT | FLOAT_LIT) 'i' -> mode(NLSEMI); @@ -172,14 +171,18 @@ BIG_U_VALUE: '\\' 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGI RAW_STRING_LIT : '`' ~'`'* '`' -> mode(NLSEMI); INTERPRETED_STRING_LIT : '"' (~["\\] | ESCAPED_VALUE)* '"' -> mode(NLSEMI); + // Hidden tokens + WS : [ \t]+ -> channel(HIDDEN); COMMENT : '/*' .*? '*/' -> channel(HIDDEN); TERMINATOR : [\r\n]+ -> channel(HIDDEN); LINE_COMMENT : '//' ~[\r\n]* -> channel(HIDDEN); fragment UNICODE_VALUE: ~[\r\n'] | LITTLE_U_VALUE | BIG_U_VALUE | ESCAPED_VALUE; + // Fragments + fragment ESCAPED_VALUE : '\\' ('u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT | 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT @@ -187,27 +190,35 @@ fragment ESCAPED_VALUE | OCTAL_DIGIT OCTAL_DIGIT OCTAL_DIGIT | 'x' HEX_DIGIT HEX_DIGIT) ; + fragment DECIMALS : [0-9] ('_'? [0-9])* ; + fragment OCTAL_DIGIT : [0-7] ; + fragment HEX_DIGIT : [0-9a-fA-F] ; + fragment BIN_DIGIT : [01] ; + fragment EXPONENT : [eE] [+-]? DECIMALS ; + fragment LETTER : UNICODE_LETTER | '_' ; + fragment UNICODE_DIGIT : [\p{Nd}] + /* [\u0030-\u0039] | [\u0660-\u0669] | [\u06F0-\u06F9] @@ -229,6 +240,7 @@ fragment UNICODE_DIGIT | [\u1810-\u1819] | [\uFF10-\uFF19]*/ ; + fragment UNICODE_LETTER : [\p{L}] /* [\u0041-\u005A] @@ -494,7 +506,11 @@ fragment UNICODE_LETTER | [\uFFDA-\uFFDC] */ ; + + mode NLSEMI; + + // Treat whitespace as normal WS_NLSEMI : [ \t]+ -> channel(HIDDEN); // Ignore any comments that only span one line @@ -504,4 +520,4 @@ LINE_COMMENT_NLSEMI : '//' ~[\r\n]* -> channel(HIDDEN); //return to normal lexing EOS: ([\r\n]+ | ';' | '/*' .*? '*/' | EOF) -> mode(DEFAULT_MODE); // Did not find an EOS, so go back to normal lexing -OTHER: -> mode(DEFAULT_MODE), channel(HIDDEN); \ No newline at end of file +OTHER: -> mode(DEFAULT_MODE), channel(HIDDEN); diff --git a/src/main/antlr4/GoParser.g4 b/src/main/antlr4/GoParser.g4 index 0843b0c2c..d357ed404 100644 --- a/src/main/antlr4/GoParser.g4 +++ b/src/main/antlr4/GoParser.g4 @@ -1,38 +1,32 @@ /* - [The "BSD licence"] - Copyright (c) 2017 Sasa Coh, Michał Błotniak - Copyright (c) 2019 Ivan Kochurkin, kvanttt@gmail.com, Positive Technologies - Copyright (c) 2019 Dmitry Rassadin, flipparassa@gmail.com, Positive Technologies - Copyright (c) 2021 Martin Mirchev, mirchevmartin2203@gmail.com - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - 1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - 3. The name of the author may not be used to endorse or promote products - derived from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + [The "BSD licence"] Copyright (c) 2017 Sasa Coh, Michał Błotniak Copyright (c) 2019 Ivan Kochurkin, + kvanttt@gmail.com, Positive Technologies Copyright (c) 2019 Dmitry Rassadin, + flipparassa@gmail.com,Positive Technologies All rights reserved. Copyright (c) 2021 Martin Mirchev, + mirchevmartin2203@gmail.com + + Redistribution and use in source and binary forms, with or without modification, are permitted + provided that the following conditions are met: 1. Redistributions of source code must retain the + above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in + binary form must reproduce the above copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the distribution. 3. The name + of the author may not be used to endorse or promote products derived from this software without + specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, + BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ + /* * A Go grammar for ANTLR 4 derived from the Go Language Specification https://golang.org/ref/spec */ -// Imported to Gobra from https://github.com/antlr/grammars-v4/blob/4c06ad8cc8130931c75ca0b17cbc1453f3830cd2/golang +// Imported to Gobra from https://github.com/antlr/grammars-v4/tree/fae6a8500e9c6a1ec895fca1495b0384b9144091/golang parser grammar GoParser; @@ -87,7 +81,7 @@ varSpec: block: L_CURLY statementList? R_CURLY; -statementList: (eos? statement eos)+; +statementList: ((SEMI? | EOS? | {this.closingBracket()}?) statement eos)+; statement: declaration @@ -194,7 +188,7 @@ commCase: CASE (sendStmt | recvStmt) | DEFAULT; recvStmt: (expressionList ASSIGN | identifierList DECLARE_ASSIGN)? recvExpr = expression; -forStmt: FOR (expression | forClause | rangeClause)? block; +forStmt: FOR (expression? | forClause | rangeClause?) block; forClause: initStmt = simpleStmt? eos expression? eos postStmt = simpleStmt?; @@ -384,5 +378,5 @@ eos: SEMI | EOF | EOS - | {closingBracket()}? - ; \ No newline at end of file + | {this.closingBracket()}? + ; From 81ea40397d882c1fc24762518a9900bfe690bf74 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 9 Mar 2023 09:38:03 +0100 Subject: [PATCH 03/54] saves ongoing work --- src/main/antlr4/GobraParser.g4 | 4 + .../java/viper/gobra/frontend/GobraLexer.java | 1820 +++--- .../viper/gobra/frontend/GobraParser.java | 5167 ++++++++++------- .../frontend/GobraParserBaseVisitor.java | 11 +- .../gobra/frontend/GobraParserVisitor.java | 9 +- src/main/scala/viper/gobra/Gobra.scala | 68 +- .../scala/viper/gobra/ast/frontend/Ast.scala | 9 + .../scala/viper/gobra/frontend/Config.scala | 17 +- .../scala/viper/gobra/frontend/Desugar.scala | 16 +- .../gobra/frontend/ParseTreeTranslator.scala | 7 + .../scala/viper/gobra/frontend/Parser.scala | 132 +- .../viper/gobra/frontend/TaskManager.scala | 107 +- .../frontend/info/ExternalTypeInfo.scala | 6 + .../viper/gobra/frontend/info/Info.scala | 733 ++- .../viper/gobra/frontend/info/TypeInfo.scala | 4 +- .../info/implementation/TypeInfoImpl.scala | 12 +- .../resolution/MemberResolution.scala | 20 +- .../typing/ghost/GhostMemberTyping.scala | 13 +- .../gobra/reporting/StatsCollector.scala | 9 + 19 files changed, 5167 insertions(+), 2997 deletions(-) diff --git a/src/main/antlr4/GobraParser.g4 b/src/main/antlr4/GobraParser.g4 index 3f08a2fcb..c37e545ba 100644 --- a/src/main/antlr4/GobraParser.g4 +++ b/src/main/antlr4/GobraParser.g4 @@ -39,6 +39,10 @@ sourceFile: (specMember | declaration | ghostMember) eos )* EOF; +// `preamble` is a second entry point allowing us to parse only the top of a source. +// That's also why we don not enforce EOF at the end. +preamble: (initPost eos)* packageClause eos (importDecl eos)*; + initPost: INIT_POST expression; importPre: IMPORT_PRE expression; diff --git a/src/main/java/viper/gobra/frontend/GobraLexer.java b/src/main/java/viper/gobra/frontend/GobraLexer.java index 0d4c2dd0e..13027367a 100644 --- a/src/main/java/viper/gobra/frontend/GobraLexer.java +++ b/src/main/java/viper/gobra/frontend/GobraLexer.java @@ -1,3 +1,4 @@ +// Generated from src/main/antlr4/GobraLexer.g4 by ANTLR 4.12.0 package viper.gobra.frontend; import org.antlr.v4.runtime.Lexer; import org.antlr.v4.runtime.CharStream; @@ -8,9 +9,9 @@ import org.antlr.v4.runtime.dfa.DFA; import org.antlr.v4.runtime.misc.*; -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) public class GobraLexer extends Lexer { - static { RuntimeMetaData.checkVersion("4.9.1", RuntimeMetaData.VERSION); } + static { RuntimeMetaData.checkVersion("4.12.0", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = @@ -214,700 +215,1125 @@ private boolean DECIMAL_FLOAT_LIT_sempred(RuleContext _localctx, int predIndex) } public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u00a2\u05db\b\1\b"+ - "\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n"+ - "\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21"+ - "\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30"+ - "\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37"+ - "\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t"+ - "*\4+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63"+ - "\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t"+ - "<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4"+ - "H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\t"+ - "S\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^"+ - "\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j"+ - "\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu"+ - "\4v\tv\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080"+ - "\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084"+ - "\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089"+ - "\t\u0089\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d"+ - "\4\u008e\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092"+ - "\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096"+ - "\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b"+ - "\t\u009b\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f"+ - "\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4"+ - "\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8"+ - "\4\u00a9\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad"+ - "\t\u00ad\4\u00ae\t\u00ae\3\2\3\2\5\2\u0161\n\2\3\2\3\2\3\3\3\3\3\3\3\3"+ - "\5\3\u0169\n\3\3\3\5\3\u016c\n\3\3\3\5\3\u016f\n\3\3\3\3\3\3\3\3\3\5\3"+ - "\u0175\n\3\5\3\u0177\n\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3"+ - "\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7"+ - "\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3"+ - "\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3"+ - "\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3"+ - "\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\17"+ - "\3\17\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+ - "\3\20\3\20\3\20\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23"+ - "\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\25\3\25"+ - "\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27"+ - "\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31"+ - "\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33"+ - "\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\36\3\36\3\37"+ - "\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3!"+ - "\3!\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3$"+ - "\3$\3$\3$\3%\3%\3%\3%\3%\3%\3&\3&\3\'\3\'\3\'\3(\3(\3(\3(\3(\3)\3)\3)"+ - "\3)\3)\3)\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3,\3,"+ - "\3-\3-\3-\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60\3"+ - "\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3"+ - "\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3"+ - "\64\3\64\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3"+ - "\66\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3"+ - "8\38\38\38\38\38\38\39\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3;\3;\3"+ - ";\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3<\3=\3=\3=\3=\3"+ - ">\3>\3>\3?\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3A\3A\3A\3"+ - "A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3C\3C\3C\3C\3"+ - "C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3E\3E\3"+ - "F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3"+ - "G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3J\3J\3J\3J\3K\3K\3K\3K\3K\3"+ - "L\3L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3O\3O\3"+ - "O\3O\3O\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3"+ - "R\3R\3R\3S\3S\3S\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3W\3"+ - "W\3W\3W\3W\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3"+ - "Z\3[\3[\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3"+ - "\\\3\\\3]\3]\3]\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3`\3`"+ - "\3`\3`\3`\3`\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3c\3c"+ - "\3c\3d\3d\3d\3d\3e\3e\3e\3e\3e\3e\3f\3f\3f\7f\u0426\nf\ff\16f\u0429\13"+ - "f\3f\3f\3g\3g\3h\3h\3h\3h\3i\3i\3j\3j\3j\3j\3k\3k\3l\3l\3l\3l\3m\3m\3"+ - "n\3n\3o\3o\3p\3p\3q\3q\3r\3r\3r\3r\3r\3s\3s\3s\3s\3s\3t\3t\3t\3u\3u\3"+ - "u\3u\3v\3v\3v\3w\3w\3w\3x\3x\3x\3y\3y\3y\3z\3z\3{\3{\3{\3|\3|\3}\3}\3"+ - "}\3~\3~\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\3\u0082\3"+ - "\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085"+ - "\3\u0086\3\u0086\3\u0087\3\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a"+ - "\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\5\u008b\u0491\n\u008b\3\u008b"+ - "\7\u008b\u0494\n\u008b\f\u008b\16\u008b\u0497\13\u008b\5\u008b\u0499\n"+ - "\u008b\3\u008b\3\u008b\3\u008c\3\u008c\3\u008c\5\u008c\u04a0\n\u008c\3"+ - "\u008c\6\u008c\u04a3\n\u008c\r\u008c\16\u008c\u04a4\3\u008c\3\u008c\3"+ - "\u008d\3\u008d\5\u008d\u04ab\n\u008d\3\u008d\5\u008d\u04ae\n\u008d\3\u008d"+ - "\6\u008d\u04b1\n\u008d\r\u008d\16\u008d\u04b2\3\u008d\3\u008d\3\u008e"+ - "\3\u008e\3\u008e\5\u008e\u04ba\n\u008e\3\u008e\6\u008e\u04bd\n\u008e\r"+ - "\u008e\16\u008e\u04be\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f"+ - "\3\u008f\3\u0090\5\u0090\u04c9\n\u0090\3\u0090\6\u0090\u04cc\n\u0090\r"+ - "\u0090\16\u0090\u04cd\3\u0090\3\u0090\5\u0090\u04d2\n\u0090\3\u0090\7"+ - "\u0090\u04d5\n\u0090\f\u0090\16\u0090\u04d8\13\u0090\5\u0090\u04da\n\u0090"+ - "\3\u0090\3\u0090\3\u0090\5\u0090\u04df\n\u0090\3\u0090\7\u0090\u04e2\n"+ - "\u0090\f\u0090\16\u0090\u04e5\13\u0090\5\u0090\u04e7\n\u0090\3\u0091\3"+ - "\u0091\3\u0091\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\5\u0092"+ - "\u04f2\n\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093"+ - "\5\u0093\u04fb\n\u0093\3\u0093\3\u0093\3\u0094\3\u0094\3\u0094\3\u0094"+ - "\3\u0095\3\u0095\5\u0095\u0505\n\u0095\3\u0096\3\u0096\3\u0096\3\u0096"+ - "\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098"+ - "\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+ - "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\7\u009a"+ - "\u0525\n\u009a\f\u009a\16\u009a\u0528\13\u009a\3\u009a\3\u009a\3\u009a"+ - "\3\u009a\3\u009b\3\u009b\3\u009b\7\u009b\u0531\n\u009b\f\u009b\16\u009b"+ - "\u0534\13\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c\6\u009c\u053b"+ - "\n\u009c\r\u009c\16\u009c\u053c\3\u009c\3\u009c\3\u009d\3\u009d\3\u009d"+ - "\3\u009d\7\u009d\u0545\n\u009d\f\u009d\16\u009d\u0548\13\u009d\3\u009d"+ - "\3\u009d\3\u009d\3\u009d\3\u009d\3\u009e\6\u009e\u0550\n\u009e\r\u009e"+ - "\16\u009e\u0551\3\u009e\3\u009e\3\u009f\3\u009f\3\u009f\3\u009f\7\u009f"+ - "\u055a\n\u009f\f\u009f\16\u009f\u055d\13\u009f\3\u009f\3\u009f\3\u00a0"+ - "\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u0565\n\u00a0\3\u00a1\3\u00a1\3\u00a1"+ - "\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1"+ - "\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1"+ - "\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\5\u00a1\u0581\n\u00a1\3\u00a2"+ - "\3\u00a2\5\u00a2\u0585\n\u00a2\3\u00a2\7\u00a2\u0588\n\u00a2\f\u00a2\16"+ - "\u00a2\u058b\13\u00a2\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a5\3\u00a5"+ - "\3\u00a6\3\u00a6\5\u00a6\u0595\n\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7"+ - "\5\u00a7\u059b\n\u00a7\3\u00a8\3\u00a8\3\u00a9\3\u00a9\3\u00aa\6\u00aa"+ - "\u05a2\n\u00aa\r\u00aa\16\u00aa\u05a3\3\u00aa\3\u00aa\3\u00ab\3\u00ab"+ - "\3\u00ab\3\u00ab\7\u00ab\u05ac\n\u00ab\f\u00ab\16\u00ab\u05af\13\u00ab"+ - "\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac"+ - "\7\u00ac\u05ba\n\u00ac\f\u00ac\16\u00ac\u05bd\13\u00ac\3\u00ac\3\u00ac"+ - "\3\u00ad\6\u00ad\u05c2\n\u00ad\r\u00ad\16\u00ad\u05c3\3\u00ad\3\u00ad"+ - "\3\u00ad\3\u00ad\3\u00ad\7\u00ad\u05cb\n\u00ad\f\u00ad\16\u00ad\u05ce"+ - "\13\u00ad\3\u00ad\3\u00ad\3\u00ad\5\u00ad\u05d3\n\u00ad\3\u00ad\3\u00ad"+ - "\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u0546\u05ad\u05cc\2\u00af\4"+ - "\3\6\4\b\5\n\6\f\7\16\b\20\t\22\n\24\13\26\f\30\r\32\16\34\17\36\20 \21"+ - "\"\22$\23&\24(\25*\26,\27.\30\60\31\62\32\64\33\66\348\35:\36<\37> @!"+ - "B\"D#F$H%J&L\'N(P)R*T+V,X-Z.\\/^\60`\61b\62d\63f\64h\65j\66l\67n8p9r:"+ - "t;v|?~@\u0080A\u0082B\u0084C\u0086D\u0088E\u008aF\u008cG\u008eH\u0090"+ - "I\u0092J\u0094K\u0096L\u0098M\u009aN\u009cO\u009eP\u00a0Q\u00a2R\u00a4"+ - "S\u00a6T\u00a8U\u00aaV\u00acW\u00aeX\u00b0Y\u00b2Z\u00b4[\u00b6\\\u00b8"+ - "]\u00ba^\u00bc_\u00be`\u00c0a\u00c2b\u00c4c\u00c6d\u00c8e\u00caf\u00cc"+ - "g\u00ceh\u00d0i\u00d2j\u00d4k\u00d6l\u00d8m\u00dan\u00dco\u00dep\u00e0"+ - "q\u00e2r\u00e4s\u00e6t\u00e8u\u00eav\u00ecw\u00eex\u00f0y\u00f2z\u00f4"+ - "{\u00f6|\u00f8}\u00fa~\u00fc\177\u00fe\u0080\u0100\u0081\u0102\u0082\u0104"+ - "\u0083\u0106\u0084\u0108\u0085\u010a\u0086\u010c\u0087\u010e\u0088\u0110"+ - "\u0089\u0112\u008a\u0114\u008b\u0116\u008c\u0118\u008d\u011a\u008e\u011c"+ - "\u008f\u011e\u0090\u0120\2\u0122\2\u0124\u0091\u0126\2\u0128\u0092\u012a"+ - "\u0093\u012c\u0094\u012e\u0095\u0130\u0096\u0132\u0097\u0134\u0098\u0136"+ - "\u0099\u0138\u009a\u013a\u009b\u013c\u009c\u013e\u009d\u0140\2\u0142\2"+ - "\u0144\2\u0146\2\u0148\2\u014a\2\u014c\2\u014e\2\u0150\2\u0152\2\u0154"+ - "\u009e\u0156\u009f\u0158\u00a0\u015a\u00a1\u015c\u00a2\4\2\3\23\3\2\63"+ - ";\3\2\62;\4\2DDdd\4\2QQqq\4\2ZZzz\4\2RRrr\4\2--//\3\2bb\4\2$$^^\4\2\13"+ - "\13\"\"\4\2\f\f\17\17\5\2\f\f\17\17))\13\2$$))^^cdhhppttvvxx\3\2\629\5"+ - "\2\62;CHch\3\2\62\63\4\2GGgg\49\2\62\2;\2\u0662\2\u066b\2\u06f2\2\u06fb"+ - "\2\u07c2\2\u07cb\2\u0968\2\u0971\2\u09e8\2\u09f1\2\u0a68\2\u0a71\2\u0ae8"+ - "\2\u0af1\2\u0b68\2\u0b71\2\u0be8\2\u0bf1\2\u0c68\2\u0c71\2\u0ce8\2\u0cf1"+ - "\2\u0d68\2\u0d71\2\u0de8\2\u0df1\2\u0e52\2\u0e5b\2\u0ed2\2\u0edb\2\u0f22"+ - "\2\u0f2b\2\u1042\2\u104b\2\u1092\2\u109b\2\u17e2\2\u17eb\2\u1812\2\u181b"+ - "\2\u1948\2\u1951\2\u19d2\2\u19db\2\u1a82\2\u1a8b\2\u1a92\2\u1a9b\2\u1b52"+ - "\2\u1b5b\2\u1bb2\2\u1bbb\2\u1c42\2\u1c4b\2\u1c52\2\u1c5b\2\ua622\2\ua62b"+ - "\2\ua8d2\2\ua8db\2\ua902\2\ua90b\2\ua9d2\2\ua9db\2\ua9f2\2\ua9fb\2\uaa52"+ - "\2\uaa5b\2\uabf2\2\uabfb\2\uff12\2\uff1b\2\u04a2\3\u04ab\3\u1068\3\u1071"+ - "\3\u10f2\3\u10fb\3\u1138\3\u1141\3\u11d2\3\u11db\3\u12f2\3\u12fb\3\u1452"+ - "\3\u145b\3\u14d2\3\u14db\3\u1652\3\u165b\3\u16c2\3\u16cb\3\u1732\3\u173b"+ - "\3\u18e2\3\u18eb\3\u1c52\3\u1c5b\3\u1d52\3\u1d5b\3\u6a62\3\u6a6b\3\u6b52"+ - "\3\u6b5b\3\ud7d0\3\ud801\3\ue952\3\ue95b\3\u024b\2C\2\\\2c\2|\2\u00ac"+ - "\2\u00ac\2\u00b7\2\u00b7\2\u00bc\2\u00bc\2\u00c2\2\u00d8\2\u00da\2\u00f8"+ - "\2\u00fa\2\u02c3\2\u02c8\2\u02d3\2\u02e2\2\u02e6\2\u02ee\2\u02ee\2\u02f0"+ - "\2\u02f0\2\u0372\2\u0376\2\u0378\2\u0379\2\u037c\2\u037f\2\u0381\2\u0381"+ - "\2\u0388\2\u0388\2\u038a\2\u038c\2\u038e\2\u038e\2\u0390\2\u03a3\2\u03a5"+ - "\2\u03f7\2\u03f9\2\u0483\2\u048c\2\u0531\2\u0533\2\u0558\2\u055b\2\u055b"+ - "\2\u0563\2\u0589\2\u05d2\2\u05ec\2\u05f2\2\u05f4\2\u0622\2\u064c\2\u0670"+ - "\2\u0671\2\u0673\2\u06d5\2\u06d7\2\u06d7\2\u06e7\2\u06e8\2\u06f0\2\u06f1"+ - "\2\u06fc\2\u06fe\2\u0701\2\u0701\2\u0712\2\u0712\2\u0714\2\u0731\2\u074f"+ - "\2\u07a7\2\u07b3\2\u07b3\2\u07cc\2\u07ec\2\u07f6\2\u07f7\2\u07fc\2\u07fc"+ - "\2\u0802\2\u0817\2\u081c\2\u081c\2\u0826\2\u0826\2\u082a\2\u082a\2\u0842"+ - "\2\u085a\2\u0862\2\u086c\2\u08a2\2\u08b6\2\u08b8\2\u08bf\2\u0906\2\u093b"+ - "\2\u093f\2\u093f\2\u0952\2\u0952\2\u095a\2\u0963\2\u0973\2\u0982\2\u0987"+ - "\2\u098e\2\u0991\2\u0992\2\u0995\2\u09aa\2\u09ac\2\u09b2\2\u09b4\2\u09b4"+ - "\2\u09b8\2\u09bb\2\u09bf\2\u09bf\2\u09d0\2\u09d0\2\u09de\2\u09df\2\u09e1"+ - "\2\u09e3\2\u09f2\2\u09f3\2\u09fe\2\u09fe\2\u0a07\2\u0a0c\2\u0a11\2\u0a12"+ - "\2\u0a15\2\u0a2a\2\u0a2c\2\u0a32\2\u0a34\2\u0a35\2\u0a37\2\u0a38\2\u0a3a"+ - "\2\u0a3b\2\u0a5b\2\u0a5e\2\u0a60\2\u0a60\2\u0a74\2\u0a76\2\u0a87\2\u0a8f"+ - "\2\u0a91\2\u0a93\2\u0a95\2\u0aaa\2\u0aac\2\u0ab2\2\u0ab4\2\u0ab5\2\u0ab7"+ - "\2\u0abb\2\u0abf\2\u0abf\2\u0ad2\2\u0ad2\2\u0ae2\2\u0ae3\2\u0afb\2\u0afb"+ - "\2\u0b07\2\u0b0e\2\u0b11\2\u0b12\2\u0b15\2\u0b2a\2\u0b2c\2\u0b32\2\u0b34"+ - "\2\u0b35\2\u0b37\2\u0b3b\2\u0b3f\2\u0b3f\2\u0b5e\2\u0b5f\2\u0b61\2\u0b63"+ - "\2\u0b73\2\u0b73\2\u0b85\2\u0b85\2\u0b87\2\u0b8c\2\u0b90\2\u0b92\2\u0b94"+ - "\2\u0b97\2\u0b9b\2\u0b9c\2\u0b9e\2\u0b9e\2\u0ba0\2\u0ba1\2\u0ba5\2\u0ba6"+ - "\2\u0baa\2\u0bac\2\u0bb0\2\u0bbb\2\u0bd2\2\u0bd2\2\u0c07\2\u0c0e\2\u0c10"+ - "\2\u0c12\2\u0c14\2\u0c2a\2\u0c2c\2\u0c3b\2\u0c3f\2\u0c3f\2\u0c5a\2\u0c5c"+ - "\2\u0c62\2\u0c63\2\u0c82\2\u0c82\2\u0c87\2\u0c8e\2\u0c90\2\u0c92\2\u0c94"+ - "\2\u0caa\2\u0cac\2\u0cb5\2\u0cb7\2\u0cbb\2\u0cbf\2\u0cbf\2\u0ce0\2\u0ce0"+ - "\2\u0ce2\2\u0ce3\2\u0cf3\2\u0cf4\2\u0d07\2\u0d0e\2\u0d10\2\u0d12\2\u0d14"+ - "\2\u0d3c\2\u0d3f\2\u0d3f\2\u0d50\2\u0d50\2\u0d56\2\u0d58\2\u0d61\2\u0d63"+ - "\2\u0d7c\2\u0d81\2\u0d87\2\u0d98\2\u0d9c\2\u0db3\2\u0db5\2\u0dbd\2\u0dbf"+ - "\2\u0dbf\2\u0dc2\2\u0dc8\2\u0e03\2\u0e32\2\u0e34\2\u0e35\2\u0e42\2\u0e48"+ - "\2\u0e83\2\u0e84\2\u0e86\2\u0e86\2\u0e89\2\u0e8a\2\u0e8c\2\u0e8c\2\u0e8f"+ - "\2\u0e8f\2\u0e96\2\u0e99\2\u0e9b\2\u0ea1\2\u0ea3\2\u0ea5\2\u0ea7\2\u0ea7"+ - "\2\u0ea9\2\u0ea9\2\u0eac\2\u0ead\2\u0eaf\2\u0eb2\2\u0eb4\2\u0eb5\2\u0ebf"+ - "\2\u0ebf\2\u0ec2\2\u0ec6\2\u0ec8\2\u0ec8\2\u0ede\2\u0ee1\2\u0f02\2\u0f02"+ - "\2\u0f42\2\u0f49\2\u0f4b\2\u0f6e\2\u0f8a\2\u0f8e\2\u1002\2\u102c\2\u1041"+ - "\2\u1041\2\u1052\2\u1057\2\u105c\2\u105f\2\u1063\2\u1063\2\u1067\2\u1068"+ - "\2\u1070\2\u1072\2\u1077\2\u1083\2\u1090\2\u1090\2\u10a2\2\u10c7\2\u10c9"+ - "\2\u10c9\2\u10cf\2\u10cf\2\u10d2\2\u10fc\2\u10fe\2\u124a\2\u124c\2\u124f"+ - "\2\u1252\2\u1258\2\u125a\2\u125a\2\u125c\2\u125f\2\u1262\2\u128a\2\u128c"+ - "\2\u128f\2\u1292\2\u12b2\2\u12b4\2\u12b7\2\u12ba\2\u12c0\2\u12c2\2\u12c2"+ - "\2\u12c4\2\u12c7\2\u12ca\2\u12d8\2\u12da\2\u1312\2\u1314\2\u1317\2\u131a"+ - "\2\u135c\2\u1382\2\u1391\2\u13a2\2\u13f7\2\u13fa\2\u13ff\2\u1403\2\u166e"+ - "\2\u1671\2\u1681\2\u1683\2\u169c\2\u16a2\2\u16ec\2\u16f3\2\u16fa\2\u1702"+ - "\2\u170e\2\u1710\2\u1713\2\u1722\2\u1733\2\u1742\2\u1753\2\u1762\2\u176e"+ - "\2\u1770\2\u1772\2\u1782\2\u17b5\2\u17d9\2\u17d9\2\u17de\2\u17de\2\u1822"+ - "\2\u1879\2\u1882\2\u1886\2\u1889\2\u18aa\2\u18ac\2\u18ac\2\u18b2\2\u18f7"+ - "\2\u1902\2\u1920\2\u1952\2\u196f\2\u1972\2\u1976\2\u1982\2\u19ad\2\u19b2"+ - "\2\u19cb\2\u1a02\2\u1a18\2\u1a22\2\u1a56\2\u1aa9\2\u1aa9\2\u1b07\2\u1b35"+ - "\2\u1b47\2\u1b4d\2\u1b85\2\u1ba2\2\u1bb0\2\u1bb1\2\u1bbc\2\u1be7\2\u1c02"+ - "\2\u1c25\2\u1c4f\2\u1c51\2\u1c5c\2\u1c7f\2\u1c82\2\u1c8a\2\u1ceb\2\u1cee"+ - "\2\u1cf0\2\u1cf3\2\u1cf7\2\u1cf8\2\u1d02\2\u1dc1\2\u1e02\2\u1f17\2\u1f1a"+ - "\2\u1f1f\2\u1f22\2\u1f47\2\u1f4a\2\u1f4f\2\u1f52\2\u1f59\2\u1f5b\2\u1f5b"+ - "\2\u1f5d\2\u1f5d\2\u1f5f\2\u1f5f\2\u1f61\2\u1f7f\2\u1f82\2\u1fb6\2\u1fb8"+ - "\2\u1fbe\2\u1fc0\2\u1fc0\2\u1fc4\2\u1fc6\2\u1fc8\2\u1fce\2\u1fd2\2\u1fd5"+ - "\2\u1fd8\2\u1fdd\2\u1fe2\2\u1fee\2\u1ff4\2\u1ff6\2\u1ff8\2\u1ffe\2\u2073"+ - "\2\u2073\2\u2081\2\u2081\2\u2092\2\u209e\2\u2104\2\u2104\2\u2109\2\u2109"+ - "\2\u210c\2\u2115\2\u2117\2\u2117\2\u211b\2\u211f\2\u2126\2\u2126\2\u2128"+ - "\2\u2128\2\u212a\2\u212a\2\u212c\2\u212f\2\u2131\2\u213b\2\u213e\2\u2141"+ - "\2\u2147\2\u214b\2\u2150\2\u2150\2\u2185\2\u2186\2\u2c02\2\u2c30\2\u2c32"+ - "\2\u2c60\2\u2c62\2\u2ce6\2\u2ced\2\u2cf0\2\u2cf4\2\u2cf5\2\u2d02\2\u2d27"+ - "\2\u2d29\2\u2d29\2\u2d2f\2\u2d2f\2\u2d32\2\u2d69\2\u2d71\2\u2d71\2\u2d82"+ - "\2\u2d98\2\u2da2\2\u2da8\2\u2daa\2\u2db0\2\u2db2\2\u2db8\2\u2dba\2\u2dc0"+ - "\2\u2dc2\2\u2dc8\2\u2dca\2\u2dd0\2\u2dd2\2\u2dd8\2\u2dda\2\u2de0\2\u2e31"+ - "\2\u2e31\2\u3007\2\u3008\2\u3033\2\u3037\2\u303d\2\u303e\2\u3043\2\u3098"+ - "\2\u309f\2\u30a1\2\u30a3\2\u30fc\2\u30fe\2\u3101\2\u3107\2\u3130\2\u3133"+ - "\2\u3190\2\u31a2\2\u31bc\2\u31f2\2\u3201\2\u3402\2\u4db7\2\u4e02\2\u9fec"+ - "\2\ua002\2\ua48e\2\ua4d2\2\ua4ff\2\ua502\2\ua60e\2\ua612\2\ua621\2\ua62c"+ - "\2\ua62d\2\ua642\2\ua670\2\ua681\2\ua69f\2\ua6a2\2\ua6e7\2\ua719\2\ua721"+ - "\2\ua724\2\ua78a\2\ua78d\2\ua7b0\2\ua7b2\2\ua7b9\2\ua7f9\2\ua803\2\ua805"+ - "\2\ua807\2\ua809\2\ua80c\2\ua80e\2\ua824\2\ua842\2\ua875\2\ua884\2\ua8b5"+ - "\2\ua8f4\2\ua8f9\2\ua8fd\2\ua8fd\2\ua8ff\2\ua8ff\2\ua90c\2\ua927\2\ua932"+ - "\2\ua948\2\ua962\2\ua97e\2\ua986\2\ua9b4\2\ua9d1\2\ua9d1\2\ua9e2\2\ua9e6"+ - "\2\ua9e8\2\ua9f1\2\ua9fc\2\uaa00\2\uaa02\2\uaa2a\2\uaa42\2\uaa44\2\uaa46"+ - "\2\uaa4d\2\uaa62\2\uaa78\2\uaa7c\2\uaa7c\2\uaa80\2\uaab1\2\uaab3\2\uaab3"+ - "\2\uaab7\2\uaab8\2\uaabb\2\uaabf\2\uaac2\2\uaac2\2\uaac4\2\uaac4\2\uaadd"+ - "\2\uaadf\2\uaae2\2\uaaec\2\uaaf4\2\uaaf6\2\uab03\2\uab08\2\uab0b\2\uab10"+ - "\2\uab13\2\uab18\2\uab22\2\uab28\2\uab2a\2\uab30\2\uab32\2\uab5c\2\uab5e"+ - "\2\uab67\2\uab72\2\uabe4\2\uac02\2\ud7a5\2\ud7b2\2\ud7c8\2\ud7cd\2\ud7fd"+ - "\2\uf902\2\ufa6f\2\ufa72\2\ufadb\2\ufb02\2\ufb08\2\ufb15\2\ufb19\2\ufb1f"+ - "\2\ufb1f\2\ufb21\2\ufb2a\2\ufb2c\2\ufb38\2\ufb3a\2\ufb3e\2\ufb40\2\ufb40"+ - "\2\ufb42\2\ufb43\2\ufb45\2\ufb46\2\ufb48\2\ufbb3\2\ufbd5\2\ufd3f\2\ufd52"+ - "\2\ufd91\2\ufd94\2\ufdc9\2\ufdf2\2\ufdfd\2\ufe72\2\ufe76\2\ufe78\2\ufefe"+ - "\2\uff23\2\uff3c\2\uff43\2\uff5c\2\uff68\2\uffc0\2\uffc4\2\uffc9\2\uffcc"+ - "\2\uffd1\2\uffd4\2\uffd9\2\uffdc\2\uffde\2\2\3\r\3\17\3(\3*\3<\3>\3?\3"+ - "A\3O\3R\3_\3\u0082\3\u00fc\3\u0282\3\u029e\3\u02a2\3\u02d2\3\u0302\3\u0321"+ - "\3\u032f\3\u0342\3\u0344\3\u034b\3\u0352\3\u0377\3\u0382\3\u039f\3\u03a2"+ - "\3\u03c5\3\u03ca\3\u03d1\3\u0402\3\u049f\3\u04b2\3\u04d5\3\u04da\3\u04fd"+ - "\3\u0502\3\u0529\3\u0532\3\u0565\3\u0602\3\u0738\3\u0742\3\u0757\3\u0762"+ - "\3\u0769\3\u0802\3\u0807\3\u080a\3\u080a\3\u080c\3\u0837\3\u0839\3\u083a"+ - "\3\u083e\3\u083e\3\u0841\3\u0857\3\u0862\3\u0878\3\u0882\3\u08a0\3\u08e2"+ - "\3\u08f4\3\u08f6\3\u08f7\3\u0902\3\u0917\3\u0922\3\u093b\3\u0982\3\u09b9"+ - "\3\u09c0\3\u09c1\3\u0a02\3\u0a02\3\u0a12\3\u0a15\3\u0a17\3\u0a19\3\u0a1b"+ - "\3\u0a35\3\u0a62\3\u0a7e\3\u0a82\3\u0a9e\3\u0ac2\3\u0ac9\3\u0acb\3\u0ae6"+ - "\3\u0b02\3\u0b37\3\u0b42\3\u0b57\3\u0b62\3\u0b74\3\u0b82\3\u0b93\3\u0c02"+ - "\3\u0c4a\3\u0c82\3\u0cb4\3\u0cc2\3\u0cf4\3\u1005\3\u1039\3\u1085\3\u10b1"+ - "\3\u10d2\3\u10ea\3\u1105\3\u1128\3\u1152\3\u1174\3\u1178\3\u1178\3\u1185"+ - "\3\u11b4\3\u11c3\3\u11c6\3\u11dc\3\u11dc\3\u11de\3\u11de\3\u1202\3\u1213"+ - "\3\u1215\3\u122d\3\u1282\3\u1288\3\u128a\3\u128a\3\u128c\3\u128f\3\u1291"+ - "\3\u129f\3\u12a1\3\u12aa\3\u12b2\3\u12e0\3\u1307\3\u130e\3\u1311\3\u1312"+ - "\3\u1315\3\u132a\3\u132c\3\u1332\3\u1334\3\u1335\3\u1337\3\u133b\3\u133f"+ - "\3\u133f\3\u1352\3\u1352\3\u135f\3\u1363\3\u1402\3\u1436\3\u1449\3\u144c"+ - "\3\u1482\3\u14b1\3\u14c6\3\u14c7\3\u14c9\3\u14c9\3\u1582\3\u15b0\3\u15da"+ - "\3\u15dd\3\u1602\3\u1631\3\u1646\3\u1646\3\u1682\3\u16ac\3\u1702\3\u171b"+ - "\3\u18a2\3\u18e1\3\u1901\3\u1901\3\u1a02\3\u1a02\3\u1a0d\3\u1a34\3\u1a3c"+ - "\3\u1a3c\3\u1a52\3\u1a52\3\u1a5e\3\u1a85\3\u1a88\3\u1a8b\3\u1ac2\3\u1afa"+ - "\3\u1c02\3\u1c0a\3\u1c0c\3\u1c30\3\u1c42\3\u1c42\3\u1c74\3\u1c91\3\u1d02"+ - "\3\u1d08\3\u1d0a\3\u1d0b\3\u1d0d\3\u1d32\3\u1d48\3\u1d48\3\u2002\3\u239b"+ - "\3\u2482\3\u2545\3\u3002\3\u3430\3\u4402\3\u4648\3\u6802\3\u6a3a\3\u6a42"+ - "\3\u6a60\3\u6ad2\3\u6aef\3\u6b02\3\u6b31\3\u6b42\3\u6b45\3\u6b65\3\u6b79"+ - "\3\u6b7f\3\u6b91\3\u6f02\3\u6f46\3\u6f52\3\u6f52\3\u6f95\3\u6fa1\3\u6fe2"+ - "\3\u6fe3\3\u7002\3\u87ee\3\u8802\3\u8af4\3\ub002\3\ub120\3\ub172\3\ub2fd"+ - "\3\ubc02\3\ubc6c\3\ubc72\3\ubc7e\3\ubc82\3\ubc8a\3\ubc92\3\ubc9b\3\ud402"+ - "\3\ud456\3\ud458\3\ud49e\3\ud4a0\3\ud4a1\3\ud4a4\3\ud4a4\3\ud4a7\3\ud4a8"+ - "\3\ud4ab\3\ud4ae\3\ud4b0\3\ud4bb\3\ud4bd\3\ud4bd\3\ud4bf\3\ud4c5\3\ud4c7"+ - "\3\ud507\3\ud509\3\ud50c\3\ud50f\3\ud516\3\ud518\3\ud51e\3\ud520\3\ud53b"+ - "\3\ud53d\3\ud540\3\ud542\3\ud546\3\ud548\3\ud548\3\ud54c\3\ud552\3\ud554"+ - "\3\ud6a7\3\ud6aa\3\ud6c2\3\ud6c4\3\ud6dc\3\ud6de\3\ud6fc\3\ud6fe\3\ud716"+ - "\3\ud718\3\ud736\3\ud738\3\ud750\3\ud752\3\ud770\3\ud772\3\ud78a\3\ud78c"+ - "\3\ud7aa\3\ud7ac\3\ud7c4\3\ud7c6\3\ud7cd\3\ue802\3\ue8c6\3\ue902\3\ue945"+ - "\3\uee02\3\uee05\3\uee07\3\uee21\3\uee23\3\uee24\3\uee26\3\uee26\3\uee29"+ - "\3\uee29\3\uee2b\3\uee34\3\uee36\3\uee39\3\uee3b\3\uee3b\3\uee3d\3\uee3d"+ - "\3\uee44\3\uee44\3\uee49\3\uee49\3\uee4b\3\uee4b\3\uee4d\3\uee4d\3\uee4f"+ - "\3\uee51\3\uee53\3\uee54\3\uee56\3\uee56\3\uee59\3\uee59\3\uee5b\3\uee5b"+ - "\3\uee5d\3\uee5d\3\uee5f\3\uee5f\3\uee61\3\uee61\3\uee63\3\uee64\3\uee66"+ - "\3\uee66\3\uee69\3\uee6c\3\uee6e\3\uee74\3\uee76\3\uee79\3\uee7b\3\uee7e"+ - "\3\uee80\3\uee80\3\uee82\3\uee8b\3\uee8d\3\uee9d\3\ueea3\3\ueea5\3\ueea7"+ - "\3\ueeab\3\ueead\3\ueebd\3\2\4\ua6d8\4\ua702\4\ub736\4\ub742\4\ub81f\4"+ - "\ub822\4\ucea3\4\uceb2\4\uebe2\4\uf802\4\ufa1f\4\u0606\2\4\3\2\2\2\2\6"+ - "\3\2\2\2\2\b\3\2\2\2\2\n\3\2\2\2\2\f\3\2\2\2\2\16\3\2\2\2\2\20\3\2\2\2"+ - "\2\22\3\2\2\2\2\24\3\2\2\2\2\26\3\2\2\2\2\30\3\2\2\2\2\32\3\2\2\2\2\34"+ - "\3\2\2\2\2\36\3\2\2\2\2 \3\2\2\2\2\"\3\2\2\2\2$\3\2\2\2\2&\3\2\2\2\2("+ - "\3\2\2\2\2*\3\2\2\2\2,\3\2\2\2\2.\3\2\2\2\2\60\3\2\2\2\2\62\3\2\2\2\2"+ - "\64\3\2\2\2\2\66\3\2\2\2\28\3\2\2\2\2:\3\2\2\2\2<\3\2\2\2\2>\3\2\2\2\2"+ - "@\3\2\2\2\2B\3\2\2\2\2D\3\2\2\2\2F\3\2\2\2\2H\3\2\2\2\2J\3\2\2\2\2L\3"+ - "\2\2\2\2N\3\2\2\2\2P\3\2\2\2\2R\3\2\2\2\2T\3\2\2\2\2V\3\2\2\2\2X\3\2\2"+ - "\2\2Z\3\2\2\2\2\\\3\2\2\2\2^\3\2\2\2\2`\3\2\2\2\2b\3\2\2\2\2d\3\2\2\2"+ - "\2f\3\2\2\2\2h\3\2\2\2\2j\3\2\2\2\2l\3\2\2\2\2n\3\2\2\2\2p\3\2\2\2\2r"+ - "\3\2\2\2\2t\3\2\2\2\2v\3\2\2\2\2x\3\2\2\2\2z\3\2\2\2\2|\3\2\2\2\2~\3\2"+ - "\2\2\2\u0080\3\2\2\2\2\u0082\3\2\2\2\2\u0084\3\2\2\2\2\u0086\3\2\2\2\2"+ - "\u0088\3\2\2\2\2\u008a\3\2\2\2\2\u008c\3\2\2\2\2\u008e\3\2\2\2\2\u0090"+ - "\3\2\2\2\2\u0092\3\2\2\2\2\u0094\3\2\2\2\2\u0096\3\2\2\2\2\u0098\3\2\2"+ - "\2\2\u009a\3\2\2\2\2\u009c\3\2\2\2\2\u009e\3\2\2\2\2\u00a0\3\2\2\2\2\u00a2"+ - "\3\2\2\2\2\u00a4\3\2\2\2\2\u00a6\3\2\2\2\2\u00a8\3\2\2\2\2\u00aa\3\2\2"+ - "\2\2\u00ac\3\2\2\2\2\u00ae\3\2\2\2\2\u00b0\3\2\2\2\2\u00b2\3\2\2\2\2\u00b4"+ - "\3\2\2\2\2\u00b6\3\2\2\2\2\u00b8\3\2\2\2\2\u00ba\3\2\2\2\2\u00bc\3\2\2"+ - "\2\2\u00be\3\2\2\2\2\u00c0\3\2\2\2\2\u00c2\3\2\2\2\2\u00c4\3\2\2\2\2\u00c6"+ - "\3\2\2\2\2\u00c8\3\2\2\2\2\u00ca\3\2\2\2\2\u00cc\3\2\2\2\2\u00ce\3\2\2"+ - "\2\2\u00d0\3\2\2\2\2\u00d2\3\2\2\2\2\u00d4\3\2\2\2\2\u00d6\3\2\2\2\2\u00d8"+ - "\3\2\2\2\2\u00da\3\2\2\2\2\u00dc\3\2\2\2\2\u00de\3\2\2\2\2\u00e0\3\2\2"+ - "\2\2\u00e2\3\2\2\2\2\u00e4\3\2\2\2\2\u00e6\3\2\2\2\2\u00e8\3\2\2\2\2\u00ea"+ - "\3\2\2\2\2\u00ec\3\2\2\2\2\u00ee\3\2\2\2\2\u00f0\3\2\2\2\2\u00f2\3\2\2"+ - "\2\2\u00f4\3\2\2\2\2\u00f6\3\2\2\2\2\u00f8\3\2\2\2\2\u00fa\3\2\2\2\2\u00fc"+ - "\3\2\2\2\2\u00fe\3\2\2\2\2\u0100\3\2\2\2\2\u0102\3\2\2\2\2\u0104\3\2\2"+ - "\2\2\u0106\3\2\2\2\2\u0108\3\2\2\2\2\u010a\3\2\2\2\2\u010c\3\2\2\2\2\u010e"+ - "\3\2\2\2\2\u0110\3\2\2\2\2\u0112\3\2\2\2\2\u0114\3\2\2\2\2\u0116\3\2\2"+ - "\2\2\u0118\3\2\2\2\2\u011a\3\2\2\2\2\u011c\3\2\2\2\2\u011e\3\2\2\2\2\u0124"+ - "\3\2\2\2\2\u0128\3\2\2\2\2\u012a\3\2\2\2\2\u012c\3\2\2\2\2\u012e\3\2\2"+ - "\2\2\u0130\3\2\2\2\2\u0132\3\2\2\2\2\u0134\3\2\2\2\2\u0136\3\2\2\2\2\u0138"+ - "\3\2\2\2\2\u013a\3\2\2\2\2\u013c\3\2\2\2\2\u013e\3\2\2\2\3\u0154\3\2\2"+ - "\2\3\u0156\3\2\2\2\3\u0158\3\2\2\2\3\u015a\3\2\2\2\3\u015c\3\2\2\2\4\u0160"+ - "\3\2\2\2\6\u0176\3\2\2\2\b\u0178\3\2\2\2\n\u017f\3\2\2\2\f\u0187\3\2\2"+ - "\2\16\u018e\3\2\2\2\20\u0195\3\2\2\2\22\u019c\3\2\2\2\24\u01a3\3\2\2\2"+ - "\26\u01ac\3\2\2\2\30\u01b6\3\2\2\2\32\u01be\3\2\2\2\34\u01c8\3\2\2\2\36"+ - "\u01d4\3\2\2\2 \u01db\3\2\2\2\"\u01e6\3\2\2\2$\u01e9\3\2\2\2&\u01ef\3"+ - "\2\2\2(\u01f8\3\2\2\2*\u01fd\3\2\2\2,\u0204\3\2\2\2.\u020b\3\2\2\2\60"+ - "\u0211\3\2\2\2\62\u0216\3\2\2\2\64\u021d\3\2\2\2\66\u0227\3\2\2\28\u022b"+ - "\3\2\2\2:\u0231\3\2\2\2<\u0234\3\2\2\2>\u0236\3\2\2\2@\u023d\3\2\2\2B"+ - "\u0243\3\2\2\2D\u0250\3\2\2\2F\u0259\3\2\2\2H\u025d\3\2\2\2J\u0261\3\2"+ - "\2\2L\u0267\3\2\2\2N\u0269\3\2\2\2P\u026c\3\2\2\2R\u0271\3\2\2\2T\u0277"+ - "\3\2\2\2V\u027d\3\2\2\2X\u0284\3\2\2\2Z\u028b\3\2\2\2\\\u0294\3\2\2\2"+ - "^\u029a\3\2\2\2`\u02a0\3\2\2\2b\u02a7\3\2\2\2d\u02ad\3\2\2\2f\u02b4\3"+ - "\2\2\2h\u02ba\3\2\2\2j\u02c3\3\2\2\2l\u02cb\3\2\2\2n\u02d1\3\2\2\2p\u02d9"+ - "\3\2\2\2r\u02e0\3\2\2\2t\u02e5\3\2\2\2v\u02ee\3\2\2\2x\u02fd\3\2\2\2z"+ - "\u0303\3\2\2\2|\u0307\3\2\2\2~\u030a\3\2\2\2\u0080\u0311\3\2\2\2\u0082"+ - "\u031b\3\2\2\2\u0084\u0325\3\2\2\2\u0086\u0331\3\2\2\2\u0088\u033a\3\2"+ - "\2\2\u008a\u0344\3\2\2\2\u008c\u034c\3\2\2\2\u008e\u0358\3\2\2\2\u0090"+ - "\u0367\3\2\2\2\u0092\u036d\3\2\2\2\u0094\u0371\3\2\2\2\u0096\u0375\3\2"+ - "\2\2\u0098\u037a\3\2\2\2\u009a\u0382\3\2\2\2\u009c\u038a\3\2\2\2\u009e"+ - "\u038f\3\2\2\2\u00a0\u0399\3\2\2\2\u00a2\u03a0\3\2\2\2\u00a4\u03a5\3\2"+ - "\2\2\u00a6\u03ab\3\2\2\2\u00a8\u03ae\3\2\2\2\u00aa\u03b2\3\2\2\2\u00ac"+ - "\u03b9\3\2\2\2\u00ae\u03be\3\2\2\2\u00b0\u03c3\3\2\2\2\u00b2\u03c8\3\2"+ - "\2\2\u00b4\u03d0\3\2\2\2\u00b6\u03d7\3\2\2\2\u00b8\u03dd\3\2\2\2\u00ba"+ - "\u03eb\3\2\2\2\u00bc\u03ee\3\2\2\2\u00be\u03f4\3\2\2\2\u00c0\u03f9\3\2"+ - "\2\2\u00c2\u0404\3\2\2\2\u00c4\u0408\3\2\2\2\u00c6\u040f\3\2\2\2\u00c8"+ - "\u0418\3\2\2\2\u00ca\u041c\3\2\2\2\u00cc\u0422\3\2\2\2\u00ce\u042c\3\2"+ - "\2\2\u00d0\u042e\3\2\2\2\u00d2\u0432\3\2\2\2\u00d4\u0434\3\2\2\2\u00d6"+ - "\u0438\3\2\2\2\u00d8\u043a\3\2\2\2\u00da\u043e\3\2\2\2\u00dc\u0440\3\2"+ - "\2\2\u00de\u0442\3\2\2\2\u00e0\u0444\3\2\2\2\u00e2\u0446\3\2\2\2\u00e4"+ - "\u0448\3\2\2\2\u00e6\u044d\3\2\2\2\u00e8\u0452\3\2\2\2\u00ea\u0455\3\2"+ - "\2\2\u00ec\u0459\3\2\2\2\u00ee\u045c\3\2\2\2\u00f0\u045f\3\2\2\2\u00f2"+ - "\u0462\3\2\2\2\u00f4\u0465\3\2\2\2\u00f6\u0467\3\2\2\2\u00f8\u046a\3\2"+ - "\2\2\u00fa\u046c\3\2\2\2\u00fc\u046f\3\2\2\2\u00fe\u0471\3\2\2\2\u0100"+ - "\u0473\3\2\2\2\u0102\u0475\3\2\2\2\u0104\u0478\3\2\2\2\u0106\u047b\3\2"+ - "\2\2\u0108\u047e\3\2\2\2\u010a\u0480\3\2\2\2\u010c\u0482\3\2\2\2\u010e"+ - "\u0484\3\2\2\2\u0110\u0486\3\2\2\2\u0112\u0488\3\2\2\2\u0114\u048a\3\2"+ - "\2\2\u0116\u0498\3\2\2\2\u0118\u049c\3\2\2\2\u011a\u04a8\3\2\2\2\u011c"+ - "\u04b6\3\2\2\2\u011e\u04c2\3\2\2\2\u0120\u04e6\3\2\2\2\u0122\u04e8\3\2"+ - "\2\2\u0124\u04f1\3\2\2\2\u0126\u04f7\3\2\2\2\u0128\u04fe\3\2\2\2\u012a"+ - "\u0504\3\2\2\2\u012c\u0506\3\2\2\2\u012e\u050b\3\2\2\2\u0130\u0510\3\2"+ - "\2\2\u0132\u0517\3\2\2\2\u0134\u0522\3\2\2\2\u0136\u052d\3\2\2\2\u0138"+ - "\u053a\3\2\2\2\u013a\u0540\3\2\2\2\u013c\u054f\3\2\2\2\u013e\u0555\3\2"+ - "\2\2\u0140\u0564\3\2\2\2\u0142\u0566\3\2\2\2\u0144\u0582\3\2\2\2\u0146"+ - "\u058c\3\2\2\2\u0148\u058e\3\2\2\2\u014a\u0590\3\2\2\2\u014c\u0592\3\2"+ - "\2\2\u014e\u059a\3\2\2\2\u0150\u059c\3\2\2\2\u0152\u059e\3\2\2\2\u0154"+ - "\u05a1\3\2\2\2\u0156\u05a7\3\2\2\2\u0158\u05b5\3\2\2\2\u015a\u05d2\3\2"+ - "\2\2\u015c\u05d6\3\2\2\2\u015e\u0161\5\6\3\2\u015f\u0161\5\u011e\u008f"+ - "\2\u0160\u015e\3\2\2\2\u0160\u015f\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163"+ - "\b\2\2\2\u0163\5\3\2\2\2\u0164\u016e\5\u0144\u00a2\2\u0165\u0166\7\60"+ - "\2\2\u0166\u0168\6\3\2\2\u0167\u0169\5\u0144\u00a2\2\u0168\u0167\3\2\2"+ - "\2\u0168\u0169\3\2\2\2\u0169\u016b\3\2\2\2\u016a\u016c\5\u014c\u00a6\2"+ - "\u016b\u016a\3\2\2\2\u016b\u016c\3\2\2\2\u016c\u016f\3\2\2\2\u016d\u016f"+ - "\5\u014c\u00a6\2\u016e\u0165\3\2\2\2\u016e\u016d\3\2\2\2\u016f\u0177\3"+ - "\2\2\2\u0170\u0171\7\60\2\2\u0171\u0172\6\3\3\2\u0172\u0174\5\u0144\u00a2"+ - "\2\u0173\u0175\5\u014c\u00a6\2\u0174\u0173\3\2\2\2\u0174\u0175\3\2\2\2"+ - "\u0175\u0177\3\2\2\2\u0176\u0164\3\2\2\2\u0176\u0170\3\2\2\2\u0177\7\3"+ - "\2\2\2\u0178\u0179\7v\2\2\u0179\u017a\7t\2\2\u017a\u017b\7w\2\2\u017b"+ - "\u017c\7g\2\2\u017c\u017d\3\2\2\2\u017d\u017e\b\4\2\2\u017e\t\3\2\2\2"+ - "\u017f\u0180\7h\2\2\u0180\u0181\7c\2\2\u0181\u0182\7n\2\2\u0182\u0183"+ - "\7u\2\2\u0183\u0184\7g\2\2\u0184\u0185\3\2\2\2\u0185\u0186\b\5\2\2\u0186"+ - "\13\3\2\2\2\u0187\u0188\7c\2\2\u0188\u0189\7u\2\2\u0189\u018a\7u\2\2\u018a"+ - "\u018b\7g\2\2\u018b\u018c\7t\2\2\u018c\u018d\7v\2\2\u018d\r\3\2\2\2\u018e"+ - "\u018f\7c\2\2\u018f\u0190\7u\2\2\u0190\u0191\7u\2\2\u0191\u0192\7w\2\2"+ - "\u0192\u0193\7o\2\2\u0193\u0194\7g\2\2\u0194\17\3\2\2\2\u0195\u0196\7"+ - "k\2\2\u0196\u0197\7p\2\2\u0197\u0198\7j\2\2\u0198\u0199\7c\2\2\u0199\u019a"+ - "\7n\2\2\u019a\u019b\7g\2\2\u019b\21\3\2\2\2\u019c\u019d\7g\2\2\u019d\u019e"+ - "\7z\2\2\u019e\u019f\7j\2\2\u019f\u01a0\7c\2\2\u01a0\u01a1\7n\2\2\u01a1"+ - "\u01a2\7g\2\2\u01a2\23\3\2\2\2\u01a3\u01a4\7t\2\2\u01a4\u01a5\7g\2\2\u01a5"+ - "\u01a6\7s\2\2\u01a6\u01a7\7w\2\2\u01a7\u01a8\7k\2\2\u01a8\u01a9\7t\2\2"+ - "\u01a9\u01aa\7g\2\2\u01aa\u01ab\7u\2\2\u01ab\25\3\2\2\2\u01ac\u01ad\7"+ - "r\2\2\u01ad\u01ae\7t\2\2\u01ae\u01af\7g\2\2\u01af\u01b0\7u\2\2\u01b0\u01b1"+ - "\7g\2\2\u01b1\u01b2\7t\2\2\u01b2\u01b3\7x\2\2\u01b3\u01b4\7g\2\2\u01b4"+ - "\u01b5\7u\2\2\u01b5\27\3\2\2\2\u01b6\u01b7\7g\2\2\u01b7\u01b8\7p\2\2\u01b8"+ - "\u01b9\7u\2\2\u01b9\u01ba\7w\2\2\u01ba\u01bb\7t\2\2\u01bb\u01bc\7g\2\2"+ - "\u01bc\u01bd\7u\2\2\u01bd\31\3\2\2\2\u01be\u01bf\7k\2\2\u01bf\u01c0\7"+ - "p\2\2\u01c0\u01c1\7x\2\2\u01c1\u01c2\7c\2\2\u01c2\u01c3\7t\2\2\u01c3\u01c4"+ - "\7k\2\2\u01c4\u01c5\7c\2\2\u01c5\u01c6\7p\2\2\u01c6\u01c7\7v\2\2\u01c7"+ - "\33\3\2\2\2\u01c8\u01c9\7f\2\2\u01c9\u01ca\7g\2\2\u01ca\u01cb\7e\2\2\u01cb"+ - "\u01cc\7t\2\2\u01cc\u01cd\7g\2\2\u01cd\u01ce\7c\2\2\u01ce\u01cf\7u\2\2"+ - "\u01cf\u01d0\7g\2\2\u01d0\u01d1\7u\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d3"+ - "\b\16\2\2\u01d3\35\3\2\2\2\u01d4\u01d5\7r\2\2\u01d5\u01d6\7w\2\2\u01d6"+ - "\u01d7\7t\2\2\u01d7\u01d8\7g\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01da\b\17"+ - "\2\2\u01da\37\3\2\2\2\u01db\u01dc\7k\2\2\u01dc\u01dd\7o\2\2\u01dd\u01de"+ - "\7r\2\2\u01de\u01df\7n\2\2\u01df\u01e0\7g\2\2\u01e0\u01e1\7o\2\2\u01e1"+ - "\u01e2\7g\2\2\u01e2\u01e3\7p\2\2\u01e3\u01e4\7v\2\2\u01e4\u01e5\7u\2\2"+ - "\u01e5!\3\2\2\2\u01e6\u01e7\7c\2\2\u01e7\u01e8\7u\2\2\u01e8#\3\2\2\2\u01e9"+ - "\u01ea\7q\2\2\u01ea\u01eb\7n\2\2\u01eb\u01ec\7f\2\2\u01ec\u01ed\3\2\2"+ - "\2\u01ed\u01ee\b\22\2\2\u01ee%\3\2\2\2\u01ef\u01f0\7d\2\2\u01f0\u01f1"+ - "\7g\2\2\u01f1\u01f2\7h\2\2\u01f2\u01f3\7q\2\2\u01f3\u01f4\7t\2\2\u01f4"+ - "\u01f5\7g\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f7\b\23\2\2\u01f7\'\3\2\2\2"+ - "\u01f8\u01f9\7%\2\2\u01f9\u01fa\7n\2\2\u01fa\u01fb\7j\2\2\u01fb\u01fc"+ - "\7u\2\2\u01fc)\3\2\2\2\u01fd\u01fe\7h\2\2\u01fe\u01ff\7q\2\2\u01ff\u0200"+ - "\7t\2\2\u0200\u0201\7c\2\2\u0201\u0202\7n\2\2\u0202\u0203\7n\2\2\u0203"+ - "+\3\2\2\2\u0204\u0205\7g\2\2\u0205\u0206\7z\2\2\u0206\u0207\7k\2\2\u0207"+ - "\u0208\7u\2\2\u0208\u0209\7v\2\2\u0209\u020a\7u\2\2\u020a-\3\2\2\2\u020b"+ - "\u020c\7c\2\2\u020c\u020d\7e\2\2\u020d\u020e\7e\2\2\u020e\u020f\3\2\2"+ - "\2\u020f\u0210\b\27\2\2\u0210/\3\2\2\2\u0211\u0212\7h\2\2\u0212\u0213"+ - "\7q\2\2\u0213\u0214\7n\2\2\u0214\u0215\7f\2\2\u0215\61\3\2\2\2\u0216\u0217"+ - "\7w\2\2\u0217\u0218\7p\2\2\u0218\u0219\7h\2\2\u0219\u021a\7q\2\2\u021a"+ - "\u021b\7n\2\2\u021b\u021c\7f\2\2\u021c\63\3\2\2\2\u021d\u021e\7w\2\2\u021e"+ - "\u021f\7p\2\2\u021f\u0220\7h\2\2\u0220\u0221\7q\2\2\u0221\u0222\7n\2\2"+ - "\u0222\u0223\7f\2\2\u0223\u0224\7k\2\2\u0224\u0225\7p\2\2\u0225\u0226"+ - "\7i\2\2\u0226\65\3\2\2\2\u0227\u0228\7n\2\2\u0228\u0229\7g\2\2\u0229\u022a"+ - "\7v\2\2\u022a\67\3\2\2\2\u022b\u022c\7i\2\2\u022c\u022d\7j\2\2\u022d\u022e"+ - "\7q\2\2\u022e\u022f\7u\2\2\u022f\u0230\7v\2\2\u02309\3\2\2\2\u0231\u0232"+ - "\7k\2\2\u0232\u0233\7p\2\2\u0233;\3\2\2\2\u0234\u0235\7%\2\2\u0235=\3"+ - "\2\2\2\u0236\u0237\7u\2\2\u0237\u0238\7w\2\2\u0238\u0239\7d\2\2\u0239"+ - "\u023a\7u\2\2\u023a\u023b\7g\2\2\u023b\u023c\7v\2\2\u023c?\3\2\2\2\u023d"+ - "\u023e\7w\2\2\u023e\u023f\7p\2\2\u023f\u0240\7k\2\2\u0240\u0241\7q\2\2"+ - "\u0241\u0242\7p\2\2\u0242A\3\2\2\2\u0243\u0244\7k\2\2\u0244\u0245\7p\2"+ - "\2\u0245\u0246\7v\2\2\u0246\u0247\7g\2\2\u0247\u0248\7t\2\2\u0248\u0249"+ - "\7u\2\2\u0249\u024a\7g\2\2\u024a\u024b\7e\2\2\u024b\u024c\7v\2\2\u024c"+ - "\u024d\7k\2\2\u024d\u024e\7q\2\2\u024e\u024f\7p\2\2\u024fC\3\2\2\2\u0250"+ - "\u0251\7u\2\2\u0251\u0252\7g\2\2\u0252\u0253\7v\2\2\u0253\u0254\7o\2\2"+ - "\u0254\u0255\7k\2\2\u0255\u0256\7p\2\2\u0256\u0257\7w\2\2\u0257\u0258"+ - "\7u\2\2\u0258E\3\2\2\2\u0259\u025a\7?\2\2\u025a\u025b\7?\2\2\u025b\u025c"+ - "\7@\2\2\u025cG\3\2\2\2\u025d\u025e\7/\2\2\u025e\u025f\7/\2\2\u025f\u0260"+ - "\7,\2\2\u0260I\3\2\2\2\u0261\u0262\7c\2\2\u0262\u0263\7r\2\2\u0263\u0264"+ - "\7r\2\2\u0264\u0265\7n\2\2\u0265\u0266\7{\2\2\u0266K\3\2\2\2\u0267\u0268"+ - "\7A\2\2\u0268M\3\2\2\2\u0269\u026a\7#\2\2\u026a\u026b\7>\2\2\u026bO\3"+ - "\2\2\2\u026c\u026d\7#\2\2\u026d\u026e\7@\2\2\u026e\u026f\3\2\2\2\u026f"+ - "\u0270\b(\2\2\u0270Q\3\2\2\2\u0271\u0272\7u\2\2\u0272\u0273\7g\2\2\u0273"+ - "\u0274\7s\2\2\u0274\u0275\3\2\2\2\u0275\u0276\b)\2\2\u0276S\3\2\2\2\u0277"+ - "\u0278\7u\2\2\u0278\u0279\7g\2\2\u0279\u027a\7v\2\2\u027a\u027b\3\2\2"+ - "\2\u027b\u027c\b*\2\2\u027cU\3\2\2\2\u027d\u027e\7o\2\2\u027e\u027f\7"+ - "u\2\2\u027f\u0280\7g\2\2\u0280\u0281\7v\2\2\u0281\u0282\3\2\2\2\u0282"+ - "\u0283\b+\2\2\u0283W\3\2\2\2\u0284\u0285\7f\2\2\u0285\u0286\7k\2\2\u0286"+ - "\u0287\7e\2\2\u0287\u0288\7v\2\2\u0288\u0289\3\2\2\2\u0289\u028a\b,\2"+ - "\2\u028aY\3\2\2\2\u028b\u028c\7q\2\2\u028c\u028d\7r\2\2\u028d\u028e\7"+ - "v\2\2\u028e\u028f\7k\2\2\u028f\u0290\7q\2\2\u0290\u0291\7p\2\2\u0291\u0292"+ - "\3\2\2\2\u0292\u0293\b-\2\2\u0293[\3\2\2\2\u0294\u0295\7n\2\2\u0295\u0296"+ - "\7g\2\2\u0296\u0297\7p\2\2\u0297\u0298\3\2\2\2\u0298\u0299\b.\2\2\u0299"+ - "]\3\2\2\2\u029a\u029b\7p\2\2\u029b\u029c\7g\2\2\u029c\u029d\7y\2\2\u029d"+ - "\u029e\3\2\2\2\u029e\u029f\b/\2\2\u029f_\3\2\2\2\u02a0\u02a1\7o\2\2\u02a1"+ - "\u02a2\7c\2\2\u02a2\u02a3\7m\2\2\u02a3\u02a4\7g\2\2\u02a4\u02a5\3\2\2"+ - "\2\u02a5\u02a6\b\60\2\2\u02a6a\3\2\2\2\u02a7\u02a8\7e\2\2\u02a8\u02a9"+ - "\7c\2\2\u02a9\u02aa\7r\2\2\u02aa\u02ab\3\2\2\2\u02ab\u02ac\b\61\2\2\u02ac"+ - "c\3\2\2\2\u02ad\u02ae\7u\2\2\u02ae\u02af\7q\2\2\u02af\u02b0\7o\2\2\u02b0"+ - "\u02b1\7g\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b3\b\62\2\2\u02b3e\3\2\2\2"+ - "\u02b4\u02b5\7i\2\2\u02b5\u02b6\7g\2\2\u02b6\u02b7\7v\2\2\u02b7\u02b8"+ - "\3\2\2\2\u02b8\u02b9\b\63\2\2\u02b9g\3\2\2\2\u02ba\u02bb\7f\2\2\u02bb"+ - "\u02bc\7q\2\2\u02bc\u02bd\7o\2\2\u02bd\u02be\7c\2\2\u02be\u02bf\7k\2\2"+ - "\u02bf\u02c0\7p\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c2\b\64\2\2\u02c2i\3"+ - "\2\2\2\u02c3\u02c4\7c\2\2\u02c4\u02c5\7z\2\2\u02c5\u02c6\7k\2\2\u02c6"+ - "\u02c7\7q\2\2\u02c7\u02c8\7o\2\2\u02c8\u02c9\3\2\2\2\u02c9\u02ca\b\65"+ - "\2\2\u02cak\3\2\2\2\u02cb\u02cc\7c\2\2\u02cc\u02cd\7f\2\2\u02cd\u02ce"+ - "\7v\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d0\b\66\2\2\u02d0m\3\2\2\2\u02d1"+ - "\u02d2\7o\2\2\u02d2\u02d3\7c\2\2\u02d3\u02d4\7v\2\2\u02d4\u02d5\7e\2\2"+ - "\u02d5\u02d6\7j\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d8\b\67\2\2\u02d8o\3"+ - "\2\2\2\u02d9\u02da\7p\2\2\u02da\u02db\7q\2\2\u02db\u02dc\7p\2\2\u02dc"+ - "\u02dd\7g\2\2\u02dd\u02de\3\2\2\2\u02de\u02df\b8\2\2\u02dfq\3\2\2\2\u02e0"+ - "\u02e1\7r\2\2\u02e1\u02e2\7t\2\2\u02e2\u02e3\7g\2\2\u02e3\u02e4\7f\2\2"+ - "\u02e4s\3\2\2\2\u02e5\u02e6\7v\2\2\u02e6\u02e7\7{\2\2\u02e7\u02e8\7r\2"+ - "\2\u02e8\u02e9\7g\2\2\u02e9\u02ea\7Q\2\2\u02ea\u02eb\7h\2\2\u02eb\u02ec"+ - "\3\2\2\2\u02ec\u02ed\b:\2\2\u02edu\3\2\2\2\u02ee\u02ef\7k\2\2\u02ef\u02f0"+ - "\7u\2\2\u02f0\u02f1\7E\2\2\u02f1\u02f2\7q\2\2\u02f2\u02f3\7o\2\2\u02f3"+ - "\u02f4\7r\2\2\u02f4\u02f5\7c\2\2\u02f5\u02f6\7t\2\2\u02f6\u02f7\7c\2\2"+ - "\u02f7\u02f8\7d\2\2\u02f8\u02f9\7n\2\2\u02f9\u02fa\7g\2\2\u02fa\u02fb"+ - "\3\2\2\2\u02fb\u02fc\b;\2\2\u02fcw\3\2\2\2\u02fd\u02fe\7u\2\2\u02fe\u02ff"+ - "\7j\2\2\u02ff\u0300\7c\2\2\u0300\u0301\7t\2\2\u0301\u0302\7g\2\2\u0302"+ - "y\3\2\2\2\u0303\u0304\7B\2\2\u0304\u0305\3\2\2\2\u0305\u0306\b=\2\2\u0306"+ - "{\3\2\2\2\u0307\u0308\7\60\2\2\u0308\u0309\7\60\2\2\u0309}\3\2\2\2\u030a"+ - "\u030b\7u\2\2\u030b\u030c\7j\2\2\u030c\u030d\7c\2\2\u030d\u030e\7t\2\2"+ - "\u030e\u030f\7g\2\2\u030f\u0310\7f\2\2\u0310\177\3\2\2\2\u0311\u0312\7"+ - "g\2\2\u0312\u0313\7z\2\2\u0313\u0314\7e\2\2\u0314\u0315\7n\2\2\u0315\u0316"+ - "\7w\2\2\u0316\u0317\7u\2\2\u0317\u0318\7k\2\2\u0318\u0319\7x\2\2\u0319"+ - "\u031a\7g\2\2\u031a\u0081\3\2\2\2\u031b\u031c\7r\2\2\u031c\u031d\7t\2"+ - "\2\u031d\u031e\7g\2\2\u031e\u031f\7f\2\2\u031f\u0320\7k\2\2\u0320\u0321"+ - "\7e\2\2\u0321\u0322\7c\2\2\u0322\u0323\7v\2\2\u0323\u0324\7g\2\2\u0324"+ - "\u0083\3\2\2\2\u0325\u0326\7y\2\2\u0326\u0327\7t\2\2\u0327\u0328\7k\2"+ - "\2\u0328\u0329\7v\2\2\u0329\u032a\7g\2\2\u032a\u032b\7R\2\2\u032b\u032c"+ - "\7g\2\2\u032c\u032d\7t\2\2\u032d\u032e\7o\2\2\u032e\u032f\3\2\2\2\u032f"+ - "\u0330\bB\2\2\u0330\u0085\3\2\2\2\u0331\u0332\7p\2\2\u0332\u0333\7q\2"+ - "\2\u0333\u0334\7R\2\2\u0334\u0335\7g\2\2\u0335\u0336\7t\2\2\u0336\u0337"+ - "\7o\2\2\u0337\u0338\3\2\2\2\u0338\u0339\bC\2\2\u0339\u0087\3\2\2\2\u033a"+ - "\u033b\7v\2\2\u033b\u033c\7t\2\2\u033c\u033d\7w\2\2\u033d\u033e\7u\2\2"+ - "\u033e\u033f\7v\2\2\u033f\u0340\7g\2\2\u0340\u0341\7f\2\2\u0341\u0342"+ - "\3\2\2\2\u0342\u0343\bD\2\2\u0343\u0089\3\2\2\2\u0344\u0345\7q\2\2\u0345"+ - "\u0346\7w\2\2\u0346\u0347\7v\2\2\u0347\u0348\7n\2\2\u0348\u0349\7k\2\2"+ - "\u0349\u034a\7p\2\2\u034a\u034b\7g\2\2\u034b\u008b\3\2\2\2\u034c\u034d"+ - "\7k\2\2\u034d\u034e\7p\2\2\u034e\u034f\7k\2\2\u034f\u0350\7v\2\2\u0350"+ - "\u0351\7G\2\2\u0351\u0352\7p\2\2\u0352\u0353\7u\2\2\u0353\u0354\7w\2\2"+ - "\u0354\u0355\7t\2\2\u0355\u0356\7g\2\2\u0356\u0357\7u\2\2\u0357\u008d"+ - "\3\2\2\2\u0358\u0359\7k\2\2\u0359\u035a\7o\2\2\u035a\u035b\7r\2\2\u035b"+ - "\u035c\7q\2\2\u035c\u035d\7t\2\2\u035d\u035e\7v\2\2\u035e\u035f\7T\2\2"+ - "\u035f\u0360\7g\2\2\u0360\u0361\7s\2\2\u0361\u0362\7w\2\2\u0362\u0363"+ - "\7k\2\2\u0363\u0364\7t\2\2\u0364\u0365\7g\2\2\u0365\u0366\7u\2\2\u0366"+ - "\u008f\3\2\2\2\u0367\u0368\7r\2\2\u0368\u0369\7t\2\2\u0369\u036a\7q\2"+ - "\2\u036a\u036b\7q\2\2\u036b\u036c\7h\2\2\u036c\u0091\3\2\2\2\u036d\u036e"+ - "\7?\2\2\u036e\u036f\7?\2\2\u036f\u0370\7?\2\2\u0370\u0093\3\2\2\2\u0371"+ - "\u0372\7#\2\2\u0372\u0373\7?\2\2\u0373\u0374\7?\2\2\u0374\u0095\3\2\2"+ - "\2\u0375\u0376\7y\2\2\u0376\u0377\7k\2\2\u0377\u0378\7v\2\2\u0378\u0379"+ - "\7j\2\2\u0379\u0097\3\2\2\2\u037a\u037b\7d\2\2\u037b\u037c\7t\2\2\u037c"+ - "\u037d\7g\2\2\u037d\u037e\7c\2\2\u037e\u037f\7m\2\2\u037f\u0380\3\2\2"+ - "\2\u0380\u0381\bL\2\2\u0381\u0099\3\2\2\2\u0382\u0383\7f\2\2\u0383\u0384"+ - "\7g\2\2\u0384\u0385\7h\2\2\u0385\u0386\7c\2\2\u0386\u0387\7w\2\2\u0387"+ - "\u0388\7n\2\2\u0388\u0389\7v\2\2\u0389\u009b\3\2\2\2\u038a\u038b\7h\2"+ - "\2\u038b\u038c\7w\2\2\u038c\u038d\7p\2\2\u038d\u038e\7e\2\2\u038e\u009d"+ - "\3\2\2\2\u038f\u0390\7k\2\2\u0390\u0391\7p\2\2\u0391\u0392\7v\2\2\u0392"+ - "\u0393\7g\2\2\u0393\u0394\7t\2\2\u0394\u0395\7h\2\2\u0395\u0396\7c\2\2"+ - "\u0396\u0397\7e\2\2\u0397\u0398\7g\2\2\u0398\u009f\3\2\2\2\u0399\u039a"+ - "\7u\2\2\u039a\u039b\7g\2\2\u039b\u039c\7n\2\2\u039c\u039d\7g\2\2\u039d"+ - "\u039e\7e\2\2\u039e\u039f\7v\2\2\u039f\u00a1\3\2\2\2\u03a0\u03a1\7e\2"+ - "\2\u03a1\u03a2\7c\2\2\u03a2\u03a3\7u\2\2\u03a3\u03a4\7g\2\2\u03a4\u00a3"+ - "\3\2\2\2\u03a5\u03a6\7f\2\2\u03a6\u03a7\7g\2\2\u03a7\u03a8\7h\2\2\u03a8"+ - "\u03a9\7g\2\2\u03a9\u03aa\7t\2\2\u03aa\u00a5\3\2\2\2\u03ab\u03ac\7i\2"+ - "\2\u03ac\u03ad\7q\2\2\u03ad\u00a7\3\2\2\2\u03ae\u03af\7o\2\2\u03af\u03b0"+ - "\7c\2\2\u03b0\u03b1\7r\2\2\u03b1\u00a9\3\2\2\2\u03b2\u03b3\7u\2\2\u03b3"+ - "\u03b4\7v\2\2\u03b4\u03b5\7t\2\2\u03b5\u03b6\7w\2\2\u03b6\u03b7\7e\2\2"+ - "\u03b7\u03b8\7v\2\2\u03b8\u00ab\3\2\2\2\u03b9\u03ba\7e\2\2\u03ba\u03bb"+ - "\7j\2\2\u03bb\u03bc\7c\2\2\u03bc\u03bd\7p\2\2\u03bd\u00ad\3\2\2\2\u03be"+ - "\u03bf\7g\2\2\u03bf\u03c0\7n\2\2\u03c0\u03c1\7u\2\2\u03c1\u03c2\7g\2\2"+ - "\u03c2\u00af\3\2\2\2\u03c3\u03c4\7i\2\2\u03c4\u03c5\7q\2\2\u03c5\u03c6"+ - "\7v\2\2\u03c6\u03c7\7q\2\2\u03c7\u00b1\3\2\2\2\u03c8\u03c9\7r\2\2\u03c9"+ - "\u03ca\7c\2\2\u03ca\u03cb\7e\2\2\u03cb\u03cc\7m\2\2\u03cc\u03cd\7c\2\2"+ - "\u03cd\u03ce\7i\2\2\u03ce\u03cf\7g\2\2\u03cf\u00b3\3\2\2\2\u03d0\u03d1"+ - "\7u\2\2\u03d1\u03d2\7y\2\2\u03d2\u03d3\7k\2\2\u03d3\u03d4\7v\2\2\u03d4"+ - "\u03d5\7e\2\2\u03d5\u03d6\7j\2\2\u03d6\u00b5\3\2\2\2\u03d7\u03d8\7e\2"+ - "\2\u03d8\u03d9\7q\2\2\u03d9\u03da\7p\2\2\u03da\u03db\7u\2\2\u03db\u03dc"+ - "\7v\2\2\u03dc\u00b7\3\2\2\2\u03dd\u03de\7h\2\2\u03de\u03df\7c\2\2\u03df"+ - "\u03e0\7n\2\2\u03e0\u03e1\7n\2\2\u03e1\u03e2\7v\2\2\u03e2\u03e3\7j\2\2"+ - "\u03e3\u03e4\7t\2\2\u03e4\u03e5\7q\2\2\u03e5\u03e6\7w\2\2\u03e6\u03e7"+ - "\7i\2\2\u03e7\u03e8\7j\2\2\u03e8\u03e9\3\2\2\2\u03e9\u03ea\b\\\2\2\u03ea"+ - "\u00b9\3\2\2\2\u03eb\u03ec\7k\2\2\u03ec\u03ed\7h\2\2\u03ed\u00bb\3\2\2"+ - "\2\u03ee\u03ef\7t\2\2\u03ef\u03f0\7c\2\2\u03f0\u03f1\7p\2\2\u03f1\u03f2"+ - "\7i\2\2\u03f2\u03f3\7g\2\2\u03f3\u00bd\3\2\2\2\u03f4\u03f5\7v\2\2\u03f5"+ - "\u03f6\7{\2\2\u03f6\u03f7\7r\2\2\u03f7\u03f8\7g\2\2\u03f8\u00bf\3\2\2"+ - "\2\u03f9\u03fa\7e\2\2\u03fa\u03fb\7q\2\2\u03fb\u03fc\7p\2\2\u03fc\u03fd"+ - "\7v\2\2\u03fd\u03fe\7k\2\2\u03fe\u03ff\7p\2\2\u03ff\u0400\7w\2\2\u0400"+ - "\u0401\7g\2\2\u0401\u0402\3\2\2\2\u0402\u0403\b`\2\2\u0403\u00c1\3\2\2"+ - "\2\u0404\u0405\7h\2\2\u0405\u0406\7q\2\2\u0406\u0407\7t\2\2\u0407\u00c3"+ - "\3\2\2\2\u0408\u0409\7k\2\2\u0409\u040a\7o\2\2\u040a\u040b\7r\2\2\u040b"+ - "\u040c\7q\2\2\u040c\u040d\7t\2\2\u040d\u040e\7v\2\2\u040e\u00c5\3\2\2"+ - "\2\u040f\u0410\7t\2\2\u0410\u0411\7g\2\2\u0411\u0412\7v\2\2\u0412\u0413"+ - "\7w\2\2\u0413\u0414\7t\2\2\u0414\u0415\7p\2\2\u0415\u0416\3\2\2\2\u0416"+ - "\u0417\bc\2\2\u0417\u00c7\3\2\2\2\u0418\u0419\7x\2\2\u0419\u041a\7c\2"+ - "\2\u041a\u041b\7t\2\2\u041b\u00c9\3\2\2\2\u041c\u041d\7p\2\2\u041d\u041e"+ - "\7k\2\2\u041e\u041f\7n\2\2\u041f\u0420\3\2\2\2\u0420\u0421\be\2\2\u0421"+ - "\u00cb\3\2\2\2\u0422\u0427\5\u014e\u00a7\2\u0423\u0426\5\u014e\u00a7\2"+ - "\u0424\u0426\5\u0150\u00a8\2\u0425\u0423\3\2\2\2\u0425\u0424\3\2\2\2\u0426"+ - "\u0429\3\2\2\2\u0427\u0425\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u042a\3\2"+ - "\2\2\u0429\u0427\3\2\2\2\u042a\u042b\bf\2\2\u042b\u00cd\3\2\2\2\u042c"+ - "\u042d\7*\2\2\u042d\u00cf\3\2\2\2\u042e\u042f\7+\2\2\u042f\u0430\3\2\2"+ - "\2\u0430\u0431\bh\2\2\u0431\u00d1\3\2\2\2\u0432\u0433\7}\2\2\u0433\u00d3"+ - "\3\2\2\2\u0434\u0435\7\177\2\2\u0435\u0436\3\2\2\2\u0436\u0437\bj\2\2"+ - "\u0437\u00d5\3\2\2\2\u0438\u0439\7]\2\2\u0439\u00d7\3\2\2\2\u043a\u043b"+ - "\7_\2\2\u043b\u043c\3\2\2\2\u043c\u043d\bl\2\2\u043d\u00d9\3\2\2\2\u043e"+ - "\u043f\7?\2\2\u043f\u00db\3\2\2\2\u0440\u0441\7.\2\2\u0441\u00dd\3\2\2"+ - "\2\u0442\u0443\7=\2\2\u0443\u00df\3\2\2\2\u0444\u0445\7<\2\2\u0445\u00e1"+ - "\3\2\2\2\u0446\u0447\7\60\2\2\u0447\u00e3\3\2\2\2\u0448\u0449\7-\2\2\u0449"+ - "\u044a\7-\2\2\u044a\u044b\3\2\2\2\u044b\u044c\br\2\2\u044c\u00e5\3\2\2"+ - "\2\u044d\u044e\7/\2\2\u044e\u044f\7/\2\2\u044f\u0450\3\2\2\2\u0450\u0451"+ - "\bs\2\2\u0451\u00e7\3\2\2\2\u0452\u0453\7<\2\2\u0453\u0454\7?\2\2\u0454"+ - "\u00e9\3\2\2\2\u0455\u0456\7\60\2\2\u0456\u0457\7\60\2\2\u0457\u0458\7"+ - "\60\2\2\u0458\u00eb\3\2\2\2\u0459\u045a\7~\2\2\u045a\u045b\7~\2\2\u045b"+ - "\u00ed\3\2\2\2\u045c\u045d\7(\2\2\u045d\u045e\7(\2\2\u045e\u00ef\3\2\2"+ - "\2\u045f\u0460\7?\2\2\u0460\u0461\7?\2\2\u0461\u00f1\3\2\2\2\u0462\u0463"+ - "\7#\2\2\u0463\u0464\7?\2\2\u0464\u00f3\3\2\2\2\u0465\u0466\7>\2\2\u0466"+ - "\u00f5\3\2\2\2\u0467\u0468\7>\2\2\u0468\u0469\7?\2\2\u0469\u00f7\3\2\2"+ - "\2\u046a\u046b\7@\2\2\u046b\u00f9\3\2\2\2\u046c\u046d\7@\2\2\u046d\u046e"+ - "\7?\2\2\u046e\u00fb\3\2\2\2\u046f\u0470\7~\2\2\u0470\u00fd\3\2\2\2\u0471"+ - "\u0472\7\61\2\2\u0472\u00ff\3\2\2\2\u0473\u0474\7\'\2\2\u0474\u0101\3"+ - "\2\2\2\u0475\u0476\7>\2\2\u0476\u0477\7>\2\2\u0477\u0103\3\2\2\2\u0478"+ - "\u0479\7@\2\2\u0479\u047a\7@\2\2\u047a\u0105\3\2\2\2\u047b\u047c\7(\2"+ - "\2\u047c\u047d\7`\2\2\u047d\u0107\3\2\2\2\u047e\u047f\7#\2\2\u047f\u0109"+ - "\3\2\2\2\u0480\u0481\7-\2\2\u0481\u010b\3\2\2\2\u0482\u0483\7/\2\2\u0483"+ - "\u010d\3\2\2\2\u0484\u0485\7`\2\2\u0485\u010f\3\2\2\2\u0486\u0487\7,\2"+ - "\2\u0487\u0111\3\2\2\2\u0488\u0489\7(\2\2\u0489\u0113\3\2\2\2\u048a\u048b"+ - "\7>\2\2\u048b\u048c\7/\2\2\u048c\u0115\3\2\2\2\u048d\u0499\7\62\2\2\u048e"+ - "\u0495\t\2\2\2\u048f\u0491\7a\2\2\u0490\u048f\3\2\2\2\u0490\u0491\3\2"+ - "\2\2\u0491\u0492\3\2\2\2\u0492\u0494\t\3\2\2\u0493\u0490\3\2\2\2\u0494"+ - "\u0497\3\2\2\2\u0495\u0493\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u0499\3\2"+ - "\2\2\u0497\u0495\3\2\2\2\u0498\u048d\3\2\2\2\u0498\u048e\3\2\2\2\u0499"+ - "\u049a\3\2\2\2\u049a\u049b\b\u008b\2\2\u049b\u0117\3\2\2\2\u049c\u049d"+ - "\7\62\2\2\u049d\u04a2\t\4\2\2\u049e\u04a0\7a\2\2\u049f\u049e\3\2\2\2\u049f"+ - "\u04a0\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a3\5\u014a\u00a5\2\u04a2\u049f"+ - "\3\2\2\2\u04a3\u04a4\3\2\2\2\u04a4\u04a2\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5"+ - "\u04a6\3\2\2\2\u04a6\u04a7\b\u008c\2\2\u04a7\u0119\3\2\2\2\u04a8\u04aa"+ - "\7\62\2\2\u04a9\u04ab\t\5\2\2\u04aa\u04a9\3\2\2\2\u04aa\u04ab\3\2\2\2"+ - "\u04ab\u04b0\3\2\2\2\u04ac\u04ae\7a\2\2\u04ad\u04ac\3\2\2\2\u04ad\u04ae"+ - "\3\2\2\2\u04ae\u04af\3\2\2\2\u04af\u04b1\5\u0146\u00a3\2\u04b0\u04ad\3"+ - "\2\2\2\u04b1\u04b2\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b2\u04b3\3\2\2\2\u04b3"+ - "\u04b4\3\2\2\2\u04b4\u04b5\b\u008d\2\2\u04b5\u011b\3\2\2\2\u04b6\u04b7"+ - "\7\62\2\2\u04b7\u04bc\t\6\2\2\u04b8\u04ba\7a\2\2\u04b9\u04b8\3\2\2\2\u04b9"+ - "\u04ba\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb\u04bd\5\u0148\u00a4\2\u04bc\u04b9"+ - "\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04bc\3\2\2\2\u04be\u04bf\3\2\2\2\u04bf"+ - "\u04c0\3\2\2\2\u04c0\u04c1\b\u008e\2\2\u04c1\u011d\3\2\2\2\u04c2\u04c3"+ - "\7\62\2\2\u04c3\u04c4\t\6\2\2\u04c4\u04c5\5\u0120\u0090\2\u04c5\u04c6"+ - "\5\u0122\u0091\2\u04c6\u011f\3\2\2\2\u04c7\u04c9\7a\2\2\u04c8\u04c7\3"+ - "\2\2\2\u04c8\u04c9\3\2\2\2\u04c9\u04ca\3\2\2\2\u04ca\u04cc\5\u0148\u00a4"+ - "\2\u04cb\u04c8\3\2\2\2\u04cc\u04cd\3\2\2\2\u04cd\u04cb\3\2\2\2\u04cd\u04ce"+ - "\3\2\2\2\u04ce\u04d9\3\2\2\2\u04cf\u04d6\7\60\2\2\u04d0\u04d2\7a\2\2\u04d1"+ - "\u04d0\3\2\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d3\3\2\2\2\u04d3\u04d5\5\u0148"+ - "\u00a4\2\u04d4\u04d1\3\2\2\2\u04d5\u04d8\3\2\2\2\u04d6\u04d4\3\2\2\2\u04d6"+ - "\u04d7\3\2\2\2\u04d7\u04da\3\2\2\2\u04d8\u04d6\3\2\2\2\u04d9\u04cf\3\2"+ - "\2\2\u04d9\u04da\3\2\2\2\u04da\u04e7\3\2\2\2\u04db\u04dc\7\60\2\2\u04dc"+ - "\u04e3\5\u0148\u00a4\2\u04dd\u04df\7a\2\2\u04de\u04dd\3\2\2\2\u04de\u04df"+ - "\3\2\2\2\u04df\u04e0\3\2\2\2\u04e0\u04e2\5\u0148\u00a4\2\u04e1\u04de\3"+ - "\2\2\2\u04e2\u04e5\3\2\2\2\u04e3\u04e1\3\2\2\2\u04e3\u04e4\3\2\2\2\u04e4"+ - "\u04e7\3\2\2\2\u04e5\u04e3\3\2\2\2\u04e6\u04cb\3\2\2\2\u04e6\u04db\3\2"+ - "\2\2\u04e7\u0121\3\2\2\2\u04e8\u04e9\t\7\2\2\u04e9\u04ea\t\b\2\2\u04ea"+ - "\u04eb\5\u0144\u00a2\2\u04eb\u0123\3\2\2\2\u04ec\u04f2\5\u0116\u008b\2"+ - "\u04ed\u04f2\5\u0118\u008c\2\u04ee\u04f2\5\u011a\u008d\2\u04ef\u04f2\5"+ - "\u011c\u008e\2\u04f0\u04f2\5\4\2\2\u04f1\u04ec\3\2\2\2\u04f1\u04ed\3\2"+ - "\2\2\u04f1\u04ee\3\2\2\2\u04f1\u04ef\3\2\2\2\u04f1\u04f0\3\2\2\2\u04f2"+ - "\u04f3\3\2\2\2\u04f3\u04f4\7k\2\2\u04f4\u04f5\3\2\2\2\u04f5\u04f6\b\u0092"+ - "\2\2\u04f6\u0125\3\2\2\2\u04f7\u04fa\7)\2\2\u04f8\u04fb\5\u0140\u00a0"+ - "\2\u04f9\u04fb\5\u012a\u0095\2\u04fa\u04f8\3\2\2\2\u04fa\u04f9\3\2\2\2"+ - "\u04fb\u04fc\3\2\2\2\u04fc\u04fd\7)\2\2\u04fd\u0127\3\2\2\2\u04fe\u04ff"+ - "\5\u0126\u0093\2\u04ff\u0500\3\2\2\2\u0500\u0501\b\u0094\2\2\u0501\u0129"+ - "\3\2\2\2\u0502\u0505\5\u012c\u0096\2\u0503\u0505\5\u012e\u0097\2\u0504"+ - "\u0502\3\2\2\2\u0504\u0503\3\2\2\2\u0505\u012b\3\2\2\2\u0506\u0507\7^"+ - "\2\2\u0507\u0508\5\u0146\u00a3\2\u0508\u0509\5\u0146\u00a3\2\u0509\u050a"+ - "\5\u0146\u00a3\2\u050a\u012d\3\2\2\2\u050b\u050c\7^\2\2\u050c\u050d\7"+ - "z\2\2\u050d\u050e\5\u0148\u00a4\2\u050e\u050f\5\u0148\u00a4\2\u050f\u012f"+ - "\3\2\2\2\u0510\u0511\7^\2\2\u0511\u0512\7w\2\2\u0512\u0513\5\u0148\u00a4"+ - "\2\u0513\u0514\5\u0148\u00a4\2\u0514\u0515\5\u0148\u00a4\2\u0515\u0516"+ - "\5\u0148\u00a4\2\u0516\u0131\3\2\2\2\u0517\u0518\7^\2\2\u0518\u0519\7"+ - "W\2\2\u0519\u051a\5\u0148\u00a4\2\u051a\u051b\5\u0148\u00a4\2\u051b\u051c"+ - "\5\u0148\u00a4\2\u051c\u051d\5\u0148\u00a4\2\u051d\u051e\5\u0148\u00a4"+ - "\2\u051e\u051f\5\u0148\u00a4\2\u051f\u0520\5\u0148\u00a4\2\u0520\u0521"+ - "\5\u0148\u00a4\2\u0521\u0133\3\2\2\2\u0522\u0526\7b\2\2\u0523\u0525\n"+ - "\t\2\2\u0524\u0523\3\2\2\2\u0525\u0528\3\2\2\2\u0526\u0524\3\2\2\2\u0526"+ - "\u0527\3\2\2\2\u0527\u0529\3\2\2\2\u0528\u0526\3\2\2\2\u0529\u052a\7b"+ - "\2\2\u052a\u052b\3\2\2\2\u052b\u052c\b\u009a\2\2\u052c\u0135\3\2\2\2\u052d"+ - "\u0532\7$\2\2\u052e\u0531\n\n\2\2\u052f\u0531\5\u0142\u00a1\2\u0530\u052e"+ - "\3\2\2\2\u0530\u052f\3\2\2\2\u0531\u0534\3\2\2\2\u0532\u0530\3\2\2\2\u0532"+ - "\u0533\3\2\2\2\u0533\u0535\3\2\2\2\u0534\u0532\3\2\2\2\u0535\u0536\7$"+ - "\2\2\u0536\u0537\3\2\2\2\u0537\u0538\b\u009b\2\2\u0538\u0137\3\2\2\2\u0539"+ - "\u053b\t\13\2\2\u053a\u0539\3\2\2\2\u053b\u053c\3\2\2\2\u053c\u053a\3"+ - "\2\2\2\u053c\u053d\3\2\2\2\u053d\u053e\3\2\2\2\u053e\u053f\b\u009c\3\2"+ - "\u053f\u0139\3\2\2\2\u0540\u0541\7\61\2\2\u0541\u0542\7,\2\2\u0542\u0546"+ - "\3\2\2\2\u0543\u0545\13\2\2\2\u0544\u0543\3\2\2\2\u0545\u0548\3\2\2\2"+ - "\u0546\u0547\3\2\2\2\u0546\u0544\3\2\2\2\u0547\u0549\3\2\2\2\u0548\u0546"+ - "\3\2\2\2\u0549\u054a\7,\2\2\u054a\u054b\7\61\2\2\u054b\u054c\3\2\2\2\u054c"+ - "\u054d\b\u009d\3\2\u054d\u013b\3\2\2\2\u054e\u0550\t\f\2\2\u054f\u054e"+ - "\3\2\2\2\u0550\u0551\3\2\2\2\u0551\u054f\3\2\2\2\u0551\u0552\3\2\2\2\u0552"+ - "\u0553\3\2\2\2\u0553\u0554\b\u009e\3\2\u0554\u013d\3\2\2\2\u0555\u0556"+ - "\7\61\2\2\u0556\u0557\7\61\2\2\u0557\u055b\3\2\2\2\u0558\u055a\n\f\2\2"+ - "\u0559\u0558\3\2\2\2\u055a\u055d\3\2\2\2\u055b\u0559\3\2\2\2\u055b\u055c"+ - "\3\2\2\2\u055c\u055e\3\2\2\2\u055d\u055b\3\2\2\2\u055e\u055f\b\u009f\3"+ - "\2\u055f\u013f\3\2\2\2\u0560\u0565\n\r\2\2\u0561\u0565\5\u0130\u0098\2"+ - "\u0562\u0565\5\u0132\u0099\2\u0563\u0565\5\u0142\u00a1\2\u0564\u0560\3"+ - "\2\2\2\u0564\u0561\3\2\2\2\u0564\u0562\3\2\2\2\u0564\u0563\3\2\2\2\u0565"+ - "\u0141\3\2\2\2\u0566\u0580\7^\2\2\u0567\u0568\7w\2\2\u0568\u0569\5\u0148"+ - "\u00a4\2\u0569\u056a\5\u0148\u00a4\2\u056a\u056b\5\u0148\u00a4\2\u056b"+ - "\u056c\5\u0148\u00a4\2\u056c\u0581\3\2\2\2\u056d\u056e\7W\2\2\u056e\u056f"+ - "\5\u0148\u00a4\2\u056f\u0570\5\u0148\u00a4\2\u0570\u0571\5\u0148\u00a4"+ - "\2\u0571\u0572\5\u0148\u00a4\2\u0572\u0573\5\u0148\u00a4\2\u0573\u0574"+ - "\5\u0148\u00a4\2\u0574\u0575\5\u0148\u00a4\2\u0575\u0576\5\u0148\u00a4"+ - "\2\u0576\u0581\3\2\2\2\u0577\u0581\t\16\2\2\u0578\u0579\5\u0146\u00a3"+ - "\2\u0579\u057a\5\u0146\u00a3\2\u057a\u057b\5\u0146\u00a3\2\u057b\u0581"+ - "\3\2\2\2\u057c\u057d\7z\2\2\u057d\u057e\5\u0148\u00a4\2\u057e\u057f\5"+ - "\u0148\u00a4\2\u057f\u0581\3\2\2\2\u0580\u0567\3\2\2\2\u0580\u056d\3\2"+ - "\2\2\u0580\u0577\3\2\2\2\u0580\u0578\3\2\2\2\u0580\u057c\3\2\2\2\u0581"+ - "\u0143\3\2\2\2\u0582\u0589\t\3\2\2\u0583\u0585\7a\2\2\u0584\u0583\3\2"+ - "\2\2\u0584\u0585\3\2\2\2\u0585\u0586\3\2\2\2\u0586\u0588\t\3\2\2\u0587"+ - "\u0584\3\2\2\2\u0588\u058b\3\2\2\2\u0589\u0587\3\2\2\2\u0589\u058a\3\2"+ - "\2\2\u058a\u0145\3\2\2\2\u058b\u0589\3\2\2\2\u058c\u058d\t\17\2\2\u058d"+ - "\u0147\3\2\2\2\u058e\u058f\t\20\2\2\u058f\u0149\3\2\2\2\u0590\u0591\t"+ - "\21\2\2\u0591\u014b\3\2\2\2\u0592\u0594\t\22\2\2\u0593\u0595\t\b\2\2\u0594"+ - "\u0593\3\2\2\2\u0594\u0595\3\2\2\2\u0595\u0596\3\2\2\2\u0596\u0597\5\u0144"+ - "\u00a2\2\u0597\u014d\3\2\2\2\u0598\u059b\5\u0152\u00a9\2\u0599\u059b\7"+ - "a\2\2\u059a\u0598\3\2\2\2\u059a\u0599\3\2\2\2\u059b\u014f\3\2\2\2\u059c"+ - "\u059d\t\23\2\2\u059d\u0151\3\2\2\2\u059e\u059f\t\24\2\2\u059f\u0153\3"+ - "\2\2\2\u05a0\u05a2\t\13\2\2\u05a1\u05a0\3\2\2\2\u05a2\u05a3\3\2\2\2\u05a3"+ - "\u05a1\3\2\2\2\u05a3\u05a4\3\2\2\2\u05a4\u05a5\3\2\2\2\u05a5\u05a6\b\u00aa"+ - "\3\2\u05a6\u0155\3\2\2\2\u05a7\u05a8\7\61\2\2\u05a8\u05a9\7,\2\2\u05a9"+ - "\u05ad\3\2\2\2\u05aa\u05ac\n\f\2\2\u05ab\u05aa\3\2\2\2\u05ac\u05af\3\2"+ - "\2\2\u05ad\u05ae\3\2\2\2\u05ad\u05ab\3\2\2\2\u05ae\u05b0\3\2\2\2\u05af"+ - "\u05ad\3\2\2\2\u05b0\u05b1\7,\2\2\u05b1\u05b2\7\61\2\2\u05b2\u05b3\3\2"+ - "\2\2\u05b3\u05b4\b\u00ab\3\2\u05b4\u0157\3\2\2\2\u05b5\u05b6\7\61\2\2"+ - "\u05b6\u05b7\7\61\2\2\u05b7\u05bb\3\2\2\2\u05b8\u05ba\n\f\2\2\u05b9\u05b8"+ - "\3\2\2\2\u05ba\u05bd\3\2\2\2\u05bb\u05b9\3\2\2\2\u05bb\u05bc\3\2\2\2\u05bc"+ - "\u05be\3\2\2\2\u05bd\u05bb\3\2\2\2\u05be\u05bf\b\u00ac\3\2\u05bf\u0159"+ - "\3\2\2\2\u05c0\u05c2\t\f\2\2\u05c1\u05c0\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3"+ - "\u05c1\3\2\2\2\u05c3\u05c4\3\2\2\2\u05c4\u05d3\3\2\2\2\u05c5\u05d3\7="+ - "\2\2\u05c6\u05c7\7\61\2\2\u05c7\u05c8\7,\2\2\u05c8\u05cc\3\2\2\2\u05c9"+ - "\u05cb\13\2\2\2\u05ca\u05c9\3\2\2\2\u05cb\u05ce\3\2\2\2\u05cc\u05cd\3"+ - "\2\2\2\u05cc\u05ca\3\2\2\2\u05cd\u05cf\3\2\2\2\u05ce\u05cc\3\2\2\2\u05cf"+ - "\u05d0\7,\2\2\u05d0\u05d3\7\61\2\2\u05d1\u05d3\7\2\2\3\u05d2\u05c1\3\2"+ - "\2\2\u05d2\u05c5\3\2\2\2\u05d2\u05c6\3\2\2\2\u05d2\u05d1\3\2\2\2\u05d3"+ - "\u05d4\3\2\2\2\u05d4\u05d5\b\u00ad\4\2\u05d5\u015b\3\2\2\2\u05d6\u05d7"+ - "\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8\u05d9\b\u00ae\4\2\u05d9\u05da\b\u00ae"+ - "\3\2\u05da\u015d\3\2\2\2\64\2\3\u0160\u0168\u016b\u016e\u0174\u0176\u0425"+ - "\u0427\u0490\u0495\u0498\u049f\u04a4\u04aa\u04ad\u04b2\u04b9\u04be\u04c8"+ - "\u04cd\u04d1\u04d6\u04d9\u04de\u04e3\u04e6\u04f1\u04fa\u0504\u0526\u0530"+ - "\u0532\u053c\u0546\u0551\u055b\u0564\u0580\u0584\u0589\u0594\u059a\u05a3"+ - "\u05ad\u05bb\u05c3\u05cc\u05d2\5\4\3\2\2\3\2\4\2\2"; + "\u0004\u0000\u00a0\u05db\u0006\uffff\uffff\u0006\uffff\uffff\u0002\u0000"+ + "\u0007\u0000\u0002\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003"+ + "\u0007\u0003\u0002\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006"+ + "\u0007\u0006\u0002\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002"+ + "\n\u0007\n\u0002\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002"+ + "\u000e\u0007\u000e\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002"+ + "\u0011\u0007\u0011\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002"+ + "\u0014\u0007\u0014\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002"+ + "\u0017\u0007\u0017\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002"+ + "\u001a\u0007\u001a\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002"+ + "\u001d\u0007\u001d\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002"+ + " \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002"+ + "%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002"+ + "*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002"+ + "/\u0007/\u00020\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u0002"+ + "4\u00074\u00025\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u0002"+ + "9\u00079\u0002:\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002"+ + ">\u0007>\u0002?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002"+ + "C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002"+ + "H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002"+ + "M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002"+ + "R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002"+ + "W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002"+ + "\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002"+ + "a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002"+ + "f\u0007f\u0002g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002"+ + "k\u0007k\u0002l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002"+ + "p\u0007p\u0002q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002"+ + "u\u0007u\u0002v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002"+ + "z\u0007z\u0002{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002"+ + "\u007f\u0007\u007f\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002"+ + "\u0082\u0007\u0082\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002"+ + "\u0085\u0007\u0085\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002"+ + "\u0088\u0007\u0088\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002"+ + "\u008b\u0007\u008b\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002"+ + "\u008e\u0007\u008e\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002"+ + "\u0091\u0007\u0091\u0002\u0092\u0007\u0092\u0002\u0093\u0007\u0093\u0002"+ + "\u0094\u0007\u0094\u0002\u0095\u0007\u0095\u0002\u0096\u0007\u0096\u0002"+ + "\u0097\u0007\u0097\u0002\u0098\u0007\u0098\u0002\u0099\u0007\u0099\u0002"+ + "\u009a\u0007\u009a\u0002\u009b\u0007\u009b\u0002\u009c\u0007\u009c\u0002"+ + "\u009d\u0007\u009d\u0002\u009e\u0007\u009e\u0002\u009f\u0007\u009f\u0002"+ + "\u00a0\u0007\u00a0\u0002\u00a1\u0007\u00a1\u0002\u00a2\u0007\u00a2\u0002"+ + "\u00a3\u0007\u00a3\u0002\u00a4\u0007\u00a4\u0002\u00a5\u0007\u00a5\u0002"+ + "\u00a6\u0007\u00a6\u0002\u00a7\u0007\u00a7\u0002\u00a8\u0007\u00a8\u0002"+ + "\u00a9\u0007\u00a9\u0002\u00aa\u0007\u00aa\u0002\u00ab\u0007\u00ab\u0002"+ + "\u00ac\u0007\u00ac\u0001\u0000\u0001\u0000\u0003\u0000\u015f\b\u0000\u0001"+ + "\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003"+ + "\u0001\u0167\b\u0001\u0001\u0001\u0003\u0001\u016a\b\u0001\u0001\u0001"+ + "\u0003\u0001\u016d\b\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0003\u0001\u0173\b\u0001\u0003\u0001\u0175\b\u0001\u0001\u0002\u0001"+ + "\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001"+ + "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+ + "\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+ + "\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+ + "\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001"+ + "\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0007\u0001"+ + "\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+ + "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ + "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ + "\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ + "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001"+ + "\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001"+ + "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e"+ + "\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+ + "\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010"+ + "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ + "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012"+ + "\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+ + "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014"+ + "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015"+ + "\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016"+ + "\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017"+ + "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018"+ + "\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+ + "\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+ + "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ + "\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001d"+ + "\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d"+ + "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+ + "\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f"+ + "\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f"+ + "\u0001\u001f\u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+ + " \u0001!\u0001!\u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0001#\u0001"+ + "#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001%\u0001%\u0001%\u0001"+ + "&\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'"+ + "\u0001\'\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001)\u0001)\u0001"+ + ")\u0001)\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+ + "*\u0001*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001"+ + "+\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001"+ + "-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001"+ + "/\u0001/\u0001/\u0001/\u0001/\u0001/\u00010\u00010\u00010\u00010\u0001"+ + "0\u00010\u00010\u00011\u00011\u00011\u00011\u00011\u00011\u00012\u0001"+ + "2\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00013\u00013\u0001"+ + "3\u00013\u00013\u00013\u00013\u00013\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00015\u00015\u00015\u00015\u00015\u00015\u00015\u00015\u0001"+ + "6\u00016\u00016\u00016\u00016\u00016\u00016\u00017\u00017\u00017\u0001"+ + "7\u00017\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ + "8\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u0001:\u0001:\u0001:\u0001:\u0001"+ + ":\u0001:\u0001;\u0001;\u0001;\u0001;\u0001<\u0001<\u0001<\u0001=\u0001"+ + "=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001"+ + ">\u0001>\u0001>\u0001>\u0001>\u0001>\u0001?\u0001?\u0001?\u0001?\u0001"+ + "?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001@\u0001"+ + "@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001A\u0001A\u0001"+ + "A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001"+ + "B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0001"+ + "C\u0001C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001D\u0001"+ + "D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001E\u0001E\u0001E\u0001"+ + "E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001"+ + "E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001G\u0001G\u0001"+ + "G\u0001G\u0001H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001"+ + "I\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001K\u0001"+ + "K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001L\u0001"+ + "L\u0001L\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+ + "M\u0001M\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001"+ + "O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001P\u0001"+ + "Q\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001T\u0001T\u0001U\u0001"+ + "U\u0001U\u0001U\u0001U\u0001V\u0001V\u0001V\u0001V\u0001V\u0001W\u0001"+ + "W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001X\u0001X\u0001X\u0001"+ + "X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ + "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ + "Z\u0001Z\u0001Z\u0001Z\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001]\u0001]\u0001]\u0001]\u0001]\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001_\u0001"+ + "_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001"+ + "a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001b\u0001"+ + "b\u0001b\u0001b\u0001c\u0001c\u0001c\u0001c\u0001c\u0001c\u0001d\u0001"+ + "d\u0001d\u0005d\u0424\bd\nd\fd\u0427\td\u0001d\u0001d\u0001e\u0001e\u0001"+ + "f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001h\u0001h\u0001h\u0001h\u0001"+ + "i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001k\u0001k\u0001l\u0001l\u0001"+ + "m\u0001m\u0001n\u0001n\u0001o\u0001o\u0001p\u0001p\u0001p\u0001p\u0001"+ + "p\u0001q\u0001q\u0001q\u0001q\u0001q\u0001r\u0001r\u0001r\u0001s\u0001"+ + "s\u0001s\u0001s\u0001t\u0001t\u0001t\u0001u\u0001u\u0001u\u0001v\u0001"+ + "v\u0001v\u0001w\u0001w\u0001w\u0001x\u0001x\u0001y\u0001y\u0001y\u0001"+ + "z\u0001z\u0001{\u0001{\u0001{\u0001|\u0001|\u0001}\u0001}\u0001~\u0001"+ + "~\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u0080\u0001\u0080\u0001\u0080"+ + "\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0082\u0001\u0082\u0001\u0083"+ + "\u0001\u0083\u0001\u0084\u0001\u0084\u0001\u0085\u0001\u0085\u0001\u0086"+ + "\u0001\u0086\u0001\u0087\u0001\u0087\u0001\u0088\u0001\u0088\u0001\u0088"+ + "\u0001\u0089\u0001\u0089\u0001\u0089\u0003\u0089\u048f\b\u0089\u0001\u0089"+ + "\u0005\u0089\u0492\b\u0089\n\u0089\f\u0089\u0495\t\u0089\u0003\u0089\u0497"+ + "\b\u0089\u0001\u0089\u0001\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0003"+ + "\u008a\u049e\b\u008a\u0001\u008a\u0004\u008a\u04a1\b\u008a\u000b\u008a"+ + "\f\u008a\u04a2\u0001\u008a\u0001\u008a\u0001\u008b\u0001\u008b\u0003\u008b"+ + "\u04a9\b\u008b\u0001\u008b\u0003\u008b\u04ac\b\u008b\u0001\u008b\u0004"+ + "\u008b\u04af\b\u008b\u000b\u008b\f\u008b\u04b0\u0001\u008b\u0001\u008b"+ + "\u0001\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u04b8\b\u008c\u0001\u008c"+ + "\u0004\u008c\u04bb\b\u008c\u000b\u008c\f\u008c\u04bc\u0001\u008c\u0001"+ + "\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001"+ + "\u008e\u0003\u008e\u04c7\b\u008e\u0001\u008e\u0004\u008e\u04ca\b\u008e"+ + "\u000b\u008e\f\u008e\u04cb\u0001\u008e\u0001\u008e\u0003\u008e\u04d0\b"+ + "\u008e\u0001\u008e\u0005\u008e\u04d3\b\u008e\n\u008e\f\u008e\u04d6\t\u008e"+ + "\u0003\u008e\u04d8\b\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0003\u008e"+ + "\u04dd\b\u008e\u0001\u008e\u0005\u008e\u04e0\b\u008e\n\u008e\f\u008e\u04e3"+ + "\t\u008e\u0003\u008e\u04e5\b\u008e\u0001\u008f\u0001\u008f\u0003\u008f"+ + "\u04e9\b\u008f\u0001\u008f\u0001\u008f\u0001\u0090\u0001\u0090\u0001\u0090"+ + "\u0001\u0090\u0001\u0090\u0003\u0090\u04f2\b\u0090\u0001\u0090\u0001\u0090"+ + "\u0001\u0090\u0001\u0090\u0001\u0091\u0001\u0091\u0001\u0091\u0003\u0091"+ + "\u04fb\b\u0091\u0001\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001\u0092"+ + "\u0001\u0092\u0001\u0093\u0001\u0093\u0003\u0093\u0505\b\u0093\u0001\u0094"+ + "\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0095\u0001\u0095"+ + "\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0096\u0001\u0096\u0001\u0096"+ + "\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097"+ + "\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097"+ + "\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0098\u0001\u0098\u0005\u0098"+ + "\u0525\b\u0098\n\u0098\f\u0098\u0528\t\u0098\u0001\u0098\u0001\u0098\u0001"+ + "\u0098\u0001\u0098\u0001\u0099\u0001\u0099\u0001\u0099\u0005\u0099\u0531"+ + "\b\u0099\n\u0099\f\u0099\u0534\t\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+ + "\u0001\u0099\u0001\u009a\u0004\u009a\u053b\b\u009a\u000b\u009a\f\u009a"+ + "\u053c\u0001\u009a\u0001\u009a\u0001\u009b\u0001\u009b\u0001\u009b\u0001"+ + "\u009b\u0005\u009b\u0545\b\u009b\n\u009b\f\u009b\u0548\t\u009b\u0001\u009b"+ + "\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009c\u0004\u009c"+ + "\u0550\b\u009c\u000b\u009c\f\u009c\u0551\u0001\u009c\u0001\u009c\u0001"+ + "\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0005\u009d\u055a\b\u009d\n"+ + "\u009d\f\u009d\u055d\t\u009d\u0001\u009d\u0001\u009d\u0001\u009e\u0001"+ + "\u009e\u0001\u009e\u0001\u009e\u0003\u009e\u0565\b\u009e\u0001\u009f\u0001"+ + "\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001"+ + "\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001"+ + "\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001"+ + "\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001"+ + "\u009f\u0003\u009f\u0581\b\u009f\u0001\u00a0\u0001\u00a0\u0003\u00a0\u0585"+ + "\b\u00a0\u0001\u00a0\u0005\u00a0\u0588\b\u00a0\n\u00a0\f\u00a0\u058b\t"+ + "\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001"+ + "\u00a3\u0001\u00a4\u0001\u00a4\u0003\u00a4\u0595\b\u00a4\u0001\u00a4\u0001"+ + "\u00a4\u0001\u00a5\u0001\u00a5\u0003\u00a5\u059b\b\u00a5\u0001\u00a6\u0001"+ + "\u00a6\u0001\u00a7\u0001\u00a7\u0001\u00a8\u0004\u00a8\u05a2\b\u00a8\u000b"+ + "\u00a8\f\u00a8\u05a3\u0001\u00a8\u0001\u00a8\u0001\u00a9\u0001\u00a9\u0001"+ + "\u00a9\u0001\u00a9\u0005\u00a9\u05ac\b\u00a9\n\u00a9\f\u00a9\u05af\t\u00a9"+ + "\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00aa"+ + "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0005\u00aa\u05ba\b\u00aa\n\u00aa"+ + "\f\u00aa\u05bd\t\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00ab\u0004\u00ab"+ + "\u05c2\b\u00ab\u000b\u00ab\f\u00ab\u05c3\u0001\u00ab\u0001\u00ab\u0001"+ + "\u00ab\u0001\u00ab\u0001\u00ab\u0005\u00ab\u05cb\b\u00ab\n\u00ab\f\u00ab"+ + "\u05ce\t\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0003\u00ab\u05d3\b"+ + "\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0001"+ + "\u00ac\u0001\u00ac\u0003\u0546\u05ad\u05cc\u0000\u00ad\u0002\u0001\u0004"+ + "\u0002\u0006\u0003\b\u0004\n\u0005\f\u0006\u000e\u0007\u0010\b\u0012\t"+ + "\u0014\n\u0016\u000b\u0018\f\u001a\r\u001c\u000e\u001e\u000f \u0010\""+ + "\u0011$\u0012&\u0013(\u0014*\u0015,\u0016.\u00170\u00182\u00194\u001a"+ + "6\u001b8\u001c:\u001d<\u001e>\u001f@ B!D\"F#H$J%L&N\'P(R)T*V+X,Z-\\.^"+ + "/`0b1d2f3h4j5l6n7p8r9t:v;x~?\u0080@\u0082A\u0084B\u0086C\u0088D\u008a"+ + "E\u008cF\u008eG\u0090H\u0092I\u0094J\u0096K\u0098L\u009aM\u009cN\u009e"+ + "O\u00a0P\u00a2Q\u00a4R\u00a6S\u00a8T\u00aaU\u00acV\u00aeW\u00b0X\u00b2"+ + "Y\u00b4Z\u00b6[\u00b8\\\u00ba]\u00bc^\u00be_\u00c0`\u00c2a\u00c4b\u00c6"+ + "c\u00c8d\u00cae\u00ccf\u00ceg\u00d0h\u00d2i\u00d4j\u00d6k\u00d8l\u00da"+ + "m\u00dcn\u00deo\u00e0p\u00e2q\u00e4r\u00e6s\u00e8t\u00eau\u00ecv\u00ee"+ + "w\u00f0x\u00f2y\u00f4z\u00f6{\u00f8|\u00fa}\u00fc~\u00fe\u007f\u0100\u0080"+ + "\u0102\u0081\u0104\u0082\u0106\u0083\u0108\u0084\u010a\u0085\u010c\u0086"+ + "\u010e\u0087\u0110\u0088\u0112\u0089\u0114\u008a\u0116\u008b\u0118\u008c"+ + "\u011a\u008d\u011c\u008e\u011e\u0000\u0120\u0000\u0122\u008f\u0124\u0000"+ + "\u0126\u0090\u0128\u0091\u012a\u0092\u012c\u0093\u012e\u0094\u0130\u0095"+ + "\u0132\u0096\u0134\u0097\u0136\u0098\u0138\u0099\u013a\u009a\u013c\u009b"+ + "\u013e\u0000\u0140\u0000\u0142\u0000\u0144\u0000\u0146\u0000\u0148\u0000"+ + "\u014a\u0000\u014c\u0000\u014e\u0000\u0150\u0000\u0152\u009c\u0154\u009d"+ + "\u0156\u009e\u0158\u009f\u015a\u00a0\u0002\u0000\u0001\u0013\u0001\u0000"+ + "19\u0001\u000009\u0002\u0000BBbb\u0002\u0000OOoo\u0002\u0000XXxx\u0002"+ + "\u0000PPpp\u0002\u0000++--\u0001\u0000``\u0002\u0000\"\"\\\\\u0002\u0000"+ + "\t\t \u0002\u0000\n\n\r\r\u0003\u0000\n\n\r\r\'\'\t\u0000\"\"\'\'\\\\"+ + "abffnnrrttvv\u0001\u000007\u0003\u000009AFaf\u0001\u000001\u0002\u0000"+ + "EEee>\u000009\u0660\u0669\u06f0\u06f9\u07c0\u07c9\u0966\u096f\u09e6\u09ef"+ + "\u0a66\u0a6f\u0ae6\u0aef\u0b66\u0b6f\u0be6\u0bef\u0c66\u0c6f\u0ce6\u0cef"+ + "\u0d66\u0d6f\u0de6\u0def\u0e50\u0e59\u0ed0\u0ed9\u0f20\u0f29\u1040\u1049"+ + "\u1090\u1099\u17e0\u17e9\u1810\u1819\u1946\u194f\u19d0\u19d9\u1a80\u1a89"+ + "\u1a90\u1a99\u1b50\u1b59\u1bb0\u1bb9\u1c40\u1c49\u1c50\u1c59\u8000\ua620"+ + "\u8000\ua629\u8000\ua8d0\u8000\ua8d9\u8000\ua900\u8000\ua909\u8000\ua9d0"+ + "\u8000\ua9d9\u8000\ua9f0\u8000\ua9f9\u8000\uaa50\u8000\uaa59\u8000\uabf0"+ + "\u8000\uabf9\u8000\uff10\u8000\uff19\u8001\u04a0\u8001\u04a9\u8001\u0d30"+ + "\u8001\u0d39\u8001\u1066\u8001\u106f\u8001\u10f0\u8001\u10f9\u8001\u1136"+ + "\u8001\u113f\u8001\u11d0\u8001\u11d9\u8001\u12f0\u8001\u12f9\u8001\u1450"+ + "\u8001\u1459\u8001\u14d0\u8001\u14d9\u8001\u1650\u8001\u1659\u8001\u16c0"+ + "\u8001\u16c9\u8001\u1730\u8001\u1739\u8001\u18e0\u8001\u18e9\u8001\u1950"+ + "\u8001\u1959\u8001\u1c50\u8001\u1c59\u8001\u1d50\u8001\u1d59\u8001\u1da0"+ + "\u8001\u1da9\u8001\u6a60\u8001\u6a69\u8001\u6ac0\u8001\u6ac9\u8001\u6b50"+ + "\u8001\u6b59\u8001\ud7ce\u8001\ud7ff\u8001\ue140\u8001\ue149\u8001\ue2f0"+ + "\u8001\ue2f9\u8001\ue950\u8001\ue959\u8001\ufbf0\u8001\ufbf9\u0288\u0000"+ + "AZaz\u00aa\u00aa\u00b5\u00b5\u00ba\u00ba\u00c0\u00d6\u00d8\u00f6\u00f8"+ + "\u02c1\u02c6\u02d1\u02e0\u02e4\u02ec\u02ec\u02ee\u02ee\u0370\u0374\u0376"+ + "\u0377\u037a\u037d\u037f\u037f\u0386\u0386\u0388\u038a\u038c\u038c\u038e"+ + "\u03a1\u03a3\u03f5\u03f7\u0481\u048a\u052f\u0531\u0556\u0559\u0559\u0560"+ + "\u0588\u05d0\u05ea\u05ef\u05f2\u0620\u064a\u066e\u066f\u0671\u06d3\u06d5"+ + "\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa\u06fc\u06ff\u06ff\u0710\u0710\u0712"+ + "\u072f\u074d\u07a5\u07b1\u07b1\u07ca\u07ea\u07f4\u07f5\u07fa\u07fa\u0800"+ + "\u0815\u081a\u081a\u0824\u0824\u0828\u0828\u0840\u0858\u0860\u086a\u0870"+ + "\u0887\u0889\u088e\u08a0\u08c9\u0904\u0939\u093d\u093d\u0950\u0950\u0958"+ + "\u0961\u0971\u0980\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2"+ + "\u09b2\u09b6\u09b9\u09bd\u09bd\u09ce\u09ce\u09dc\u09dd\u09df\u09e1\u09f0"+ + "\u09f1\u09fc\u09fc\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a\u0a30\u0a32"+ + "\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72\u0a74\u0a85"+ + "\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5\u0ab9\u0abd"+ + "\u0abd\u0ad0\u0ad0\u0ae0\u0ae1\u0af9\u0af9\u0b05\u0b0c\u0b0f\u0b10\u0b13"+ + "\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b35\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f"+ + "\u0b61\u0b71\u0b71\u0b83\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99"+ + "\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb9\u0bd0"+ + "\u0bd0\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c39\u0c3d\u0c3d\u0c58"+ + "\u0c5a\u0c5d\u0c5d\u0c60\u0c61\u0c80\u0c80\u0c85\u0c8c\u0c8e\u0c90\u0c92"+ + "\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cbd\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1"+ + "\u0cf2\u0d04\u0d0c\u0d0e\u0d10\u0d12\u0d3a\u0d3d\u0d3d\u0d4e\u0d4e\u0d54"+ + "\u0d56\u0d5f\u0d61\u0d7a\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3\u0dbb\u0dbd"+ + "\u0dbd\u0dc0\u0dc6\u0e01\u0e30\u0e32\u0e33\u0e40\u0e46\u0e81\u0e82\u0e84"+ + "\u0e84\u0e86\u0e8a\u0e8c\u0ea3\u0ea5\u0ea5\u0ea7\u0eb0\u0eb2\u0eb3\u0ebd"+ + "\u0ebd\u0ec0\u0ec4\u0ec6\u0ec6\u0edc\u0edf\u0f00\u0f00\u0f40\u0f47\u0f49"+ + "\u0f6c\u0f88\u0f8c\u1000\u102a\u103f\u103f\u1050\u1055\u105a\u105d\u1061"+ + "\u1061\u1065\u1066\u106e\u1070\u1075\u1081\u108e\u108e\u10a0\u10c5\u10c7"+ + "\u10c7\u10cd\u10cd\u10d0\u10fa\u10fc\u1248\u124a\u124d\u1250\u1256\u1258"+ + "\u1258\u125a\u125d\u1260\u1288\u128a\u128d\u1290\u12b0\u12b2\u12b5\u12b8"+ + "\u12be\u12c0\u12c0\u12c2\u12c5\u12c8\u12d6\u12d8\u1310\u1312\u1315\u1318"+ + "\u135a\u1380\u138f\u13a0\u13f5\u13f8\u13fd\u1401\u166c\u166f\u167f\u1681"+ + "\u169a\u16a0\u16ea\u16f1\u16f8\u1700\u1711\u171f\u1731\u1740\u1751\u1760"+ + "\u176c\u176e\u1770\u1780\u17b3\u17d7\u17d7\u17dc\u17dc\u1820\u1878\u1880"+ + "\u1884\u1887\u18a8\u18aa\u18aa\u18b0\u18f5\u1900\u191e\u1950\u196d\u1970"+ + "\u1974\u1980\u19ab\u19b0\u19c9\u1a00\u1a16\u1a20\u1a54\u1aa7\u1aa7\u1b05"+ + "\u1b33\u1b45\u1b4c\u1b83\u1ba0\u1bae\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d"+ + "\u1c4f\u1c5a\u1c7d\u1c80\u1c88\u1c90\u1cba\u1cbd\u1cbf\u1ce9\u1cec\u1cee"+ + "\u1cf3\u1cf5\u1cf6\u1cfa\u1cfa\u1d00\u1dbf\u1e00\u1f15\u1f18\u1f1d\u1f20"+ + "\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f"+ + "\u1f7d\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0"+ + "\u1fd3\u1fd6\u1fdb\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u2071\u2071\u207f"+ + "\u207f\u2090\u209c\u2102\u2102\u2107\u2107\u210a\u2113\u2115\u2115\u2119"+ + "\u211d\u2124\u2124\u2126\u2126\u2128\u2128\u212a\u212d\u212f\u2139\u213c"+ + "\u213f\u2145\u2149\u214e\u214e\u2183\u2184\u2c00\u2ce4\u2ceb\u2cee\u2cf2"+ + "\u2cf3\u2d00\u2d25\u2d27\u2d27\u2d2d\u2d2d\u2d30\u2d67\u2d6f\u2d6f\u2d80"+ + "\u2d96\u2da0\u2da6\u2da8\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8"+ + "\u2dce\u2dd0\u2dd6\u2dd8\u2dde\u2e2f\u2e2f\u3005\u3006\u3031\u3035\u303b"+ + "\u303c\u3041\u3096\u309d\u309f\u30a1\u30fa\u30fc\u30ff\u3105\u312f\u3131"+ + "\u318e\u31a0\u31bf\u31f0\u31ff\u3400\u4dbf\u4e00\u8000\ua48c\u8000\ua4d0"+ + "\u8000\ua4fd\u8000\ua500\u8000\ua60c\u8000\ua610\u8000\ua61f\u8000\ua62a"+ + "\u8000\ua62b\u8000\ua640\u8000\ua66e\u8000\ua67f\u8000\ua69d\u8000\ua6a0"+ + "\u8000\ua6e5\u8000\ua717\u8000\ua71f\u8000\ua722\u8000\ua788\u8000\ua78b"+ + "\u8000\ua7ca\u8000\ua7d0\u8000\ua7d1\u8000\ua7d3\u8000\ua7d3\u8000\ua7d5"+ + "\u8000\ua7d9\u8000\ua7f2\u8000\ua801\u8000\ua803\u8000\ua805\u8000\ua807"+ + "\u8000\ua80a\u8000\ua80c\u8000\ua822\u8000\ua840\u8000\ua873\u8000\ua882"+ + "\u8000\ua8b3\u8000\ua8f2\u8000\ua8f7\u8000\ua8fb\u8000\ua8fb\u8000\ua8fd"+ + "\u8000\ua8fe\u8000\ua90a\u8000\ua925\u8000\ua930\u8000\ua946\u8000\ua960"+ + "\u8000\ua97c\u8000\ua984\u8000\ua9b2\u8000\ua9cf\u8000\ua9cf\u8000\ua9e0"+ + "\u8000\ua9e4\u8000\ua9e6\u8000\ua9ef\u8000\ua9fa\u8000\ua9fe\u8000\uaa00"+ + "\u8000\uaa28\u8000\uaa40\u8000\uaa42\u8000\uaa44\u8000\uaa4b\u8000\uaa60"+ + "\u8000\uaa76\u8000\uaa7a\u8000\uaa7a\u8000\uaa7e\u8000\uaaaf\u8000\uaab1"+ + "\u8000\uaab1\u8000\uaab5\u8000\uaab6\u8000\uaab9\u8000\uaabd\u8000\uaac0"+ + "\u8000\uaac0\u8000\uaac2\u8000\uaac2\u8000\uaadb\u8000\uaadd\u8000\uaae0"+ + "\u8000\uaaea\u8000\uaaf2\u8000\uaaf4\u8000\uab01\u8000\uab06\u8000\uab09"+ + "\u8000\uab0e\u8000\uab11\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28"+ + "\u8000\uab2e\u8000\uab30\u8000\uab5a\u8000\uab5c\u8000\uab69\u8000\uab70"+ + "\u8000\uabe2\u8000\uac00\u8000\ud7a3\u8000\ud7b0\u8000\ud7c6\u8000\ud7cb"+ + "\u8000\ud7fb\u8000\uf900\u8000\ufa6d\u8000\ufa70\u8000\ufad9\u8000\ufb00"+ + "\u8000\ufb06\u8000\ufb13\u8000\ufb17\u8000\ufb1d\u8000\ufb1d\u8000\ufb1f"+ + "\u8000\ufb28\u8000\ufb2a\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e"+ + "\u8000\ufb3e\u8000\ufb40\u8000\ufb41\u8000\ufb43\u8000\ufb44\u8000\ufb46"+ + "\u8000\ufbb1\u8000\ufbd3\u8000\ufd3d\u8000\ufd50\u8000\ufd8f\u8000\ufd92"+ + "\u8000\ufdc7\u8000\ufdf0\u8000\ufdfb\u8000\ufe70\u8000\ufe74\u8000\ufe76"+ + "\u8000\ufefc\u8000\uff21\u8000\uff3a\u8000\uff41\u8000\uff5a\u8000\uff66"+ + "\u8000\uffbe\u8000\uffc2\u8000\uffc7\u8000\uffca\u8000\uffcf\u8000\uffd2"+ + "\u8000\uffd7\u8000\uffda\u8000\uffdc\u8001\u0000\u8001\u000b\u8001\r\u8001"+ + "&\u8001(\u8001:\u8001<\u8001=\u8001?\u8001M\u8001P\u8001]\u8001\u0080"+ + "\u8001\u00fa\u8001\u0280\u8001\u029c\u8001\u02a0\u8001\u02d0\u8001\u0300"+ + "\u8001\u031f\u8001\u032d\u8001\u0340\u8001\u0342\u8001\u0349\u8001\u0350"+ + "\u8001\u0375\u8001\u0380\u8001\u039d\u8001\u03a0\u8001\u03c3\u8001\u03c8"+ + "\u8001\u03cf\u8001\u0400\u8001\u049d\u8001\u04b0\u8001\u04d3\u8001\u04d8"+ + "\u8001\u04fb\u8001\u0500\u8001\u0527\u8001\u0530\u8001\u0563\u8001\u0570"+ + "\u8001\u057a\u8001\u057c\u8001\u058a\u8001\u058c\u8001\u0592\u8001\u0594"+ + "\u8001\u0595\u8001\u0597\u8001\u05a1\u8001\u05a3\u8001\u05b1\u8001\u05b3"+ + "\u8001\u05b9\u8001\u05bb\u8001\u05bc\u8001\u0600\u8001\u0736\u8001\u0740"+ + "\u8001\u0755\u8001\u0760\u8001\u0767\u8001\u0780\u8001\u0785\u8001\u0787"+ + "\u8001\u07b0\u8001\u07b2\u8001\u07ba\u8001\u0800\u8001\u0805\u8001\u0808"+ + "\u8001\u0808\u8001\u080a\u8001\u0835\u8001\u0837\u8001\u0838\u8001\u083c"+ + "\u8001\u083c\u8001\u083f\u8001\u0855\u8001\u0860\u8001\u0876\u8001\u0880"+ + "\u8001\u089e\u8001\u08e0\u8001\u08f2\u8001\u08f4\u8001\u08f5\u8001\u0900"+ + "\u8001\u0915\u8001\u0920\u8001\u0939\u8001\u0980\u8001\u09b7\u8001\u09be"+ + "\u8001\u09bf\u8001\u0a00\u8001\u0a00\u8001\u0a10\u8001\u0a13\u8001\u0a15"+ + "\u8001\u0a17\u8001\u0a19\u8001\u0a35\u8001\u0a60\u8001\u0a7c\u8001\u0a80"+ + "\u8001\u0a9c\u8001\u0ac0\u8001\u0ac7\u8001\u0ac9\u8001\u0ae4\u8001\u0b00"+ + "\u8001\u0b35\u8001\u0b40\u8001\u0b55\u8001\u0b60\u8001\u0b72\u8001\u0b80"+ + "\u8001\u0b91\u8001\u0c00\u8001\u0c48\u8001\u0c80\u8001\u0cb2\u8001\u0cc0"+ + "\u8001\u0cf2\u8001\u0d00\u8001\u0d23\u8001\u0e80\u8001\u0ea9\u8001\u0eb0"+ + "\u8001\u0eb1\u8001\u0f00\u8001\u0f1c\u8001\u0f27\u8001\u0f27\u8001\u0f30"+ + "\u8001\u0f45\u8001\u0f70\u8001\u0f81\u8001\u0fb0\u8001\u0fc4\u8001\u0fe0"+ + "\u8001\u0ff6\u8001\u1003\u8001\u1037\u8001\u1071\u8001\u1072\u8001\u1075"+ + "\u8001\u1075\u8001\u1083\u8001\u10af\u8001\u10d0\u8001\u10e8\u8001\u1103"+ + "\u8001\u1126\u8001\u1144\u8001\u1144\u8001\u1147\u8001\u1147\u8001\u1150"+ + "\u8001\u1172\u8001\u1176\u8001\u1176\u8001\u1183\u8001\u11b2\u8001\u11c1"+ + "\u8001\u11c4\u8001\u11da\u8001\u11da\u8001\u11dc\u8001\u11dc\u8001\u1200"+ + "\u8001\u1211\u8001\u1213\u8001\u122b\u8001\u1280\u8001\u1286\u8001\u1288"+ + "\u8001\u1288\u8001\u128a\u8001\u128d\u8001\u128f\u8001\u129d\u8001\u129f"+ + "\u8001\u12a8\u8001\u12b0\u8001\u12de\u8001\u1305\u8001\u130c\u8001\u130f"+ + "\u8001\u1310\u8001\u1313\u8001\u1328\u8001\u132a\u8001\u1330\u8001\u1332"+ + "\u8001\u1333\u8001\u1335\u8001\u1339\u8001\u133d\u8001\u133d\u8001\u1350"+ + "\u8001\u1350\u8001\u135d\u8001\u1361\u8001\u1400\u8001\u1434\u8001\u1447"+ + "\u8001\u144a\u8001\u145f\u8001\u1461\u8001\u1480\u8001\u14af\u8001\u14c4"+ + "\u8001\u14c5\u8001\u14c7\u8001\u14c7\u8001\u1580\u8001\u15ae\u8001\u15d8"+ + "\u8001\u15db\u8001\u1600\u8001\u162f\u8001\u1644\u8001\u1644\u8001\u1680"+ + "\u8001\u16aa\u8001\u16b8\u8001\u16b8\u8001\u1700\u8001\u171a\u8001\u1740"+ + "\u8001\u1746\u8001\u1800\u8001\u182b\u8001\u18a0\u8001\u18df\u8001\u18ff"+ + "\u8001\u1906\u8001\u1909\u8001\u1909\u8001\u190c\u8001\u1913\u8001\u1915"+ + "\u8001\u1916\u8001\u1918\u8001\u192f\u8001\u193f\u8001\u193f\u8001\u1941"+ + "\u8001\u1941\u8001\u19a0\u8001\u19a7\u8001\u19aa\u8001\u19d0\u8001\u19e1"+ + "\u8001\u19e1\u8001\u19e3\u8001\u19e3\u8001\u1a00\u8001\u1a00\u8001\u1a0b"+ + "\u8001\u1a32\u8001\u1a3a\u8001\u1a3a\u8001\u1a50\u8001\u1a50\u8001\u1a5c"+ + "\u8001\u1a89\u8001\u1a9d\u8001\u1a9d\u8001\u1ab0\u8001\u1af8\u8001\u1c00"+ + "\u8001\u1c08\u8001\u1c0a\u8001\u1c2e\u8001\u1c40\u8001\u1c40\u8001\u1c72"+ + "\u8001\u1c8f\u8001\u1d00\u8001\u1d06\u8001\u1d08\u8001\u1d09\u8001\u1d0b"+ + "\u8001\u1d30\u8001\u1d46\u8001\u1d46\u8001\u1d60\u8001\u1d65\u8001\u1d67"+ + "\u8001\u1d68\u8001\u1d6a\u8001\u1d89\u8001\u1d98\u8001\u1d98\u8001\u1ee0"+ + "\u8001\u1ef2\u8001\u1fb0\u8001\u1fb0\u8001\u2000\u8001\u2399\u8001\u2480"+ + "\u8001\u2543\u8001\u2f90\u8001\u2ff0\u8001\u3000\u8001\u342e\u8001\u4400"+ + "\u8001\u4646\u8001\u6800\u8001\u6a38\u8001\u6a40\u8001\u6a5e\u8001\u6a70"+ + "\u8001\u6abe\u8001\u6ad0\u8001\u6aed\u8001\u6b00\u8001\u6b2f\u8001\u6b40"+ + "\u8001\u6b43\u8001\u6b63\u8001\u6b77\u8001\u6b7d\u8001\u6b8f\u8001\u6e40"+ + "\u8001\u6e7f\u8001\u6f00\u8001\u6f4a\u8001\u6f50\u8001\u6f50\u8001\u6f93"+ + "\u8001\u6f9f\u8001\u6fe0\u8001\u6fe1\u8001\u6fe3\u8001\u6fe3\u8001\u7000"+ + "\u8001\u87f7\u8001\u8800\u8001\u8cd5\u8001\u8d00\u8001\u8d08\u8001\uaff0"+ + "\u8001\uaff3\u8001\uaff5\u8001\uaffb\u8001\uaffd\u8001\uaffe\u8001\ub000"+ + "\u8001\ub122\u8001\ub150\u8001\ub152\u8001\ub164\u8001\ub167\u8001\ub170"+ + "\u8001\ub2fb\u8001\ubc00\u8001\ubc6a\u8001\ubc70\u8001\ubc7c\u8001\ubc80"+ + "\u8001\ubc88\u8001\ubc90\u8001\ubc99\u8001\ud400\u8001\ud454\u8001\ud456"+ + "\u8001\ud49c\u8001\ud49e\u8001\ud49f\u8001\ud4a2\u8001\ud4a2\u8001\ud4a5"+ + "\u8001\ud4a6\u8001\ud4a9\u8001\ud4ac\u8001\ud4ae\u8001\ud4b9\u8001\ud4bb"+ + "\u8001\ud4bb\u8001\ud4bd\u8001\ud4c3\u8001\ud4c5\u8001\ud505\u8001\ud507"+ + "\u8001\ud50a\u8001\ud50d\u8001\ud514\u8001\ud516\u8001\ud51c\u8001\ud51e"+ + "\u8001\ud539\u8001\ud53b\u8001\ud53e\u8001\ud540\u8001\ud544\u8001\ud546"+ + "\u8001\ud546\u8001\ud54a\u8001\ud550\u8001\ud552\u8001\ud6a5\u8001\ud6a8"+ + "\u8001\ud6c0\u8001\ud6c2\u8001\ud6da\u8001\ud6dc\u8001\ud6fa\u8001\ud6fc"+ + "\u8001\ud714\u8001\ud716\u8001\ud734\u8001\ud736\u8001\ud74e\u8001\ud750"+ + "\u8001\ud76e\u8001\ud770\u8001\ud788\u8001\ud78a\u8001\ud7a8\u8001\ud7aa"+ + "\u8001\ud7c2\u8001\ud7c4\u8001\ud7cb\u8001\udf00\u8001\udf1e\u8001\ue100"+ + "\u8001\ue12c\u8001\ue137\u8001\ue13d\u8001\ue14e\u8001\ue14e\u8001\ue290"+ + "\u8001\ue2ad\u8001\ue2c0\u8001\ue2eb\u8001\ue7e0\u8001\ue7e6\u8001\ue7e8"+ + "\u8001\ue7eb\u8001\ue7ed\u8001\ue7ee\u8001\ue7f0\u8001\ue7fe\u8001\ue800"+ + "\u8001\ue8c4\u8001\ue900\u8001\ue943\u8001\ue94b\u8001\ue94b\u8001\uee00"+ + "\u8001\uee03\u8001\uee05\u8001\uee1f\u8001\uee21\u8001\uee22\u8001\uee24"+ + "\u8001\uee24\u8001\uee27\u8001\uee27\u8001\uee29\u8001\uee32\u8001\uee34"+ + "\u8001\uee37\u8001\uee39\u8001\uee39\u8001\uee3b\u8001\uee3b\u8001\uee42"+ + "\u8001\uee42\u8001\uee47\u8001\uee47\u8001\uee49\u8001\uee49\u8001\uee4b"+ + "\u8001\uee4b\u8001\uee4d\u8001\uee4f\u8001\uee51\u8001\uee52\u8001\uee54"+ + "\u8001\uee54\u8001\uee57\u8001\uee57\u8001\uee59\u8001\uee59\u8001\uee5b"+ + "\u8001\uee5b\u8001\uee5d\u8001\uee5d\u8001\uee5f\u8001\uee5f\u8001\uee61"+ + "\u8001\uee62\u8001\uee64\u8001\uee64\u8001\uee67\u8001\uee6a\u8001\uee6c"+ + "\u8001\uee72\u8001\uee74\u8001\uee77\u8001\uee79\u8001\uee7c\u8001\uee7e"+ + "\u8001\uee7e\u8001\uee80\u8001\uee89\u8001\uee8b\u8001\uee9b\u8001\ueea1"+ + "\u8001\ueea3\u8001\ueea5\u8001\ueea9\u8001\ueeab\u8001\ueebb\u8002\u0000"+ + "\u8002\ua6df\u8002\ua700\u8002\ub738\u8002\ub740\u8002\ub81d\u8002\ub820"+ + "\u8002\ucea1\u8002\uceb0\u8002\uebe0\u8002\uf800\u8002\ufa1d\u8003\u0000"+ + "\u8003\u134a\u0607\u0000\u0002\u0001\u0000\u0000\u0000\u0000\u0004\u0001"+ + "\u0000\u0000\u0000\u0000\u0006\u0001\u0000\u0000\u0000\u0000\b\u0001\u0000"+ + "\u0000\u0000\u0000\n\u0001\u0000\u0000\u0000\u0000\f\u0001\u0000\u0000"+ + "\u0000\u0000\u000e\u0001\u0000\u0000\u0000\u0000\u0010\u0001\u0000\u0000"+ + "\u0000\u0000\u0012\u0001\u0000\u0000\u0000\u0000\u0014\u0001\u0000\u0000"+ + "\u0000\u0000\u0016\u0001\u0000\u0000\u0000\u0000\u0018\u0001\u0000\u0000"+ + "\u0000\u0000\u001a\u0001\u0000\u0000\u0000\u0000\u001c\u0001\u0000\u0000"+ + "\u0000\u0000\u001e\u0001\u0000\u0000\u0000\u0000 \u0001\u0000\u0000\u0000"+ + "\u0000\"\u0001\u0000\u0000\u0000\u0000$\u0001\u0000\u0000\u0000\u0000"+ + "&\u0001\u0000\u0000\u0000\u0000(\u0001\u0000\u0000\u0000\u0000*\u0001"+ + "\u0000\u0000\u0000\u0000,\u0001\u0000\u0000\u0000\u0000.\u0001\u0000\u0000"+ + "\u0000\u00000\u0001\u0000\u0000\u0000\u00002\u0001\u0000\u0000\u0000\u0000"+ + "4\u0001\u0000\u0000\u0000\u00006\u0001\u0000\u0000\u0000\u00008\u0001"+ + "\u0000\u0000\u0000\u0000:\u0001\u0000\u0000\u0000\u0000<\u0001\u0000\u0000"+ + "\u0000\u0000>\u0001\u0000\u0000\u0000\u0000@\u0001\u0000\u0000\u0000\u0000"+ + "B\u0001\u0000\u0000\u0000\u0000D\u0001\u0000\u0000\u0000\u0000F\u0001"+ + "\u0000\u0000\u0000\u0000H\u0001\u0000\u0000\u0000\u0000J\u0001\u0000\u0000"+ + "\u0000\u0000L\u0001\u0000\u0000\u0000\u0000N\u0001\u0000\u0000\u0000\u0000"+ + "P\u0001\u0000\u0000\u0000\u0000R\u0001\u0000\u0000\u0000\u0000T\u0001"+ + "\u0000\u0000\u0000\u0000V\u0001\u0000\u0000\u0000\u0000X\u0001\u0000\u0000"+ + "\u0000\u0000Z\u0001\u0000\u0000\u0000\u0000\\\u0001\u0000\u0000\u0000"+ + "\u0000^\u0001\u0000\u0000\u0000\u0000`\u0001\u0000\u0000\u0000\u0000b"+ + "\u0001\u0000\u0000\u0000\u0000d\u0001\u0000\u0000\u0000\u0000f\u0001\u0000"+ + "\u0000\u0000\u0000h\u0001\u0000\u0000\u0000\u0000j\u0001\u0000\u0000\u0000"+ + "\u0000l\u0001\u0000\u0000\u0000\u0000n\u0001\u0000\u0000\u0000\u0000p"+ + "\u0001\u0000\u0000\u0000\u0000r\u0001\u0000\u0000\u0000\u0000t\u0001\u0000"+ + "\u0000\u0000\u0000v\u0001\u0000\u0000\u0000\u0000x\u0001\u0000\u0000\u0000"+ + "\u0000z\u0001\u0000\u0000\u0000\u0000|\u0001\u0000\u0000\u0000\u0000~"+ + "\u0001\u0000\u0000\u0000\u0000\u0080\u0001\u0000\u0000\u0000\u0000\u0082"+ + "\u0001\u0000\u0000\u0000\u0000\u0084\u0001\u0000\u0000\u0000\u0000\u0086"+ + "\u0001\u0000\u0000\u0000\u0000\u0088\u0001\u0000\u0000\u0000\u0000\u008a"+ + "\u0001\u0000\u0000\u0000\u0000\u008c\u0001\u0000\u0000\u0000\u0000\u008e"+ + "\u0001\u0000\u0000\u0000\u0000\u0090\u0001\u0000\u0000\u0000\u0000\u0092"+ + "\u0001\u0000\u0000\u0000\u0000\u0094\u0001\u0000\u0000\u0000\u0000\u0096"+ + "\u0001\u0000\u0000\u0000\u0000\u0098\u0001\u0000\u0000\u0000\u0000\u009a"+ + "\u0001\u0000\u0000\u0000\u0000\u009c\u0001\u0000\u0000\u0000\u0000\u009e"+ + "\u0001\u0000\u0000\u0000\u0000\u00a0\u0001\u0000\u0000\u0000\u0000\u00a2"+ + "\u0001\u0000\u0000\u0000\u0000\u00a4\u0001\u0000\u0000\u0000\u0000\u00a6"+ + "\u0001\u0000\u0000\u0000\u0000\u00a8\u0001\u0000\u0000\u0000\u0000\u00aa"+ + "\u0001\u0000\u0000\u0000\u0000\u00ac\u0001\u0000\u0000\u0000\u0000\u00ae"+ + "\u0001\u0000\u0000\u0000\u0000\u00b0\u0001\u0000\u0000\u0000\u0000\u00b2"+ + "\u0001\u0000\u0000\u0000\u0000\u00b4\u0001\u0000\u0000\u0000\u0000\u00b6"+ + "\u0001\u0000\u0000\u0000\u0000\u00b8\u0001\u0000\u0000\u0000\u0000\u00ba"+ + "\u0001\u0000\u0000\u0000\u0000\u00bc\u0001\u0000\u0000\u0000\u0000\u00be"+ + "\u0001\u0000\u0000\u0000\u0000\u00c0\u0001\u0000\u0000\u0000\u0000\u00c2"+ + "\u0001\u0000\u0000\u0000\u0000\u00c4\u0001\u0000\u0000\u0000\u0000\u00c6"+ + "\u0001\u0000\u0000\u0000\u0000\u00c8\u0001\u0000\u0000\u0000\u0000\u00ca"+ + "\u0001\u0000\u0000\u0000\u0000\u00cc\u0001\u0000\u0000\u0000\u0000\u00ce"+ + "\u0001\u0000\u0000\u0000\u0000\u00d0\u0001\u0000\u0000\u0000\u0000\u00d2"+ + "\u0001\u0000\u0000\u0000\u0000\u00d4\u0001\u0000\u0000\u0000\u0000\u00d6"+ + "\u0001\u0000\u0000\u0000\u0000\u00d8\u0001\u0000\u0000\u0000\u0000\u00da"+ + "\u0001\u0000\u0000\u0000\u0000\u00dc\u0001\u0000\u0000\u0000\u0000\u00de"+ + "\u0001\u0000\u0000\u0000\u0000\u00e0\u0001\u0000\u0000\u0000\u0000\u00e2"+ + "\u0001\u0000\u0000\u0000\u0000\u00e4\u0001\u0000\u0000\u0000\u0000\u00e6"+ + "\u0001\u0000\u0000\u0000\u0000\u00e8\u0001\u0000\u0000\u0000\u0000\u00ea"+ + "\u0001\u0000\u0000\u0000\u0000\u00ec\u0001\u0000\u0000\u0000\u0000\u00ee"+ + "\u0001\u0000\u0000\u0000\u0000\u00f0\u0001\u0000\u0000\u0000\u0000\u00f2"+ + "\u0001\u0000\u0000\u0000\u0000\u00f4\u0001\u0000\u0000\u0000\u0000\u00f6"+ + "\u0001\u0000\u0000\u0000\u0000\u00f8\u0001\u0000\u0000\u0000\u0000\u00fa"+ + "\u0001\u0000\u0000\u0000\u0000\u00fc\u0001\u0000\u0000\u0000\u0000\u00fe"+ + "\u0001\u0000\u0000\u0000\u0000\u0100\u0001\u0000\u0000\u0000\u0000\u0102"+ + "\u0001\u0000\u0000\u0000\u0000\u0104\u0001\u0000\u0000\u0000\u0000\u0106"+ + "\u0001\u0000\u0000\u0000\u0000\u0108\u0001\u0000\u0000\u0000\u0000\u010a"+ + "\u0001\u0000\u0000\u0000\u0000\u010c\u0001\u0000\u0000\u0000\u0000\u010e"+ + "\u0001\u0000\u0000\u0000\u0000\u0110\u0001\u0000\u0000\u0000\u0000\u0112"+ + "\u0001\u0000\u0000\u0000\u0000\u0114\u0001\u0000\u0000\u0000\u0000\u0116"+ + "\u0001\u0000\u0000\u0000\u0000\u0118\u0001\u0000\u0000\u0000\u0000\u011a"+ + "\u0001\u0000\u0000\u0000\u0000\u011c\u0001\u0000\u0000\u0000\u0000\u0122"+ + "\u0001\u0000\u0000\u0000\u0000\u0126\u0001\u0000\u0000\u0000\u0000\u0128"+ + "\u0001\u0000\u0000\u0000\u0000\u012a\u0001\u0000\u0000\u0000\u0000\u012c"+ + "\u0001\u0000\u0000\u0000\u0000\u012e\u0001\u0000\u0000\u0000\u0000\u0130"+ + "\u0001\u0000\u0000\u0000\u0000\u0132\u0001\u0000\u0000\u0000\u0000\u0134"+ + "\u0001\u0000\u0000\u0000\u0000\u0136\u0001\u0000\u0000\u0000\u0000\u0138"+ + "\u0001\u0000\u0000\u0000\u0000\u013a\u0001\u0000\u0000\u0000\u0000\u013c"+ + "\u0001\u0000\u0000\u0000\u0001\u0152\u0001\u0000\u0000\u0000\u0001\u0154"+ + "\u0001\u0000\u0000\u0000\u0001\u0156\u0001\u0000\u0000\u0000\u0001\u0158"+ + "\u0001\u0000\u0000\u0000\u0001\u015a\u0001\u0000\u0000\u0000\u0002\u015e"+ + "\u0001\u0000\u0000\u0000\u0004\u0174\u0001\u0000\u0000\u0000\u0006\u0176"+ + "\u0001\u0000\u0000\u0000\b\u017d\u0001\u0000\u0000\u0000\n\u0185\u0001"+ + "\u0000\u0000\u0000\f\u018c\u0001\u0000\u0000\u0000\u000e\u0193\u0001\u0000"+ + "\u0000\u0000\u0010\u019a\u0001\u0000\u0000\u0000\u0012\u01a1\u0001\u0000"+ + "\u0000\u0000\u0014\u01aa\u0001\u0000\u0000\u0000\u0016\u01b4\u0001\u0000"+ + "\u0000\u0000\u0018\u01bc\u0001\u0000\u0000\u0000\u001a\u01c6\u0001\u0000"+ + "\u0000\u0000\u001c\u01d2\u0001\u0000\u0000\u0000\u001e\u01d9\u0001\u0000"+ + "\u0000\u0000 \u01e4\u0001\u0000\u0000\u0000\"\u01e7\u0001\u0000\u0000"+ + "\u0000$\u01ed\u0001\u0000\u0000\u0000&\u01f6\u0001\u0000\u0000\u0000("+ + "\u01fb\u0001\u0000\u0000\u0000*\u0202\u0001\u0000\u0000\u0000,\u0209\u0001"+ + "\u0000\u0000\u0000.\u020f\u0001\u0000\u0000\u00000\u0214\u0001\u0000\u0000"+ + "\u00002\u021b\u0001\u0000\u0000\u00004\u0225\u0001\u0000\u0000\u00006"+ + "\u0229\u0001\u0000\u0000\u00008\u022f\u0001\u0000\u0000\u0000:\u0232\u0001"+ + "\u0000\u0000\u0000<\u0234\u0001\u0000\u0000\u0000>\u023b\u0001\u0000\u0000"+ + "\u0000@\u0241\u0001\u0000\u0000\u0000B\u024e\u0001\u0000\u0000\u0000D"+ + "\u0257\u0001\u0000\u0000\u0000F\u025b\u0001\u0000\u0000\u0000H\u025f\u0001"+ + "\u0000\u0000\u0000J\u0265\u0001\u0000\u0000\u0000L\u0267\u0001\u0000\u0000"+ + "\u0000N\u026a\u0001\u0000\u0000\u0000P\u026f\u0001\u0000\u0000\u0000R"+ + "\u0275\u0001\u0000\u0000\u0000T\u027b\u0001\u0000\u0000\u0000V\u0282\u0001"+ + "\u0000\u0000\u0000X\u0289\u0001\u0000\u0000\u0000Z\u0292\u0001\u0000\u0000"+ + "\u0000\\\u0298\u0001\u0000\u0000\u0000^\u029e\u0001\u0000\u0000\u0000"+ + "`\u02a5\u0001\u0000\u0000\u0000b\u02ab\u0001\u0000\u0000\u0000d\u02b2"+ + "\u0001\u0000\u0000\u0000f\u02b8\u0001\u0000\u0000\u0000h\u02c1\u0001\u0000"+ + "\u0000\u0000j\u02c9\u0001\u0000\u0000\u0000l\u02cf\u0001\u0000\u0000\u0000"+ + "n\u02d7\u0001\u0000\u0000\u0000p\u02de\u0001\u0000\u0000\u0000r\u02e3"+ + "\u0001\u0000\u0000\u0000t\u02ec\u0001\u0000\u0000\u0000v\u02fb\u0001\u0000"+ + "\u0000\u0000x\u0301\u0001\u0000\u0000\u0000z\u0305\u0001\u0000\u0000\u0000"+ + "|\u0308\u0001\u0000\u0000\u0000~\u030f\u0001\u0000\u0000\u0000\u0080\u0319"+ + "\u0001\u0000\u0000\u0000\u0082\u0323\u0001\u0000\u0000\u0000\u0084\u032f"+ + "\u0001\u0000\u0000\u0000\u0086\u0338\u0001\u0000\u0000\u0000\u0088\u0342"+ + "\u0001\u0000\u0000\u0000\u008a\u034a\u0001\u0000\u0000\u0000\u008c\u0356"+ + "\u0001\u0000\u0000\u0000\u008e\u0365\u0001\u0000\u0000\u0000\u0090\u036b"+ + "\u0001\u0000\u0000\u0000\u0092\u036f\u0001\u0000\u0000\u0000\u0094\u0373"+ + "\u0001\u0000\u0000\u0000\u0096\u0378\u0001\u0000\u0000\u0000\u0098\u0380"+ + "\u0001\u0000\u0000\u0000\u009a\u0388\u0001\u0000\u0000\u0000\u009c\u038d"+ + "\u0001\u0000\u0000\u0000\u009e\u0397\u0001\u0000\u0000\u0000\u00a0\u039e"+ + "\u0001\u0000\u0000\u0000\u00a2\u03a3\u0001\u0000\u0000\u0000\u00a4\u03a9"+ + "\u0001\u0000\u0000\u0000\u00a6\u03ac\u0001\u0000\u0000\u0000\u00a8\u03b0"+ + "\u0001\u0000\u0000\u0000\u00aa\u03b7\u0001\u0000\u0000\u0000\u00ac\u03bc"+ + "\u0001\u0000\u0000\u0000\u00ae\u03c1\u0001\u0000\u0000\u0000\u00b0\u03c6"+ + "\u0001\u0000\u0000\u0000\u00b2\u03ce\u0001\u0000\u0000\u0000\u00b4\u03d5"+ + "\u0001\u0000\u0000\u0000\u00b6\u03db\u0001\u0000\u0000\u0000\u00b8\u03e9"+ + "\u0001\u0000\u0000\u0000\u00ba\u03ec\u0001\u0000\u0000\u0000\u00bc\u03f2"+ + "\u0001\u0000\u0000\u0000\u00be\u03f7\u0001\u0000\u0000\u0000\u00c0\u0402"+ + "\u0001\u0000\u0000\u0000\u00c2\u0406\u0001\u0000\u0000\u0000\u00c4\u040d"+ + "\u0001\u0000\u0000\u0000\u00c6\u0416\u0001\u0000\u0000\u0000\u00c8\u041a"+ + "\u0001\u0000\u0000\u0000\u00ca\u0420\u0001\u0000\u0000\u0000\u00cc\u042a"+ + "\u0001\u0000\u0000\u0000\u00ce\u042c\u0001\u0000\u0000\u0000\u00d0\u0430"+ + "\u0001\u0000\u0000\u0000\u00d2\u0432\u0001\u0000\u0000\u0000\u00d4\u0436"+ + "\u0001\u0000\u0000\u0000\u00d6\u0438\u0001\u0000\u0000\u0000\u00d8\u043c"+ + "\u0001\u0000\u0000\u0000\u00da\u043e\u0001\u0000\u0000\u0000\u00dc\u0440"+ + "\u0001\u0000\u0000\u0000\u00de\u0442\u0001\u0000\u0000\u0000\u00e0\u0444"+ + "\u0001\u0000\u0000\u0000\u00e2\u0446\u0001\u0000\u0000\u0000\u00e4\u044b"+ + "\u0001\u0000\u0000\u0000\u00e6\u0450\u0001\u0000\u0000\u0000\u00e8\u0453"+ + "\u0001\u0000\u0000\u0000\u00ea\u0457\u0001\u0000\u0000\u0000\u00ec\u045a"+ + "\u0001\u0000\u0000\u0000\u00ee\u045d\u0001\u0000\u0000\u0000\u00f0\u0460"+ + "\u0001\u0000\u0000\u0000\u00f2\u0463\u0001\u0000\u0000\u0000\u00f4\u0465"+ + "\u0001\u0000\u0000\u0000\u00f6\u0468\u0001\u0000\u0000\u0000\u00f8\u046a"+ + "\u0001\u0000\u0000\u0000\u00fa\u046d\u0001\u0000\u0000\u0000\u00fc\u046f"+ + "\u0001\u0000\u0000\u0000\u00fe\u0471\u0001\u0000\u0000\u0000\u0100\u0473"+ + "\u0001\u0000\u0000\u0000\u0102\u0476\u0001\u0000\u0000\u0000\u0104\u0479"+ + "\u0001\u0000\u0000\u0000\u0106\u047c\u0001\u0000\u0000\u0000\u0108\u047e"+ + "\u0001\u0000\u0000\u0000\u010a\u0480\u0001\u0000\u0000\u0000\u010c\u0482"+ + "\u0001\u0000\u0000\u0000\u010e\u0484\u0001\u0000\u0000\u0000\u0110\u0486"+ + "\u0001\u0000\u0000\u0000\u0112\u0488\u0001\u0000\u0000\u0000\u0114\u0496"+ + "\u0001\u0000\u0000\u0000\u0116\u049a\u0001\u0000\u0000\u0000\u0118\u04a6"+ + "\u0001\u0000\u0000\u0000\u011a\u04b4\u0001\u0000\u0000\u0000\u011c\u04c0"+ + "\u0001\u0000\u0000\u0000\u011e\u04e4\u0001\u0000\u0000\u0000\u0120\u04e6"+ + "\u0001\u0000\u0000\u0000\u0122\u04f1\u0001\u0000\u0000\u0000\u0124\u04f7"+ + "\u0001\u0000\u0000\u0000\u0126\u04fe\u0001\u0000\u0000\u0000\u0128\u0504"+ + "\u0001\u0000\u0000\u0000\u012a\u0506\u0001\u0000\u0000\u0000\u012c\u050b"+ + "\u0001\u0000\u0000\u0000\u012e\u0510\u0001\u0000\u0000\u0000\u0130\u0517"+ + "\u0001\u0000\u0000\u0000\u0132\u0522\u0001\u0000\u0000\u0000\u0134\u052d"+ + "\u0001\u0000\u0000\u0000\u0136\u053a\u0001\u0000\u0000\u0000\u0138\u0540"+ + "\u0001\u0000\u0000\u0000\u013a\u054f\u0001\u0000\u0000\u0000\u013c\u0555"+ + "\u0001\u0000\u0000\u0000\u013e\u0564\u0001\u0000\u0000\u0000\u0140\u0566"+ + "\u0001\u0000\u0000\u0000\u0142\u0582\u0001\u0000\u0000\u0000\u0144\u058c"+ + "\u0001\u0000\u0000\u0000\u0146\u058e\u0001\u0000\u0000\u0000\u0148\u0590"+ + "\u0001\u0000\u0000\u0000\u014a\u0592\u0001\u0000\u0000\u0000\u014c\u059a"+ + "\u0001\u0000\u0000\u0000\u014e\u059c\u0001\u0000\u0000\u0000\u0150\u059e"+ + "\u0001\u0000\u0000\u0000\u0152\u05a1\u0001\u0000\u0000\u0000\u0154\u05a7"+ + "\u0001\u0000\u0000\u0000\u0156\u05b5\u0001\u0000\u0000\u0000\u0158\u05d2"+ + "\u0001\u0000\u0000\u0000\u015a\u05d6\u0001\u0000\u0000\u0000\u015c\u015f"+ + "\u0003\u0004\u0001\u0000\u015d\u015f\u0003\u011c\u008d\u0000\u015e\u015c"+ + "\u0001\u0000\u0000\u0000\u015e\u015d\u0001\u0000\u0000\u0000\u015f\u0160"+ + "\u0001\u0000\u0000\u0000\u0160\u0161\u0006\u0000\u0000\u0000\u0161\u0003"+ + "\u0001\u0000\u0000\u0000\u0162\u016c\u0003\u0142\u00a0\u0000\u0163\u0164"+ + "\u0005.\u0000\u0000\u0164\u0166\u0004\u0001\u0000\u0000\u0165\u0167\u0003"+ + "\u0142\u00a0\u0000\u0166\u0165\u0001\u0000\u0000\u0000\u0166\u0167\u0001"+ + "\u0000\u0000\u0000\u0167\u0169\u0001\u0000\u0000\u0000\u0168\u016a\u0003"+ + "\u014a\u00a4\u0000\u0169\u0168\u0001\u0000\u0000\u0000\u0169\u016a\u0001"+ + "\u0000\u0000\u0000\u016a\u016d\u0001\u0000\u0000\u0000\u016b\u016d\u0003"+ + "\u014a\u00a4\u0000\u016c\u0163\u0001\u0000\u0000\u0000\u016c\u016b\u0001"+ + "\u0000\u0000\u0000\u016d\u0175\u0001\u0000\u0000\u0000\u016e\u016f\u0005"+ + ".\u0000\u0000\u016f\u0170\u0004\u0001\u0001\u0000\u0170\u0172\u0003\u0142"+ + "\u00a0\u0000\u0171\u0173\u0003\u014a\u00a4\u0000\u0172\u0171\u0001\u0000"+ + "\u0000\u0000\u0172\u0173\u0001\u0000\u0000\u0000\u0173\u0175\u0001\u0000"+ + "\u0000\u0000\u0174\u0162\u0001\u0000\u0000\u0000\u0174\u016e\u0001\u0000"+ + "\u0000\u0000\u0175\u0005\u0001\u0000\u0000\u0000\u0176\u0177\u0005t\u0000"+ + "\u0000\u0177\u0178\u0005r\u0000\u0000\u0178\u0179\u0005u\u0000\u0000\u0179"+ + "\u017a\u0005e\u0000\u0000\u017a\u017b\u0001\u0000\u0000\u0000\u017b\u017c"+ + "\u0006\u0002\u0000\u0000\u017c\u0007\u0001\u0000\u0000\u0000\u017d\u017e"+ + "\u0005f\u0000\u0000\u017e\u017f\u0005a\u0000\u0000\u017f\u0180\u0005l"+ + "\u0000\u0000\u0180\u0181\u0005s\u0000\u0000\u0181\u0182\u0005e\u0000\u0000"+ + "\u0182\u0183\u0001\u0000\u0000\u0000\u0183\u0184\u0006\u0003\u0000\u0000"+ + "\u0184\t\u0001\u0000\u0000\u0000\u0185\u0186\u0005a\u0000\u0000\u0186"+ + "\u0187\u0005s\u0000\u0000\u0187\u0188\u0005s\u0000\u0000\u0188\u0189\u0005"+ + "e\u0000\u0000\u0189\u018a\u0005r\u0000\u0000\u018a\u018b\u0005t\u0000"+ + "\u0000\u018b\u000b\u0001\u0000\u0000\u0000\u018c\u018d\u0005a\u0000\u0000"+ + "\u018d\u018e\u0005s\u0000\u0000\u018e\u018f\u0005s\u0000\u0000\u018f\u0190"+ + "\u0005u\u0000\u0000\u0190\u0191\u0005m\u0000\u0000\u0191\u0192\u0005e"+ + "\u0000\u0000\u0192\r\u0001\u0000\u0000\u0000\u0193\u0194\u0005i\u0000"+ + "\u0000\u0194\u0195\u0005n\u0000\u0000\u0195\u0196\u0005h\u0000\u0000\u0196"+ + "\u0197\u0005a\u0000\u0000\u0197\u0198\u0005l\u0000\u0000\u0198\u0199\u0005"+ + "e\u0000\u0000\u0199\u000f\u0001\u0000\u0000\u0000\u019a\u019b\u0005e\u0000"+ + "\u0000\u019b\u019c\u0005x\u0000\u0000\u019c\u019d\u0005h\u0000\u0000\u019d"+ + "\u019e\u0005a\u0000\u0000\u019e\u019f\u0005l\u0000\u0000\u019f\u01a0\u0005"+ + "e\u0000\u0000\u01a0\u0011\u0001\u0000\u0000\u0000\u01a1\u01a2\u0005r\u0000"+ + "\u0000\u01a2\u01a3\u0005e\u0000\u0000\u01a3\u01a4\u0005q\u0000\u0000\u01a4"+ + "\u01a5\u0005u\u0000\u0000\u01a5\u01a6\u0005i\u0000\u0000\u01a6\u01a7\u0005"+ + "r\u0000\u0000\u01a7\u01a8\u0005e\u0000\u0000\u01a8\u01a9\u0005s\u0000"+ + "\u0000\u01a9\u0013\u0001\u0000\u0000\u0000\u01aa\u01ab\u0005p\u0000\u0000"+ + "\u01ab\u01ac\u0005r\u0000\u0000\u01ac\u01ad\u0005e\u0000\u0000\u01ad\u01ae"+ + "\u0005s\u0000\u0000\u01ae\u01af\u0005e\u0000\u0000\u01af\u01b0\u0005r"+ + "\u0000\u0000\u01b0\u01b1\u0005v\u0000\u0000\u01b1\u01b2\u0005e\u0000\u0000"+ + "\u01b2\u01b3\u0005s\u0000\u0000\u01b3\u0015\u0001\u0000\u0000\u0000\u01b4"+ + "\u01b5\u0005e\u0000\u0000\u01b5\u01b6\u0005n\u0000\u0000\u01b6\u01b7\u0005"+ + "s\u0000\u0000\u01b7\u01b8\u0005u\u0000\u0000\u01b8\u01b9\u0005r\u0000"+ + "\u0000\u01b9\u01ba\u0005e\u0000\u0000\u01ba\u01bb\u0005s\u0000\u0000\u01bb"+ + "\u0017\u0001\u0000\u0000\u0000\u01bc\u01bd\u0005i\u0000\u0000\u01bd\u01be"+ + "\u0005n\u0000\u0000\u01be\u01bf\u0005v\u0000\u0000\u01bf\u01c0\u0005a"+ + "\u0000\u0000\u01c0\u01c1\u0005r\u0000\u0000\u01c1\u01c2\u0005i\u0000\u0000"+ + "\u01c2\u01c3\u0005a\u0000\u0000\u01c3\u01c4\u0005n\u0000\u0000\u01c4\u01c5"+ + "\u0005t\u0000\u0000\u01c5\u0019\u0001\u0000\u0000\u0000\u01c6\u01c7\u0005"+ + "d\u0000\u0000\u01c7\u01c8\u0005e\u0000\u0000\u01c8\u01c9\u0005c\u0000"+ + "\u0000\u01c9\u01ca\u0005r\u0000\u0000\u01ca\u01cb\u0005e\u0000\u0000\u01cb"+ + "\u01cc\u0005a\u0000\u0000\u01cc\u01cd\u0005s\u0000\u0000\u01cd\u01ce\u0005"+ + "e\u0000\u0000\u01ce\u01cf\u0005s\u0000\u0000\u01cf\u01d0\u0001\u0000\u0000"+ + "\u0000\u01d0\u01d1\u0006\f\u0000\u0000\u01d1\u001b\u0001\u0000\u0000\u0000"+ + "\u01d2\u01d3\u0005p\u0000\u0000\u01d3\u01d4\u0005u\u0000\u0000\u01d4\u01d5"+ + "\u0005r\u0000\u0000\u01d5\u01d6\u0005e\u0000\u0000\u01d6\u01d7\u0001\u0000"+ + "\u0000\u0000\u01d7\u01d8\u0006\r\u0000\u0000\u01d8\u001d\u0001\u0000\u0000"+ + "\u0000\u01d9\u01da\u0005i\u0000\u0000\u01da\u01db\u0005m\u0000\u0000\u01db"+ + "\u01dc\u0005p\u0000\u0000\u01dc\u01dd\u0005l\u0000\u0000\u01dd\u01de\u0005"+ + "e\u0000\u0000\u01de\u01df\u0005m\u0000\u0000\u01df\u01e0\u0005e\u0000"+ + "\u0000\u01e0\u01e1\u0005n\u0000\u0000\u01e1\u01e2\u0005t\u0000\u0000\u01e2"+ + "\u01e3\u0005s\u0000\u0000\u01e3\u001f\u0001\u0000\u0000\u0000\u01e4\u01e5"+ + "\u0005a\u0000\u0000\u01e5\u01e6\u0005s\u0000\u0000\u01e6!\u0001\u0000"+ + "\u0000\u0000\u01e7\u01e8\u0005o\u0000\u0000\u01e8\u01e9\u0005l\u0000\u0000"+ + "\u01e9\u01ea\u0005d\u0000\u0000\u01ea\u01eb\u0001\u0000\u0000\u0000\u01eb"+ + "\u01ec\u0006\u0010\u0000\u0000\u01ec#\u0001\u0000\u0000\u0000\u01ed\u01ee"+ + "\u0005b\u0000\u0000\u01ee\u01ef\u0005e\u0000\u0000\u01ef\u01f0\u0005f"+ + "\u0000\u0000\u01f0\u01f1\u0005o\u0000\u0000\u01f1\u01f2\u0005r\u0000\u0000"+ + "\u01f2\u01f3\u0005e\u0000\u0000\u01f3\u01f4\u0001\u0000\u0000\u0000\u01f4"+ + "\u01f5\u0006\u0011\u0000\u0000\u01f5%\u0001\u0000\u0000\u0000\u01f6\u01f7"+ + "\u0005#\u0000\u0000\u01f7\u01f8\u0005l\u0000\u0000\u01f8\u01f9\u0005h"+ + "\u0000\u0000\u01f9\u01fa\u0005s\u0000\u0000\u01fa\'\u0001\u0000\u0000"+ + "\u0000\u01fb\u01fc\u0005f\u0000\u0000\u01fc\u01fd\u0005o\u0000\u0000\u01fd"+ + "\u01fe\u0005r\u0000\u0000\u01fe\u01ff\u0005a\u0000\u0000\u01ff\u0200\u0005"+ + "l\u0000\u0000\u0200\u0201\u0005l\u0000\u0000\u0201)\u0001\u0000\u0000"+ + "\u0000\u0202\u0203\u0005e\u0000\u0000\u0203\u0204\u0005x\u0000\u0000\u0204"+ + "\u0205\u0005i\u0000\u0000\u0205\u0206\u0005s\u0000\u0000\u0206\u0207\u0005"+ + "t\u0000\u0000\u0207\u0208\u0005s\u0000\u0000\u0208+\u0001\u0000\u0000"+ + "\u0000\u0209\u020a\u0005a\u0000\u0000\u020a\u020b\u0005c\u0000\u0000\u020b"+ + "\u020c\u0005c\u0000\u0000\u020c\u020d\u0001\u0000\u0000\u0000\u020d\u020e"+ + "\u0006\u0015\u0000\u0000\u020e-\u0001\u0000\u0000\u0000\u020f\u0210\u0005"+ + "f\u0000\u0000\u0210\u0211\u0005o\u0000\u0000\u0211\u0212\u0005l\u0000"+ + "\u0000\u0212\u0213\u0005d\u0000\u0000\u0213/\u0001\u0000\u0000\u0000\u0214"+ + "\u0215\u0005u\u0000\u0000\u0215\u0216\u0005n\u0000\u0000\u0216\u0217\u0005"+ + "f\u0000\u0000\u0217\u0218\u0005o\u0000\u0000\u0218\u0219\u0005l\u0000"+ + "\u0000\u0219\u021a\u0005d\u0000\u0000\u021a1\u0001\u0000\u0000\u0000\u021b"+ + "\u021c\u0005u\u0000\u0000\u021c\u021d\u0005n\u0000\u0000\u021d\u021e\u0005"+ + "f\u0000\u0000\u021e\u021f\u0005o\u0000\u0000\u021f\u0220\u0005l\u0000"+ + "\u0000\u0220\u0221\u0005d\u0000\u0000\u0221\u0222\u0005i\u0000\u0000\u0222"+ + "\u0223\u0005n\u0000\u0000\u0223\u0224\u0005g\u0000\u0000\u02243\u0001"+ + "\u0000\u0000\u0000\u0225\u0226\u0005l\u0000\u0000\u0226\u0227\u0005e\u0000"+ + "\u0000\u0227\u0228\u0005t\u0000\u0000\u02285\u0001\u0000\u0000\u0000\u0229"+ + "\u022a\u0005g\u0000\u0000\u022a\u022b\u0005h\u0000\u0000\u022b\u022c\u0005"+ + "o\u0000\u0000\u022c\u022d\u0005s\u0000\u0000\u022d\u022e\u0005t\u0000"+ + "\u0000\u022e7\u0001\u0000\u0000\u0000\u022f\u0230\u0005i\u0000\u0000\u0230"+ + "\u0231\u0005n\u0000\u0000\u02319\u0001\u0000\u0000\u0000\u0232\u0233\u0005"+ + "#\u0000\u0000\u0233;\u0001\u0000\u0000\u0000\u0234\u0235\u0005s\u0000"+ + "\u0000\u0235\u0236\u0005u\u0000\u0000\u0236\u0237\u0005b\u0000\u0000\u0237"+ + "\u0238\u0005s\u0000\u0000\u0238\u0239\u0005e\u0000\u0000\u0239\u023a\u0005"+ + "t\u0000\u0000\u023a=\u0001\u0000\u0000\u0000\u023b\u023c\u0005u\u0000"+ + "\u0000\u023c\u023d\u0005n\u0000\u0000\u023d\u023e\u0005i\u0000\u0000\u023e"+ + "\u023f\u0005o\u0000\u0000\u023f\u0240\u0005n\u0000\u0000\u0240?\u0001"+ + "\u0000\u0000\u0000\u0241\u0242\u0005i\u0000\u0000\u0242\u0243\u0005n\u0000"+ + "\u0000\u0243\u0244\u0005t\u0000\u0000\u0244\u0245\u0005e\u0000\u0000\u0245"+ + "\u0246\u0005r\u0000\u0000\u0246\u0247\u0005s\u0000\u0000\u0247\u0248\u0005"+ + "e\u0000\u0000\u0248\u0249\u0005c\u0000\u0000\u0249\u024a\u0005t\u0000"+ + "\u0000\u024a\u024b\u0005i\u0000\u0000\u024b\u024c\u0005o\u0000\u0000\u024c"+ + "\u024d\u0005n\u0000\u0000\u024dA\u0001\u0000\u0000\u0000\u024e\u024f\u0005"+ + "s\u0000\u0000\u024f\u0250\u0005e\u0000\u0000\u0250\u0251\u0005t\u0000"+ + "\u0000\u0251\u0252\u0005m\u0000\u0000\u0252\u0253\u0005i\u0000\u0000\u0253"+ + "\u0254\u0005n\u0000\u0000\u0254\u0255\u0005u\u0000\u0000\u0255\u0256\u0005"+ + "s\u0000\u0000\u0256C\u0001\u0000\u0000\u0000\u0257\u0258\u0005=\u0000"+ + "\u0000\u0258\u0259\u0005=\u0000\u0000\u0259\u025a\u0005>\u0000\u0000\u025a"+ + "E\u0001\u0000\u0000\u0000\u025b\u025c\u0005-\u0000\u0000\u025c\u025d\u0005"+ + "-\u0000\u0000\u025d\u025e\u0005*\u0000\u0000\u025eG\u0001\u0000\u0000"+ + "\u0000\u025f\u0260\u0005a\u0000\u0000\u0260\u0261\u0005p\u0000\u0000\u0261"+ + "\u0262\u0005p\u0000\u0000\u0262\u0263\u0005l\u0000\u0000\u0263\u0264\u0005"+ + "y\u0000\u0000\u0264I\u0001\u0000\u0000\u0000\u0265\u0266\u0005?\u0000"+ + "\u0000\u0266K\u0001\u0000\u0000\u0000\u0267\u0268\u0005!\u0000\u0000\u0268"+ + "\u0269\u0005<\u0000\u0000\u0269M\u0001\u0000\u0000\u0000\u026a\u026b\u0005"+ + "!\u0000\u0000\u026b\u026c\u0005>\u0000\u0000\u026c\u026d\u0001\u0000\u0000"+ + "\u0000\u026d\u026e\u0006&\u0000\u0000\u026eO\u0001\u0000\u0000\u0000\u026f"+ + "\u0270\u0005s\u0000\u0000\u0270\u0271\u0005e\u0000\u0000\u0271\u0272\u0005"+ + "q\u0000\u0000\u0272\u0273\u0001\u0000\u0000\u0000\u0273\u0274\u0006\'"+ + "\u0000\u0000\u0274Q\u0001\u0000\u0000\u0000\u0275\u0276\u0005s\u0000\u0000"+ + "\u0276\u0277\u0005e\u0000\u0000\u0277\u0278\u0005t\u0000\u0000\u0278\u0279"+ + "\u0001\u0000\u0000\u0000\u0279\u027a\u0006(\u0000\u0000\u027aS\u0001\u0000"+ + "\u0000\u0000\u027b\u027c\u0005m\u0000\u0000\u027c\u027d\u0005s\u0000\u0000"+ + "\u027d\u027e\u0005e\u0000\u0000\u027e\u027f\u0005t\u0000\u0000\u027f\u0280"+ + "\u0001\u0000\u0000\u0000\u0280\u0281\u0006)\u0000\u0000\u0281U\u0001\u0000"+ + "\u0000\u0000\u0282\u0283\u0005d\u0000\u0000\u0283\u0284\u0005i\u0000\u0000"+ + "\u0284\u0285\u0005c\u0000\u0000\u0285\u0286\u0005t\u0000\u0000\u0286\u0287"+ + "\u0001\u0000\u0000\u0000\u0287\u0288\u0006*\u0000\u0000\u0288W\u0001\u0000"+ + "\u0000\u0000\u0289\u028a\u0005o\u0000\u0000\u028a\u028b\u0005p\u0000\u0000"+ + "\u028b\u028c\u0005t\u0000\u0000\u028c\u028d\u0005i\u0000\u0000\u028d\u028e"+ + "\u0005o\u0000\u0000\u028e\u028f\u0005n\u0000\u0000\u028f\u0290\u0001\u0000"+ + "\u0000\u0000\u0290\u0291\u0006+\u0000\u0000\u0291Y\u0001\u0000\u0000\u0000"+ + "\u0292\u0293\u0005l\u0000\u0000\u0293\u0294\u0005e\u0000\u0000\u0294\u0295"+ + "\u0005n\u0000\u0000\u0295\u0296\u0001\u0000\u0000\u0000\u0296\u0297\u0006"+ + ",\u0000\u0000\u0297[\u0001\u0000\u0000\u0000\u0298\u0299\u0005n\u0000"+ + "\u0000\u0299\u029a\u0005e\u0000\u0000\u029a\u029b\u0005w\u0000\u0000\u029b"+ + "\u029c\u0001\u0000\u0000\u0000\u029c\u029d\u0006-\u0000\u0000\u029d]\u0001"+ + "\u0000\u0000\u0000\u029e\u029f\u0005m\u0000\u0000\u029f\u02a0\u0005a\u0000"+ + "\u0000\u02a0\u02a1\u0005k\u0000\u0000\u02a1\u02a2\u0005e\u0000\u0000\u02a2"+ + "\u02a3\u0001\u0000\u0000\u0000\u02a3\u02a4\u0006.\u0000\u0000\u02a4_\u0001"+ + "\u0000\u0000\u0000\u02a5\u02a6\u0005c\u0000\u0000\u02a6\u02a7\u0005a\u0000"+ + "\u0000\u02a7\u02a8\u0005p\u0000\u0000\u02a8\u02a9\u0001\u0000\u0000\u0000"+ + "\u02a9\u02aa\u0006/\u0000\u0000\u02aaa\u0001\u0000\u0000\u0000\u02ab\u02ac"+ + "\u0005s\u0000\u0000\u02ac\u02ad\u0005o\u0000\u0000\u02ad\u02ae\u0005m"+ + "\u0000\u0000\u02ae\u02af\u0005e\u0000\u0000\u02af\u02b0\u0001\u0000\u0000"+ + "\u0000\u02b0\u02b1\u00060\u0000\u0000\u02b1c\u0001\u0000\u0000\u0000\u02b2"+ + "\u02b3\u0005g\u0000\u0000\u02b3\u02b4\u0005e\u0000\u0000\u02b4\u02b5\u0005"+ + "t\u0000\u0000\u02b5\u02b6\u0001\u0000\u0000\u0000\u02b6\u02b7\u00061\u0000"+ + "\u0000\u02b7e\u0001\u0000\u0000\u0000\u02b8\u02b9\u0005d\u0000\u0000\u02b9"+ + "\u02ba\u0005o\u0000\u0000\u02ba\u02bb\u0005m\u0000\u0000\u02bb\u02bc\u0005"+ + "a\u0000\u0000\u02bc\u02bd\u0005i\u0000\u0000\u02bd\u02be\u0005n\u0000"+ + "\u0000\u02be\u02bf\u0001\u0000\u0000\u0000\u02bf\u02c0\u00062\u0000\u0000"+ + "\u02c0g\u0001\u0000\u0000\u0000\u02c1\u02c2\u0005a\u0000\u0000\u02c2\u02c3"+ + "\u0005x\u0000\u0000\u02c3\u02c4\u0005i\u0000\u0000\u02c4\u02c5\u0005o"+ + "\u0000\u0000\u02c5\u02c6\u0005m\u0000\u0000\u02c6\u02c7\u0001\u0000\u0000"+ + "\u0000\u02c7\u02c8\u00063\u0000\u0000\u02c8i\u0001\u0000\u0000\u0000\u02c9"+ + "\u02ca\u0005a\u0000\u0000\u02ca\u02cb\u0005d\u0000\u0000\u02cb\u02cc\u0005"+ + "t\u0000\u0000\u02cc\u02cd\u0001\u0000\u0000\u0000\u02cd\u02ce\u00064\u0000"+ + "\u0000\u02cek\u0001\u0000\u0000\u0000\u02cf\u02d0\u0005m\u0000\u0000\u02d0"+ + "\u02d1\u0005a\u0000\u0000\u02d1\u02d2\u0005t\u0000\u0000\u02d2\u02d3\u0005"+ + "c\u0000\u0000\u02d3\u02d4\u0005h\u0000\u0000\u02d4\u02d5\u0001\u0000\u0000"+ + "\u0000\u02d5\u02d6\u00065\u0000\u0000\u02d6m\u0001\u0000\u0000\u0000\u02d7"+ + "\u02d8\u0005n\u0000\u0000\u02d8\u02d9\u0005o\u0000\u0000\u02d9\u02da\u0005"+ + "n\u0000\u0000\u02da\u02db\u0005e\u0000\u0000\u02db\u02dc\u0001\u0000\u0000"+ + "\u0000\u02dc\u02dd\u00066\u0000\u0000\u02ddo\u0001\u0000\u0000\u0000\u02de"+ + "\u02df\u0005p\u0000\u0000\u02df\u02e0\u0005r\u0000\u0000\u02e0\u02e1\u0005"+ + "e\u0000\u0000\u02e1\u02e2\u0005d\u0000\u0000\u02e2q\u0001\u0000\u0000"+ + "\u0000\u02e3\u02e4\u0005t\u0000\u0000\u02e4\u02e5\u0005y\u0000\u0000\u02e5"+ + "\u02e6\u0005p\u0000\u0000\u02e6\u02e7\u0005e\u0000\u0000\u02e7\u02e8\u0005"+ + "O\u0000\u0000\u02e8\u02e9\u0005f\u0000\u0000\u02e9\u02ea\u0001\u0000\u0000"+ + "\u0000\u02ea\u02eb\u00068\u0000\u0000\u02ebs\u0001\u0000\u0000\u0000\u02ec"+ + "\u02ed\u0005i\u0000\u0000\u02ed\u02ee\u0005s\u0000\u0000\u02ee\u02ef\u0005"+ + "C\u0000\u0000\u02ef\u02f0\u0005o\u0000\u0000\u02f0\u02f1\u0005m\u0000"+ + "\u0000\u02f1\u02f2\u0005p\u0000\u0000\u02f2\u02f3\u0005a\u0000\u0000\u02f3"+ + "\u02f4\u0005r\u0000\u0000\u02f4\u02f5\u0005a\u0000\u0000\u02f5\u02f6\u0005"+ + "b\u0000\u0000\u02f6\u02f7\u0005l\u0000\u0000\u02f7\u02f8\u0005e\u0000"+ + "\u0000\u02f8\u02f9\u0001\u0000\u0000\u0000\u02f9\u02fa\u00069\u0000\u0000"+ + "\u02fau\u0001\u0000\u0000\u0000\u02fb\u02fc\u0005s\u0000\u0000\u02fc\u02fd"+ + "\u0005h\u0000\u0000\u02fd\u02fe\u0005a\u0000\u0000\u02fe\u02ff\u0005r"+ + "\u0000\u0000\u02ff\u0300\u0005e\u0000\u0000\u0300w\u0001\u0000\u0000\u0000"+ + "\u0301\u0302\u0005@\u0000\u0000\u0302\u0303\u0001\u0000\u0000\u0000\u0303"+ + "\u0304\u0006;\u0000\u0000\u0304y\u0001\u0000\u0000\u0000\u0305\u0306\u0005"+ + ".\u0000\u0000\u0306\u0307\u0005.\u0000\u0000\u0307{\u0001\u0000\u0000"+ + "\u0000\u0308\u0309\u0005s\u0000\u0000\u0309\u030a\u0005h\u0000\u0000\u030a"+ + "\u030b\u0005a\u0000\u0000\u030b\u030c\u0005r\u0000\u0000\u030c\u030d\u0005"+ + "e\u0000\u0000\u030d\u030e\u0005d\u0000\u0000\u030e}\u0001\u0000\u0000"+ + "\u0000\u030f\u0310\u0005e\u0000\u0000\u0310\u0311\u0005x\u0000\u0000\u0311"+ + "\u0312\u0005c\u0000\u0000\u0312\u0313\u0005l\u0000\u0000\u0313\u0314\u0005"+ + "u\u0000\u0000\u0314\u0315\u0005s\u0000\u0000\u0315\u0316\u0005i\u0000"+ + "\u0000\u0316\u0317\u0005v\u0000\u0000\u0317\u0318\u0005e\u0000\u0000\u0318"+ + "\u007f\u0001\u0000\u0000\u0000\u0319\u031a\u0005p\u0000\u0000\u031a\u031b"+ + "\u0005r\u0000\u0000\u031b\u031c\u0005e\u0000\u0000\u031c\u031d\u0005d"+ + "\u0000\u0000\u031d\u031e\u0005i\u0000\u0000\u031e\u031f\u0005c\u0000\u0000"+ + "\u031f\u0320\u0005a\u0000\u0000\u0320\u0321\u0005t\u0000\u0000\u0321\u0322"+ + "\u0005e\u0000\u0000\u0322\u0081\u0001\u0000\u0000\u0000\u0323\u0324\u0005"+ + "w\u0000\u0000\u0324\u0325\u0005r\u0000\u0000\u0325\u0326\u0005i\u0000"+ + "\u0000\u0326\u0327\u0005t\u0000\u0000\u0327\u0328\u0005e\u0000\u0000\u0328"+ + "\u0329\u0005P\u0000\u0000\u0329\u032a\u0005e\u0000\u0000\u032a\u032b\u0005"+ + "r\u0000\u0000\u032b\u032c\u0005m\u0000\u0000\u032c\u032d\u0001\u0000\u0000"+ + "\u0000\u032d\u032e\u0006@\u0000\u0000\u032e\u0083\u0001\u0000\u0000\u0000"+ + "\u032f\u0330\u0005n\u0000\u0000\u0330\u0331\u0005o\u0000\u0000\u0331\u0332"+ + "\u0005P\u0000\u0000\u0332\u0333\u0005e\u0000\u0000\u0333\u0334\u0005r"+ + "\u0000\u0000\u0334\u0335\u0005m\u0000\u0000\u0335\u0336\u0001\u0000\u0000"+ + "\u0000\u0336\u0337\u0006A\u0000\u0000\u0337\u0085\u0001\u0000\u0000\u0000"+ + "\u0338\u0339\u0005t\u0000\u0000\u0339\u033a\u0005r\u0000\u0000\u033a\u033b"+ + "\u0005u\u0000\u0000\u033b\u033c\u0005s\u0000\u0000\u033c\u033d\u0005t"+ + "\u0000\u0000\u033d\u033e\u0005e\u0000\u0000\u033e\u033f\u0005d\u0000\u0000"+ + "\u033f\u0340\u0001\u0000\u0000\u0000\u0340\u0341\u0006B\u0000\u0000\u0341"+ + "\u0087\u0001\u0000\u0000\u0000\u0342\u0343\u0005o\u0000\u0000\u0343\u0344"+ + "\u0005u\u0000\u0000\u0344\u0345\u0005t\u0000\u0000\u0345\u0346\u0005l"+ + "\u0000\u0000\u0346\u0347\u0005i\u0000\u0000\u0347\u0348\u0005n\u0000\u0000"+ + "\u0348\u0349\u0005e\u0000\u0000\u0349\u0089\u0001\u0000\u0000\u0000\u034a"+ + "\u034b\u0005i\u0000\u0000\u034b\u034c\u0005n\u0000\u0000\u034c\u034d\u0005"+ + "i\u0000\u0000\u034d\u034e\u0005t\u0000\u0000\u034e\u034f\u0005E\u0000"+ + "\u0000\u034f\u0350\u0005n\u0000\u0000\u0350\u0351\u0005s\u0000\u0000\u0351"+ + "\u0352\u0005u\u0000\u0000\u0352\u0353\u0005r\u0000\u0000\u0353\u0354\u0005"+ + "e\u0000\u0000\u0354\u0355\u0005s\u0000\u0000\u0355\u008b\u0001\u0000\u0000"+ + "\u0000\u0356\u0357\u0005i\u0000\u0000\u0357\u0358\u0005m\u0000\u0000\u0358"+ + "\u0359\u0005p\u0000\u0000\u0359\u035a\u0005o\u0000\u0000\u035a\u035b\u0005"+ + "r\u0000\u0000\u035b\u035c\u0005t\u0000\u0000\u035c\u035d\u0005R\u0000"+ + "\u0000\u035d\u035e\u0005e\u0000\u0000\u035e\u035f\u0005q\u0000\u0000\u035f"+ + "\u0360\u0005u\u0000\u0000\u0360\u0361\u0005i\u0000\u0000\u0361\u0362\u0005"+ + "r\u0000\u0000\u0362\u0363\u0005e\u0000\u0000\u0363\u0364\u0005s\u0000"+ + "\u0000\u0364\u008d\u0001\u0000\u0000\u0000\u0365\u0366\u0005p\u0000\u0000"+ + "\u0366\u0367\u0005r\u0000\u0000\u0367\u0368\u0005o\u0000\u0000\u0368\u0369"+ + "\u0005o\u0000\u0000\u0369\u036a\u0005f\u0000\u0000\u036a\u008f\u0001\u0000"+ + "\u0000\u0000\u036b\u036c\u0005=\u0000\u0000\u036c\u036d\u0005=\u0000\u0000"+ + "\u036d\u036e\u0005=\u0000\u0000\u036e\u0091\u0001\u0000\u0000\u0000\u036f"+ + "\u0370\u0005!\u0000\u0000\u0370\u0371\u0005=\u0000\u0000\u0371\u0372\u0005"+ + "=\u0000\u0000\u0372\u0093\u0001\u0000\u0000\u0000\u0373\u0374\u0005w\u0000"+ + "\u0000\u0374\u0375\u0005i\u0000\u0000\u0375\u0376\u0005t\u0000\u0000\u0376"+ + "\u0377\u0005h\u0000\u0000\u0377\u0095\u0001\u0000\u0000\u0000\u0378\u0379"+ + "\u0005b\u0000\u0000\u0379\u037a\u0005r\u0000\u0000\u037a\u037b\u0005e"+ + "\u0000\u0000\u037b\u037c\u0005a\u0000\u0000\u037c\u037d\u0005k\u0000\u0000"+ + "\u037d\u037e\u0001\u0000\u0000\u0000\u037e\u037f\u0006J\u0000\u0000\u037f"+ + "\u0097\u0001\u0000\u0000\u0000\u0380\u0381\u0005d\u0000\u0000\u0381\u0382"+ + "\u0005e\u0000\u0000\u0382\u0383\u0005f\u0000\u0000\u0383\u0384\u0005a"+ + "\u0000\u0000\u0384\u0385\u0005u\u0000\u0000\u0385\u0386\u0005l\u0000\u0000"+ + "\u0386\u0387\u0005t\u0000\u0000\u0387\u0099\u0001\u0000\u0000\u0000\u0388"+ + "\u0389\u0005f\u0000\u0000\u0389\u038a\u0005u\u0000\u0000\u038a\u038b\u0005"+ + "n\u0000\u0000\u038b\u038c\u0005c\u0000\u0000\u038c\u009b\u0001\u0000\u0000"+ + "\u0000\u038d\u038e\u0005i\u0000\u0000\u038e\u038f\u0005n\u0000\u0000\u038f"+ + "\u0390\u0005t\u0000\u0000\u0390\u0391\u0005e\u0000\u0000\u0391\u0392\u0005"+ + "r\u0000\u0000\u0392\u0393\u0005f\u0000\u0000\u0393\u0394\u0005a\u0000"+ + "\u0000\u0394\u0395\u0005c\u0000\u0000\u0395\u0396\u0005e\u0000\u0000\u0396"+ + "\u009d\u0001\u0000\u0000\u0000\u0397\u0398\u0005s\u0000\u0000\u0398\u0399"+ + "\u0005e\u0000\u0000\u0399\u039a\u0005l\u0000\u0000\u039a\u039b\u0005e"+ + "\u0000\u0000\u039b\u039c\u0005c\u0000\u0000\u039c\u039d\u0005t\u0000\u0000"+ + "\u039d\u009f\u0001\u0000\u0000\u0000\u039e\u039f\u0005c\u0000\u0000\u039f"+ + "\u03a0\u0005a\u0000\u0000\u03a0\u03a1\u0005s\u0000\u0000\u03a1\u03a2\u0005"+ + "e\u0000\u0000\u03a2\u00a1\u0001\u0000\u0000\u0000\u03a3\u03a4\u0005d\u0000"+ + "\u0000\u03a4\u03a5\u0005e\u0000\u0000\u03a5\u03a6\u0005f\u0000\u0000\u03a6"+ + "\u03a7\u0005e\u0000\u0000\u03a7\u03a8\u0005r\u0000\u0000\u03a8\u00a3\u0001"+ + "\u0000\u0000\u0000\u03a9\u03aa\u0005g\u0000\u0000\u03aa\u03ab\u0005o\u0000"+ + "\u0000\u03ab\u00a5\u0001\u0000\u0000\u0000\u03ac\u03ad\u0005m\u0000\u0000"+ + "\u03ad\u03ae\u0005a\u0000\u0000\u03ae\u03af\u0005p\u0000\u0000\u03af\u00a7"+ + "\u0001\u0000\u0000\u0000\u03b0\u03b1\u0005s\u0000\u0000\u03b1\u03b2\u0005"+ + "t\u0000\u0000\u03b2\u03b3\u0005r\u0000\u0000\u03b3\u03b4\u0005u\u0000"+ + "\u0000\u03b4\u03b5\u0005c\u0000\u0000\u03b5\u03b6\u0005t\u0000\u0000\u03b6"+ + "\u00a9\u0001\u0000\u0000\u0000\u03b7\u03b8\u0005c\u0000\u0000\u03b8\u03b9"+ + "\u0005h\u0000\u0000\u03b9\u03ba\u0005a\u0000\u0000\u03ba\u03bb\u0005n"+ + "\u0000\u0000\u03bb\u00ab\u0001\u0000\u0000\u0000\u03bc\u03bd\u0005e\u0000"+ + "\u0000\u03bd\u03be\u0005l\u0000\u0000\u03be\u03bf\u0005s\u0000\u0000\u03bf"+ + "\u03c0\u0005e\u0000\u0000\u03c0\u00ad\u0001\u0000\u0000\u0000\u03c1\u03c2"+ + "\u0005g\u0000\u0000\u03c2\u03c3\u0005o\u0000\u0000\u03c3\u03c4\u0005t"+ + "\u0000\u0000\u03c4\u03c5\u0005o\u0000\u0000\u03c5\u00af\u0001\u0000\u0000"+ + "\u0000\u03c6\u03c7\u0005p\u0000\u0000\u03c7\u03c8\u0005a\u0000\u0000\u03c8"+ + "\u03c9\u0005c\u0000\u0000\u03c9\u03ca\u0005k\u0000\u0000\u03ca\u03cb\u0005"+ + "a\u0000\u0000\u03cb\u03cc\u0005g\u0000\u0000\u03cc\u03cd\u0005e\u0000"+ + "\u0000\u03cd\u00b1\u0001\u0000\u0000\u0000\u03ce\u03cf\u0005s\u0000\u0000"+ + "\u03cf\u03d0\u0005w\u0000\u0000\u03d0\u03d1\u0005i\u0000\u0000\u03d1\u03d2"+ + "\u0005t\u0000\u0000\u03d2\u03d3\u0005c\u0000\u0000\u03d3\u03d4\u0005h"+ + "\u0000\u0000\u03d4\u00b3\u0001\u0000\u0000\u0000\u03d5\u03d6\u0005c\u0000"+ + "\u0000\u03d6\u03d7\u0005o\u0000\u0000\u03d7\u03d8\u0005n\u0000\u0000\u03d8"+ + "\u03d9\u0005s\u0000\u0000\u03d9\u03da\u0005t\u0000\u0000\u03da\u00b5\u0001"+ + "\u0000\u0000\u0000\u03db\u03dc\u0005f\u0000\u0000\u03dc\u03dd\u0005a\u0000"+ + "\u0000\u03dd\u03de\u0005l\u0000\u0000\u03de\u03df\u0005l\u0000\u0000\u03df"+ + "\u03e0\u0005t\u0000\u0000\u03e0\u03e1\u0005h\u0000\u0000\u03e1\u03e2\u0005"+ + "r\u0000\u0000\u03e2\u03e3\u0005o\u0000\u0000\u03e3\u03e4\u0005u\u0000"+ + "\u0000\u03e4\u03e5\u0005g\u0000\u0000\u03e5\u03e6\u0005h\u0000\u0000\u03e6"+ + "\u03e7\u0001\u0000\u0000\u0000\u03e7\u03e8\u0006Z\u0000\u0000\u03e8\u00b7"+ + "\u0001\u0000\u0000\u0000\u03e9\u03ea\u0005i\u0000\u0000\u03ea\u03eb\u0005"+ + "f\u0000\u0000\u03eb\u00b9\u0001\u0000\u0000\u0000\u03ec\u03ed\u0005r\u0000"+ + "\u0000\u03ed\u03ee\u0005a\u0000\u0000\u03ee\u03ef\u0005n\u0000\u0000\u03ef"+ + "\u03f0\u0005g\u0000\u0000\u03f0\u03f1\u0005e\u0000\u0000\u03f1\u00bb\u0001"+ + "\u0000\u0000\u0000\u03f2\u03f3\u0005t\u0000\u0000\u03f3\u03f4\u0005y\u0000"+ + "\u0000\u03f4\u03f5\u0005p\u0000\u0000\u03f5\u03f6\u0005e\u0000\u0000\u03f6"+ + "\u00bd\u0001\u0000\u0000\u0000\u03f7\u03f8\u0005c\u0000\u0000\u03f8\u03f9"+ + "\u0005o\u0000\u0000\u03f9\u03fa\u0005n\u0000\u0000\u03fa\u03fb\u0005t"+ + "\u0000\u0000\u03fb\u03fc\u0005i\u0000\u0000\u03fc\u03fd\u0005n\u0000\u0000"+ + "\u03fd\u03fe\u0005u\u0000\u0000\u03fe\u03ff\u0005e\u0000\u0000\u03ff\u0400"+ + "\u0001\u0000\u0000\u0000\u0400\u0401\u0006^\u0000\u0000\u0401\u00bf\u0001"+ + "\u0000\u0000\u0000\u0402\u0403\u0005f\u0000\u0000\u0403\u0404\u0005o\u0000"+ + "\u0000\u0404\u0405\u0005r\u0000\u0000\u0405\u00c1\u0001\u0000\u0000\u0000"+ + "\u0406\u0407\u0005i\u0000\u0000\u0407\u0408\u0005m\u0000\u0000\u0408\u0409"+ + "\u0005p\u0000\u0000\u0409\u040a\u0005o\u0000\u0000\u040a\u040b\u0005r"+ + "\u0000\u0000\u040b\u040c\u0005t\u0000\u0000\u040c\u00c3\u0001\u0000\u0000"+ + "\u0000\u040d\u040e\u0005r\u0000\u0000\u040e\u040f\u0005e\u0000\u0000\u040f"+ + "\u0410\u0005t\u0000\u0000\u0410\u0411\u0005u\u0000\u0000\u0411\u0412\u0005"+ + "r\u0000\u0000\u0412\u0413\u0005n\u0000\u0000\u0413\u0414\u0001\u0000\u0000"+ + "\u0000\u0414\u0415\u0006a\u0000\u0000\u0415\u00c5\u0001\u0000\u0000\u0000"+ + "\u0416\u0417\u0005v\u0000\u0000\u0417\u0418\u0005a\u0000\u0000\u0418\u0419"+ + "\u0005r\u0000\u0000\u0419\u00c7\u0001\u0000\u0000\u0000\u041a\u041b\u0005"+ + "n\u0000\u0000\u041b\u041c\u0005i\u0000\u0000\u041c\u041d\u0005l\u0000"+ + "\u0000\u041d\u041e\u0001\u0000\u0000\u0000\u041e\u041f\u0006c\u0000\u0000"+ + "\u041f\u00c9\u0001\u0000\u0000\u0000\u0420\u0425\u0003\u014c\u00a5\u0000"+ + "\u0421\u0424\u0003\u014c\u00a5\u0000\u0422\u0424\u0003\u014e\u00a6\u0000"+ + "\u0423\u0421\u0001\u0000\u0000\u0000\u0423\u0422\u0001\u0000\u0000\u0000"+ + "\u0424\u0427\u0001\u0000\u0000\u0000\u0425\u0423\u0001\u0000\u0000\u0000"+ + "\u0425\u0426\u0001\u0000\u0000\u0000\u0426\u0428\u0001\u0000\u0000\u0000"+ + "\u0427\u0425\u0001\u0000\u0000\u0000\u0428\u0429\u0006d\u0000\u0000\u0429"+ + "\u00cb\u0001\u0000\u0000\u0000\u042a\u042b\u0005(\u0000\u0000\u042b\u00cd"+ + "\u0001\u0000\u0000\u0000\u042c\u042d\u0005)\u0000\u0000\u042d\u042e\u0001"+ + "\u0000\u0000\u0000\u042e\u042f\u0006f\u0000\u0000\u042f\u00cf\u0001\u0000"+ + "\u0000\u0000\u0430\u0431\u0005{\u0000\u0000\u0431\u00d1\u0001\u0000\u0000"+ + "\u0000\u0432\u0433\u0005}\u0000\u0000\u0433\u0434\u0001\u0000\u0000\u0000"+ + "\u0434\u0435\u0006h\u0000\u0000\u0435\u00d3\u0001\u0000\u0000\u0000\u0436"+ + "\u0437\u0005[\u0000\u0000\u0437\u00d5\u0001\u0000\u0000\u0000\u0438\u0439"+ + "\u0005]\u0000\u0000\u0439\u043a\u0001\u0000\u0000\u0000\u043a\u043b\u0006"+ + "j\u0000\u0000\u043b\u00d7\u0001\u0000\u0000\u0000\u043c\u043d\u0005=\u0000"+ + "\u0000\u043d\u00d9\u0001\u0000\u0000\u0000\u043e\u043f\u0005,\u0000\u0000"+ + "\u043f\u00db\u0001\u0000\u0000\u0000\u0440\u0441\u0005;\u0000\u0000\u0441"+ + "\u00dd\u0001\u0000\u0000\u0000\u0442\u0443\u0005:\u0000\u0000\u0443\u00df"+ + "\u0001\u0000\u0000\u0000\u0444\u0445\u0005.\u0000\u0000\u0445\u00e1\u0001"+ + "\u0000\u0000\u0000\u0446\u0447\u0005+\u0000\u0000\u0447\u0448\u0005+\u0000"+ + "\u0000\u0448\u0449\u0001\u0000\u0000\u0000\u0449\u044a\u0006p\u0000\u0000"+ + "\u044a\u00e3\u0001\u0000\u0000\u0000\u044b\u044c\u0005-\u0000\u0000\u044c"+ + "\u044d\u0005-\u0000\u0000\u044d\u044e\u0001\u0000\u0000\u0000\u044e\u044f"+ + "\u0006q\u0000\u0000\u044f\u00e5\u0001\u0000\u0000\u0000\u0450\u0451\u0005"+ + ":\u0000\u0000\u0451\u0452\u0005=\u0000\u0000\u0452\u00e7\u0001\u0000\u0000"+ + "\u0000\u0453\u0454\u0005.\u0000\u0000\u0454\u0455\u0005.\u0000\u0000\u0455"+ + "\u0456\u0005.\u0000\u0000\u0456\u00e9\u0001\u0000\u0000\u0000\u0457\u0458"+ + "\u0005|\u0000\u0000\u0458\u0459\u0005|\u0000\u0000\u0459\u00eb\u0001\u0000"+ + "\u0000\u0000\u045a\u045b\u0005&\u0000\u0000\u045b\u045c\u0005&\u0000\u0000"+ + "\u045c\u00ed\u0001\u0000\u0000\u0000\u045d\u045e\u0005=\u0000\u0000\u045e"+ + "\u045f\u0005=\u0000\u0000\u045f\u00ef\u0001\u0000\u0000\u0000\u0460\u0461"+ + "\u0005!\u0000\u0000\u0461\u0462\u0005=\u0000\u0000\u0462\u00f1\u0001\u0000"+ + "\u0000\u0000\u0463\u0464\u0005<\u0000\u0000\u0464\u00f3\u0001\u0000\u0000"+ + "\u0000\u0465\u0466\u0005<\u0000\u0000\u0466\u0467\u0005=\u0000\u0000\u0467"+ + "\u00f5\u0001\u0000\u0000\u0000\u0468\u0469\u0005>\u0000\u0000\u0469\u00f7"+ + "\u0001\u0000\u0000\u0000\u046a\u046b\u0005>\u0000\u0000\u046b\u046c\u0005"+ + "=\u0000\u0000\u046c\u00f9\u0001\u0000\u0000\u0000\u046d\u046e\u0005|\u0000"+ + "\u0000\u046e\u00fb\u0001\u0000\u0000\u0000\u046f\u0470\u0005/\u0000\u0000"+ + "\u0470\u00fd\u0001\u0000\u0000\u0000\u0471\u0472\u0005%\u0000\u0000\u0472"+ + "\u00ff\u0001\u0000\u0000\u0000\u0473\u0474\u0005<\u0000\u0000\u0474\u0475"+ + "\u0005<\u0000\u0000\u0475\u0101\u0001\u0000\u0000\u0000\u0476\u0477\u0005"+ + ">\u0000\u0000\u0477\u0478\u0005>\u0000\u0000\u0478\u0103\u0001\u0000\u0000"+ + "\u0000\u0479\u047a\u0005&\u0000\u0000\u047a\u047b\u0005^\u0000\u0000\u047b"+ + "\u0105\u0001\u0000\u0000\u0000\u047c\u047d\u0005!\u0000\u0000\u047d\u0107"+ + "\u0001\u0000\u0000\u0000\u047e\u047f\u0005+\u0000\u0000\u047f\u0109\u0001"+ + "\u0000\u0000\u0000\u0480\u0481\u0005-\u0000\u0000\u0481\u010b\u0001\u0000"+ + "\u0000\u0000\u0482\u0483\u0005^\u0000\u0000\u0483\u010d\u0001\u0000\u0000"+ + "\u0000\u0484\u0485\u0005*\u0000\u0000\u0485\u010f\u0001\u0000\u0000\u0000"+ + "\u0486\u0487\u0005&\u0000\u0000\u0487\u0111\u0001\u0000\u0000\u0000\u0488"+ + "\u0489\u0005<\u0000\u0000\u0489\u048a\u0005-\u0000\u0000\u048a\u0113\u0001"+ + "\u0000\u0000\u0000\u048b\u0497\u00050\u0000\u0000\u048c\u0493\u0007\u0000"+ + "\u0000\u0000\u048d\u048f\u0005_\u0000\u0000\u048e\u048d\u0001\u0000\u0000"+ + "\u0000\u048e\u048f\u0001\u0000\u0000\u0000\u048f\u0490\u0001\u0000\u0000"+ + "\u0000\u0490\u0492\u0007\u0001\u0000\u0000\u0491\u048e\u0001\u0000\u0000"+ + "\u0000\u0492\u0495\u0001\u0000\u0000\u0000\u0493\u0491\u0001\u0000\u0000"+ + "\u0000\u0493\u0494\u0001\u0000\u0000\u0000\u0494\u0497\u0001\u0000\u0000"+ + "\u0000\u0495\u0493\u0001\u0000\u0000\u0000\u0496\u048b\u0001\u0000\u0000"+ + "\u0000\u0496\u048c\u0001\u0000\u0000\u0000\u0497\u0498\u0001\u0000\u0000"+ + "\u0000\u0498\u0499\u0006\u0089\u0000\u0000\u0499\u0115\u0001\u0000\u0000"+ + "\u0000\u049a\u049b\u00050\u0000\u0000\u049b\u04a0\u0007\u0002\u0000\u0000"+ + "\u049c\u049e\u0005_\u0000\u0000\u049d\u049c\u0001\u0000\u0000\u0000\u049d"+ + "\u049e\u0001\u0000\u0000\u0000\u049e\u049f\u0001\u0000\u0000\u0000\u049f"+ + "\u04a1\u0003\u0148\u00a3\u0000\u04a0\u049d\u0001\u0000\u0000\u0000\u04a1"+ + "\u04a2\u0001\u0000\u0000\u0000\u04a2\u04a0\u0001\u0000\u0000\u0000\u04a2"+ + "\u04a3\u0001\u0000\u0000\u0000\u04a3\u04a4\u0001\u0000\u0000\u0000\u04a4"+ + "\u04a5\u0006\u008a\u0000\u0000\u04a5\u0117\u0001\u0000\u0000\u0000\u04a6"+ + "\u04a8\u00050\u0000\u0000\u04a7\u04a9\u0007\u0003\u0000\u0000\u04a8\u04a7"+ + "\u0001\u0000\u0000\u0000\u04a8\u04a9\u0001\u0000\u0000\u0000\u04a9\u04ae"+ + "\u0001\u0000\u0000\u0000\u04aa\u04ac\u0005_\u0000\u0000\u04ab\u04aa\u0001"+ + "\u0000\u0000\u0000\u04ab\u04ac\u0001\u0000\u0000\u0000\u04ac\u04ad\u0001"+ + "\u0000\u0000\u0000\u04ad\u04af\u0003\u0144\u00a1\u0000\u04ae\u04ab\u0001"+ + "\u0000\u0000\u0000\u04af\u04b0\u0001\u0000\u0000\u0000\u04b0\u04ae\u0001"+ + "\u0000\u0000\u0000\u04b0\u04b1\u0001\u0000\u0000\u0000\u04b1\u04b2\u0001"+ + "\u0000\u0000\u0000\u04b2\u04b3\u0006\u008b\u0000\u0000\u04b3\u0119\u0001"+ + "\u0000\u0000\u0000\u04b4\u04b5\u00050\u0000\u0000\u04b5\u04ba\u0007\u0004"+ + "\u0000\u0000\u04b6\u04b8\u0005_\u0000\u0000\u04b7\u04b6\u0001\u0000\u0000"+ + "\u0000\u04b7\u04b8\u0001\u0000\u0000\u0000\u04b8\u04b9\u0001\u0000\u0000"+ + "\u0000\u04b9\u04bb\u0003\u0146\u00a2\u0000\u04ba\u04b7\u0001\u0000\u0000"+ + "\u0000\u04bb\u04bc\u0001\u0000\u0000\u0000\u04bc\u04ba\u0001\u0000\u0000"+ + "\u0000\u04bc\u04bd\u0001\u0000\u0000\u0000\u04bd\u04be\u0001\u0000\u0000"+ + "\u0000\u04be\u04bf\u0006\u008c\u0000\u0000\u04bf\u011b\u0001\u0000\u0000"+ + "\u0000\u04c0\u04c1\u00050\u0000\u0000\u04c1\u04c2\u0007\u0004\u0000\u0000"+ + "\u04c2\u04c3\u0003\u011e\u008e\u0000\u04c3\u04c4\u0003\u0120\u008f\u0000"+ + "\u04c4\u011d\u0001\u0000\u0000\u0000\u04c5\u04c7\u0005_\u0000\u0000\u04c6"+ + "\u04c5\u0001\u0000\u0000\u0000\u04c6\u04c7\u0001\u0000\u0000\u0000\u04c7"+ + "\u04c8\u0001\u0000\u0000\u0000\u04c8\u04ca\u0003\u0146\u00a2\u0000\u04c9"+ + "\u04c6\u0001\u0000\u0000\u0000\u04ca\u04cb\u0001\u0000\u0000\u0000\u04cb"+ + "\u04c9\u0001\u0000\u0000\u0000\u04cb\u04cc\u0001\u0000\u0000\u0000\u04cc"+ + "\u04d7\u0001\u0000\u0000\u0000\u04cd\u04d4\u0005.\u0000\u0000\u04ce\u04d0"+ + "\u0005_\u0000\u0000\u04cf\u04ce\u0001\u0000\u0000\u0000\u04cf\u04d0\u0001"+ + "\u0000\u0000\u0000\u04d0\u04d1\u0001\u0000\u0000\u0000\u04d1\u04d3\u0003"+ + "\u0146\u00a2\u0000\u04d2\u04cf\u0001\u0000\u0000\u0000\u04d3\u04d6\u0001"+ + "\u0000\u0000\u0000\u04d4\u04d2\u0001\u0000\u0000\u0000\u04d4\u04d5\u0001"+ + "\u0000\u0000\u0000\u04d5\u04d8\u0001\u0000\u0000\u0000\u04d6\u04d4\u0001"+ + "\u0000\u0000\u0000\u04d7\u04cd\u0001\u0000\u0000\u0000\u04d7\u04d8\u0001"+ + "\u0000\u0000\u0000\u04d8\u04e5\u0001\u0000\u0000\u0000\u04d9\u04da\u0005"+ + ".\u0000\u0000\u04da\u04e1\u0003\u0146\u00a2\u0000\u04db\u04dd\u0005_\u0000"+ + "\u0000\u04dc\u04db\u0001\u0000\u0000\u0000\u04dc\u04dd\u0001\u0000\u0000"+ + "\u0000\u04dd\u04de\u0001\u0000\u0000\u0000\u04de\u04e0\u0003\u0146\u00a2"+ + "\u0000\u04df\u04dc\u0001\u0000\u0000\u0000\u04e0\u04e3\u0001\u0000\u0000"+ + "\u0000\u04e1\u04df\u0001\u0000\u0000\u0000\u04e1\u04e2\u0001\u0000\u0000"+ + "\u0000\u04e2\u04e5\u0001\u0000\u0000\u0000\u04e3\u04e1\u0001\u0000\u0000"+ + "\u0000\u04e4\u04c9\u0001\u0000\u0000\u0000\u04e4\u04d9\u0001\u0000\u0000"+ + "\u0000\u04e5\u011f\u0001\u0000\u0000\u0000\u04e6\u04e8\u0007\u0005\u0000"+ + "\u0000\u04e7\u04e9\u0007\u0006\u0000\u0000\u04e8\u04e7\u0001\u0000\u0000"+ + "\u0000\u04e8\u04e9\u0001\u0000\u0000\u0000\u04e9\u04ea\u0001\u0000\u0000"+ + "\u0000\u04ea\u04eb\u0003\u0142\u00a0\u0000\u04eb\u0121\u0001\u0000\u0000"+ + "\u0000\u04ec\u04f2\u0003\u0114\u0089\u0000\u04ed\u04f2\u0003\u0116\u008a"+ + "\u0000\u04ee\u04f2\u0003\u0118\u008b\u0000\u04ef\u04f2\u0003\u011a\u008c"+ + "\u0000\u04f0\u04f2\u0003\u0002\u0000\u0000\u04f1\u04ec\u0001\u0000\u0000"+ + "\u0000\u04f1\u04ed\u0001\u0000\u0000\u0000\u04f1\u04ee\u0001\u0000\u0000"+ + "\u0000\u04f1\u04ef\u0001\u0000\u0000\u0000\u04f1\u04f0\u0001\u0000\u0000"+ + "\u0000\u04f2\u04f3\u0001\u0000\u0000\u0000\u04f3\u04f4\u0005i\u0000\u0000"+ + "\u04f4\u04f5\u0001\u0000\u0000\u0000\u04f5\u04f6\u0006\u0090\u0000\u0000"+ + "\u04f6\u0123\u0001\u0000\u0000\u0000\u04f7\u04fa\u0005\'\u0000\u0000\u04f8"+ + "\u04fb\u0003\u013e\u009e\u0000\u04f9\u04fb\u0003\u0128\u0093\u0000\u04fa"+ + "\u04f8\u0001\u0000\u0000\u0000\u04fa\u04f9\u0001\u0000\u0000\u0000\u04fb"+ + "\u04fc\u0001\u0000\u0000\u0000\u04fc\u04fd\u0005\'\u0000\u0000\u04fd\u0125"+ + "\u0001\u0000\u0000\u0000\u04fe\u04ff\u0003\u0124\u0091\u0000\u04ff\u0500"+ + "\u0001\u0000\u0000\u0000\u0500\u0501\u0006\u0092\u0000\u0000\u0501\u0127"+ + "\u0001\u0000\u0000\u0000\u0502\u0505\u0003\u012a\u0094\u0000\u0503\u0505"+ + "\u0003\u012c\u0095\u0000\u0504\u0502\u0001\u0000\u0000\u0000\u0504\u0503"+ + "\u0001\u0000\u0000\u0000\u0505\u0129\u0001\u0000\u0000\u0000\u0506\u0507"+ + "\u0005\\\u0000\u0000\u0507\u0508\u0003\u0144\u00a1\u0000\u0508\u0509\u0003"+ + "\u0144\u00a1\u0000\u0509\u050a\u0003\u0144\u00a1\u0000\u050a\u012b\u0001"+ + "\u0000\u0000\u0000\u050b\u050c\u0005\\\u0000\u0000\u050c\u050d\u0005x"+ + "\u0000\u0000\u050d\u050e\u0003\u0146\u00a2\u0000\u050e\u050f\u0003\u0146"+ + "\u00a2\u0000\u050f\u012d\u0001\u0000\u0000\u0000\u0510\u0511\u0005\\\u0000"+ + "\u0000\u0511\u0512\u0005u\u0000\u0000\u0512\u0513\u0003\u0146\u00a2\u0000"+ + "\u0513\u0514\u0003\u0146\u00a2\u0000\u0514\u0515\u0003\u0146\u00a2\u0000"+ + "\u0515\u0516\u0003\u0146\u00a2\u0000\u0516\u012f\u0001\u0000\u0000\u0000"+ + "\u0517\u0518\u0005\\\u0000\u0000\u0518\u0519\u0005U\u0000\u0000\u0519"+ + "\u051a\u0003\u0146\u00a2\u0000\u051a\u051b\u0003\u0146\u00a2\u0000\u051b"+ + "\u051c\u0003\u0146\u00a2\u0000\u051c\u051d\u0003\u0146\u00a2\u0000\u051d"+ + "\u051e\u0003\u0146\u00a2\u0000\u051e\u051f\u0003\u0146\u00a2\u0000\u051f"+ + "\u0520\u0003\u0146\u00a2\u0000\u0520\u0521\u0003\u0146\u00a2\u0000\u0521"+ + "\u0131\u0001\u0000\u0000\u0000\u0522\u0526\u0005`\u0000\u0000\u0523\u0525"+ + "\b\u0007\u0000\u0000\u0524\u0523\u0001\u0000\u0000\u0000\u0525\u0528\u0001"+ + "\u0000\u0000\u0000\u0526\u0524\u0001\u0000\u0000\u0000\u0526\u0527\u0001"+ + "\u0000\u0000\u0000\u0527\u0529\u0001\u0000\u0000\u0000\u0528\u0526\u0001"+ + "\u0000\u0000\u0000\u0529\u052a\u0005`\u0000\u0000\u052a\u052b\u0001\u0000"+ + "\u0000\u0000\u052b\u052c\u0006\u0098\u0000\u0000\u052c\u0133\u0001\u0000"+ + "\u0000\u0000\u052d\u0532\u0005\"\u0000\u0000\u052e\u0531\b\b\u0000\u0000"+ + "\u052f\u0531\u0003\u0140\u009f\u0000\u0530\u052e\u0001\u0000\u0000\u0000"+ + "\u0530\u052f\u0001\u0000\u0000\u0000\u0531\u0534\u0001\u0000\u0000\u0000"+ + "\u0532\u0530\u0001\u0000\u0000\u0000\u0532\u0533\u0001\u0000\u0000\u0000"+ + "\u0533\u0535\u0001\u0000\u0000\u0000\u0534\u0532\u0001\u0000\u0000\u0000"+ + "\u0535\u0536\u0005\"\u0000\u0000\u0536\u0537\u0001\u0000\u0000\u0000\u0537"+ + "\u0538\u0006\u0099\u0000\u0000\u0538\u0135\u0001\u0000\u0000\u0000\u0539"+ + "\u053b\u0007\t\u0000\u0000\u053a\u0539\u0001\u0000\u0000\u0000\u053b\u053c"+ + "\u0001\u0000\u0000\u0000\u053c\u053a\u0001\u0000\u0000\u0000\u053c\u053d"+ + "\u0001\u0000\u0000\u0000\u053d\u053e\u0001\u0000\u0000\u0000\u053e\u053f"+ + "\u0006\u009a\u0001\u0000\u053f\u0137\u0001\u0000\u0000\u0000\u0540\u0541"+ + "\u0005/\u0000\u0000\u0541\u0542\u0005*\u0000\u0000\u0542\u0546\u0001\u0000"+ + "\u0000\u0000\u0543\u0545\t\u0000\u0000\u0000\u0544\u0543\u0001\u0000\u0000"+ + "\u0000\u0545\u0548\u0001\u0000\u0000\u0000\u0546\u0547\u0001\u0000\u0000"+ + "\u0000\u0546\u0544\u0001\u0000\u0000\u0000\u0547\u0549\u0001\u0000\u0000"+ + "\u0000\u0548\u0546\u0001\u0000\u0000\u0000\u0549\u054a\u0005*\u0000\u0000"+ + "\u054a\u054b\u0005/\u0000\u0000\u054b\u054c\u0001\u0000\u0000\u0000\u054c"+ + "\u054d\u0006\u009b\u0001\u0000\u054d\u0139\u0001\u0000\u0000\u0000\u054e"+ + "\u0550\u0007\n\u0000\u0000\u054f\u054e\u0001\u0000\u0000\u0000\u0550\u0551"+ + "\u0001\u0000\u0000\u0000\u0551\u054f\u0001\u0000\u0000\u0000\u0551\u0552"+ + "\u0001\u0000\u0000\u0000\u0552\u0553\u0001\u0000\u0000\u0000\u0553\u0554"+ + "\u0006\u009c\u0001\u0000\u0554\u013b\u0001\u0000\u0000\u0000\u0555\u0556"+ + "\u0005/\u0000\u0000\u0556\u0557\u0005/\u0000\u0000\u0557\u055b\u0001\u0000"+ + "\u0000\u0000\u0558\u055a\b\n\u0000\u0000\u0559\u0558\u0001\u0000\u0000"+ + "\u0000\u055a\u055d\u0001\u0000\u0000\u0000\u055b\u0559\u0001\u0000\u0000"+ + "\u0000\u055b\u055c\u0001\u0000\u0000\u0000\u055c\u055e\u0001\u0000\u0000"+ + "\u0000\u055d\u055b\u0001\u0000\u0000\u0000\u055e\u055f\u0006\u009d\u0001"+ + "\u0000\u055f\u013d\u0001\u0000\u0000\u0000\u0560\u0565\b\u000b\u0000\u0000"+ + "\u0561\u0565\u0003\u012e\u0096\u0000\u0562\u0565\u0003\u0130\u0097\u0000"+ + "\u0563\u0565\u0003\u0140\u009f\u0000\u0564\u0560\u0001\u0000\u0000\u0000"+ + "\u0564\u0561\u0001\u0000\u0000\u0000\u0564\u0562\u0001\u0000\u0000\u0000"+ + "\u0564\u0563\u0001\u0000\u0000\u0000\u0565\u013f\u0001\u0000\u0000\u0000"+ + "\u0566\u0580\u0005\\\u0000\u0000\u0567\u0568\u0005u\u0000\u0000\u0568"+ + "\u0569\u0003\u0146\u00a2\u0000\u0569\u056a\u0003\u0146\u00a2\u0000\u056a"+ + "\u056b\u0003\u0146\u00a2\u0000\u056b\u056c\u0003\u0146\u00a2\u0000\u056c"+ + "\u0581\u0001\u0000\u0000\u0000\u056d\u056e\u0005U\u0000\u0000\u056e\u056f"+ + "\u0003\u0146\u00a2\u0000\u056f\u0570\u0003\u0146\u00a2\u0000\u0570\u0571"+ + "\u0003\u0146\u00a2\u0000\u0571\u0572\u0003\u0146\u00a2\u0000\u0572\u0573"+ + "\u0003\u0146\u00a2\u0000\u0573\u0574\u0003\u0146\u00a2\u0000\u0574\u0575"+ + "\u0003\u0146\u00a2\u0000\u0575\u0576\u0003\u0146\u00a2\u0000\u0576\u0581"+ + "\u0001\u0000\u0000\u0000\u0577\u0581\u0007\f\u0000\u0000\u0578\u0579\u0003"+ + "\u0144\u00a1\u0000\u0579\u057a\u0003\u0144\u00a1\u0000\u057a\u057b\u0003"+ + "\u0144\u00a1\u0000\u057b\u0581\u0001\u0000\u0000\u0000\u057c\u057d\u0005"+ + "x\u0000\u0000\u057d\u057e\u0003\u0146\u00a2\u0000\u057e\u057f\u0003\u0146"+ + "\u00a2\u0000\u057f\u0581\u0001\u0000\u0000\u0000\u0580\u0567\u0001\u0000"+ + "\u0000\u0000\u0580\u056d\u0001\u0000\u0000\u0000\u0580\u0577\u0001\u0000"+ + "\u0000\u0000\u0580\u0578\u0001\u0000\u0000\u0000\u0580\u057c\u0001\u0000"+ + "\u0000\u0000\u0581\u0141\u0001\u0000\u0000\u0000\u0582\u0589\u0007\u0001"+ + "\u0000\u0000\u0583\u0585\u0005_\u0000\u0000\u0584\u0583\u0001\u0000\u0000"+ + "\u0000\u0584\u0585\u0001\u0000\u0000\u0000\u0585\u0586\u0001\u0000\u0000"+ + "\u0000\u0586\u0588\u0007\u0001\u0000\u0000\u0587\u0584\u0001\u0000\u0000"+ + "\u0000\u0588\u058b\u0001\u0000\u0000\u0000\u0589\u0587\u0001\u0000\u0000"+ + "\u0000\u0589\u058a\u0001\u0000\u0000\u0000\u058a\u0143\u0001\u0000\u0000"+ + "\u0000\u058b\u0589\u0001\u0000\u0000\u0000\u058c\u058d\u0007\r\u0000\u0000"+ + "\u058d\u0145\u0001\u0000\u0000\u0000\u058e\u058f\u0007\u000e\u0000\u0000"+ + "\u058f\u0147\u0001\u0000\u0000\u0000\u0590\u0591\u0007\u000f\u0000\u0000"+ + "\u0591\u0149\u0001\u0000\u0000\u0000\u0592\u0594\u0007\u0010\u0000\u0000"+ + "\u0593\u0595\u0007\u0006\u0000\u0000\u0594\u0593\u0001\u0000\u0000\u0000"+ + "\u0594\u0595\u0001\u0000\u0000\u0000\u0595\u0596\u0001\u0000\u0000\u0000"+ + "\u0596\u0597\u0003\u0142\u00a0\u0000\u0597\u014b\u0001\u0000\u0000\u0000"+ + "\u0598\u059b\u0003\u0150\u00a7\u0000\u0599\u059b\u0005_\u0000\u0000\u059a"+ + "\u0598\u0001\u0000\u0000\u0000\u059a\u0599\u0001\u0000\u0000\u0000\u059b"+ + "\u014d\u0001\u0000\u0000\u0000\u059c\u059d\u0007\u0011\u0000\u0000\u059d"+ + "\u014f\u0001\u0000\u0000\u0000\u059e\u059f\u0007\u0012\u0000\u0000\u059f"+ + "\u0151\u0001\u0000\u0000\u0000\u05a0\u05a2\u0007\t\u0000\u0000\u05a1\u05a0"+ + "\u0001\u0000\u0000\u0000\u05a2\u05a3\u0001\u0000\u0000\u0000\u05a3\u05a1"+ + "\u0001\u0000\u0000\u0000\u05a3\u05a4\u0001\u0000\u0000\u0000\u05a4\u05a5"+ + "\u0001\u0000\u0000\u0000\u05a5\u05a6\u0006\u00a8\u0001\u0000\u05a6\u0153"+ + "\u0001\u0000\u0000\u0000\u05a7\u05a8\u0005/\u0000\u0000\u05a8\u05a9\u0005"+ + "*\u0000\u0000\u05a9\u05ad\u0001\u0000\u0000\u0000\u05aa\u05ac\b\n\u0000"+ + "\u0000\u05ab\u05aa\u0001\u0000\u0000\u0000\u05ac\u05af\u0001\u0000\u0000"+ + "\u0000\u05ad\u05ae\u0001\u0000\u0000\u0000\u05ad\u05ab\u0001\u0000\u0000"+ + "\u0000\u05ae\u05b0\u0001\u0000\u0000\u0000\u05af\u05ad\u0001\u0000\u0000"+ + "\u0000\u05b0\u05b1\u0005*\u0000\u0000\u05b1\u05b2\u0005/\u0000\u0000\u05b2"+ + "\u05b3\u0001\u0000\u0000\u0000\u05b3\u05b4\u0006\u00a9\u0001\u0000\u05b4"+ + "\u0155\u0001\u0000\u0000\u0000\u05b5\u05b6\u0005/\u0000\u0000\u05b6\u05b7"+ + "\u0005/\u0000\u0000\u05b7\u05bb\u0001\u0000\u0000\u0000\u05b8\u05ba\b"+ + "\n\u0000\u0000\u05b9\u05b8\u0001\u0000\u0000\u0000\u05ba\u05bd\u0001\u0000"+ + "\u0000\u0000\u05bb\u05b9\u0001\u0000\u0000\u0000\u05bb\u05bc\u0001\u0000"+ + "\u0000\u0000\u05bc\u05be\u0001\u0000\u0000\u0000\u05bd\u05bb\u0001\u0000"+ + "\u0000\u0000\u05be\u05bf\u0006\u00aa\u0001\u0000\u05bf\u0157\u0001\u0000"+ + "\u0000\u0000\u05c0\u05c2\u0007\n\u0000\u0000\u05c1\u05c0\u0001\u0000\u0000"+ + "\u0000\u05c2\u05c3\u0001\u0000\u0000\u0000\u05c3\u05c1\u0001\u0000\u0000"+ + "\u0000\u05c3\u05c4\u0001\u0000\u0000\u0000\u05c4\u05d3\u0001\u0000\u0000"+ + "\u0000\u05c5\u05d3\u0005;\u0000\u0000\u05c6\u05c7\u0005/\u0000\u0000\u05c7"+ + "\u05c8\u0005*\u0000\u0000\u05c8\u05cc\u0001\u0000\u0000\u0000\u05c9\u05cb"+ + "\t\u0000\u0000\u0000\u05ca\u05c9\u0001\u0000\u0000\u0000\u05cb\u05ce\u0001"+ + "\u0000\u0000\u0000\u05cc\u05cd\u0001\u0000\u0000\u0000\u05cc\u05ca\u0001"+ + "\u0000\u0000\u0000\u05cd\u05cf\u0001\u0000\u0000\u0000\u05ce\u05cc\u0001"+ + "\u0000\u0000\u0000\u05cf\u05d0\u0005*\u0000\u0000\u05d0\u05d3\u0005/\u0000"+ + "\u0000\u05d1\u05d3\u0005\u0000\u0000\u0001\u05d2\u05c1\u0001\u0000\u0000"+ + "\u0000\u05d2\u05c5\u0001\u0000\u0000\u0000\u05d2\u05c6\u0001\u0000\u0000"+ + "\u0000\u05d2\u05d1\u0001\u0000\u0000\u0000\u05d3\u05d4\u0001\u0000\u0000"+ + "\u0000\u05d4\u05d5\u0006\u00ab\u0002\u0000\u05d5\u0159\u0001\u0000\u0000"+ + "\u0000\u05d6\u05d7\u0001\u0000\u0000\u0000\u05d7\u05d8\u0001\u0000\u0000"+ + "\u0000\u05d8\u05d9\u0006\u00ac\u0002\u0000\u05d9\u05da\u0006\u00ac\u0001"+ + "\u0000\u05da\u015b\u0001\u0000\u0000\u00003\u0000\u0001\u015e\u0166\u0169"+ + "\u016c\u0172\u0174\u0423\u0425\u048e\u0493\u0496\u049d\u04a2\u04a8\u04ab"+ + "\u04b0\u04b7\u04bc\u04c6\u04cb\u04cf\u04d4\u04d7\u04dc\u04e1\u04e4\u04e8"+ + "\u04f1\u04fa\u0504\u0526\u0530\u0532\u053c\u0546\u0551\u055b\u0564\u0580"+ + "\u0584\u0589\u0594\u059a\u05a3\u05ad\u05bb\u05c3\u05cc\u05d2\u0003\u0002"+ + "\u0001\u0000\u0000\u0001\u0000\u0002\u0000\u0000"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); static { @@ -916,4 +1342,4 @@ private boolean DECIMAL_FLOAT_LIT_sempred(RuleContext _localctx, int predIndex) _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); } } -} +} \ No newline at end of file diff --git a/src/main/java/viper/gobra/frontend/GobraParser.java b/src/main/java/viper/gobra/frontend/GobraParser.java index 5771a622b..0b583ef70 100644 --- a/src/main/java/viper/gobra/frontend/GobraParser.java +++ b/src/main/java/viper/gobra/frontend/GobraParser.java @@ -1,3 +1,4 @@ +// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.12.0 package viper.gobra.frontend; import org.antlr.v4.runtime.atn.*; import org.antlr.v4.runtime.dfa.DFA; @@ -8,9 +9,9 @@ import java.util.Iterator; import java.util.ArrayList; -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) public class GobraParser extends GobraParserBase { - static { RuntimeMetaData.checkVersion("4.9.1", RuntimeMetaData.VERSION); } + static { RuntimeMetaData.checkVersion("4.12.0", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = @@ -44,62 +45,62 @@ public class GobraParser extends GobraParserBase { EOS=159, OTHER=160; public static final int RULE_exprOnly = 0, RULE_stmtOnly = 1, RULE_typeOnly = 2, RULE_maybeAddressableIdentifierList = 3, - RULE_maybeAddressableIdentifier = 4, RULE_sourceFile = 5, RULE_initPost = 6, - RULE_importPre = 7, RULE_importSpec = 8, RULE_importDecl = 9, RULE_ghostMember = 10, - RULE_ghostStatement = 11, RULE_auxiliaryStatement = 12, RULE_statementWithSpec = 13, - RULE_outlineStatement = 14, RULE_ghostPrimaryExpr = 15, RULE_permission = 16, - RULE_typeExpr = 17, RULE_boundVariables = 18, RULE_boundVariableDecl = 19, - RULE_triggers = 20, RULE_trigger = 21, RULE_predicateAccess = 22, RULE_optionSome = 23, - RULE_optionNone = 24, RULE_optionGet = 25, RULE_sConversion = 26, RULE_old = 27, - RULE_oldLabelUse = 28, RULE_labelUse = 29, RULE_before = 30, RULE_isComparable = 31, - RULE_typeOf = 32, RULE_access = 33, RULE_range = 34, RULE_matchExpr = 35, - RULE_matchExprClause = 36, RULE_seqUpdExp = 37, RULE_seqUpdClause = 38, - RULE_ghostTypeLit = 39, RULE_domainType = 40, RULE_domainClause = 41, - RULE_adtType = 42, RULE_adtClause = 43, RULE_ghostSliceType = 44, RULE_sqType = 45, - RULE_specification = 46, RULE_specStatement = 47, RULE_terminationMeasure = 48, - RULE_assertion = 49, RULE_matchStmt = 50, RULE_matchStmtClause = 51, RULE_matchCase = 52, - RULE_matchPattern = 53, RULE_matchPatternList = 54, RULE_blockWithBodyParameterInfo = 55, - RULE_closureSpecInstance = 56, RULE_closureSpecParams = 57, RULE_closureSpecParam = 58, - RULE_closureImplProofStmt = 59, RULE_implementationProof = 60, RULE_methodImplementationProof = 61, - RULE_nonLocalReceiver = 62, RULE_selection = 63, RULE_implementationProofPredicateAlias = 64, - RULE_make = 65, RULE_new_ = 66, RULE_specMember = 67, RULE_functionDecl = 68, - RULE_methodDecl = 69, RULE_explicitGhostMember = 70, RULE_fpredicateDecl = 71, - RULE_predicateBody = 72, RULE_mpredicateDecl = 73, RULE_varSpec = 74, - RULE_shortVarDecl = 75, RULE_receiver = 76, RULE_parameterDecl = 77, RULE_actualParameterDecl = 78, - RULE_ghostParameterDecl = 79, RULE_parameterType = 80, RULE_expression = 81, - RULE_statement = 82, RULE_applyStmt = 83, RULE_packageStmt = 84, RULE_specForStmt = 85, - RULE_loopSpec = 86, RULE_deferStmt = 87, RULE_basicLit = 88, RULE_primaryExpr = 89, - RULE_functionLit = 90, RULE_closureDecl = 91, RULE_predConstructArgs = 92, - RULE_interfaceType = 93, RULE_predicateSpec = 94, RULE_methodSpec = 95, - RULE_type_ = 96, RULE_typeLit = 97, RULE_predType = 98, RULE_predTypeParams = 99, - RULE_literalType = 100, RULE_implicitArray = 101, RULE_slice_ = 102, RULE_low = 103, - RULE_high = 104, RULE_cap = 105, RULE_assign_op = 106, RULE_rangeClause = 107, - RULE_packageClause = 108, RULE_importPath = 109, RULE_declaration = 110, - RULE_constDecl = 111, RULE_constSpec = 112, RULE_identifierList = 113, - RULE_expressionList = 114, RULE_typeDecl = 115, RULE_typeSpec = 116, RULE_varDecl = 117, - RULE_block = 118, RULE_statementList = 119, RULE_simpleStmt = 120, RULE_expressionStmt = 121, - RULE_sendStmt = 122, RULE_incDecStmt = 123, RULE_assignment = 124, RULE_emptyStmt = 125, - RULE_labeledStmt = 126, RULE_returnStmt = 127, RULE_breakStmt = 128, RULE_continueStmt = 129, - RULE_gotoStmt = 130, RULE_fallthroughStmt = 131, RULE_ifStmt = 132, RULE_switchStmt = 133, - RULE_exprSwitchStmt = 134, RULE_exprCaseClause = 135, RULE_exprSwitchCase = 136, - RULE_typeSwitchStmt = 137, RULE_typeSwitchGuard = 138, RULE_typeCaseClause = 139, - RULE_typeSwitchCase = 140, RULE_typeList = 141, RULE_selectStmt = 142, - RULE_commClause = 143, RULE_commCase = 144, RULE_recvStmt = 145, RULE_forStmt = 146, - RULE_forClause = 147, RULE_goStmt = 148, RULE_typeName = 149, RULE_arrayType = 150, - RULE_arrayLength = 151, RULE_elementType = 152, RULE_pointerType = 153, - RULE_sliceType = 154, RULE_mapType = 155, RULE_channelType = 156, RULE_functionType = 157, - RULE_signature = 158, RULE_result = 159, RULE_parameters = 160, RULE_conversion = 161, - RULE_nonNamedType = 162, RULE_operand = 163, RULE_literal = 164, RULE_integer = 165, - RULE_operandName = 166, RULE_qualifiedIdent = 167, RULE_compositeLit = 168, - RULE_literalValue = 169, RULE_elementList = 170, RULE_keyedElement = 171, - RULE_key = 172, RULE_element = 173, RULE_structType = 174, RULE_fieldDecl = 175, - RULE_string_ = 176, RULE_embeddedField = 177, RULE_index = 178, RULE_typeAssertion = 179, - RULE_arguments = 180, RULE_methodExpr = 181, RULE_receiverType = 182, - RULE_eos = 183; + RULE_maybeAddressableIdentifier = 4, RULE_sourceFile = 5, RULE_preamble = 6, + RULE_initPost = 7, RULE_importPre = 8, RULE_importSpec = 9, RULE_importDecl = 10, + RULE_ghostMember = 11, RULE_ghostStatement = 12, RULE_auxiliaryStatement = 13, + RULE_statementWithSpec = 14, RULE_outlineStatement = 15, RULE_ghostPrimaryExpr = 16, + RULE_permission = 17, RULE_typeExpr = 18, RULE_boundVariables = 19, RULE_boundVariableDecl = 20, + RULE_triggers = 21, RULE_trigger = 22, RULE_predicateAccess = 23, RULE_optionSome = 24, + RULE_optionNone = 25, RULE_optionGet = 26, RULE_sConversion = 27, RULE_old = 28, + RULE_oldLabelUse = 29, RULE_labelUse = 30, RULE_before = 31, RULE_isComparable = 32, + RULE_typeOf = 33, RULE_access = 34, RULE_range = 35, RULE_matchExpr = 36, + RULE_matchExprClause = 37, RULE_seqUpdExp = 38, RULE_seqUpdClause = 39, + RULE_ghostTypeLit = 40, RULE_domainType = 41, RULE_domainClause = 42, + RULE_adtType = 43, RULE_adtClause = 44, RULE_ghostSliceType = 45, RULE_sqType = 46, + RULE_specification = 47, RULE_specStatement = 48, RULE_terminationMeasure = 49, + RULE_assertion = 50, RULE_matchStmt = 51, RULE_matchStmtClause = 52, RULE_matchCase = 53, + RULE_matchPattern = 54, RULE_matchPatternList = 55, RULE_blockWithBodyParameterInfo = 56, + RULE_closureSpecInstance = 57, RULE_closureSpecParams = 58, RULE_closureSpecParam = 59, + RULE_closureImplProofStmt = 60, RULE_implementationProof = 61, RULE_methodImplementationProof = 62, + RULE_nonLocalReceiver = 63, RULE_selection = 64, RULE_implementationProofPredicateAlias = 65, + RULE_make = 66, RULE_new_ = 67, RULE_specMember = 68, RULE_functionDecl = 69, + RULE_methodDecl = 70, RULE_explicitGhostMember = 71, RULE_fpredicateDecl = 72, + RULE_predicateBody = 73, RULE_mpredicateDecl = 74, RULE_varSpec = 75, + RULE_shortVarDecl = 76, RULE_receiver = 77, RULE_parameterDecl = 78, RULE_actualParameterDecl = 79, + RULE_ghostParameterDecl = 80, RULE_parameterType = 81, RULE_expression = 82, + RULE_statement = 83, RULE_applyStmt = 84, RULE_packageStmt = 85, RULE_specForStmt = 86, + RULE_loopSpec = 87, RULE_deferStmt = 88, RULE_basicLit = 89, RULE_primaryExpr = 90, + RULE_functionLit = 91, RULE_closureDecl = 92, RULE_predConstructArgs = 93, + RULE_interfaceType = 94, RULE_predicateSpec = 95, RULE_methodSpec = 96, + RULE_type_ = 97, RULE_typeLit = 98, RULE_predType = 99, RULE_predTypeParams = 100, + RULE_literalType = 101, RULE_implicitArray = 102, RULE_slice_ = 103, RULE_low = 104, + RULE_high = 105, RULE_cap = 106, RULE_assign_op = 107, RULE_rangeClause = 108, + RULE_packageClause = 109, RULE_importPath = 110, RULE_declaration = 111, + RULE_constDecl = 112, RULE_constSpec = 113, RULE_identifierList = 114, + RULE_expressionList = 115, RULE_typeDecl = 116, RULE_typeSpec = 117, RULE_varDecl = 118, + RULE_block = 119, RULE_statementList = 120, RULE_simpleStmt = 121, RULE_expressionStmt = 122, + RULE_sendStmt = 123, RULE_incDecStmt = 124, RULE_assignment = 125, RULE_emptyStmt = 126, + RULE_labeledStmt = 127, RULE_returnStmt = 128, RULE_breakStmt = 129, RULE_continueStmt = 130, + RULE_gotoStmt = 131, RULE_fallthroughStmt = 132, RULE_ifStmt = 133, RULE_switchStmt = 134, + RULE_exprSwitchStmt = 135, RULE_exprCaseClause = 136, RULE_exprSwitchCase = 137, + RULE_typeSwitchStmt = 138, RULE_typeSwitchGuard = 139, RULE_typeCaseClause = 140, + RULE_typeSwitchCase = 141, RULE_typeList = 142, RULE_selectStmt = 143, + RULE_commClause = 144, RULE_commCase = 145, RULE_recvStmt = 146, RULE_forStmt = 147, + RULE_forClause = 148, RULE_goStmt = 149, RULE_typeName = 150, RULE_arrayType = 151, + RULE_arrayLength = 152, RULE_elementType = 153, RULE_pointerType = 154, + RULE_sliceType = 155, RULE_mapType = 156, RULE_channelType = 157, RULE_functionType = 158, + RULE_signature = 159, RULE_result = 160, RULE_parameters = 161, RULE_conversion = 162, + RULE_nonNamedType = 163, RULE_operand = 164, RULE_literal = 165, RULE_integer = 166, + RULE_operandName = 167, RULE_qualifiedIdent = 168, RULE_compositeLit = 169, + RULE_literalValue = 170, RULE_elementList = 171, RULE_keyedElement = 172, + RULE_key = 173, RULE_element = 174, RULE_structType = 175, RULE_fieldDecl = 176, + RULE_string_ = 177, RULE_embeddedField = 178, RULE_index = 179, RULE_typeAssertion = 180, + RULE_arguments = 181, RULE_methodExpr = 182, RULE_receiverType = 183, + RULE_eos = 184; private static String[] makeRuleNames() { return new String[] { "exprOnly", "stmtOnly", "typeOnly", "maybeAddressableIdentifierList", - "maybeAddressableIdentifier", "sourceFile", "initPost", "importPre", + "maybeAddressableIdentifier", "sourceFile", "preamble", "initPost", "importPre", "importSpec", "importDecl", "ghostMember", "ghostStatement", "auxiliaryStatement", "statementWithSpec", "outlineStatement", "ghostPrimaryExpr", "permission", "typeExpr", "boundVariables", "boundVariableDecl", "triggers", "trigger", @@ -243,6 +244,7 @@ public GobraParser(TokenStream input) { _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); } + @SuppressWarnings("CheckReturnValue") public static class ExprOnlyContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -265,9 +267,9 @@ public final ExprOnlyContext exprOnly() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(368); + setState(370); expression(0); - setState(369); + setState(371); match(EOF); } } @@ -282,6 +284,7 @@ public final ExprOnlyContext exprOnly() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StmtOnlyContext extends ParserRuleContext { public StatementContext statement() { return getRuleContext(StatementContext.class,0); @@ -304,9 +307,9 @@ public final StmtOnlyContext stmtOnly() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(371); + setState(373); statement(); - setState(372); + setState(374); match(EOF); } } @@ -321,6 +324,7 @@ public final StmtOnlyContext stmtOnly() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeOnlyContext extends ParserRuleContext { public Type_Context type_() { return getRuleContext(Type_Context.class,0); @@ -343,9 +347,9 @@ public final TypeOnlyContext typeOnly() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(374); + setState(376); type_(); - setState(375); + setState(377); match(EOF); } } @@ -360,6 +364,7 @@ public final TypeOnlyContext typeOnly() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MaybeAddressableIdentifierListContext extends ParserRuleContext { public List maybeAddressableIdentifier() { return getRuleContexts(MaybeAddressableIdentifierContext.class); @@ -389,21 +394,21 @@ public final MaybeAddressableIdentifierListContext maybeAddressableIdentifierLis try { enterOuterAlt(_localctx, 1); { - setState(377); + setState(379); maybeAddressableIdentifier(); - setState(382); + setState(384); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(378); + setState(380); match(COMMA); - setState(379); + setState(381); maybeAddressableIdentifier(); } } - setState(384); + setState(386); _errHandler.sync(this); _la = _input.LA(1); } @@ -420,6 +425,7 @@ public final MaybeAddressableIdentifierListContext maybeAddressableIdentifierLis return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MaybeAddressableIdentifierContext extends ParserRuleContext { public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } public TerminalNode ADDR_MOD() { return getToken(GobraParser.ADDR_MOD, 0); } @@ -441,14 +447,14 @@ public final MaybeAddressableIdentifierContext maybeAddressableIdentifier() thro try { enterOuterAlt(_localctx, 1); { - setState(385); - match(IDENTIFIER); setState(387); + match(IDENTIFIER); + setState(389); _errHandler.sync(this); _la = _input.LA(1); if (_la==ADDR_MOD) { { - setState(386); + setState(388); match(ADDR_MOD); } } @@ -466,6 +472,7 @@ public final MaybeAddressableIdentifierContext maybeAddressableIdentifier() thro return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SourceFileContext extends ParserRuleContext { public PackageClauseContext packageClause() { return getRuleContext(PackageClauseContext.class,0); @@ -525,79 +532,79 @@ public final SourceFileContext sourceFile() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(394); + setState(396); _errHandler.sync(this); _la = _input.LA(1); while (_la==INIT_POST) { { { - setState(389); + setState(391); initPost(); - setState(390); + setState(392); eos(); } } - setState(396); + setState(398); _errHandler.sync(this); _la = _input.LA(1); } - setState(397); + setState(399); packageClause(); - setState(398); + setState(400); eos(); - setState(404); + setState(406); _errHandler.sync(this); _la = _input.LA(1); while (_la==IMPORT_PRE || _la==IMPORT) { { { - setState(399); + setState(401); importDecl(); - setState(400); + setState(402); eos(); } } - setState(406); + setState(408); _errHandler.sync(this); _la = _input.LA(1); } - setState(416); + setState(418); _errHandler.sync(this); _la = _input.LA(1); - while (((((_la - 9)) & ~0x3f) == 0 && ((1L << (_la - 9)) & ((1L << (PRE - 9)) | (1L << (PRESERVES - 9)) | (1L << (POST - 9)) | (1L << (DEC - 9)) | (1L << (PURE - 9)) | (1L << (GHOST - 9)) | (1L << (SEQ - 9)) | (1L << (SET - 9)) | (1L << (MSET - 9)) | (1L << (DICT - 9)) | (1L << (OPT - 9)) | (1L << (DOM - 9)) | (1L << (ADT - 9)) | (1L << (PRED - 9)) | (1L << (TRUSTED - 9)))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (FUNC - 77)) | (1L << (INTERFACE - 77)) | (1L << (MAP - 77)) | (1L << (STRUCT - 77)) | (1L << (CHAN - 77)) | (1L << (CONST - 77)) | (1L << (TYPE - 77)) | (1L << (VAR - 77)) | (1L << (IDENTIFIER - 77)) | (1L << (L_PAREN - 77)) | (1L << (L_BRACKET - 77)) | (1L << (STAR - 77)) | (1L << (RECEIVE - 77)))) != 0)) { + while (((((_la - 9)) & ~0x3f) == 0 && ((1L << (_la - 9)) & 288393170444877879L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441151881350095299L) != 0)) { { { - setState(410); + setState(412); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { case 1: { - setState(407); + setState(409); specMember(); } break; case 2: { - setState(408); + setState(410); declaration(); } break; case 3: { - setState(409); + setState(411); ghostMember(); } break; } - setState(412); + setState(414); eos(); } } - setState(418); + setState(420); _errHandler.sync(this); _la = _input.LA(1); } - setState(419); + setState(421); match(EOF); } } @@ -612,6 +619,97 @@ public final SourceFileContext sourceFile() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") + public static class PreambleContext extends ParserRuleContext { + public PackageClauseContext packageClause() { + return getRuleContext(PackageClauseContext.class,0); + } + public List eos() { + return getRuleContexts(EosContext.class); + } + public EosContext eos(int i) { + return getRuleContext(EosContext.class,i); + } + public List initPost() { + return getRuleContexts(InitPostContext.class); + } + public InitPostContext initPost(int i) { + return getRuleContext(InitPostContext.class,i); + } + public List importDecl() { + return getRuleContexts(ImportDeclContext.class); + } + public ImportDeclContext importDecl(int i) { + return getRuleContext(ImportDeclContext.class,i); + } + public PreambleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_preamble; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof GobraParserVisitor ) return ((GobraParserVisitor)visitor).visitPreamble(this); + else return visitor.visitChildren(this); + } + } + + public final PreambleContext preamble() throws RecognitionException { + PreambleContext _localctx = new PreambleContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_preamble); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(428); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==INIT_POST) { + { + { + setState(423); + initPost(); + setState(424); + eos(); + } + } + setState(430); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(431); + packageClause(); + setState(432); + eos(); + setState(438); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==IMPORT_PRE || _la==IMPORT) { + { + { + setState(433); + importDecl(); + setState(434); + eos(); + } + } + setState(440); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") public static class InitPostContext extends ParserRuleContext { public TerminalNode INIT_POST() { return getToken(GobraParser.INIT_POST, 0); } public ExpressionContext expression() { @@ -630,13 +728,13 @@ public T accept(ParseTreeVisitor visitor) { public final InitPostContext initPost() throws RecognitionException { InitPostContext _localctx = new InitPostContext(_ctx, getState()); - enterRule(_localctx, 12, RULE_initPost); + enterRule(_localctx, 14, RULE_initPost); try { enterOuterAlt(_localctx, 1); { - setState(421); + setState(441); match(INIT_POST); - setState(422); + setState(442); expression(0); } } @@ -651,6 +749,7 @@ public final InitPostContext initPost() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ImportPreContext extends ParserRuleContext { public TerminalNode IMPORT_PRE() { return getToken(GobraParser.IMPORT_PRE, 0); } public ExpressionContext expression() { @@ -669,13 +768,13 @@ public T accept(ParseTreeVisitor visitor) { public final ImportPreContext importPre() throws RecognitionException { ImportPreContext _localctx = new ImportPreContext(_ctx, getState()); - enterRule(_localctx, 14, RULE_importPre); + enterRule(_localctx, 16, RULE_importPre); try { enterOuterAlt(_localctx, 1); { - setState(424); + setState(444); match(IMPORT_PRE); - setState(425); + setState(445); expression(0); } } @@ -690,6 +789,7 @@ public final ImportPreContext importPre() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ImportSpecContext extends ParserRuleContext { public Token alias; public ImportPathContext importPath() { @@ -722,33 +822,33 @@ public T accept(ParseTreeVisitor visitor) { public final ImportSpecContext importSpec() throws RecognitionException { ImportSpecContext _localctx = new ImportSpecContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_importSpec); + enterRule(_localctx, 18, RULE_importSpec); int _la; try { enterOuterAlt(_localctx, 1); { - setState(432); + setState(452); _errHandler.sync(this); _la = _input.LA(1); while (_la==IMPORT_PRE) { { { - setState(427); + setState(447); importPre(); - setState(428); + setState(448); eos(); } } - setState(434); + setState(454); _errHandler.sync(this); _la = _input.LA(1); } - setState(436); + setState(456); _errHandler.sync(this); _la = _input.LA(1); if (_la==IDENTIFIER || _la==DOT) { { - setState(435); + setState(455); ((ImportSpecContext)_localctx).alias = _input.LT(1); _la = _input.LA(1); if ( !(_la==IDENTIFIER || _la==DOT) ) { @@ -762,7 +862,7 @@ public final ImportSpecContext importSpec() throws RecognitionException { } } - setState(438); + setState(458); importPath(); } } @@ -777,6 +877,7 @@ public final ImportSpecContext importSpec() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ImportDeclContext extends ParserRuleContext { public TerminalNode IMPORT() { return getToken(GobraParser.IMPORT, 0); } public List importSpec() { @@ -812,61 +913,61 @@ public T accept(ParseTreeVisitor visitor) { public final ImportDeclContext importDecl() throws RecognitionException { ImportDeclContext _localctx = new ImportDeclContext(_ctx, getState()); - enterRule(_localctx, 18, RULE_importDecl); + enterRule(_localctx, 20, RULE_importDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(445); + setState(465); _errHandler.sync(this); _la = _input.LA(1); while (_la==IMPORT_PRE) { { { - setState(440); + setState(460); importPre(); - setState(441); + setState(461); eos(); } } - setState(447); + setState(467); _errHandler.sync(this); _la = _input.LA(1); } - setState(461); + setState(481); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { case 1: { - setState(448); + setState(468); match(IMPORT); - setState(449); + setState(469); importSpec(); } break; case 2: { - setState(450); + setState(470); match(IMPORT); - setState(451); + setState(471); match(L_PAREN); - setState(457); + setState(477); _errHandler.sync(this); _la = _input.LA(1); - while (((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (IMPORT_PRE - 70)) | (1L << (IDENTIFIER - 70)) | (1L << (DOT - 70)))) != 0) || _la==RAW_STRING_LIT || _la==INTERPRETED_STRING_LIT) { + while (((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 4400193994753L) != 0) || _la==RAW_STRING_LIT || _la==INTERPRETED_STRING_LIT) { { { - setState(452); + setState(472); importSpec(); - setState(453); + setState(473); eos(); } } - setState(459); + setState(479); _errHandler.sync(this); _la = _input.LA(1); } - setState(460); + setState(480); match(R_PAREN); } break; @@ -884,6 +985,7 @@ public final ImportDeclContext importDecl() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class GhostMemberContext extends ParserRuleContext { public ImplementationProofContext implementationProof() { return getRuleContext(ImplementationProofContext.class,0); @@ -910,36 +1012,36 @@ public T accept(ParseTreeVisitor visitor) { public final GhostMemberContext ghostMember() throws RecognitionException { GhostMemberContext _localctx = new GhostMemberContext(_ctx, getState()); - enterRule(_localctx, 20, RULE_ghostMember); + enterRule(_localctx, 22, RULE_ghostMember); try { - setState(467); + setState(487); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(463); + setState(483); implementationProof(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(464); + setState(484); fpredicateDecl(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(465); + setState(485); mpredicateDecl(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(466); + setState(486); explicitGhostMember(); } break; @@ -956,6 +1058,7 @@ public final GhostMemberContext ghostMember() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class GhostStatementContext extends ParserRuleContext { public GhostStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -967,6 +1070,7 @@ public void copyFrom(GhostStatementContext ctx) { super.copyFrom(ctx); } } + @SuppressWarnings("CheckReturnValue") public static class ProofStatementContext extends GhostStatementContext { public Token kind; public ExpressionContext expression() { @@ -983,6 +1087,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class MatchStmt_Context extends GhostStatementContext { public MatchStmtContext matchStmt() { return getRuleContext(MatchStmtContext.class,0); @@ -994,6 +1099,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class ExplicitGhostStatementContext extends GhostStatementContext { public TerminalNode GHOST() { return getToken(GobraParser.GHOST, 0); } public StatementContext statement() { @@ -1006,6 +1112,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class FoldStatementContext extends GhostStatementContext { public Token fold_stmt; public PredicateAccessContext predicateAccess() { @@ -1023,19 +1130,19 @@ public T accept(ParseTreeVisitor visitor) { public final GhostStatementContext ghostStatement() throws RecognitionException { GhostStatementContext _localctx = new GhostStatementContext(_ctx, getState()); - enterRule(_localctx, 22, RULE_ghostStatement); + enterRule(_localctx, 24, RULE_ghostStatement); int _la; try { - setState(476); + setState(496); _errHandler.sync(this); switch (_input.LA(1)) { case GHOST: _localctx = new ExplicitGhostStatementContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(469); + setState(489); match(GHOST); - setState(470); + setState(490); statement(); } break; @@ -1044,7 +1151,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _localctx = new FoldStatementContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(471); + setState(491); ((FoldStatementContext)_localctx).fold_stmt = _input.LT(1); _la = _input.LA(1); if ( !(_la==FOLD || _la==UNFOLD) ) { @@ -1055,7 +1162,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _errHandler.reportMatch(this); consume(); } - setState(472); + setState(492); predicateAccess(); } break; @@ -1066,10 +1173,10 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _localctx = new ProofStatementContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(473); + setState(493); ((ProofStatementContext)_localctx).kind = _input.LT(1); _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSERT) | (1L << ASSUME) | (1L << INHALE) | (1L << EXHALE))) != 0)) ) { + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 480L) != 0)) ) { ((ProofStatementContext)_localctx).kind = (Token)_errHandler.recoverInline(this); } else { @@ -1077,7 +1184,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _errHandler.reportMatch(this); consume(); } - setState(474); + setState(494); expression(0); } break; @@ -1085,7 +1192,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _localctx = new MatchStmt_Context(_localctx); enterOuterAlt(_localctx, 4); { - setState(475); + setState(495); matchStmt(); } break; @@ -1104,6 +1211,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AuxiliaryStatementContext extends ParserRuleContext { public StatementWithSpecContext statementWithSpec() { return getRuleContext(StatementWithSpecContext.class,0); @@ -1121,11 +1229,11 @@ public T accept(ParseTreeVisitor visitor) { public final AuxiliaryStatementContext auxiliaryStatement() throws RecognitionException { AuxiliaryStatementContext _localctx = new AuxiliaryStatementContext(_ctx, getState()); - enterRule(_localctx, 24, RULE_auxiliaryStatement); + enterRule(_localctx, 26, RULE_auxiliaryStatement); try { enterOuterAlt(_localctx, 1); { - setState(478); + setState(498); statementWithSpec(); } } @@ -1140,6 +1248,7 @@ public final AuxiliaryStatementContext auxiliaryStatement() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StatementWithSpecContext extends ParserRuleContext { public SpecificationContext specification; public SpecificationContext specification() { @@ -1161,14 +1270,14 @@ public T accept(ParseTreeVisitor visitor) { public final StatementWithSpecContext statementWithSpec() throws RecognitionException { StatementWithSpecContext _localctx = new StatementWithSpecContext(_ctx, getState()); - enterRule(_localctx, 26, RULE_statementWithSpec); + enterRule(_localctx, 28, RULE_statementWithSpec); try { enterOuterAlt(_localctx, 1); { - setState(480); + setState(500); ((StatementWithSpecContext)_localctx).specification = specification(); { - setState(481); + setState(501); outlineStatement(((StatementWithSpecContext)_localctx).specification.trusted, ((StatementWithSpecContext)_localctx).specification.pure); } } @@ -1184,6 +1293,7 @@ public final StatementWithSpecContext statementWithSpec() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OutlineStatementContext extends ParserRuleContext { public boolean trusted; public boolean pure; @@ -1209,25 +1319,25 @@ public T accept(ParseTreeVisitor visitor) { public final OutlineStatementContext outlineStatement(boolean trusted,boolean pure) throws RecognitionException { OutlineStatementContext _localctx = new OutlineStatementContext(_ctx, getState(), trusted, pure); - enterRule(_localctx, 28, RULE_outlineStatement); + enterRule(_localctx, 30, RULE_outlineStatement); try { enterOuterAlt(_localctx, 1); { - setState(483); + setState(503); match(OUTLINE); - setState(484); + setState(504); match(L_PAREN); - setState(486); + setState(506); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { case 1: { - setState(485); + setState(505); statementList(); } break; } - setState(488); + setState(508); match(R_PAREN); } } @@ -1242,6 +1352,7 @@ public final OutlineStatementContext outlineStatement(boolean trusted,boolean pu return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class GhostPrimaryExprContext extends ParserRuleContext { public RangeContext range() { return getRuleContext(RangeContext.class,0); @@ -1295,99 +1406,99 @@ public T accept(ParseTreeVisitor visitor) { public final GhostPrimaryExprContext ghostPrimaryExpr() throws RecognitionException { GhostPrimaryExprContext _localctx = new GhostPrimaryExprContext(_ctx, getState()); - enterRule(_localctx, 30, RULE_ghostPrimaryExpr); + enterRule(_localctx, 32, RULE_ghostPrimaryExpr); try { - setState(503); + setState(523); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(490); + setState(510); range(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(491); + setState(511); access(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(492); + setState(512); typeOf(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(493); + setState(513); typeExpr(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(494); + setState(514); isComparable(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(495); + setState(515); old(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(496); + setState(516); before(); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(497); + setState(517); sConversion(); } break; case 9: enterOuterAlt(_localctx, 9); { - setState(498); + setState(518); optionNone(); } break; case 10: enterOuterAlt(_localctx, 10); { - setState(499); + setState(519); optionSome(); } break; case 11: enterOuterAlt(_localctx, 11); { - setState(500); + setState(520); optionGet(); } break; case 12: enterOuterAlt(_localctx, 12); { - setState(501); + setState(521); permission(); } break; case 13: enterOuterAlt(_localctx, 13); { - setState(502); + setState(522); matchExpr(); } break; @@ -1404,6 +1515,7 @@ public final GhostPrimaryExprContext ghostPrimaryExpr() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PermissionContext extends ParserRuleContext { public TerminalNode WRITEPERM() { return getToken(GobraParser.WRITEPERM, 0); } public TerminalNode NOPERM() { return getToken(GobraParser.NOPERM, 0); } @@ -1420,12 +1532,12 @@ public T accept(ParseTreeVisitor visitor) { public final PermissionContext permission() throws RecognitionException { PermissionContext _localctx = new PermissionContext(_ctx, getState()); - enterRule(_localctx, 32, RULE_permission); + enterRule(_localctx, 34, RULE_permission); int _la; try { enterOuterAlt(_localctx, 1); { - setState(505); + setState(525); _la = _input.LA(1); if ( !(_la==WRITEPERM || _la==NOPERM) ) { _errHandler.recoverInline(this); @@ -1448,6 +1560,7 @@ public final PermissionContext permission() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeExprContext extends ParserRuleContext { public TerminalNode TYPE() { return getToken(GobraParser.TYPE, 0); } public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } @@ -1468,17 +1581,17 @@ public T accept(ParseTreeVisitor visitor) { public final TypeExprContext typeExpr() throws RecognitionException { TypeExprContext _localctx = new TypeExprContext(_ctx, getState()); - enterRule(_localctx, 34, RULE_typeExpr); + enterRule(_localctx, 36, RULE_typeExpr); try { enterOuterAlt(_localctx, 1); { - setState(507); + setState(527); match(TYPE); - setState(508); + setState(528); match(L_BRACKET); - setState(509); + setState(529); type_(); - setState(510); + setState(530); match(R_BRACKET); } } @@ -1493,6 +1606,7 @@ public final TypeExprContext typeExpr() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BoundVariablesContext extends ParserRuleContext { public List boundVariableDecl() { return getRuleContexts(BoundVariableDeclContext.class); @@ -1517,38 +1631,38 @@ public T accept(ParseTreeVisitor visitor) { public final BoundVariablesContext boundVariables() throws RecognitionException { BoundVariablesContext _localctx = new BoundVariablesContext(_ctx, getState()); - enterRule(_localctx, 36, RULE_boundVariables); + enterRule(_localctx, 38, RULE_boundVariables); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(512); + setState(532); boundVariableDecl(); - setState(517); + setState(537); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,15,_ctx); + _alt = getInterpreter().adaptivePredict(_input,17,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(513); + setState(533); match(COMMA); - setState(514); + setState(534); boundVariableDecl(); } } } - setState(519); + setState(539); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,15,_ctx); + _alt = getInterpreter().adaptivePredict(_input,17,_ctx); } - setState(521); + setState(541); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(520); + setState(540); match(COMMA); } } @@ -1566,6 +1680,7 @@ public final BoundVariablesContext boundVariables() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BoundVariableDeclContext extends ParserRuleContext { public List IDENTIFIER() { return getTokens(GobraParser.IDENTIFIER); } public TerminalNode IDENTIFIER(int i) { @@ -1591,30 +1706,30 @@ public T accept(ParseTreeVisitor visitor) { public final BoundVariableDeclContext boundVariableDecl() throws RecognitionException { BoundVariableDeclContext _localctx = new BoundVariableDeclContext(_ctx, getState()); - enterRule(_localctx, 38, RULE_boundVariableDecl); + enterRule(_localctx, 40, RULE_boundVariableDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(523); + setState(543); match(IDENTIFIER); - setState(528); + setState(548); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(524); + setState(544); match(COMMA); - setState(525); + setState(545); match(IDENTIFIER); } } - setState(530); + setState(550); _errHandler.sync(this); _la = _input.LA(1); } - setState(531); + setState(551); elementType(); } } @@ -1629,6 +1744,7 @@ public final BoundVariableDeclContext boundVariableDecl() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TriggersContext extends ParserRuleContext { public List trigger() { return getRuleContexts(TriggerContext.class); @@ -1649,22 +1765,22 @@ public T accept(ParseTreeVisitor visitor) { public final TriggersContext triggers() throws RecognitionException { TriggersContext _localctx = new TriggersContext(_ctx, getState()); - enterRule(_localctx, 40, RULE_triggers); + enterRule(_localctx, 42, RULE_triggers); int _la; try { enterOuterAlt(_localctx, 1); { - setState(536); + setState(556); _errHandler.sync(this); _la = _input.LA(1); while (_la==L_CURLY) { { { - setState(533); + setState(553); trigger(); } } - setState(538); + setState(558); _errHandler.sync(this); _la = _input.LA(1); } @@ -1681,6 +1797,7 @@ public final TriggersContext triggers() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TriggerContext extends ParserRuleContext { public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } public List expression() { @@ -1707,32 +1824,32 @@ public T accept(ParseTreeVisitor visitor) { public final TriggerContext trigger() throws RecognitionException { TriggerContext _localctx = new TriggerContext(_ctx, getState()); - enterRule(_localctx, 42, RULE_trigger); + enterRule(_localctx, 44, RULE_trigger); int _la; try { enterOuterAlt(_localctx, 1); { - setState(539); + setState(559); match(L_CURLY); - setState(540); + setState(560); expression(0); - setState(545); + setState(565); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(541); + setState(561); match(COMMA); - setState(542); + setState(562); expression(0); } } - setState(547); + setState(567); _errHandler.sync(this); _la = _input.LA(1); } - setState(548); + setState(568); match(R_CURLY); } } @@ -1747,6 +1864,7 @@ public final TriggerContext trigger() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PredicateAccessContext extends ParserRuleContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -1764,11 +1882,11 @@ public T accept(ParseTreeVisitor visitor) { public final PredicateAccessContext predicateAccess() throws RecognitionException { PredicateAccessContext _localctx = new PredicateAccessContext(_ctx, getState()); - enterRule(_localctx, 44, RULE_predicateAccess); + enterRule(_localctx, 46, RULE_predicateAccess); try { enterOuterAlt(_localctx, 1); { - setState(550); + setState(570); primaryExpr(0); } } @@ -1783,6 +1901,7 @@ public final PredicateAccessContext predicateAccess() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OptionSomeContext extends ParserRuleContext { public TerminalNode SOME() { return getToken(GobraParser.SOME, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -1803,17 +1922,17 @@ public T accept(ParseTreeVisitor visitor) { public final OptionSomeContext optionSome() throws RecognitionException { OptionSomeContext _localctx = new OptionSomeContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_optionSome); + enterRule(_localctx, 48, RULE_optionSome); try { enterOuterAlt(_localctx, 1); { - setState(552); + setState(572); match(SOME); - setState(553); + setState(573); match(L_PAREN); - setState(554); + setState(574); expression(0); - setState(555); + setState(575); match(R_PAREN); } } @@ -1828,6 +1947,7 @@ public final OptionSomeContext optionSome() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OptionNoneContext extends ParserRuleContext { public TerminalNode NONE() { return getToken(GobraParser.NONE, 0); } public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } @@ -1848,17 +1968,17 @@ public T accept(ParseTreeVisitor visitor) { public final OptionNoneContext optionNone() throws RecognitionException { OptionNoneContext _localctx = new OptionNoneContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_optionNone); + enterRule(_localctx, 50, RULE_optionNone); try { enterOuterAlt(_localctx, 1); { - setState(557); + setState(577); match(NONE); - setState(558); + setState(578); match(L_BRACKET); - setState(559); + setState(579); type_(); - setState(560); + setState(580); match(R_BRACKET); } } @@ -1873,6 +1993,7 @@ public final OptionNoneContext optionNone() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OptionGetContext extends ParserRuleContext { public TerminalNode GET() { return getToken(GobraParser.GET, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -1893,17 +2014,17 @@ public T accept(ParseTreeVisitor visitor) { public final OptionGetContext optionGet() throws RecognitionException { OptionGetContext _localctx = new OptionGetContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_optionGet); + enterRule(_localctx, 52, RULE_optionGet); try { enterOuterAlt(_localctx, 1); { - setState(562); + setState(582); match(GET); - setState(563); + setState(583); match(L_PAREN); - setState(564); + setState(584); expression(0); - setState(565); + setState(585); match(R_PAREN); } } @@ -1918,6 +2039,7 @@ public final OptionGetContext optionGet() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SConversionContext extends ParserRuleContext { public Token kind; public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -1941,15 +2063,15 @@ public T accept(ParseTreeVisitor visitor) { public final SConversionContext sConversion() throws RecognitionException { SConversionContext _localctx = new SConversionContext(_ctx, getState()); - enterRule(_localctx, 52, RULE_sConversion); + enterRule(_localctx, 54, RULE_sConversion); int _la; try { enterOuterAlt(_localctx, 1); { - setState(567); + setState(587); ((SConversionContext)_localctx).kind = _input.LT(1); _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEQ) | (1L << SET) | (1L << MSET))) != 0)) ) { + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 7696581394432L) != 0)) ) { ((SConversionContext)_localctx).kind = (Token)_errHandler.recoverInline(this); } else { @@ -1957,11 +2079,11 @@ public final SConversionContext sConversion() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(568); + setState(588); match(L_PAREN); - setState(569); + setState(589); expression(0); - setState(570); + setState(590); match(R_PAREN); } } @@ -1976,6 +2098,7 @@ public final SConversionContext sConversion() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OldContext extends ParserRuleContext { public TerminalNode OLD() { return getToken(GobraParser.OLD, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -2001,32 +2124,32 @@ public T accept(ParseTreeVisitor visitor) { public final OldContext old() throws RecognitionException { OldContext _localctx = new OldContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_old); + enterRule(_localctx, 56, RULE_old); int _la; try { enterOuterAlt(_localctx, 1); { - setState(572); + setState(592); match(OLD); - setState(577); + setState(597); _errHandler.sync(this); _la = _input.LA(1); if (_la==L_BRACKET) { { - setState(573); + setState(593); match(L_BRACKET); - setState(574); + setState(594); oldLabelUse(); - setState(575); + setState(595); match(R_BRACKET); } } - setState(579); + setState(599); match(L_PAREN); - setState(580); + setState(600); expression(0); - setState(581); + setState(601); match(R_PAREN); } } @@ -2041,6 +2164,7 @@ public final OldContext old() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OldLabelUseContext extends ParserRuleContext { public LabelUseContext labelUse() { return getRuleContext(LabelUseContext.class,0); @@ -2059,22 +2183,22 @@ public T accept(ParseTreeVisitor visitor) { public final OldLabelUseContext oldLabelUse() throws RecognitionException { OldLabelUseContext _localctx = new OldLabelUseContext(_ctx, getState()); - enterRule(_localctx, 56, RULE_oldLabelUse); + enterRule(_localctx, 58, RULE_oldLabelUse); try { - setState(585); + setState(605); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: enterOuterAlt(_localctx, 1); { - setState(583); + setState(603); labelUse(); } break; case LHS: enterOuterAlt(_localctx, 2); { - setState(584); + setState(604); match(LHS); } break; @@ -2093,6 +2217,7 @@ public final OldLabelUseContext oldLabelUse() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LabelUseContext extends ParserRuleContext { public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } public LabelUseContext(ParserRuleContext parent, int invokingState) { @@ -2108,11 +2233,11 @@ public T accept(ParseTreeVisitor visitor) { public final LabelUseContext labelUse() throws RecognitionException { LabelUseContext _localctx = new LabelUseContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_labelUse); + enterRule(_localctx, 60, RULE_labelUse); try { enterOuterAlt(_localctx, 1); { - setState(587); + setState(607); match(IDENTIFIER); } } @@ -2127,6 +2252,7 @@ public final LabelUseContext labelUse() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BeforeContext extends ParserRuleContext { public TerminalNode BEFORE() { return getToken(GobraParser.BEFORE, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -2147,17 +2273,17 @@ public T accept(ParseTreeVisitor visitor) { public final BeforeContext before() throws RecognitionException { BeforeContext _localctx = new BeforeContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_before); + enterRule(_localctx, 62, RULE_before); try { enterOuterAlt(_localctx, 1); { - setState(589); + setState(609); match(BEFORE); - setState(590); + setState(610); match(L_PAREN); - setState(591); + setState(611); expression(0); - setState(592); + setState(612); match(R_PAREN); } } @@ -2172,6 +2298,7 @@ public final BeforeContext before() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class IsComparableContext extends ParserRuleContext { public TerminalNode IS_COMPARABLE() { return getToken(GobraParser.IS_COMPARABLE, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -2192,17 +2319,17 @@ public T accept(ParseTreeVisitor visitor) { public final IsComparableContext isComparable() throws RecognitionException { IsComparableContext _localctx = new IsComparableContext(_ctx, getState()); - enterRule(_localctx, 62, RULE_isComparable); + enterRule(_localctx, 64, RULE_isComparable); try { enterOuterAlt(_localctx, 1); { - setState(594); + setState(614); match(IS_COMPARABLE); - setState(595); + setState(615); match(L_PAREN); - setState(596); + setState(616); expression(0); - setState(597); + setState(617); match(R_PAREN); } } @@ -2217,6 +2344,7 @@ public final IsComparableContext isComparable() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeOfContext extends ParserRuleContext { public TerminalNode TYPE_OF() { return getToken(GobraParser.TYPE_OF, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -2237,17 +2365,17 @@ public T accept(ParseTreeVisitor visitor) { public final TypeOfContext typeOf() throws RecognitionException { TypeOfContext _localctx = new TypeOfContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_typeOf); + enterRule(_localctx, 66, RULE_typeOf); try { enterOuterAlt(_localctx, 1); { - setState(599); + setState(619); match(TYPE_OF); - setState(600); + setState(620); match(L_PAREN); - setState(601); + setState(621); expression(0); - setState(602); + setState(622); match(R_PAREN); } } @@ -2262,6 +2390,7 @@ public final TypeOfContext typeOf() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AccessContext extends ParserRuleContext { public TerminalNode ACCESS() { return getToken(GobraParser.ACCESS, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -2286,30 +2415,30 @@ public T accept(ParseTreeVisitor visitor) { public final AccessContext access() throws RecognitionException { AccessContext _localctx = new AccessContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_access); + enterRule(_localctx, 68, RULE_access); int _la; try { enterOuterAlt(_localctx, 1); { - setState(604); + setState(624); match(ACCESS); - setState(605); + setState(625); match(L_PAREN); - setState(606); + setState(626); expression(0); - setState(609); + setState(629); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(607); + setState(627); match(COMMA); - setState(608); + setState(628); expression(0); } } - setState(611); + setState(631); match(R_PAREN); } } @@ -2324,6 +2453,7 @@ public final AccessContext access() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class RangeContext extends ParserRuleContext { public Token kind; public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } @@ -2351,15 +2481,15 @@ public T accept(ParseTreeVisitor visitor) { public final RangeContext range() throws RecognitionException { RangeContext _localctx = new RangeContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_range); + enterRule(_localctx, 70, RULE_range); int _la; try { enterOuterAlt(_localctx, 1); { - setState(613); + setState(633); ((RangeContext)_localctx).kind = _input.LT(1); _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEQ) | (1L << SET) | (1L << MSET))) != 0)) ) { + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 7696581394432L) != 0)) ) { ((RangeContext)_localctx).kind = (Token)_errHandler.recoverInline(this); } else { @@ -2367,15 +2497,15 @@ public final RangeContext range() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(614); + setState(634); match(L_BRACKET); - setState(615); + setState(635); expression(0); - setState(616); + setState(636); match(DOT_DOT); - setState(617); + setState(637); expression(0); - setState(618); + setState(638); match(R_BRACKET); } } @@ -2390,6 +2520,7 @@ public final RangeContext range() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MatchExprContext extends ParserRuleContext { public TerminalNode MATCH() { return getToken(GobraParser.MATCH, 0); } public ExpressionContext expression() { @@ -2422,34 +2553,34 @@ public T accept(ParseTreeVisitor visitor) { public final MatchExprContext matchExpr() throws RecognitionException { MatchExprContext _localctx = new MatchExprContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_matchExpr); + enterRule(_localctx, 72, RULE_matchExpr); int _la; try { enterOuterAlt(_localctx, 1); { - setState(620); + setState(640); match(MATCH); - setState(621); + setState(641); expression(0); - setState(622); + setState(642); match(L_CURLY); - setState(628); + setState(648); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(623); + setState(643); matchExprClause(); - setState(624); + setState(644); eos(); } } - setState(630); + setState(650); _errHandler.sync(this); _la = _input.LA(1); } - setState(631); + setState(651); match(R_CURLY); } } @@ -2464,6 +2595,7 @@ public final MatchExprContext matchExpr() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MatchExprClauseContext extends ParserRuleContext { public MatchCaseContext matchCase() { return getRuleContext(MatchCaseContext.class,0); @@ -2485,15 +2617,15 @@ public T accept(ParseTreeVisitor visitor) { public final MatchExprClauseContext matchExprClause() throws RecognitionException { MatchExprClauseContext _localctx = new MatchExprClauseContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_matchExprClause); + enterRule(_localctx, 74, RULE_matchExprClause); try { enterOuterAlt(_localctx, 1); { - setState(633); + setState(653); matchCase(); - setState(634); + setState(654); match(COLON); - setState(635); + setState(655); expression(0); } } @@ -2508,6 +2640,7 @@ public final MatchExprClauseContext matchExprClause() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SeqUpdExpContext extends ParserRuleContext { public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } public TerminalNode R_BRACKET() { return getToken(GobraParser.R_BRACKET, 0); } @@ -2534,34 +2667,34 @@ public T accept(ParseTreeVisitor visitor) { public final SeqUpdExpContext seqUpdExp() throws RecognitionException { SeqUpdExpContext _localctx = new SeqUpdExpContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_seqUpdExp); + enterRule(_localctx, 76, RULE_seqUpdExp); int _la; try { enterOuterAlt(_localctx, 1); { - setState(637); + setState(657); match(L_BRACKET); { - setState(638); + setState(658); seqUpdClause(); - setState(643); + setState(663); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(639); + setState(659); match(COMMA); - setState(640); + setState(660); seqUpdClause(); } } - setState(645); + setState(665); _errHandler.sync(this); _la = _input.LA(1); } } - setState(646); + setState(666); match(R_BRACKET); } } @@ -2576,6 +2709,7 @@ public final SeqUpdExpContext seqUpdExp() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SeqUpdClauseContext extends ParserRuleContext { public List expression() { return getRuleContexts(ExpressionContext.class); @@ -2597,15 +2731,15 @@ public T accept(ParseTreeVisitor visitor) { public final SeqUpdClauseContext seqUpdClause() throws RecognitionException { SeqUpdClauseContext _localctx = new SeqUpdClauseContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_seqUpdClause); + enterRule(_localctx, 78, RULE_seqUpdClause); try { enterOuterAlt(_localctx, 1); { - setState(648); + setState(668); expression(0); - setState(649); + setState(669); match(ASSIGN); - setState(650); + setState(670); expression(0); } } @@ -2620,6 +2754,7 @@ public final SeqUpdClauseContext seqUpdClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class GhostTypeLitContext extends ParserRuleContext { public SqTypeContext sqType() { return getRuleContext(SqTypeContext.class,0); @@ -2646,9 +2781,9 @@ public T accept(ParseTreeVisitor visitor) { public final GhostTypeLitContext ghostTypeLit() throws RecognitionException { GhostTypeLitContext _localctx = new GhostTypeLitContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_ghostTypeLit); + enterRule(_localctx, 80, RULE_ghostTypeLit); try { - setState(656); + setState(676); _errHandler.sync(this); switch (_input.LA(1)) { case SEQ: @@ -2658,28 +2793,28 @@ public final GhostTypeLitContext ghostTypeLit() throws RecognitionException { case OPT: enterOuterAlt(_localctx, 1); { - setState(652); + setState(672); sqType(); } break; case GHOST: enterOuterAlt(_localctx, 2); { - setState(653); + setState(673); ghostSliceType(); } break; case DOM: enterOuterAlt(_localctx, 3); { - setState(654); + setState(674); domainType(); } break; case ADT: enterOuterAlt(_localctx, 4); { - setState(655); + setState(675); adtType(); } break; @@ -2698,6 +2833,7 @@ public final GhostTypeLitContext ghostTypeLit() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DomainTypeContext extends ParserRuleContext { public TerminalNode DOM() { return getToken(GobraParser.DOM, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } @@ -2727,32 +2863,32 @@ public T accept(ParseTreeVisitor visitor) { public final DomainTypeContext domainType() throws RecognitionException { DomainTypeContext _localctx = new DomainTypeContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_domainType); + enterRule(_localctx, 82, RULE_domainType); int _la; try { enterOuterAlt(_localctx, 1); { - setState(658); + setState(678); match(DOM); - setState(659); + setState(679); match(L_CURLY); - setState(665); + setState(685); _errHandler.sync(this); _la = _input.LA(1); while (_la==AXIOM || _la==FUNC) { { { - setState(660); + setState(680); domainClause(); - setState(661); + setState(681); eos(); } } - setState(667); + setState(687); _errHandler.sync(this); _la = _input.LA(1); } - setState(668); + setState(688); match(R_CURLY); } } @@ -2767,6 +2903,7 @@ public final DomainTypeContext domainType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DomainClauseContext extends ParserRuleContext { public TerminalNode FUNC() { return getToken(GobraParser.FUNC, 0); } public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } @@ -2795,34 +2932,34 @@ public T accept(ParseTreeVisitor visitor) { public final DomainClauseContext domainClause() throws RecognitionException { DomainClauseContext _localctx = new DomainClauseContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_domainClause); + enterRule(_localctx, 84, RULE_domainClause); try { - setState(679); + setState(699); _errHandler.sync(this); switch (_input.LA(1)) { case FUNC: enterOuterAlt(_localctx, 1); { - setState(670); + setState(690); match(FUNC); - setState(671); + setState(691); match(IDENTIFIER); - setState(672); + setState(692); signature(); } break; case AXIOM: enterOuterAlt(_localctx, 2); { - setState(673); + setState(693); match(AXIOM); - setState(674); + setState(694); match(L_CURLY); - setState(675); + setState(695); expression(0); - setState(676); + setState(696); eos(); - setState(677); + setState(697); match(R_CURLY); } break; @@ -2841,6 +2978,7 @@ public final DomainClauseContext domainClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AdtTypeContext extends ParserRuleContext { public TerminalNode ADT() { return getToken(GobraParser.ADT, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } @@ -2870,32 +3008,32 @@ public T accept(ParseTreeVisitor visitor) { public final AdtTypeContext adtType() throws RecognitionException { AdtTypeContext _localctx = new AdtTypeContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_adtType); + enterRule(_localctx, 86, RULE_adtType); int _la; try { enterOuterAlt(_localctx, 1); { - setState(681); + setState(701); match(ADT); - setState(682); + setState(702); match(L_CURLY); - setState(688); + setState(708); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER) { { { - setState(683); + setState(703); adtClause(); - setState(684); + setState(704); eos(); } } - setState(690); + setState(710); _errHandler.sync(this); _la = _input.LA(1); } - setState(691); + setState(711); match(R_CURLY); } } @@ -2910,6 +3048,7 @@ public final AdtTypeContext adtType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AdtClauseContext extends ParserRuleContext { public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } @@ -2939,32 +3078,32 @@ public T accept(ParseTreeVisitor visitor) { public final AdtClauseContext adtClause() throws RecognitionException { AdtClauseContext _localctx = new AdtClauseContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_adtClause); + enterRule(_localctx, 88, RULE_adtClause); int _la; try { enterOuterAlt(_localctx, 1); { - setState(693); + setState(713); match(IDENTIFIER); - setState(694); + setState(714); match(L_CURLY); - setState(700); + setState(720); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER || _la==STAR) { { { - setState(695); + setState(715); fieldDecl(); - setState(696); + setState(716); eos(); } } - setState(702); + setState(722); _errHandler.sync(this); _la = _input.LA(1); } - setState(703); + setState(723); match(R_CURLY); } } @@ -2979,6 +3118,7 @@ public final AdtClauseContext adtClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class GhostSliceTypeContext extends ParserRuleContext { public TerminalNode GHOST() { return getToken(GobraParser.GHOST, 0); } public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } @@ -2999,17 +3139,17 @@ public T accept(ParseTreeVisitor visitor) { public final GhostSliceTypeContext ghostSliceType() throws RecognitionException { GhostSliceTypeContext _localctx = new GhostSliceTypeContext(_ctx, getState()); - enterRule(_localctx, 88, RULE_ghostSliceType); + enterRule(_localctx, 90, RULE_ghostSliceType); try { enterOuterAlt(_localctx, 1); { - setState(705); + setState(725); match(GHOST); - setState(706); + setState(726); match(L_BRACKET); - setState(707); + setState(727); match(R_BRACKET); - setState(708); + setState(728); elementType(); } } @@ -3024,6 +3164,7 @@ public final GhostSliceTypeContext ghostSliceType() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SqTypeContext extends ParserRuleContext { public Token kind; public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } @@ -3052,10 +3193,10 @@ public T accept(ParseTreeVisitor visitor) { public final SqTypeContext sqType() throws RecognitionException { SqTypeContext _localctx = new SqTypeContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_sqType); + enterRule(_localctx, 92, RULE_sqType); int _la; try { - setState(721); + setState(741); _errHandler.sync(this); switch (_input.LA(1)) { case SEQ: @@ -3065,10 +3206,10 @@ public final SqTypeContext sqType() throws RecognitionException { enterOuterAlt(_localctx, 1); { { - setState(710); + setState(730); ((SqTypeContext)_localctx).kind = _input.LT(1); _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << OPT))) != 0)) ) { + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 25288767438848L) != 0)) ) { ((SqTypeContext)_localctx).kind = (Token)_errHandler.recoverInline(this); } else { @@ -3076,11 +3217,11 @@ public final SqTypeContext sqType() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(711); + setState(731); match(L_BRACKET); - setState(712); + setState(732); type_(); - setState(713); + setState(733); match(R_BRACKET); } } @@ -3088,15 +3229,15 @@ public final SqTypeContext sqType() throws RecognitionException { case DICT: enterOuterAlt(_localctx, 2); { - setState(715); + setState(735); ((SqTypeContext)_localctx).kind = match(DICT); - setState(716); + setState(736); match(L_BRACKET); - setState(717); + setState(737); type_(); - setState(718); + setState(738); match(R_BRACKET); - setState(719); + setState(739); type_(); } break; @@ -3115,6 +3256,7 @@ public final SqTypeContext sqType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SpecificationContext extends ParserRuleContext { public boolean trusted = false; public boolean pure = false;; @@ -3151,20 +3293,20 @@ public T accept(ParseTreeVisitor visitor) { public final SpecificationContext specification() throws RecognitionException { SpecificationContext _localctx = new SpecificationContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_specification); + enterRule(_localctx, 94, RULE_specification); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(733); + setState(753); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + _alt = getInterpreter().adaptivePredict(_input,34,_ctx); while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1+1 ) { { { - setState(728); + setState(748); _errHandler.sync(this); switch (_input.LA(1)) { case PRE: @@ -3172,20 +3314,20 @@ public final SpecificationContext specification() throws RecognitionException { case POST: case DEC: { - setState(723); + setState(743); specStatement(); } break; case PURE: { - setState(724); + setState(744); match(PURE); ((SpecificationContext)_localctx).pure = true; } break; case TRUSTED: { - setState(726); + setState(746); match(TRUSTED); ((SpecificationContext)_localctx).trusted = true; } @@ -3193,21 +3335,21 @@ public final SpecificationContext specification() throws RecognitionException { default: throw new NoViableAltException(this); } - setState(730); + setState(750); eos(); } } } - setState(735); + setState(755); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + _alt = getInterpreter().adaptivePredict(_input,34,_ctx); } - setState(738); + setState(758); _errHandler.sync(this); _la = _input.LA(1); if (_la==PURE) { { - setState(736); + setState(756); match(PURE); ((SpecificationContext)_localctx).pure = true; } @@ -3226,6 +3368,7 @@ public final SpecificationContext specification() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SpecStatementContext extends ParserRuleContext { public Token kind; public AssertionContext assertion() { @@ -3251,44 +3394,44 @@ public T accept(ParseTreeVisitor visitor) { public final SpecStatementContext specStatement() throws RecognitionException { SpecStatementContext _localctx = new SpecStatementContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_specStatement); + enterRule(_localctx, 96, RULE_specStatement); try { - setState(748); + setState(768); _errHandler.sync(this); switch (_input.LA(1)) { case PRE: enterOuterAlt(_localctx, 1); { - setState(740); + setState(760); ((SpecStatementContext)_localctx).kind = match(PRE); - setState(741); + setState(761); assertion(); } break; case PRESERVES: enterOuterAlt(_localctx, 2); { - setState(742); + setState(762); ((SpecStatementContext)_localctx).kind = match(PRESERVES); - setState(743); + setState(763); assertion(); } break; case POST: enterOuterAlt(_localctx, 3); { - setState(744); + setState(764); ((SpecStatementContext)_localctx).kind = match(POST); - setState(745); + setState(765); assertion(); } break; case DEC: enterOuterAlt(_localctx, 4); { - setState(746); + setState(766); ((SpecStatementContext)_localctx).kind = match(DEC); - setState(747); + setState(767); terminationMeasure(); } break; @@ -3307,6 +3450,7 @@ public final SpecStatementContext specStatement() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TerminationMeasureContext extends ParserRuleContext { public ExpressionListContext expressionList() { return getRuleContext(ExpressionListContext.class,0); @@ -3328,28 +3472,28 @@ public T accept(ParseTreeVisitor visitor) { public final TerminationMeasureContext terminationMeasure() throws RecognitionException { TerminationMeasureContext _localctx = new TerminationMeasureContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_terminationMeasure); + enterRule(_localctx, 98, RULE_terminationMeasure); try { enterOuterAlt(_localctx, 1); { - setState(751); + setState(771); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { case 1: { - setState(750); + setState(770); expressionList(); } break; } - setState(755); + setState(775); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { case 1: { - setState(753); + setState(773); match(IF); - setState(754); + setState(774); expression(0); } break; @@ -3367,6 +3511,7 @@ public final TerminationMeasureContext terminationMeasure() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AssertionContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -3384,11 +3529,11 @@ public T accept(ParseTreeVisitor visitor) { public final AssertionContext assertion() throws RecognitionException { AssertionContext _localctx = new AssertionContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_assertion); + enterRule(_localctx, 100, RULE_assertion); try { - setState(759); + setState(779); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { @@ -3397,7 +3542,7 @@ public final AssertionContext assertion() throws RecognitionException { case 2: enterOuterAlt(_localctx, 2); { - setState(758); + setState(778); expression(0); } break; @@ -3414,6 +3559,7 @@ public final AssertionContext assertion() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MatchStmtContext extends ParserRuleContext { public TerminalNode MATCH() { return getToken(GobraParser.MATCH, 0); } public ExpressionContext expression() { @@ -3440,32 +3586,32 @@ public T accept(ParseTreeVisitor visitor) { public final MatchStmtContext matchStmt() throws RecognitionException { MatchStmtContext _localctx = new MatchStmtContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_matchStmt); + enterRule(_localctx, 102, RULE_matchStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(761); + setState(781); match(MATCH); - setState(762); + setState(782); expression(0); - setState(763); + setState(783); match(L_CURLY); - setState(767); + setState(787); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(764); + setState(784); matchStmtClause(); } } - setState(769); + setState(789); _errHandler.sync(this); _la = _input.LA(1); } - setState(770); + setState(790); match(R_CURLY); } } @@ -3480,6 +3626,7 @@ public final MatchStmtContext matchStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MatchStmtClauseContext extends ParserRuleContext { public MatchCaseContext matchCase() { return getRuleContext(MatchCaseContext.class,0); @@ -3501,20 +3648,20 @@ public T accept(ParseTreeVisitor visitor) { public final MatchStmtClauseContext matchStmtClause() throws RecognitionException { MatchStmtClauseContext _localctx = new MatchStmtClauseContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_matchStmtClause); + enterRule(_localctx, 104, RULE_matchStmtClause); try { enterOuterAlt(_localctx, 1); { - setState(772); + setState(792); matchCase(); - setState(773); + setState(793); match(COLON); - setState(775); + setState(795); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { case 1: { - setState(774); + setState(794); statementList(); } break; @@ -3532,6 +3679,7 @@ public final MatchStmtClauseContext matchStmtClause() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MatchCaseContext extends ParserRuleContext { public TerminalNode CASE() { return getToken(GobraParser.CASE, 0); } public MatchPatternContext matchPattern() { @@ -3551,24 +3699,24 @@ public T accept(ParseTreeVisitor visitor) { public final MatchCaseContext matchCase() throws RecognitionException { MatchCaseContext _localctx = new MatchCaseContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_matchCase); + enterRule(_localctx, 106, RULE_matchCase); try { - setState(780); + setState(800); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { - setState(777); + setState(797); match(CASE); - setState(778); + setState(798); matchPattern(); } break; case DEFAULT: enterOuterAlt(_localctx, 2); { - setState(779); + setState(799); match(DEFAULT); } break; @@ -3587,6 +3735,7 @@ public final MatchCaseContext matchCase() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MatchPatternContext extends ParserRuleContext { public MatchPatternContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -3598,6 +3747,7 @@ public void copyFrom(MatchPatternContext ctx) { super.copyFrom(ctx); } } + @SuppressWarnings("CheckReturnValue") public static class MatchPatternValueContext extends MatchPatternContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -3609,6 +3759,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class MatchPatternCompositeContext extends MatchPatternContext { public LiteralTypeContext literalType() { return getRuleContext(LiteralTypeContext.class,0); @@ -3626,6 +3777,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class MatchPatternBindContext extends MatchPatternContext { public TerminalNode QMARK() { return getToken(GobraParser.QMARK, 0); } public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } @@ -3639,19 +3791,19 @@ public T accept(ParseTreeVisitor visitor) { public final MatchPatternContext matchPattern() throws RecognitionException { MatchPatternContext _localctx = new MatchPatternContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_matchPattern); + enterRule(_localctx, 108, RULE_matchPattern); int _la; try { - setState(795); + setState(815); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { case 1: _localctx = new MatchPatternBindContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(782); + setState(802); match(QMARK); - setState(783); + setState(803); match(IDENTIFIER); } break; @@ -3659,23 +3811,23 @@ public final MatchPatternContext matchPattern() throws RecognitionException { _localctx = new MatchPatternCompositeContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(784); + setState(804); literalType(); - setState(785); + setState(805); match(L_CURLY); - setState(790); + setState(810); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << QMARK) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956190846021146L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(786); + setState(806); matchPatternList(); - setState(788); + setState(808); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(787); + setState(807); match(COMMA); } } @@ -3683,7 +3835,7 @@ public final MatchPatternContext matchPattern() throws RecognitionException { } } - setState(792); + setState(812); match(R_CURLY); } break; @@ -3691,7 +3843,7 @@ public final MatchPatternContext matchPattern() throws RecognitionException { _localctx = new MatchPatternValueContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(794); + setState(814); expression(0); } break; @@ -3708,6 +3860,7 @@ public final MatchPatternContext matchPattern() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MatchPatternListContext extends ParserRuleContext { public List matchPattern() { return getRuleContexts(MatchPatternContext.class); @@ -3732,30 +3885,30 @@ public T accept(ParseTreeVisitor visitor) { public final MatchPatternListContext matchPatternList() throws RecognitionException { MatchPatternListContext _localctx = new MatchPatternListContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_matchPatternList); + enterRule(_localctx, 110, RULE_matchPatternList); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(797); + setState(817); matchPattern(); - setState(802); + setState(822); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,44,_ctx); + _alt = getInterpreter().adaptivePredict(_input,46,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(798); + setState(818); match(COMMA); - setState(799); + setState(819); matchPattern(); } } } - setState(804); + setState(824); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,44,_ctx); + _alt = getInterpreter().adaptivePredict(_input,46,_ctx); } } } @@ -3770,6 +3923,7 @@ public final MatchPatternListContext matchPatternList() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BlockWithBodyParameterInfoContext extends ParserRuleContext { public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } public TerminalNode R_CURLY() { return getToken(GobraParser.R_CURLY, 0); } @@ -3796,37 +3950,37 @@ public T accept(ParseTreeVisitor visitor) { public final BlockWithBodyParameterInfoContext blockWithBodyParameterInfo() throws RecognitionException { BlockWithBodyParameterInfoContext _localctx = new BlockWithBodyParameterInfoContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_blockWithBodyParameterInfo); + enterRule(_localctx, 112, RULE_blockWithBodyParameterInfo); try { enterOuterAlt(_localctx, 1); { - setState(805); + setState(825); match(L_CURLY); - setState(810); + setState(830); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { case 1: { - setState(806); + setState(826); match(SHARE); - setState(807); + setState(827); identifierList(); - setState(808); + setState(828); eos(); } break; } - setState(813); + setState(833); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { case 1: { - setState(812); + setState(832); statementList(); } break; } - setState(815); + setState(835); match(R_CURLY); } } @@ -3841,6 +3995,7 @@ public final BlockWithBodyParameterInfoContext blockWithBodyParameterInfo() thro return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClosureSpecInstanceContext extends ParserRuleContext { public QualifiedIdentContext qualifiedIdent() { return getRuleContext(QualifiedIdentContext.class,0); @@ -3865,47 +4020,47 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureSpecInstanceContext closureSpecInstance() throws RecognitionException { ClosureSpecInstanceContext _localctx = new ClosureSpecInstanceContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_closureSpecInstance); + enterRule(_localctx, 114, RULE_closureSpecInstance); int _la; try { enterOuterAlt(_localctx, 1); { - setState(819); + setState(839); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { case 1: { - setState(817); + setState(837); qualifiedIdent(); } break; case 2: { - setState(818); + setState(838); match(IDENTIFIER); } break; } - setState(829); + setState(849); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { case 1: { - setState(821); + setState(841); match(L_CURLY); - setState(826); + setState(846); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(822); + setState(842); closureSpecParams(); - setState(824); + setState(844); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(823); + setState(843); match(COMMA); } } @@ -3913,7 +4068,7 @@ public final ClosureSpecInstanceContext closureSpecInstance() throws Recognition } } - setState(828); + setState(848); match(R_CURLY); } break; @@ -3931,6 +4086,7 @@ public final ClosureSpecInstanceContext closureSpecInstance() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClosureSpecParamsContext extends ParserRuleContext { public List closureSpecParam() { return getRuleContexts(ClosureSpecParamContext.class); @@ -3955,30 +4111,30 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureSpecParamsContext closureSpecParams() throws RecognitionException { ClosureSpecParamsContext _localctx = new ClosureSpecParamsContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_closureSpecParams); + enterRule(_localctx, 116, RULE_closureSpecParams); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(831); + setState(851); closureSpecParam(); - setState(836); + setState(856); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,51,_ctx); + _alt = getInterpreter().adaptivePredict(_input,53,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(832); + setState(852); match(COMMA); - setState(833); + setState(853); closureSpecParam(); } } } - setState(838); + setState(858); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,51,_ctx); + _alt = getInterpreter().adaptivePredict(_input,53,_ctx); } } } @@ -3993,6 +4149,7 @@ public final ClosureSpecParamsContext closureSpecParams() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClosureSpecParamContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -4012,23 +4169,23 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureSpecParamContext closureSpecParam() throws RecognitionException { ClosureSpecParamContext _localctx = new ClosureSpecParamContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_closureSpecParam); + enterRule(_localctx, 118, RULE_closureSpecParam); try { enterOuterAlt(_localctx, 1); { - setState(841); + setState(861); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { case 1: { - setState(839); + setState(859); match(IDENTIFIER); - setState(840); + setState(860); match(COLON); } break; } - setState(843); + setState(863); expression(0); } } @@ -4043,6 +4200,7 @@ public final ClosureSpecParamContext closureSpecParam() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClosureImplProofStmtContext extends ParserRuleContext { public TerminalNode PROOF() { return getToken(GobraParser.PROOF, 0); } public ExpressionContext expression() { @@ -4068,19 +4226,19 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureImplProofStmtContext closureImplProofStmt() throws RecognitionException { ClosureImplProofStmtContext _localctx = new ClosureImplProofStmtContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_closureImplProofStmt); + enterRule(_localctx, 120, RULE_closureImplProofStmt); try { enterOuterAlt(_localctx, 1); { - setState(845); + setState(865); match(PROOF); - setState(846); + setState(866); expression(0); - setState(847); + setState(867); match(IMPL); - setState(848); + setState(868); closureSpecInstance(); - setState(849); + setState(869); block(); } } @@ -4095,6 +4253,7 @@ public final ClosureImplProofStmtContext closureImplProofStmt() throws Recogniti return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ImplementationProofContext extends ParserRuleContext { public List type_() { return getRuleContexts(Type_Context.class); @@ -4136,57 +4295,57 @@ public T accept(ParseTreeVisitor visitor) { public final ImplementationProofContext implementationProof() throws RecognitionException { ImplementationProofContext _localctx = new ImplementationProofContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_implementationProof); + enterRule(_localctx, 122, RULE_implementationProof); int _la; try { enterOuterAlt(_localctx, 1); { - setState(851); + setState(871); type_(); - setState(852); + setState(872); match(IMPL); - setState(853); + setState(873); type_(); - setState(872); + setState(892); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { case 1: { - setState(854); + setState(874); match(L_CURLY); - setState(860); + setState(880); _errHandler.sync(this); _la = _input.LA(1); while (_la==PRED) { { { - setState(855); + setState(875); implementationProofPredicateAlias(); - setState(856); + setState(876); eos(); } } - setState(862); + setState(882); _errHandler.sync(this); _la = _input.LA(1); } - setState(868); + setState(888); _errHandler.sync(this); _la = _input.LA(1); while (_la==PURE || _la==L_PAREN) { { { - setState(863); + setState(883); methodImplementationProof(); - setState(864); + setState(884); eos(); } } - setState(870); + setState(890); _errHandler.sync(this); _la = _input.LA(1); } - setState(871); + setState(891); match(R_CURLY); } break; @@ -4204,6 +4363,7 @@ public final ImplementationProofContext implementationProof() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MethodImplementationProofContext extends ParserRuleContext { public NonLocalReceiverContext nonLocalReceiver() { return getRuleContext(NonLocalReceiverContext.class,0); @@ -4229,33 +4389,33 @@ public T accept(ParseTreeVisitor visitor) { public final MethodImplementationProofContext methodImplementationProof() throws RecognitionException { MethodImplementationProofContext _localctx = new MethodImplementationProofContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_methodImplementationProof); + enterRule(_localctx, 124, RULE_methodImplementationProof); int _la; try { enterOuterAlt(_localctx, 1); { - setState(875); + setState(895); _errHandler.sync(this); _la = _input.LA(1); if (_la==PURE) { { - setState(874); + setState(894); match(PURE); } } - setState(877); + setState(897); nonLocalReceiver(); - setState(878); + setState(898); match(IDENTIFIER); - setState(879); + setState(899); signature(); - setState(881); + setState(901); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) { case 1: { - setState(880); + setState(900); block(); } break; @@ -4273,6 +4433,7 @@ public final MethodImplementationProofContext methodImplementationProof() throws return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NonLocalReceiverContext extends ParserRuleContext { public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } public TypeNameContext typeName() { @@ -4294,36 +4455,36 @@ public T accept(ParseTreeVisitor visitor) { public final NonLocalReceiverContext nonLocalReceiver() throws RecognitionException { NonLocalReceiverContext _localctx = new NonLocalReceiverContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_nonLocalReceiver); + enterRule(_localctx, 126, RULE_nonLocalReceiver); int _la; try { enterOuterAlt(_localctx, 1); { - setState(883); + setState(903); match(L_PAREN); - setState(885); + setState(905); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { case 1: { - setState(884); + setState(904); match(IDENTIFIER); } break; } - setState(888); + setState(908); _errHandler.sync(this); _la = _input.LA(1); if (_la==STAR) { { - setState(887); + setState(907); match(STAR); } } - setState(890); + setState(910); typeName(); - setState(891); + setState(911); match(R_PAREN); } } @@ -4338,6 +4499,7 @@ public final NonLocalReceiverContext nonLocalReceiver() throws RecognitionExcept return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SelectionContext extends ParserRuleContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -4360,26 +4522,26 @@ public T accept(ParseTreeVisitor visitor) { public final SelectionContext selection() throws RecognitionException { SelectionContext _localctx = new SelectionContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_selection); + enterRule(_localctx, 128, RULE_selection); try { - setState(898); + setState(918); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(893); + setState(913); primaryExpr(0); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(894); + setState(914); type_(); - setState(895); + setState(915); match(DOT); - setState(896); + setState(916); match(IDENTIFIER); } break; @@ -4396,6 +4558,7 @@ public final SelectionContext selection() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ImplementationProofPredicateAliasContext extends ParserRuleContext { public TerminalNode PRED() { return getToken(GobraParser.PRED, 0); } public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } @@ -4419,28 +4582,28 @@ public T accept(ParseTreeVisitor visitor) { public final ImplementationProofPredicateAliasContext implementationProofPredicateAlias() throws RecognitionException { ImplementationProofPredicateAliasContext _localctx = new ImplementationProofPredicateAliasContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_implementationProofPredicateAlias); + enterRule(_localctx, 130, RULE_implementationProofPredicateAlias); try { enterOuterAlt(_localctx, 1); { - setState(900); + setState(920); match(PRED); - setState(901); + setState(921); match(IDENTIFIER); - setState(902); + setState(922); match(DECLARE_ASSIGN); - setState(905); + setState(925); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) { case 1: { - setState(903); + setState(923); selection(); } break; case 2: { - setState(904); + setState(924); operandName(); } break; @@ -4458,6 +4621,7 @@ public final ImplementationProofPredicateAliasContext implementationProofPredica return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MakeContext extends ParserRuleContext { public TerminalNode MAKE() { return getToken(GobraParser.MAKE, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -4482,30 +4646,30 @@ public T accept(ParseTreeVisitor visitor) { public final MakeContext make() throws RecognitionException { MakeContext _localctx = new MakeContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_make); + enterRule(_localctx, 132, RULE_make); int _la; try { enterOuterAlt(_localctx, 1); { - setState(907); + setState(927); match(MAKE); - setState(908); + setState(928); match(L_PAREN); - setState(909); + setState(929); type_(); - setState(912); + setState(932); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(910); + setState(930); match(COMMA); - setState(911); + setState(931); expressionList(); } } - setState(914); + setState(934); match(R_PAREN); } } @@ -4520,6 +4684,7 @@ public final MakeContext make() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class New_Context extends ParserRuleContext { public TerminalNode NEW() { return getToken(GobraParser.NEW, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -4540,17 +4705,17 @@ public T accept(ParseTreeVisitor visitor) { public final New_Context new_() throws RecognitionException { New_Context _localctx = new New_Context(_ctx, getState()); - enterRule(_localctx, 132, RULE_new_); + enterRule(_localctx, 134, RULE_new_); try { enterOuterAlt(_localctx, 1); { - setState(916); + setState(936); match(NEW); - setState(917); + setState(937); match(L_PAREN); - setState(918); + setState(938); type_(); - setState(919); + setState(939); match(R_PAREN); } } @@ -4565,6 +4730,7 @@ public final New_Context new_() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SpecMemberContext extends ParserRuleContext { public SpecificationContext specification; public SpecificationContext specification() { @@ -4589,24 +4755,24 @@ public T accept(ParseTreeVisitor visitor) { public final SpecMemberContext specMember() throws RecognitionException { SpecMemberContext _localctx = new SpecMemberContext(_ctx, getState()); - enterRule(_localctx, 134, RULE_specMember); + enterRule(_localctx, 136, RULE_specMember); try { enterOuterAlt(_localctx, 1); { - setState(921); + setState(941); ((SpecMemberContext)_localctx).specification = specification(); - setState(924); + setState(944); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { case 1: { - setState(922); + setState(942); functionDecl(((SpecMemberContext)_localctx).specification.trusted, ((SpecMemberContext)_localctx).specification.pure); } break; case 2: { - setState(923); + setState(943); methodDecl(((SpecMemberContext)_localctx).specification.trusted, ((SpecMemberContext)_localctx).specification.pure); } break; @@ -4624,6 +4790,7 @@ public final SpecMemberContext specMember() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FunctionDeclContext extends ParserRuleContext { public boolean trusted; public boolean pure; @@ -4651,23 +4818,23 @@ public T accept(ParseTreeVisitor visitor) { public final FunctionDeclContext functionDecl(boolean trusted,boolean pure) throws RecognitionException { FunctionDeclContext _localctx = new FunctionDeclContext(_ctx, getState(), trusted, pure); - enterRule(_localctx, 136, RULE_functionDecl); + enterRule(_localctx, 138, RULE_functionDecl); try { enterOuterAlt(_localctx, 1); { - setState(926); + setState(946); match(FUNC); - setState(927); + setState(947); match(IDENTIFIER); { - setState(928); + setState(948); signature(); - setState(930); + setState(950); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) { case 1: { - setState(929); + setState(949); blockWithBodyParameterInfo(); } break; @@ -4686,6 +4853,7 @@ public final FunctionDeclContext functionDecl(boolean trusted,boolean pure) thro return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MethodDeclContext extends ParserRuleContext { public boolean trusted; public boolean pure; @@ -4716,25 +4884,25 @@ public T accept(ParseTreeVisitor visitor) { public final MethodDeclContext methodDecl(boolean trusted,boolean pure) throws RecognitionException { MethodDeclContext _localctx = new MethodDeclContext(_ctx, getState(), trusted, pure); - enterRule(_localctx, 138, RULE_methodDecl); + enterRule(_localctx, 140, RULE_methodDecl); try { enterOuterAlt(_localctx, 1); { - setState(932); + setState(952); match(FUNC); - setState(933); + setState(953); receiver(); - setState(934); + setState(954); match(IDENTIFIER); { - setState(935); + setState(955); signature(); - setState(937); + setState(957); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { case 1: { - setState(936); + setState(956); blockWithBodyParameterInfo(); } break; @@ -4753,6 +4921,7 @@ public final MethodDeclContext methodDecl(boolean trusted,boolean pure) throws R return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExplicitGhostMemberContext extends ParserRuleContext { public TerminalNode GHOST() { return getToken(GobraParser.GHOST, 0); } public SpecMemberContext specMember() { @@ -4774,13 +4943,13 @@ public T accept(ParseTreeVisitor visitor) { public final ExplicitGhostMemberContext explicitGhostMember() throws RecognitionException { ExplicitGhostMemberContext _localctx = new ExplicitGhostMemberContext(_ctx, getState()); - enterRule(_localctx, 140, RULE_explicitGhostMember); + enterRule(_localctx, 142, RULE_explicitGhostMember); try { enterOuterAlt(_localctx, 1); { - setState(939); + setState(959); match(GHOST); - setState(942); + setState(962); _errHandler.sync(this); switch (_input.LA(1)) { case PRE: @@ -4791,7 +4960,7 @@ public final ExplicitGhostMemberContext explicitGhostMember() throws Recognition case TRUSTED: case FUNC: { - setState(940); + setState(960); specMember(); } break; @@ -4799,7 +4968,7 @@ public final ExplicitGhostMemberContext explicitGhostMember() throws Recognition case TYPE: case VAR: { - setState(941); + setState(961); declaration(); } break; @@ -4819,6 +4988,7 @@ public final ExplicitGhostMemberContext explicitGhostMember() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FpredicateDeclContext extends ParserRuleContext { public TerminalNode PRED() { return getToken(GobraParser.PRED, 0); } public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } @@ -4841,22 +5011,22 @@ public T accept(ParseTreeVisitor visitor) { public final FpredicateDeclContext fpredicateDecl() throws RecognitionException { FpredicateDeclContext _localctx = new FpredicateDeclContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_fpredicateDecl); + enterRule(_localctx, 144, RULE_fpredicateDecl); try { enterOuterAlt(_localctx, 1); { - setState(944); + setState(964); match(PRED); - setState(945); + setState(965); match(IDENTIFIER); - setState(946); + setState(966); parameters(); - setState(948); + setState(968); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) { case 1: { - setState(947); + setState(967); predicateBody(); } break; @@ -4874,6 +5044,7 @@ public final FpredicateDeclContext fpredicateDecl() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PredicateBodyContext extends ParserRuleContext { public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } public ExpressionContext expression() { @@ -4896,17 +5067,17 @@ public T accept(ParseTreeVisitor visitor) { public final PredicateBodyContext predicateBody() throws RecognitionException { PredicateBodyContext _localctx = new PredicateBodyContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_predicateBody); + enterRule(_localctx, 146, RULE_predicateBody); try { enterOuterAlt(_localctx, 1); { - setState(950); + setState(970); match(L_CURLY); - setState(951); + setState(971); expression(0); - setState(952); + setState(972); eos(); - setState(953); + setState(973); match(R_CURLY); } } @@ -4921,6 +5092,7 @@ public final PredicateBodyContext predicateBody() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MpredicateDeclContext extends ParserRuleContext { public TerminalNode PRED() { return getToken(GobraParser.PRED, 0); } public ReceiverContext receiver() { @@ -4946,24 +5118,24 @@ public T accept(ParseTreeVisitor visitor) { public final MpredicateDeclContext mpredicateDecl() throws RecognitionException { MpredicateDeclContext _localctx = new MpredicateDeclContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_mpredicateDecl); + enterRule(_localctx, 148, RULE_mpredicateDecl); try { enterOuterAlt(_localctx, 1); { - setState(955); + setState(975); match(PRED); - setState(956); + setState(976); receiver(); - setState(957); + setState(977); match(IDENTIFIER); - setState(958); + setState(978); parameters(); - setState(960); + setState(980); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { case 1: { - setState(959); + setState(979); predicateBody(); } break; @@ -4981,6 +5153,7 @@ public final MpredicateDeclContext mpredicateDecl() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class VarSpecContext extends ParserRuleContext { public MaybeAddressableIdentifierListContext maybeAddressableIdentifierList() { return getRuleContext(MaybeAddressableIdentifierListContext.class,0); @@ -5005,13 +5178,13 @@ public T accept(ParseTreeVisitor visitor) { public final VarSpecContext varSpec() throws RecognitionException { VarSpecContext _localctx = new VarSpecContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_varSpec); + enterRule(_localctx, 150, RULE_varSpec); try { enterOuterAlt(_localctx, 1); { - setState(962); + setState(982); maybeAddressableIdentifierList(); - setState(970); + setState(990); _errHandler.sync(this); switch (_input.LA(1)) { case GHOST: @@ -5034,16 +5207,16 @@ public final VarSpecContext varSpec() throws RecognitionException { case STAR: case RECEIVE: { - setState(963); + setState(983); type_(); - setState(966); + setState(986); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { case 1: { - setState(964); + setState(984); match(ASSIGN); - setState(965); + setState(985); expressionList(); } break; @@ -5052,9 +5225,9 @@ public final VarSpecContext varSpec() throws RecognitionException { break; case ASSIGN: { - setState(968); + setState(988); match(ASSIGN); - setState(969); + setState(989); expressionList(); } break; @@ -5074,6 +5247,7 @@ public final VarSpecContext varSpec() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ShortVarDeclContext extends ParserRuleContext { public MaybeAddressableIdentifierListContext maybeAddressableIdentifierList() { return getRuleContext(MaybeAddressableIdentifierListContext.class,0); @@ -5095,15 +5269,15 @@ public T accept(ParseTreeVisitor visitor) { public final ShortVarDeclContext shortVarDecl() throws RecognitionException { ShortVarDeclContext _localctx = new ShortVarDeclContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_shortVarDecl); + enterRule(_localctx, 152, RULE_shortVarDecl); try { enterOuterAlt(_localctx, 1); { - setState(972); + setState(992); maybeAddressableIdentifierList(); - setState(973); + setState(993); match(DECLARE_ASSIGN); - setState(974); + setState(994); expressionList(); } } @@ -5118,6 +5292,7 @@ public final ShortVarDeclContext shortVarDecl() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ReceiverContext extends ParserRuleContext { public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } public Type_Context type_() { @@ -5141,36 +5316,36 @@ public T accept(ParseTreeVisitor visitor) { public final ReceiverContext receiver() throws RecognitionException { ReceiverContext _localctx = new ReceiverContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_receiver); + enterRule(_localctx, 154, RULE_receiver); int _la; try { enterOuterAlt(_localctx, 1); { - setState(976); + setState(996); match(L_PAREN); - setState(978); + setState(998); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { case 1: { - setState(977); + setState(997); maybeAddressableIdentifier(); } break; } - setState(980); + setState(1000); type_(); - setState(982); + setState(1002); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(981); + setState(1001); match(COMMA); } } - setState(984); + setState(1004); match(R_PAREN); } } @@ -5185,6 +5360,7 @@ public final ReceiverContext receiver() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ParameterDeclContext extends ParserRuleContext { public ActualParameterDeclContext actualParameterDecl() { return getRuleContext(ActualParameterDeclContext.class,0); @@ -5205,22 +5381,22 @@ public T accept(ParseTreeVisitor visitor) { public final ParameterDeclContext parameterDecl() throws RecognitionException { ParameterDeclContext _localctx = new ParameterDeclContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_parameterDecl); + enterRule(_localctx, 156, RULE_parameterDecl); try { - setState(988); + setState(1008); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(986); + setState(1006); actualParameterDecl(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(987); + setState(1007); ghostParameterDecl(); } break; @@ -5237,6 +5413,7 @@ public final ParameterDeclContext parameterDecl() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ActualParameterDeclContext extends ParserRuleContext { public ParameterTypeContext parameterType() { return getRuleContext(ParameterTypeContext.class,0); @@ -5257,21 +5434,21 @@ public T accept(ParseTreeVisitor visitor) { public final ActualParameterDeclContext actualParameterDecl() throws RecognitionException { ActualParameterDeclContext _localctx = new ActualParameterDeclContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_actualParameterDecl); + enterRule(_localctx, 158, RULE_actualParameterDecl); try { enterOuterAlt(_localctx, 1); { - setState(991); + setState(1011); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { case 1: { - setState(990); + setState(1010); identifierList(); } break; } - setState(993); + setState(1013); parameterType(); } } @@ -5286,6 +5463,7 @@ public final ActualParameterDeclContext actualParameterDecl() throws Recognition return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class GhostParameterDeclContext extends ParserRuleContext { public TerminalNode GHOST() { return getToken(GobraParser.GHOST, 0); } public ParameterTypeContext parameterType() { @@ -5307,23 +5485,23 @@ public T accept(ParseTreeVisitor visitor) { public final GhostParameterDeclContext ghostParameterDecl() throws RecognitionException { GhostParameterDeclContext _localctx = new GhostParameterDeclContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_ghostParameterDecl); + enterRule(_localctx, 160, RULE_ghostParameterDecl); try { enterOuterAlt(_localctx, 1); { - setState(995); + setState(1015); match(GHOST); - setState(997); + setState(1017); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { case 1: { - setState(996); + setState(1016); identifierList(); } break; } - setState(999); + setState(1019); parameterType(); } } @@ -5338,6 +5516,7 @@ public final GhostParameterDeclContext ghostParameterDecl() throws RecognitionEx return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ParameterTypeContext extends ParserRuleContext { public Type_Context type_() { return getRuleContext(Type_Context.class,0); @@ -5356,22 +5535,22 @@ public T accept(ParseTreeVisitor visitor) { public final ParameterTypeContext parameterType() throws RecognitionException { ParameterTypeContext _localctx = new ParameterTypeContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_parameterType); + enterRule(_localctx, 162, RULE_parameterType); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1002); + setState(1022); _errHandler.sync(this); _la = _input.LA(1); if (_la==ELLIPSIS) { { - setState(1001); + setState(1021); match(ELLIPSIS); } } - setState(1004); + setState(1024); type_(); } } @@ -5386,6 +5565,7 @@ public final ParameterTypeContext parameterType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExpressionContext extends ParserRuleContext { public ExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -5397,6 +5577,7 @@ public void copyFrom(ExpressionContext ctx) { super.copyFrom(ctx); } } + @SuppressWarnings("CheckReturnValue") public static class ClosureImplSpecExprContext extends ExpressionContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -5412,6 +5593,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class PrimaryExpr_Context extends ExpressionContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -5423,6 +5605,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class QuantificationContext extends ExpressionContext { public BoundVariablesContext boundVariables() { return getRuleContext(BoundVariablesContext.class,0); @@ -5446,6 +5629,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class UnfoldingContext extends ExpressionContext { public TerminalNode UNFOLDING() { return getToken(GobraParser.UNFOLDING, 0); } public PredicateAccessContext predicateAccess() { @@ -5462,6 +5646,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class OrExprContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); @@ -5477,6 +5662,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class P41ExprContext extends ExpressionContext { public Token p41_op; public List expression() { @@ -5495,6 +5681,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class UnaryExprContext extends ExpressionContext { public Token unary_op; public ExpressionContext expression() { @@ -5514,6 +5701,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class P42ExprContext extends ExpressionContext { public Token p42_op; public List expression() { @@ -5532,6 +5720,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class TernaryExprContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); @@ -5548,6 +5737,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class AddExprContext extends ExpressionContext { public Token add_op; public List expression() { @@ -5569,6 +5759,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class ImplicationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); @@ -5584,6 +5775,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class MulExprContext extends ExpressionContext { public Token mul_op; public List expression() { @@ -5606,6 +5798,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class LetContext extends ExpressionContext { public TerminalNode LET() { return getToken(GobraParser.LET, 0); } public ShortVarDeclContext shortVarDecl() { @@ -5622,6 +5815,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class RelExprContext extends ExpressionContext { public Token rel_op; public List expression() { @@ -5645,6 +5839,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class AndExprContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); @@ -5670,26 +5865,26 @@ private ExpressionContext expression(int _p) throws RecognitionException { int _parentState = getState(); ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); ExpressionContext _prevctx = _localctx; - int _startState = 162; - enterRecursionRule(_localctx, 162, RULE_expression, _p); + int _startState = 164; + enterRecursionRule(_localctx, 164, RULE_expression, _p); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1027); + setState(1047); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { case 1: { _localctx = new UnaryExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1007); + setState(1027); ((UnaryExprContext)_localctx).unary_op = _input.LT(1); _la = _input.LA(1); - if ( !(((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)))) != 0)) ) { + if ( !(((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 127L) != 0)) ) { ((UnaryExprContext)_localctx).unary_op = (Token)_errHandler.recoverInline(this); } else { @@ -5697,7 +5892,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1008); + setState(1028); expression(15); } break; @@ -5706,7 +5901,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new PrimaryExpr_Context(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1009); + setState(1029); primaryExpr(0); } break; @@ -5715,13 +5910,13 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new UnfoldingContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1010); + setState(1030); match(UNFOLDING); - setState(1011); + setState(1031); predicateAccess(); - setState(1012); + setState(1032); match(IN); - setState(1013); + setState(1033); expression(3); } break; @@ -5730,13 +5925,13 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new LetContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1015); + setState(1035); match(LET); - setState(1016); + setState(1036); shortVarDecl(); - setState(1017); + setState(1037); match(IN); - setState(1018); + setState(1038); expression(2); } break; @@ -5745,7 +5940,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new QuantificationContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1020); + setState(1040); _la = _input.LA(1); if ( !(_la==FORALL || _la==EXISTS) ) { _errHandler.recoverInline(this); @@ -5755,41 +5950,41 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1021); + setState(1041); boundVariables(); - setState(1022); + setState(1042); match(COLON); - setState(1023); + setState(1043); match(COLON); - setState(1024); + setState(1044); triggers(); - setState(1025); + setState(1045); expression(1); } break; } _ctx.stop = _input.LT(-1); - setState(1064); + setState(1084); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,79,_ctx); + _alt = getInterpreter().adaptivePredict(_input,81,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { - setState(1062); + setState(1082); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { case 1: { _localctx = new MulExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1029); + setState(1049); if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); - setState(1030); + setState(1050); ((MulExprContext)_localctx).mul_op = _input.LT(1); _la = _input.LA(1); - if ( !(((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & ((1L << (DIV - 126)) | (1L << (MOD - 126)) | (1L << (LSHIFT - 126)) | (1L << (RSHIFT - 126)) | (1L << (BIT_CLEAR - 126)) | (1L << (STAR - 126)) | (1L << (AMPERSAND - 126)))) != 0)) ) { + if ( !(((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & 1567L) != 0)) ) { ((MulExprContext)_localctx).mul_op = (Token)_errHandler.recoverInline(this); } else { @@ -5797,7 +5992,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1031); + setState(1051); expression(14); } break; @@ -5805,12 +6000,12 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new AddExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1032); + setState(1052); if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); - setState(1033); + setState(1053); ((AddExprContext)_localctx).add_op = _input.LT(1); _la = _input.LA(1); - if ( !(_la==WAND || ((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & ((1L << (PLUS_PLUS - 113)) | (1L << (OR - 113)) | (1L << (PLUS - 113)) | (1L << (MINUS - 113)) | (1L << (CARET - 113)))) != 0)) ) { + if ( !(_la==WAND || ((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & 3674113L) != 0)) ) { ((AddExprContext)_localctx).add_op = (Token)_errHandler.recoverInline(this); } else { @@ -5818,7 +6013,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1034); + setState(1054); expression(13); } break; @@ -5826,12 +6021,12 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new P42ExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1035); + setState(1055); if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); - setState(1036); + setState(1056); ((P42ExprContext)_localctx).p42_op = _input.LT(1); _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << UNION) | (1L << INTERSECTION) | (1L << SETMINUS))) != 0)) ) { + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 15032385536L) != 0)) ) { ((P42ExprContext)_localctx).p42_op = (Token)_errHandler.recoverInline(this); } else { @@ -5839,7 +6034,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1037); + setState(1057); expression(12); } break; @@ -5847,12 +6042,12 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new P41ExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1038); + setState(1058); if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); - setState(1039); + setState(1059); ((P41ExprContext)_localctx).p41_op = _input.LT(1); _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IN) | (1L << MULTI) | (1L << SUBSET))) != 0)) ) { + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1879048192L) != 0)) ) { ((P41ExprContext)_localctx).p41_op = (Token)_errHandler.recoverInline(this); } else { @@ -5860,7 +6055,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1040); + setState(1060); expression(11); } break; @@ -5868,12 +6063,12 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new RelExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1041); + setState(1061); if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); - setState(1042); + setState(1062); ((RelExprContext)_localctx).rel_op = _input.LT(1); _la = _input.LA(1); - if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (GHOST_EQUALS - 72)) | (1L << (GHOST_NOT_EQUALS - 72)) | (1L << (EQUALS - 72)) | (1L << (NOT_EQUALS - 72)) | (1L << (LESS - 72)) | (1L << (LESS_OR_EQUALS - 72)) | (1L << (GREATER - 72)) | (1L << (GREATER_OR_EQUALS - 72)))) != 0)) ) { + if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 8866461766385667L) != 0)) ) { ((RelExprContext)_localctx).rel_op = (Token)_errHandler.recoverInline(this); } else { @@ -5881,7 +6076,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1043); + setState(1063); expression(10); } break; @@ -5889,11 +6084,11 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new AndExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1044); + setState(1064); if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); - setState(1045); + setState(1065); match(LOGICAL_AND); - setState(1046); + setState(1066); expression(8); } break; @@ -5901,11 +6096,11 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new OrExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1047); + setState(1067); if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); - setState(1048); + setState(1068); match(LOGICAL_OR); - setState(1049); + setState(1069); expression(7); } break; @@ -5913,11 +6108,11 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new ImplicationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1050); + setState(1070); if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); - setState(1051); + setState(1071); match(IMPLIES); - setState(1052); + setState(1072); expression(5); } break; @@ -5925,15 +6120,15 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new TernaryExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1053); + setState(1073); if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); - setState(1054); + setState(1074); match(QMARK); - setState(1055); + setState(1075); expression(0); - setState(1056); + setState(1076); match(COLON); - setState(1057); + setState(1077); expression(4); } break; @@ -5941,20 +6136,20 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new ClosureImplSpecExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1059); + setState(1079); if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); - setState(1060); + setState(1080); match(IMPL); - setState(1061); + setState(1081); closureSpecInstance(); } break; } } } - setState(1066); + setState(1086); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,79,_ctx); + _alt = getInterpreter().adaptivePredict(_input,81,_ctx); } } } @@ -5969,6 +6164,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StatementContext extends ParserRuleContext { public GhostStatementContext ghostStatement() { return getRuleContext(GhostStatementContext.class,0); @@ -6043,148 +6239,148 @@ public T accept(ParseTreeVisitor visitor) { public final StatementContext statement() throws RecognitionException { StatementContext _localctx = new StatementContext(_ctx, getState()); - enterRule(_localctx, 164, RULE_statement); + enterRule(_localctx, 166, RULE_statement); try { - setState(1087); + setState(1107); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1067); + setState(1087); ghostStatement(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1068); + setState(1088); auxiliaryStatement(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1069); + setState(1089); packageStmt(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1070); + setState(1090); applyStmt(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1071); + setState(1091); declaration(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(1072); + setState(1092); labeledStmt(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(1073); + setState(1093); simpleStmt(); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(1074); + setState(1094); goStmt(); } break; case 9: enterOuterAlt(_localctx, 9); { - setState(1075); + setState(1095); returnStmt(); } break; case 10: enterOuterAlt(_localctx, 10); { - setState(1076); + setState(1096); breakStmt(); } break; case 11: enterOuterAlt(_localctx, 11); { - setState(1077); + setState(1097); continueStmt(); } break; case 12: enterOuterAlt(_localctx, 12); { - setState(1078); + setState(1098); gotoStmt(); } break; case 13: enterOuterAlt(_localctx, 13); { - setState(1079); + setState(1099); fallthroughStmt(); } break; case 14: enterOuterAlt(_localctx, 14); { - setState(1080); + setState(1100); block(); } break; case 15: enterOuterAlt(_localctx, 15); { - setState(1081); + setState(1101); ifStmt(); } break; case 16: enterOuterAlt(_localctx, 16); { - setState(1082); + setState(1102); switchStmt(); } break; case 17: enterOuterAlt(_localctx, 17); { - setState(1083); + setState(1103); selectStmt(); } break; case 18: enterOuterAlt(_localctx, 18); { - setState(1084); + setState(1104); specForStmt(); } break; case 19: enterOuterAlt(_localctx, 19); { - setState(1085); + setState(1105); deferStmt(); } break; case 20: enterOuterAlt(_localctx, 20); { - setState(1086); + setState(1106); closureImplProofStmt(); } break; @@ -6201,6 +6397,7 @@ public final StatementContext statement() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ApplyStmtContext extends ParserRuleContext { public TerminalNode APPLY() { return getToken(GobraParser.APPLY, 0); } public ExpressionContext expression() { @@ -6219,13 +6416,13 @@ public T accept(ParseTreeVisitor visitor) { public final ApplyStmtContext applyStmt() throws RecognitionException { ApplyStmtContext _localctx = new ApplyStmtContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_applyStmt); + enterRule(_localctx, 168, RULE_applyStmt); try { enterOuterAlt(_localctx, 1); { - setState(1089); + setState(1109); match(APPLY); - setState(1090); + setState(1110); expression(0); } } @@ -6240,6 +6437,7 @@ public final ApplyStmtContext applyStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PackageStmtContext extends ParserRuleContext { public TerminalNode PACKAGE() { return getToken(GobraParser.PACKAGE, 0); } public ExpressionContext expression() { @@ -6261,20 +6459,20 @@ public T accept(ParseTreeVisitor visitor) { public final PackageStmtContext packageStmt() throws RecognitionException { PackageStmtContext _localctx = new PackageStmtContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_packageStmt); + enterRule(_localctx, 170, RULE_packageStmt); try { enterOuterAlt(_localctx, 1); { - setState(1092); + setState(1112); match(PACKAGE); - setState(1093); + setState(1113); expression(0); - setState(1095); + setState(1115); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) { case 1: { - setState(1094); + setState(1114); block(); } break; @@ -6292,6 +6490,7 @@ public final PackageStmtContext packageStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SpecForStmtContext extends ParserRuleContext { public LoopSpecContext loopSpec() { return getRuleContext(LoopSpecContext.class,0); @@ -6312,13 +6511,13 @@ public T accept(ParseTreeVisitor visitor) { public final SpecForStmtContext specForStmt() throws RecognitionException { SpecForStmtContext _localctx = new SpecForStmtContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_specForStmt); + enterRule(_localctx, 172, RULE_specForStmt); try { enterOuterAlt(_localctx, 1); { - setState(1097); + setState(1117); loopSpec(); - setState(1098); + setState(1118); forStmt(); } } @@ -6333,6 +6532,7 @@ public final SpecForStmtContext specForStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LoopSpecContext extends ParserRuleContext { public List INV() { return getTokens(GobraParser.INV); } public TerminalNode INV(int i) { @@ -6367,39 +6567,39 @@ public T accept(ParseTreeVisitor visitor) { public final LoopSpecContext loopSpec() throws RecognitionException { LoopSpecContext _localctx = new LoopSpecContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_loopSpec); + enterRule(_localctx, 174, RULE_loopSpec); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1106); + setState(1126); _errHandler.sync(this); _la = _input.LA(1); while (_la==INV) { { { - setState(1100); + setState(1120); match(INV); - setState(1101); + setState(1121); expression(0); - setState(1102); + setState(1122); eos(); } } - setState(1108); + setState(1128); _errHandler.sync(this); _la = _input.LA(1); } - setState(1113); + setState(1133); _errHandler.sync(this); _la = _input.LA(1); if (_la==DEC) { { - setState(1109); + setState(1129); match(DEC); - setState(1110); + setState(1130); terminationMeasure(); - setState(1111); + setState(1131); eos(); } } @@ -6417,6 +6617,7 @@ public final LoopSpecContext loopSpec() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeferStmtContext extends ParserRuleContext { public Token fold_stmt; public TerminalNode DEFER() { return getToken(GobraParser.DEFER, 0); } @@ -6441,27 +6642,27 @@ public T accept(ParseTreeVisitor visitor) { public final DeferStmtContext deferStmt() throws RecognitionException { DeferStmtContext _localctx = new DeferStmtContext(_ctx, getState()); - enterRule(_localctx, 174, RULE_deferStmt); + enterRule(_localctx, 176, RULE_deferStmt); int _la; try { - setState(1120); + setState(1140); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1115); + setState(1135); match(DEFER); - setState(1116); + setState(1136); expression(0); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1117); + setState(1137); match(DEFER); - setState(1118); + setState(1138); ((DeferStmtContext)_localctx).fold_stmt = _input.LT(1); _la = _input.LA(1); if ( !(_la==FOLD || _la==UNFOLD) ) { @@ -6472,7 +6673,7 @@ public final DeferStmtContext deferStmt() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1119); + setState(1139); predicateAccess(); } break; @@ -6489,6 +6690,7 @@ public final DeferStmtContext deferStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BasicLitContext extends ParserRuleContext { public TerminalNode TRUE() { return getToken(GobraParser.TRUE, 0); } public TerminalNode FALSE() { return getToken(GobraParser.FALSE, 0); } @@ -6515,64 +6717,64 @@ public T accept(ParseTreeVisitor visitor) { public final BasicLitContext basicLit() throws RecognitionException { BasicLitContext _localctx = new BasicLitContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_basicLit); + enterRule(_localctx, 178, RULE_basicLit); try { - setState(1130); + setState(1150); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1122); + setState(1142); match(TRUE); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1123); + setState(1143); match(FALSE); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1124); + setState(1144); match(NIL_LIT); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1125); + setState(1145); integer(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1126); + setState(1146); string_(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(1127); + setState(1147); match(FLOAT_LIT); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(1128); + setState(1148); match(IMAGINARY_LIT); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(1129); + setState(1149); match(RUNE_LIT); } break; @@ -6589,6 +6791,7 @@ public final BasicLitContext basicLit() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PrimaryExprContext extends ParserRuleContext { public PrimaryExprContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -6600,6 +6803,7 @@ public void copyFrom(PrimaryExprContext ctx) { super.copyFrom(ctx); } } + @SuppressWarnings("CheckReturnValue") public static class NewExprContext extends PrimaryExprContext { public New_Context new_() { return getRuleContext(New_Context.class,0); @@ -6611,6 +6815,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class MakeExprContext extends PrimaryExprContext { public MakeContext make() { return getRuleContext(MakeContext.class,0); @@ -6622,6 +6827,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class GhostPrimaryExpr_Context extends PrimaryExprContext { public GhostPrimaryExprContext ghostPrimaryExpr() { return getRuleContext(GhostPrimaryExprContext.class,0); @@ -6633,6 +6839,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class InvokePrimaryExprWithSpecContext extends PrimaryExprContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -6651,6 +6858,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class IndexPrimaryExprContext extends PrimaryExprContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -6665,6 +6873,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class SeqUpdPrimaryExprContext extends PrimaryExprContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -6679,6 +6888,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class MethodPrimaryExprContext extends PrimaryExprContext { public MethodExprContext methodExpr() { return getRuleContext(MethodExprContext.class,0); @@ -6690,6 +6900,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class PredConstrPrimaryExprContext extends PrimaryExprContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -6704,6 +6915,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class InvokePrimaryExprContext extends PrimaryExprContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -6718,6 +6930,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class OperandPrimaryExprContext extends PrimaryExprContext { public OperandContext operand() { return getRuleContext(OperandContext.class,0); @@ -6729,6 +6942,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class TypeAssertionPrimaryExprContext extends PrimaryExprContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -6743,6 +6957,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class BuiltInCallExprContext extends PrimaryExprContext { public Token call_op; public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -6761,6 +6976,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class SelectorPrimaryExprContext extends PrimaryExprContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -6774,6 +6990,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class ConversionPrimaryExprContext extends PrimaryExprContext { public ConversionContext conversion() { return getRuleContext(ConversionContext.class,0); @@ -6785,6 +7002,7 @@ public T accept(ParseTreeVisitor visitor) { else return visitor.visitChildren(this); } } + @SuppressWarnings("CheckReturnValue") public static class SlicePrimaryExprContext extends PrimaryExprContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -6809,23 +7027,23 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { int _parentState = getState(); PrimaryExprContext _localctx = new PrimaryExprContext(_ctx, _parentState); PrimaryExprContext _prevctx = _localctx; - int _startState = 178; - enterRecursionRule(_localctx, 178, RULE_primaryExpr, _p); + int _startState = 180; + enterRecursionRule(_localctx, 180, RULE_primaryExpr, _p); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1144); + setState(1164); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { case 1: { _localctx = new OperandPrimaryExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1133); + setState(1153); operand(); } break; @@ -6834,7 +7052,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new ConversionPrimaryExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1134); + setState(1154); conversion(); } break; @@ -6843,7 +7061,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new MethodPrimaryExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1135); + setState(1155); methodExpr(); } break; @@ -6852,7 +7070,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new GhostPrimaryExpr_Context(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1136); + setState(1156); ghostPrimaryExpr(); } break; @@ -6861,7 +7079,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new NewExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1137); + setState(1157); new_(); } break; @@ -6870,7 +7088,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new MakeExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1138); + setState(1158); make(); } break; @@ -6879,10 +7097,10 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new BuiltInCallExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1139); + setState(1159); ((BuiltInCallExprContext)_localctx).call_op = _input.LT(1); _la = _input.LA(1); - if ( !(((((_la - 45)) & ~0x3f) == 0 && ((1L << (_la - 45)) & ((1L << (LEN - 45)) | (1L << (CAP - 45)) | (1L << (DOM - 45)) | (1L << (RANGE - 45)))) != 0)) ) { + if ( !(((((_la - 45)) & ~0x3f) == 0 && ((1L << (_la - 45)) & 281474976710729L) != 0)) ) { ((BuiltInCallExprContext)_localctx).call_op = (Token)_errHandler.recoverInline(this); } else { @@ -6890,36 +7108,36 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1140); + setState(1160); match(L_PAREN); - setState(1141); + setState(1161); expression(0); - setState(1142); + setState(1162); match(R_PAREN); } break; } _ctx.stop = _input.LT(-1); - setState(1168); + setState(1188); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,88,_ctx); + _alt = getInterpreter().adaptivePredict(_input,90,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { - setState(1166); + setState(1186); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { case 1: { _localctx = new SelectorPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1146); + setState(1166); if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); - setState(1147); + setState(1167); match(DOT); - setState(1148); + setState(1168); match(IDENTIFIER); } break; @@ -6927,9 +7145,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new IndexPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1149); + setState(1169); if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); - setState(1150); + setState(1170); index(); } break; @@ -6937,9 +7155,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new SlicePrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1151); + setState(1171); if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); - setState(1152); + setState(1172); slice_(); } break; @@ -6947,9 +7165,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new SeqUpdPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1153); + setState(1173); if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); - setState(1154); + setState(1174); seqUpdExp(); } break; @@ -6957,9 +7175,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new TypeAssertionPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1155); + setState(1175); if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); - setState(1156); + setState(1176); typeAssertion(); } break; @@ -6967,9 +7185,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new InvokePrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1157); + setState(1177); if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); - setState(1158); + setState(1178); arguments(); } break; @@ -6977,13 +7195,13 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new InvokePrimaryExprWithSpecContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1159); + setState(1179); if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(1160); + setState(1180); arguments(); - setState(1161); + setState(1181); match(AS); - setState(1162); + setState(1182); closureSpecInstance(); } break; @@ -6991,18 +7209,18 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new PredConstrPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1164); + setState(1184); if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(1165); + setState(1185); predConstructArgs(); } break; } } } - setState(1170); + setState(1190); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,88,_ctx); + _alt = getInterpreter().adaptivePredict(_input,90,_ctx); } } } @@ -7017,6 +7235,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FunctionLitContext extends ParserRuleContext { public SpecificationContext specification; public SpecificationContext specification() { @@ -7038,13 +7257,13 @@ public T accept(ParseTreeVisitor visitor) { public final FunctionLitContext functionLit() throws RecognitionException { FunctionLitContext _localctx = new FunctionLitContext(_ctx, getState()); - enterRule(_localctx, 180, RULE_functionLit); + enterRule(_localctx, 182, RULE_functionLit); try { enterOuterAlt(_localctx, 1); { - setState(1171); + setState(1191); ((FunctionLitContext)_localctx).specification = specification(); - setState(1172); + setState(1192); closureDecl(((FunctionLitContext)_localctx).specification.trusted, ((FunctionLitContext)_localctx).specification.pure); } } @@ -7059,6 +7278,7 @@ public final FunctionLitContext functionLit() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ClosureDeclContext extends ParserRuleContext { public boolean trusted; public boolean pure; @@ -7086,32 +7306,32 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureDeclContext closureDecl(boolean trusted,boolean pure) throws RecognitionException { ClosureDeclContext _localctx = new ClosureDeclContext(_ctx, getState(), trusted, pure); - enterRule(_localctx, 182, RULE_closureDecl); + enterRule(_localctx, 184, RULE_closureDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1174); + setState(1194); match(FUNC); - setState(1176); + setState(1196); _errHandler.sync(this); _la = _input.LA(1); if (_la==IDENTIFIER) { { - setState(1175); + setState(1195); match(IDENTIFIER); } } { - setState(1178); + setState(1198); signature(); - setState(1180); + setState(1200); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { case 1: { - setState(1179); + setState(1199); blockWithBodyParameterInfo(); } break; @@ -7130,6 +7350,7 @@ public final ClosureDeclContext closureDecl(boolean trusted,boolean pure) throws return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PredConstructArgsContext extends ParserRuleContext { public TerminalNode L_PRED() { return getToken(GobraParser.L_PRED, 0); } public TerminalNode R_PRED() { return getToken(GobraParser.R_PRED, 0); } @@ -7150,34 +7371,34 @@ public T accept(ParseTreeVisitor visitor) { public final PredConstructArgsContext predConstructArgs() throws RecognitionException { PredConstructArgsContext _localctx = new PredConstructArgsContext(_ctx, getState()); - enterRule(_localctx, 184, RULE_predConstructArgs); + enterRule(_localctx, 186, RULE_predConstructArgs); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1182); + setState(1202); match(L_PRED); - setState(1184); + setState(1204); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1183); + setState(1203); expressionList(); } } - setState(1187); + setState(1207); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1186); + setState(1206); match(COMMA); } } - setState(1189); + setState(1209); match(R_PRED); } } @@ -7192,6 +7413,7 @@ public final PredConstructArgsContext predConstructArgs() throws RecognitionExce return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class InterfaceTypeContext extends ParserRuleContext { public TerminalNode INTERFACE() { return getToken(GobraParser.INTERFACE, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } @@ -7233,52 +7455,52 @@ public T accept(ParseTreeVisitor visitor) { public final InterfaceTypeContext interfaceType() throws RecognitionException { InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_interfaceType); + enterRule(_localctx, 188, RULE_interfaceType); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1191); + setState(1211); match(INTERFACE); - setState(1192); + setState(1212); match(L_CURLY); - setState(1202); + setState(1222); _errHandler.sync(this); _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << GHOST) | (1L << PRED))) != 0) || _la==TRUSTED || _la==IDENTIFIER) { + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 72057594172173824L) != 0) || _la==TRUSTED || _la==IDENTIFIER) { { { - setState(1196); + setState(1216); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) { case 1: { - setState(1193); + setState(1213); methodSpec(); } break; case 2: { - setState(1194); + setState(1214); typeName(); } break; case 3: { - setState(1195); + setState(1215); predicateSpec(); } break; } - setState(1198); + setState(1218); eos(); } } - setState(1204); + setState(1224); _errHandler.sync(this); _la = _input.LA(1); } - setState(1205); + setState(1225); match(R_CURLY); } } @@ -7293,6 +7515,7 @@ public final InterfaceTypeContext interfaceType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PredicateSpecContext extends ParserRuleContext { public TerminalNode PRED() { return getToken(GobraParser.PRED, 0); } public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } @@ -7312,15 +7535,15 @@ public T accept(ParseTreeVisitor visitor) { public final PredicateSpecContext predicateSpec() throws RecognitionException { PredicateSpecContext _localctx = new PredicateSpecContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_predicateSpec); + enterRule(_localctx, 190, RULE_predicateSpec); try { enterOuterAlt(_localctx, 1); { - setState(1207); + setState(1227); match(PRED); - setState(1208); + setState(1228); match(IDENTIFIER); - setState(1209); + setState(1229); parameters(); } } @@ -7335,6 +7558,7 @@ public final PredicateSpecContext predicateSpec() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MethodSpecContext extends ParserRuleContext { public SpecificationContext specification() { return getRuleContext(SpecificationContext.class,0); @@ -7360,53 +7584,53 @@ public T accept(ParseTreeVisitor visitor) { public final MethodSpecContext methodSpec() throws RecognitionException { MethodSpecContext _localctx = new MethodSpecContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_methodSpec); + enterRule(_localctx, 192, RULE_methodSpec); int _la; try { - setState(1226); + setState(1246); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1212); + setState(1232); _errHandler.sync(this); _la = _input.LA(1); if (_la==GHOST) { { - setState(1211); + setState(1231); match(GHOST); } } - setState(1214); + setState(1234); specification(); - setState(1215); + setState(1235); match(IDENTIFIER); - setState(1216); + setState(1236); parameters(); - setState(1217); + setState(1237); result(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1220); + setState(1240); _errHandler.sync(this); _la = _input.LA(1); if (_la==GHOST) { { - setState(1219); + setState(1239); match(GHOST); } } - setState(1222); + setState(1242); specification(); - setState(1223); + setState(1243); match(IDENTIFIER); - setState(1224); + setState(1244); parameters(); } break; @@ -7423,6 +7647,7 @@ public final MethodSpecContext methodSpec() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class Type_Context extends ParserRuleContext { public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); @@ -7451,15 +7676,15 @@ public T accept(ParseTreeVisitor visitor) { public final Type_Context type_() throws RecognitionException { Type_Context _localctx = new Type_Context(_ctx, getState()); - enterRule(_localctx, 192, RULE_type_); + enterRule(_localctx, 194, RULE_type_); try { - setState(1235); + setState(1255); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: enterOuterAlt(_localctx, 1); { - setState(1228); + setState(1248); typeName(); } break; @@ -7474,7 +7699,7 @@ public final Type_Context type_() throws RecognitionException { case RECEIVE: enterOuterAlt(_localctx, 2); { - setState(1229); + setState(1249); typeLit(); } break; @@ -7488,18 +7713,18 @@ public final Type_Context type_() throws RecognitionException { case ADT: enterOuterAlt(_localctx, 3); { - setState(1230); + setState(1250); ghostTypeLit(); } break; case L_PAREN: enterOuterAlt(_localctx, 4); { - setState(1231); + setState(1251); match(L_PAREN); - setState(1232); + setState(1252); type_(); - setState(1233); + setState(1253); match(R_PAREN); } break; @@ -7518,6 +7743,7 @@ public final Type_Context type_() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeLitContext extends ParserRuleContext { public ArrayTypeContext arrayType() { return getRuleContext(ArrayTypeContext.class,0); @@ -7559,71 +7785,71 @@ public T accept(ParseTreeVisitor visitor) { public final TypeLitContext typeLit() throws RecognitionException { TypeLitContext _localctx = new TypeLitContext(_ctx, getState()); - enterRule(_localctx, 194, RULE_typeLit); + enterRule(_localctx, 196, RULE_typeLit); try { - setState(1246); + setState(1266); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1237); + setState(1257); arrayType(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1238); + setState(1258); structType(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1239); + setState(1259); pointerType(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1240); + setState(1260); functionType(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1241); + setState(1261); interfaceType(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(1242); + setState(1262); sliceType(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(1243); + setState(1263); mapType(); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(1244); + setState(1264); channelType(); } break; case 9: enterOuterAlt(_localctx, 9); { - setState(1245); + setState(1265); predType(); } break; @@ -7640,6 +7866,7 @@ public final TypeLitContext typeLit() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PredTypeContext extends ParserRuleContext { public TerminalNode PRED() { return getToken(GobraParser.PRED, 0); } public PredTypeParamsContext predTypeParams() { @@ -7658,13 +7885,13 @@ public T accept(ParseTreeVisitor visitor) { public final PredTypeContext predType() throws RecognitionException { PredTypeContext _localctx = new PredTypeContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_predType); + enterRule(_localctx, 198, RULE_predType); try { enterOuterAlt(_localctx, 1); { - setState(1248); + setState(1268); match(PRED); - setState(1249); + setState(1269); predTypeParams(); } } @@ -7679,6 +7906,7 @@ public final PredTypeContext predType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PredTypeParamsContext extends ParserRuleContext { public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } public TerminalNode R_PAREN() { return getToken(GobraParser.R_PAREN, 0); } @@ -7705,45 +7933,45 @@ public T accept(ParseTreeVisitor visitor) { public final PredTypeParamsContext predTypeParams() throws RecognitionException { PredTypeParamsContext _localctx = new PredTypeParamsContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_predTypeParams); + enterRule(_localctx, 200, RULE_predTypeParams); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1251); + setState(1271); match(L_PAREN); - setState(1263); + setState(1283); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << DOM) | (1L << ADT) | (1L << PRED))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (FUNC - 77)) | (1L << (INTERFACE - 77)) | (1L << (MAP - 77)) | (1L << (STRUCT - 77)) | (1L << (CHAN - 77)) | (1L << (IDENTIFIER - 77)) | (1L << (L_PAREN - 77)) | (1L << (L_BRACKET - 77)) | (1L << (STAR - 77)) | (1L << (RECEIVE - 77)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 83350678101032960L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441151881345761731L) != 0)) { { - setState(1252); + setState(1272); type_(); - setState(1257); + setState(1277); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,100,_ctx); + _alt = getInterpreter().adaptivePredict(_input,102,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1253); + setState(1273); match(COMMA); - setState(1254); + setState(1274); type_(); } } } - setState(1259); + setState(1279); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,100,_ctx); + _alt = getInterpreter().adaptivePredict(_input,102,_ctx); } - setState(1261); + setState(1281); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1260); + setState(1280); match(COMMA); } } @@ -7751,7 +7979,7 @@ public final PredTypeParamsContext predTypeParams() throws RecognitionException } } - setState(1265); + setState(1285); match(R_PAREN); } } @@ -7766,6 +7994,7 @@ public final PredTypeParamsContext predTypeParams() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LiteralTypeContext extends ParserRuleContext { public StructTypeContext structType() { return getRuleContext(StructTypeContext.class,0); @@ -7801,57 +8030,57 @@ public T accept(ParseTreeVisitor visitor) { public final LiteralTypeContext literalType() throws RecognitionException { LiteralTypeContext _localctx = new LiteralTypeContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_literalType); + enterRule(_localctx, 202, RULE_literalType); try { - setState(1274); + setState(1294); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1267); + setState(1287); structType(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1268); + setState(1288); arrayType(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1269); + setState(1289); implicitArray(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1270); + setState(1290); sliceType(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1271); + setState(1291); mapType(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(1272); + setState(1292); ghostTypeLit(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(1273); + setState(1293); typeName(); } break; @@ -7868,6 +8097,7 @@ public final LiteralTypeContext literalType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ImplicitArrayContext extends ParserRuleContext { public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } public TerminalNode ELLIPSIS() { return getToken(GobraParser.ELLIPSIS, 0); } @@ -7888,17 +8118,17 @@ public T accept(ParseTreeVisitor visitor) { public final ImplicitArrayContext implicitArray() throws RecognitionException { ImplicitArrayContext _localctx = new ImplicitArrayContext(_ctx, getState()); - enterRule(_localctx, 202, RULE_implicitArray); + enterRule(_localctx, 204, RULE_implicitArray); try { enterOuterAlt(_localctx, 1); { - setState(1276); + setState(1296); match(L_BRACKET); - setState(1277); + setState(1297); match(ELLIPSIS); - setState(1278); + setState(1298); match(R_BRACKET); - setState(1279); + setState(1299); elementType(); } } @@ -7913,6 +8143,7 @@ public final ImplicitArrayContext implicitArray() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class Slice_Context extends ParserRuleContext { public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } public TerminalNode R_BRACKET() { return getToken(GobraParser.R_BRACKET, 0); } @@ -7942,36 +8173,36 @@ public T accept(ParseTreeVisitor visitor) { public final Slice_Context slice_() throws RecognitionException { Slice_Context _localctx = new Slice_Context(_ctx, getState()); - enterRule(_localctx, 204, RULE_slice_); + enterRule(_localctx, 206, RULE_slice_); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1281); + setState(1301); match(L_BRACKET); - setState(1297); + setState(1317); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) { case 1: { - setState(1283); + setState(1303); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1282); + setState(1302); low(); } } - setState(1285); + setState(1305); match(COLON); - setState(1287); + setState(1307); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1286); + setState(1306); high(); } } @@ -7980,28 +8211,28 @@ public final Slice_Context slice_() throws RecognitionException { break; case 2: { - setState(1290); + setState(1310); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1289); + setState(1309); low(); } } - setState(1292); + setState(1312); match(COLON); - setState(1293); + setState(1313); high(); - setState(1294); + setState(1314); match(COLON); - setState(1295); + setState(1315); cap(); } break; } - setState(1299); + setState(1319); match(R_BRACKET); } } @@ -8016,6 +8247,7 @@ public final Slice_Context slice_() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LowContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -8033,11 +8265,11 @@ public T accept(ParseTreeVisitor visitor) { public final LowContext low() throws RecognitionException { LowContext _localctx = new LowContext(_ctx, getState()); - enterRule(_localctx, 206, RULE_low); + enterRule(_localctx, 208, RULE_low); try { enterOuterAlt(_localctx, 1); { - setState(1301); + setState(1321); expression(0); } } @@ -8052,6 +8284,7 @@ public final LowContext low() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class HighContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -8069,11 +8302,11 @@ public T accept(ParseTreeVisitor visitor) { public final HighContext high() throws RecognitionException { HighContext _localctx = new HighContext(_ctx, getState()); - enterRule(_localctx, 208, RULE_high); + enterRule(_localctx, 210, RULE_high); try { enterOuterAlt(_localctx, 1); { - setState(1303); + setState(1323); expression(0); } } @@ -8088,6 +8321,7 @@ public final HighContext high() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CapContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -8105,11 +8339,11 @@ public T accept(ParseTreeVisitor visitor) { public final CapContext cap() throws RecognitionException { CapContext _localctx = new CapContext(_ctx, getState()); - enterRule(_localctx, 210, RULE_cap); + enterRule(_localctx, 212, RULE_cap); try { enterOuterAlt(_localctx, 1); { - setState(1305); + setState(1325); expression(0); } } @@ -8124,6 +8358,7 @@ public final CapContext cap() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class Assign_opContext extends ParserRuleContext { public Token ass_op; public TerminalNode ASSIGN() { return getToken(GobraParser.ASSIGN, 0); } @@ -8151,20 +8386,20 @@ public T accept(ParseTreeVisitor visitor) { public final Assign_opContext assign_op() throws RecognitionException { Assign_opContext _localctx = new Assign_opContext(_ctx, getState()); - enterRule(_localctx, 212, RULE_assign_op); + enterRule(_localctx, 214, RULE_assign_op); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1308); + setState(1328); _errHandler.sync(this); _la = _input.LA(1); - if (((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & ((1L << (OR - 125)) | (1L << (DIV - 125)) | (1L << (MOD - 125)) | (1L << (LSHIFT - 125)) | (1L << (RSHIFT - 125)) | (1L << (BIT_CLEAR - 125)) | (1L << (PLUS - 125)) | (1L << (MINUS - 125)) | (1L << (CARET - 125)) | (1L << (STAR - 125)) | (1L << (AMPERSAND - 125)))) != 0)) { + if (((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & 4031L) != 0)) { { - setState(1307); + setState(1327); ((Assign_opContext)_localctx).ass_op = _input.LT(1); _la = _input.LA(1); - if ( !(((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & ((1L << (OR - 125)) | (1L << (DIV - 125)) | (1L << (MOD - 125)) | (1L << (LSHIFT - 125)) | (1L << (RSHIFT - 125)) | (1L << (BIT_CLEAR - 125)) | (1L << (PLUS - 125)) | (1L << (MINUS - 125)) | (1L << (CARET - 125)) | (1L << (STAR - 125)) | (1L << (AMPERSAND - 125)))) != 0)) ) { + if ( !(((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & 4031L) != 0)) ) { ((Assign_opContext)_localctx).ass_op = (Token)_errHandler.recoverInline(this); } else { @@ -8175,7 +8410,7 @@ public final Assign_opContext assign_op() throws RecognitionException { } } - setState(1310); + setState(1330); match(ASSIGN); } } @@ -8190,6 +8425,7 @@ public final Assign_opContext assign_op() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class RangeClauseContext extends ParserRuleContext { public TerminalNode RANGE() { return getToken(GobraParser.RANGE, 0); } public ExpressionContext expression() { @@ -8218,48 +8454,48 @@ public T accept(ParseTreeVisitor visitor) { public final RangeClauseContext rangeClause() throws RecognitionException { RangeClauseContext _localctx = new RangeClauseContext(_ctx, getState()); - enterRule(_localctx, 214, RULE_rangeClause); + enterRule(_localctx, 216, RULE_rangeClause); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1318); + setState(1338); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) { case 1: { - setState(1312); + setState(1332); expressionList(); - setState(1313); + setState(1333); match(ASSIGN); } break; case 2: { - setState(1315); + setState(1335); maybeAddressableIdentifierList(); - setState(1316); + setState(1336); match(DECLARE_ASSIGN); } break; } - setState(1320); + setState(1340); match(RANGE); - setState(1321); + setState(1341); expression(0); - setState(1326); + setState(1346); _errHandler.sync(this); _la = _input.LA(1); if (_la==WITH) { { - setState(1322); + setState(1342); match(WITH); - setState(1324); + setState(1344); _errHandler.sync(this); _la = _input.LA(1); if (_la==IDENTIFIER) { { - setState(1323); + setState(1343); match(IDENTIFIER); } } @@ -8280,6 +8516,7 @@ public final RangeClauseContext rangeClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PackageClauseContext extends ParserRuleContext { public Token packageName; public TerminalNode PACKAGE() { return getToken(GobraParser.PACKAGE, 0); } @@ -8297,13 +8534,13 @@ public T accept(ParseTreeVisitor visitor) { public final PackageClauseContext packageClause() throws RecognitionException { PackageClauseContext _localctx = new PackageClauseContext(_ctx, getState()); - enterRule(_localctx, 216, RULE_packageClause); + enterRule(_localctx, 218, RULE_packageClause); try { enterOuterAlt(_localctx, 1); { - setState(1328); + setState(1348); match(PACKAGE); - setState(1329); + setState(1349); ((PackageClauseContext)_localctx).packageName = match(IDENTIFIER); } } @@ -8318,6 +8555,7 @@ public final PackageClauseContext packageClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ImportPathContext extends ParserRuleContext { public String_Context string_() { return getRuleContext(String_Context.class,0); @@ -8335,11 +8573,11 @@ public T accept(ParseTreeVisitor visitor) { public final ImportPathContext importPath() throws RecognitionException { ImportPathContext _localctx = new ImportPathContext(_ctx, getState()); - enterRule(_localctx, 218, RULE_importPath); + enterRule(_localctx, 220, RULE_importPath); try { enterOuterAlt(_localctx, 1); { - setState(1331); + setState(1351); string_(); } } @@ -8354,6 +8592,7 @@ public final ImportPathContext importPath() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class DeclarationContext extends ParserRuleContext { public ConstDeclContext constDecl() { return getRuleContext(ConstDeclContext.class,0); @@ -8377,29 +8616,29 @@ public T accept(ParseTreeVisitor visitor) { public final DeclarationContext declaration() throws RecognitionException { DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); - enterRule(_localctx, 220, RULE_declaration); + enterRule(_localctx, 222, RULE_declaration); try { - setState(1336); + setState(1356); _errHandler.sync(this); switch (_input.LA(1)) { case CONST: enterOuterAlt(_localctx, 1); { - setState(1333); + setState(1353); constDecl(); } break; case TYPE: enterOuterAlt(_localctx, 2); { - setState(1334); + setState(1354); typeDecl(); } break; case VAR: enterOuterAlt(_localctx, 3); { - setState(1335); + setState(1355); varDecl(); } break; @@ -8418,6 +8657,7 @@ public final DeclarationContext declaration() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConstDeclContext extends ParserRuleContext { public TerminalNode CONST() { return getToken(GobraParser.CONST, 0); } public List constSpec() { @@ -8447,43 +8687,43 @@ public T accept(ParseTreeVisitor visitor) { public final ConstDeclContext constDecl() throws RecognitionException { ConstDeclContext _localctx = new ConstDeclContext(_ctx, getState()); - enterRule(_localctx, 222, RULE_constDecl); + enterRule(_localctx, 224, RULE_constDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1338); + setState(1358); match(CONST); - setState(1350); + setState(1370); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: { - setState(1339); + setState(1359); constSpec(); } break; case L_PAREN: { - setState(1340); + setState(1360); match(L_PAREN); - setState(1346); + setState(1366); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER) { { { - setState(1341); + setState(1361); constSpec(); - setState(1342); + setState(1362); eos(); } } - setState(1348); + setState(1368); _errHandler.sync(this); _la = _input.LA(1); } - setState(1349); + setState(1369); match(R_PAREN); } break; @@ -8503,6 +8743,7 @@ public final ConstDeclContext constDecl() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConstSpecContext extends ParserRuleContext { public IdentifierListContext identifierList() { return getRuleContext(IdentifierListContext.class,0); @@ -8527,31 +8768,31 @@ public T accept(ParseTreeVisitor visitor) { public final ConstSpecContext constSpec() throws RecognitionException { ConstSpecContext _localctx = new ConstSpecContext(_ctx, getState()); - enterRule(_localctx, 224, RULE_constSpec); + enterRule(_localctx, 226, RULE_constSpec); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1352); + setState(1372); identifierList(); - setState(1358); + setState(1378); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { case 1: { - setState(1354); + setState(1374); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << DOM) | (1L << ADT) | (1L << PRED))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (FUNC - 77)) | (1L << (INTERFACE - 77)) | (1L << (MAP - 77)) | (1L << (STRUCT - 77)) | (1L << (CHAN - 77)) | (1L << (IDENTIFIER - 77)) | (1L << (L_PAREN - 77)) | (1L << (L_BRACKET - 77)) | (1L << (STAR - 77)) | (1L << (RECEIVE - 77)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 83350678101032960L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441151881345761731L) != 0)) { { - setState(1353); + setState(1373); type_(); } } - setState(1356); + setState(1376); match(ASSIGN); - setState(1357); + setState(1377); expressionList(); } break; @@ -8569,6 +8810,7 @@ public final ConstSpecContext constSpec() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class IdentifierListContext extends ParserRuleContext { public List IDENTIFIER() { return getTokens(GobraParser.IDENTIFIER); } public TerminalNode IDENTIFIER(int i) { @@ -8591,30 +8833,30 @@ public T accept(ParseTreeVisitor visitor) { public final IdentifierListContext identifierList() throws RecognitionException { IdentifierListContext _localctx = new IdentifierListContext(_ctx, getState()); - enterRule(_localctx, 226, RULE_identifierList); + enterRule(_localctx, 228, RULE_identifierList); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1360); + setState(1380); match(IDENTIFIER); - setState(1365); + setState(1385); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,117,_ctx); + _alt = getInterpreter().adaptivePredict(_input,119,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1361); + setState(1381); match(COMMA); - setState(1362); + setState(1382); match(IDENTIFIER); } } } - setState(1367); + setState(1387); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,117,_ctx); + _alt = getInterpreter().adaptivePredict(_input,119,_ctx); } } } @@ -8629,6 +8871,7 @@ public final IdentifierListContext identifierList() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExpressionListContext extends ParserRuleContext { public List expression() { return getRuleContexts(ExpressionContext.class); @@ -8653,30 +8896,30 @@ public T accept(ParseTreeVisitor visitor) { public final ExpressionListContext expressionList() throws RecognitionException { ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); - enterRule(_localctx, 228, RULE_expressionList); + enterRule(_localctx, 230, RULE_expressionList); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1368); + setState(1388); expression(0); - setState(1373); + setState(1393); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,118,_ctx); + _alt = getInterpreter().adaptivePredict(_input,120,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1369); + setState(1389); match(COMMA); - setState(1370); + setState(1390); expression(0); } } } - setState(1375); + setState(1395); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,118,_ctx); + _alt = getInterpreter().adaptivePredict(_input,120,_ctx); } } } @@ -8691,6 +8934,7 @@ public final ExpressionListContext expressionList() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeDeclContext extends ParserRuleContext { public TerminalNode TYPE() { return getToken(GobraParser.TYPE, 0); } public List typeSpec() { @@ -8720,43 +8964,43 @@ public T accept(ParseTreeVisitor visitor) { public final TypeDeclContext typeDecl() throws RecognitionException { TypeDeclContext _localctx = new TypeDeclContext(_ctx, getState()); - enterRule(_localctx, 230, RULE_typeDecl); + enterRule(_localctx, 232, RULE_typeDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1376); + setState(1396); match(TYPE); - setState(1388); + setState(1408); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: { - setState(1377); + setState(1397); typeSpec(); } break; case L_PAREN: { - setState(1378); + setState(1398); match(L_PAREN); - setState(1384); + setState(1404); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER) { { { - setState(1379); + setState(1399); typeSpec(); - setState(1380); + setState(1400); eos(); } } - setState(1386); + setState(1406); _errHandler.sync(this); _la = _input.LA(1); } - setState(1387); + setState(1407); match(R_PAREN); } break; @@ -8776,6 +9020,7 @@ public final TypeDeclContext typeDecl() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeSpecContext extends ParserRuleContext { public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } public Type_Context type_() { @@ -8795,24 +9040,24 @@ public T accept(ParseTreeVisitor visitor) { public final TypeSpecContext typeSpec() throws RecognitionException { TypeSpecContext _localctx = new TypeSpecContext(_ctx, getState()); - enterRule(_localctx, 232, RULE_typeSpec); + enterRule(_localctx, 234, RULE_typeSpec); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1390); + setState(1410); match(IDENTIFIER); - setState(1392); + setState(1412); _errHandler.sync(this); _la = _input.LA(1); if (_la==ASSIGN) { { - setState(1391); + setState(1411); match(ASSIGN); } } - setState(1394); + setState(1414); type_(); } } @@ -8827,6 +9072,7 @@ public final TypeSpecContext typeSpec() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class VarDeclContext extends ParserRuleContext { public TerminalNode VAR() { return getToken(GobraParser.VAR, 0); } public List varSpec() { @@ -8856,43 +9102,43 @@ public T accept(ParseTreeVisitor visitor) { public final VarDeclContext varDecl() throws RecognitionException { VarDeclContext _localctx = new VarDeclContext(_ctx, getState()); - enterRule(_localctx, 234, RULE_varDecl); + enterRule(_localctx, 236, RULE_varDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1396); + setState(1416); match(VAR); - setState(1408); + setState(1428); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: { - setState(1397); + setState(1417); varSpec(); } break; case L_PAREN: { - setState(1398); + setState(1418); match(L_PAREN); - setState(1404); + setState(1424); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER) { { { - setState(1399); + setState(1419); varSpec(); - setState(1400); + setState(1420); eos(); } } - setState(1406); + setState(1426); _errHandler.sync(this); _la = _input.LA(1); } - setState(1407); + setState(1427); match(R_PAREN); } break; @@ -8912,6 +9158,7 @@ public final VarDeclContext varDecl() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BlockContext extends ParserRuleContext { public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } public TerminalNode R_CURLY() { return getToken(GobraParser.R_CURLY, 0); } @@ -8931,23 +9178,23 @@ public T accept(ParseTreeVisitor visitor) { public final BlockContext block() throws RecognitionException { BlockContext _localctx = new BlockContext(_ctx, getState()); - enterRule(_localctx, 236, RULE_block); + enterRule(_localctx, 238, RULE_block); try { enterOuterAlt(_localctx, 1); { - setState(1410); + setState(1430); match(L_CURLY); - setState(1412); + setState(1432); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { case 1: { - setState(1411); + setState(1431); statementList(); } break; } - setState(1414); + setState(1434); match(R_CURLY); } } @@ -8962,6 +9209,7 @@ public final BlockContext block() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StatementListContext extends ParserRuleContext { public List statement() { return getRuleContexts(StatementContext.class); @@ -8975,6 +9223,14 @@ public List eos() { public EosContext eos(int i) { return getRuleContext(EosContext.class,i); } + public List SEMI() { return getTokens(GobraParser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(GobraParser.SEMI, i); + } + public List EOS() { return getTokens(GobraParser.EOS); } + public TerminalNode EOS(int i) { + return getToken(GobraParser.EOS, i); + } public StatementListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -8988,12 +9244,13 @@ public T accept(ParseTreeVisitor visitor) { public final StatementListContext statementList() throws RecognitionException { StatementListContext _localctx = new StatementListContext(_ctx, getState()); - enterRule(_localctx, 238, RULE_statementList); + enterRule(_localctx, 240, RULE_statementList); + int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1422); + setState(1448); _errHandler.sync(this); _alt = 1; do { @@ -9001,19 +9258,47 @@ public final StatementListContext statementList() throws RecognitionException { case 1: { { - setState(1417); + setState(1443); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { case 1: { - setState(1416); - eos(); + setState(1437); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(1436); + match(SEMI); + } + } + + } + break; + case 2: + { + setState(1440); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOS) { + { + setState(1439); + match(EOS); + } + } + + } + break; + case 3: + { + setState(1442); + if (!(this.closingBracket())) throw new FailedPredicateException(this, "this.closingBracket()"); } break; } - setState(1419); + setState(1445); statement(); - setState(1420); + setState(1446); eos(); } } @@ -9021,9 +9306,9 @@ public final StatementListContext statementList() throws RecognitionException { default: throw new NoViableAltException(this); } - setState(1424); + setState(1450); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,126,_ctx); + _alt = getInterpreter().adaptivePredict(_input,130,_ctx); } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); } } @@ -9038,6 +9323,7 @@ public final StatementListContext statementList() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SimpleStmtContext extends ParserRuleContext { public SendStmtContext sendStmt() { return getRuleContext(SendStmtContext.class,0); @@ -9067,43 +9353,43 @@ public T accept(ParseTreeVisitor visitor) { public final SimpleStmtContext simpleStmt() throws RecognitionException { SimpleStmtContext _localctx = new SimpleStmtContext(_ctx, getState()); - enterRule(_localctx, 240, RULE_simpleStmt); + enterRule(_localctx, 242, RULE_simpleStmt); try { - setState(1431); + setState(1457); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1426); + setState(1452); sendStmt(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1427); + setState(1453); incDecStmt(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1428); + setState(1454); assignment(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1429); + setState(1455); expressionStmt(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1430); + setState(1456); shortVarDecl(); } break; @@ -9120,6 +9406,7 @@ public final SimpleStmtContext simpleStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExpressionStmtContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -9137,11 +9424,11 @@ public T accept(ParseTreeVisitor visitor) { public final ExpressionStmtContext expressionStmt() throws RecognitionException { ExpressionStmtContext _localctx = new ExpressionStmtContext(_ctx, getState()); - enterRule(_localctx, 242, RULE_expressionStmt); + enterRule(_localctx, 244, RULE_expressionStmt); try { enterOuterAlt(_localctx, 1); { - setState(1433); + setState(1459); expression(0); } } @@ -9156,6 +9443,7 @@ public final ExpressionStmtContext expressionStmt() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SendStmtContext extends ParserRuleContext { public ExpressionContext channel; public TerminalNode RECEIVE() { return getToken(GobraParser.RECEIVE, 0); } @@ -9178,15 +9466,15 @@ public T accept(ParseTreeVisitor visitor) { public final SendStmtContext sendStmt() throws RecognitionException { SendStmtContext _localctx = new SendStmtContext(_ctx, getState()); - enterRule(_localctx, 244, RULE_sendStmt); + enterRule(_localctx, 246, RULE_sendStmt); try { enterOuterAlt(_localctx, 1); { - setState(1435); + setState(1461); ((SendStmtContext)_localctx).channel = expression(0); - setState(1436); + setState(1462); match(RECEIVE); - setState(1437); + setState(1463); expression(0); } } @@ -9201,6 +9489,7 @@ public final SendStmtContext sendStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class IncDecStmtContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -9220,14 +9509,14 @@ public T accept(ParseTreeVisitor visitor) { public final IncDecStmtContext incDecStmt() throws RecognitionException { IncDecStmtContext _localctx = new IncDecStmtContext(_ctx, getState()); - enterRule(_localctx, 246, RULE_incDecStmt); + enterRule(_localctx, 248, RULE_incDecStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1439); + setState(1465); expression(0); - setState(1440); + setState(1466); _la = _input.LA(1); if ( !(_la==PLUS_PLUS || _la==MINUS_MINUS) ) { _errHandler.recoverInline(this); @@ -9250,6 +9539,7 @@ public final IncDecStmtContext incDecStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class AssignmentContext extends ParserRuleContext { public List expressionList() { return getRuleContexts(ExpressionListContext.class); @@ -9273,15 +9563,15 @@ public T accept(ParseTreeVisitor visitor) { public final AssignmentContext assignment() throws RecognitionException { AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); - enterRule(_localctx, 248, RULE_assignment); + enterRule(_localctx, 250, RULE_assignment); try { enterOuterAlt(_localctx, 1); { - setState(1442); + setState(1468); expressionList(); - setState(1443); + setState(1469); assign_op(); - setState(1444); + setState(1470); expressionList(); } } @@ -9296,6 +9586,7 @@ public final AssignmentContext assignment() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EmptyStmtContext extends ParserRuleContext { public TerminalNode EOS() { return getToken(GobraParser.EOS, 0); } public TerminalNode SEMI() { return getToken(GobraParser.SEMI, 0); } @@ -9312,12 +9603,12 @@ public T accept(ParseTreeVisitor visitor) { public final EmptyStmtContext emptyStmt() throws RecognitionException { EmptyStmtContext _localctx = new EmptyStmtContext(_ctx, getState()); - enterRule(_localctx, 250, RULE_emptyStmt); + enterRule(_localctx, 252, RULE_emptyStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1446); + setState(1472); _la = _input.LA(1); if ( !(_la==SEMI || _la==EOS) ) { _errHandler.recoverInline(this); @@ -9340,6 +9631,7 @@ public final EmptyStmtContext emptyStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LabeledStmtContext extends ParserRuleContext { public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } public TerminalNode COLON() { return getToken(GobraParser.COLON, 0); } @@ -9359,20 +9651,20 @@ public T accept(ParseTreeVisitor visitor) { public final LabeledStmtContext labeledStmt() throws RecognitionException { LabeledStmtContext _localctx = new LabeledStmtContext(_ctx, getState()); - enterRule(_localctx, 252, RULE_labeledStmt); + enterRule(_localctx, 254, RULE_labeledStmt); try { enterOuterAlt(_localctx, 1); { - setState(1448); + setState(1474); match(IDENTIFIER); - setState(1449); + setState(1475); match(COLON); - setState(1451); + setState(1477); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { case 1: { - setState(1450); + setState(1476); statement(); } break; @@ -9390,6 +9682,7 @@ public final LabeledStmtContext labeledStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ReturnStmtContext extends ParserRuleContext { public TerminalNode RETURN() { return getToken(GobraParser.RETURN, 0); } public ExpressionListContext expressionList() { @@ -9408,18 +9701,18 @@ public T accept(ParseTreeVisitor visitor) { public final ReturnStmtContext returnStmt() throws RecognitionException { ReturnStmtContext _localctx = new ReturnStmtContext(_ctx, getState()); - enterRule(_localctx, 254, RULE_returnStmt); + enterRule(_localctx, 256, RULE_returnStmt); try { enterOuterAlt(_localctx, 1); { - setState(1453); + setState(1479); match(RETURN); - setState(1455); + setState(1481); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) { case 1: { - setState(1454); + setState(1480); expressionList(); } break; @@ -9437,6 +9730,7 @@ public final ReturnStmtContext returnStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class BreakStmtContext extends ParserRuleContext { public TerminalNode BREAK() { return getToken(GobraParser.BREAK, 0); } public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } @@ -9453,18 +9747,18 @@ public T accept(ParseTreeVisitor visitor) { public final BreakStmtContext breakStmt() throws RecognitionException { BreakStmtContext _localctx = new BreakStmtContext(_ctx, getState()); - enterRule(_localctx, 256, RULE_breakStmt); + enterRule(_localctx, 258, RULE_breakStmt); try { enterOuterAlt(_localctx, 1); { - setState(1457); + setState(1483); match(BREAK); - setState(1459); + setState(1485); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) { case 1: { - setState(1458); + setState(1484); match(IDENTIFIER); } break; @@ -9482,6 +9776,7 @@ public final BreakStmtContext breakStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ContinueStmtContext extends ParserRuleContext { public TerminalNode CONTINUE() { return getToken(GobraParser.CONTINUE, 0); } public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } @@ -9498,18 +9793,18 @@ public T accept(ParseTreeVisitor visitor) { public final ContinueStmtContext continueStmt() throws RecognitionException { ContinueStmtContext _localctx = new ContinueStmtContext(_ctx, getState()); - enterRule(_localctx, 258, RULE_continueStmt); + enterRule(_localctx, 260, RULE_continueStmt); try { enterOuterAlt(_localctx, 1); { - setState(1461); + setState(1487); match(CONTINUE); - setState(1463); + setState(1489); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { case 1: { - setState(1462); + setState(1488); match(IDENTIFIER); } break; @@ -9527,6 +9822,7 @@ public final ContinueStmtContext continueStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class GotoStmtContext extends ParserRuleContext { public TerminalNode GOTO() { return getToken(GobraParser.GOTO, 0); } public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } @@ -9543,13 +9839,13 @@ public T accept(ParseTreeVisitor visitor) { public final GotoStmtContext gotoStmt() throws RecognitionException { GotoStmtContext _localctx = new GotoStmtContext(_ctx, getState()); - enterRule(_localctx, 260, RULE_gotoStmt); + enterRule(_localctx, 262, RULE_gotoStmt); try { enterOuterAlt(_localctx, 1); { - setState(1465); + setState(1491); match(GOTO); - setState(1466); + setState(1492); match(IDENTIFIER); } } @@ -9564,6 +9860,7 @@ public final GotoStmtContext gotoStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FallthroughStmtContext extends ParserRuleContext { public TerminalNode FALLTHROUGH() { return getToken(GobraParser.FALLTHROUGH, 0); } public FallthroughStmtContext(ParserRuleContext parent, int invokingState) { @@ -9579,11 +9876,11 @@ public T accept(ParseTreeVisitor visitor) { public final FallthroughStmtContext fallthroughStmt() throws RecognitionException { FallthroughStmtContext _localctx = new FallthroughStmtContext(_ctx, getState()); - enterRule(_localctx, 262, RULE_fallthroughStmt); + enterRule(_localctx, 264, RULE_fallthroughStmt); try { enterOuterAlt(_localctx, 1); { - setState(1468); + setState(1494); match(FALLTHROUGH); } } @@ -9598,6 +9895,7 @@ public final FallthroughStmtContext fallthroughStmt() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class IfStmtContext extends ParserRuleContext { public TerminalNode IF() { return getToken(GobraParser.IF, 0); } public List block() { @@ -9632,61 +9930,61 @@ public T accept(ParseTreeVisitor visitor) { public final IfStmtContext ifStmt() throws RecognitionException { IfStmtContext _localctx = new IfStmtContext(_ctx, getState()); - enterRule(_localctx, 264, RULE_ifStmt); + enterRule(_localctx, 266, RULE_ifStmt); try { enterOuterAlt(_localctx, 1); { - setState(1470); + setState(1496); match(IF); - setState(1479); + setState(1505); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { case 1: { - setState(1471); + setState(1497); expression(0); } break; case 2: { - setState(1472); + setState(1498); eos(); - setState(1473); + setState(1499); expression(0); } break; case 3: { - setState(1475); + setState(1501); simpleStmt(); - setState(1476); + setState(1502); eos(); - setState(1477); + setState(1503); expression(0); } break; } - setState(1481); + setState(1507); block(); - setState(1487); + setState(1513); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { case 1: { - setState(1482); + setState(1508); match(ELSE); - setState(1485); + setState(1511); _errHandler.sync(this); switch (_input.LA(1)) { case IF: { - setState(1483); + setState(1509); ifStmt(); } break; case L_CURLY: { - setState(1484); + setState(1510); block(); } break; @@ -9709,6 +10007,7 @@ public final IfStmtContext ifStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SwitchStmtContext extends ParserRuleContext { public ExprSwitchStmtContext exprSwitchStmt() { return getRuleContext(ExprSwitchStmtContext.class,0); @@ -9729,22 +10028,22 @@ public T accept(ParseTreeVisitor visitor) { public final SwitchStmtContext switchStmt() throws RecognitionException { SwitchStmtContext _localctx = new SwitchStmtContext(_ctx, getState()); - enterRule(_localctx, 266, RULE_switchStmt); + enterRule(_localctx, 268, RULE_switchStmt); try { - setState(1491); + setState(1517); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1489); + setState(1515); exprSwitchStmt(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1490); + setState(1516); typeSwitchStmt(); } break; @@ -9761,6 +10060,7 @@ public final SwitchStmtContext switchStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExprSwitchStmtContext extends ParserRuleContext { public TerminalNode SWITCH() { return getToken(GobraParser.SWITCH, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } @@ -9793,24 +10093,24 @@ public T accept(ParseTreeVisitor visitor) { public final ExprSwitchStmtContext exprSwitchStmt() throws RecognitionException { ExprSwitchStmtContext _localctx = new ExprSwitchStmtContext(_ctx, getState()); - enterRule(_localctx, 268, RULE_exprSwitchStmt); + enterRule(_localctx, 270, RULE_exprSwitchStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1493); + setState(1519); match(SWITCH); - setState(1504); + setState(1530); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { case 1: { - setState(1495); + setState(1521); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1494); + setState(1520); expression(0); } } @@ -9819,24 +10119,24 @@ public final ExprSwitchStmtContext exprSwitchStmt() throws RecognitionException break; case 2: { - setState(1498); + setState(1524); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { case 1: { - setState(1497); + setState(1523); simpleStmt(); } break; } - setState(1500); + setState(1526); eos(); - setState(1502); + setState(1528); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1501); + setState(1527); expression(0); } } @@ -9844,23 +10144,23 @@ public final ExprSwitchStmtContext exprSwitchStmt() throws RecognitionException } break; } - setState(1506); + setState(1532); match(L_CURLY); - setState(1510); + setState(1536); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(1507); + setState(1533); exprCaseClause(); } } - setState(1512); + setState(1538); _errHandler.sync(this); _la = _input.LA(1); } - setState(1513); + setState(1539); match(R_CURLY); } } @@ -9875,6 +10175,7 @@ public final ExprSwitchStmtContext exprSwitchStmt() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExprCaseClauseContext extends ParserRuleContext { public ExprSwitchCaseContext exprSwitchCase() { return getRuleContext(ExprSwitchCaseContext.class,0); @@ -9896,20 +10197,20 @@ public T accept(ParseTreeVisitor visitor) { public final ExprCaseClauseContext exprCaseClause() throws RecognitionException { ExprCaseClauseContext _localctx = new ExprCaseClauseContext(_ctx, getState()); - enterRule(_localctx, 270, RULE_exprCaseClause); + enterRule(_localctx, 272, RULE_exprCaseClause); try { enterOuterAlt(_localctx, 1); { - setState(1515); + setState(1541); exprSwitchCase(); - setState(1516); + setState(1542); match(COLON); - setState(1518); + setState(1544); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { case 1: { - setState(1517); + setState(1543); statementList(); } break; @@ -9927,6 +10228,7 @@ public final ExprCaseClauseContext exprCaseClause() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ExprSwitchCaseContext extends ParserRuleContext { public TerminalNode CASE() { return getToken(GobraParser.CASE, 0); } public ExpressionListContext expressionList() { @@ -9946,24 +10248,24 @@ public T accept(ParseTreeVisitor visitor) { public final ExprSwitchCaseContext exprSwitchCase() throws RecognitionException { ExprSwitchCaseContext _localctx = new ExprSwitchCaseContext(_ctx, getState()); - enterRule(_localctx, 272, RULE_exprSwitchCase); + enterRule(_localctx, 274, RULE_exprSwitchCase); try { - setState(1523); + setState(1549); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { - setState(1520); + setState(1546); match(CASE); - setState(1521); + setState(1547); expressionList(); } break; case DEFAULT: enterOuterAlt(_localctx, 2); { - setState(1522); + setState(1548); match(DEFAULT); } break; @@ -9982,6 +10284,7 @@ public final ExprSwitchCaseContext exprSwitchCase() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeSwitchStmtContext extends ParserRuleContext { public TerminalNode SWITCH() { return getToken(GobraParser.SWITCH, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } @@ -10014,58 +10317,58 @@ public T accept(ParseTreeVisitor visitor) { public final TypeSwitchStmtContext typeSwitchStmt() throws RecognitionException { TypeSwitchStmtContext _localctx = new TypeSwitchStmtContext(_ctx, getState()); - enterRule(_localctx, 274, RULE_typeSwitchStmt); + enterRule(_localctx, 276, RULE_typeSwitchStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1525); + setState(1551); match(SWITCH); - setState(1534); + setState(1560); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) { case 1: { - setState(1526); + setState(1552); typeSwitchGuard(); } break; case 2: { - setState(1527); + setState(1553); eos(); - setState(1528); + setState(1554); typeSwitchGuard(); } break; case 3: { - setState(1530); + setState(1556); simpleStmt(); - setState(1531); + setState(1557); eos(); - setState(1532); + setState(1558); typeSwitchGuard(); } break; } - setState(1536); + setState(1562); match(L_CURLY); - setState(1540); + setState(1566); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(1537); + setState(1563); typeCaseClause(); } } - setState(1542); + setState(1568); _errHandler.sync(this); _la = _input.LA(1); } - setState(1543); + setState(1569); match(R_CURLY); } } @@ -10080,6 +10383,7 @@ public final TypeSwitchStmtContext typeSwitchStmt() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeSwitchGuardContext extends ParserRuleContext { public PrimaryExprContext primaryExpr() { return getRuleContext(PrimaryExprContext.class,0); @@ -10103,31 +10407,31 @@ public T accept(ParseTreeVisitor visitor) { public final TypeSwitchGuardContext typeSwitchGuard() throws RecognitionException { TypeSwitchGuardContext _localctx = new TypeSwitchGuardContext(_ctx, getState()); - enterRule(_localctx, 276, RULE_typeSwitchGuard); + enterRule(_localctx, 278, RULE_typeSwitchGuard); try { enterOuterAlt(_localctx, 1); { - setState(1547); + setState(1573); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) { case 1: { - setState(1545); + setState(1571); match(IDENTIFIER); - setState(1546); + setState(1572); match(DECLARE_ASSIGN); } break; } - setState(1549); + setState(1575); primaryExpr(0); - setState(1550); + setState(1576); match(DOT); - setState(1551); + setState(1577); match(L_PAREN); - setState(1552); + setState(1578); match(TYPE); - setState(1553); + setState(1579); match(R_PAREN); } } @@ -10142,6 +10446,7 @@ public final TypeSwitchGuardContext typeSwitchGuard() throws RecognitionExceptio return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeCaseClauseContext extends ParserRuleContext { public TypeSwitchCaseContext typeSwitchCase() { return getRuleContext(TypeSwitchCaseContext.class,0); @@ -10163,20 +10468,20 @@ public T accept(ParseTreeVisitor visitor) { public final TypeCaseClauseContext typeCaseClause() throws RecognitionException { TypeCaseClauseContext _localctx = new TypeCaseClauseContext(_ctx, getState()); - enterRule(_localctx, 278, RULE_typeCaseClause); + enterRule(_localctx, 280, RULE_typeCaseClause); try { enterOuterAlt(_localctx, 1); { - setState(1555); + setState(1581); typeSwitchCase(); - setState(1556); + setState(1582); match(COLON); - setState(1558); + setState(1584); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { case 1: { - setState(1557); + setState(1583); statementList(); } break; @@ -10194,6 +10499,7 @@ public final TypeCaseClauseContext typeCaseClause() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeSwitchCaseContext extends ParserRuleContext { public TerminalNode CASE() { return getToken(GobraParser.CASE, 0); } public TypeListContext typeList() { @@ -10213,24 +10519,24 @@ public T accept(ParseTreeVisitor visitor) { public final TypeSwitchCaseContext typeSwitchCase() throws RecognitionException { TypeSwitchCaseContext _localctx = new TypeSwitchCaseContext(_ctx, getState()); - enterRule(_localctx, 280, RULE_typeSwitchCase); + enterRule(_localctx, 282, RULE_typeSwitchCase); try { - setState(1563); + setState(1589); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { - setState(1560); + setState(1586); match(CASE); - setState(1561); + setState(1587); typeList(); } break; case DEFAULT: enterOuterAlt(_localctx, 2); { - setState(1562); + setState(1588); match(DEFAULT); } break; @@ -10249,6 +10555,7 @@ public final TypeSwitchCaseContext typeSwitchCase() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeListContext extends ParserRuleContext { public List type_() { return getRuleContexts(Type_Context.class); @@ -10277,12 +10584,12 @@ public T accept(ParseTreeVisitor visitor) { public final TypeListContext typeList() throws RecognitionException { TypeListContext _localctx = new TypeListContext(_ctx, getState()); - enterRule(_localctx, 282, RULE_typeList); + enterRule(_localctx, 284, RULE_typeList); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1567); + setState(1593); _errHandler.sync(this); switch (_input.LA(1)) { case GHOST: @@ -10305,28 +10612,28 @@ public final TypeListContext typeList() throws RecognitionException { case STAR: case RECEIVE: { - setState(1565); + setState(1591); type_(); } break; case NIL_LIT: { - setState(1566); + setState(1592); match(NIL_LIT); } break; default: throw new NoViableAltException(this); } - setState(1576); + setState(1602); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(1569); + setState(1595); match(COMMA); - setState(1572); + setState(1598); _errHandler.sync(this); switch (_input.LA(1)) { case GHOST: @@ -10349,13 +10656,13 @@ public final TypeListContext typeList() throws RecognitionException { case STAR: case RECEIVE: { - setState(1570); + setState(1596); type_(); } break; case NIL_LIT: { - setState(1571); + setState(1597); match(NIL_LIT); } break; @@ -10364,7 +10671,7 @@ public final TypeListContext typeList() throws RecognitionException { } } } - setState(1578); + setState(1604); _errHandler.sync(this); _la = _input.LA(1); } @@ -10381,6 +10688,7 @@ public final TypeListContext typeList() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SelectStmtContext extends ParserRuleContext { public TerminalNode SELECT() { return getToken(GobraParser.SELECT, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } @@ -10404,30 +10712,30 @@ public T accept(ParseTreeVisitor visitor) { public final SelectStmtContext selectStmt() throws RecognitionException { SelectStmtContext _localctx = new SelectStmtContext(_ctx, getState()); - enterRule(_localctx, 284, RULE_selectStmt); + enterRule(_localctx, 286, RULE_selectStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1579); + setState(1605); match(SELECT); - setState(1580); + setState(1606); match(L_CURLY); - setState(1584); + setState(1610); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(1581); + setState(1607); commClause(); } } - setState(1586); + setState(1612); _errHandler.sync(this); _la = _input.LA(1); } - setState(1587); + setState(1613); match(R_CURLY); } } @@ -10442,6 +10750,7 @@ public final SelectStmtContext selectStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CommClauseContext extends ParserRuleContext { public CommCaseContext commCase() { return getRuleContext(CommCaseContext.class,0); @@ -10463,20 +10772,20 @@ public T accept(ParseTreeVisitor visitor) { public final CommClauseContext commClause() throws RecognitionException { CommClauseContext _localctx = new CommClauseContext(_ctx, getState()); - enterRule(_localctx, 286, RULE_commClause); + enterRule(_localctx, 288, RULE_commClause); try { enterOuterAlt(_localctx, 1); { - setState(1589); + setState(1615); commCase(); - setState(1590); + setState(1616); match(COLON); - setState(1592); + setState(1618); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { case 1: { - setState(1591); + setState(1617); statementList(); } break; @@ -10494,6 +10803,7 @@ public final CommClauseContext commClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CommCaseContext extends ParserRuleContext { public TerminalNode CASE() { return getToken(GobraParser.CASE, 0); } public SendStmtContext sendStmt() { @@ -10516,28 +10826,28 @@ public T accept(ParseTreeVisitor visitor) { public final CommCaseContext commCase() throws RecognitionException { CommCaseContext _localctx = new CommCaseContext(_ctx, getState()); - enterRule(_localctx, 288, RULE_commCase); + enterRule(_localctx, 290, RULE_commCase); try { - setState(1600); + setState(1626); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { - setState(1594); + setState(1620); match(CASE); - setState(1597); + setState(1623); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { case 1: { - setState(1595); + setState(1621); sendStmt(); } break; case 2: { - setState(1596); + setState(1622); recvStmt(); } break; @@ -10547,7 +10857,7 @@ public final CommCaseContext commCase() throws RecognitionException { case DEFAULT: enterOuterAlt(_localctx, 2); { - setState(1599); + setState(1625); match(DEFAULT); } break; @@ -10566,6 +10876,7 @@ public final CommCaseContext commCase() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class RecvStmtContext extends ParserRuleContext { public ExpressionContext recvExpr; public ExpressionContext expression() { @@ -10592,31 +10903,31 @@ public T accept(ParseTreeVisitor visitor) { public final RecvStmtContext recvStmt() throws RecognitionException { RecvStmtContext _localctx = new RecvStmtContext(_ctx, getState()); - enterRule(_localctx, 290, RULE_recvStmt); + enterRule(_localctx, 292, RULE_recvStmt); try { enterOuterAlt(_localctx, 1); { - setState(1608); + setState(1634); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { case 1: { - setState(1602); + setState(1628); expressionList(); - setState(1603); + setState(1629); match(ASSIGN); } break; case 2: { - setState(1605); + setState(1631); identifierList(); - setState(1606); + setState(1632); match(DECLARE_ASSIGN); } break; } - setState(1610); + setState(1636); ((RecvStmtContext)_localctx).recvExpr = expression(0); } } @@ -10631,17 +10942,18 @@ public final RecvStmtContext recvStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ForStmtContext extends ParserRuleContext { public TerminalNode FOR() { return getToken(GobraParser.FOR, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } public ForClauseContext forClause() { return getRuleContext(ForClauseContext.class,0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } public RangeClauseContext rangeClause() { return getRuleContext(RangeClauseContext.class,0); } @@ -10658,35 +10970,52 @@ public T accept(ParseTreeVisitor visitor) { public final ForStmtContext forStmt() throws RecognitionException { ForStmtContext _localctx = new ForStmtContext(_ctx, getState()); - enterRule(_localctx, 292, RULE_forStmt); + enterRule(_localctx, 294, RULE_forStmt); + int _la; try { enterOuterAlt(_localctx, 1); { - setState(1612); + setState(1638); match(FOR); - setState(1616); + setState(1646); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { case 1: { - setState(1613); - expression(0); + setState(1640); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { + { + setState(1639); + expression(0); + } + } + } break; case 2: { - setState(1614); + setState(1642); forClause(); } break; case 3: { - setState(1615); - rangeClause(); + setState(1644); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { + { + setState(1643); + rangeClause(); + } + } + } break; } - setState(1618); + setState(1648); block(); } } @@ -10701,6 +11030,7 @@ public final ForStmtContext forStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ForClauseContext extends ParserRuleContext { public SimpleStmtContext initStmt; public SimpleStmtContext postStmt; @@ -10732,41 +11062,41 @@ public T accept(ParseTreeVisitor visitor) { public final ForClauseContext forClause() throws RecognitionException { ForClauseContext _localctx = new ForClauseContext(_ctx, getState()); - enterRule(_localctx, 294, RULE_forClause); + enterRule(_localctx, 296, RULE_forClause); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1621); + setState(1651); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { case 1: { - setState(1620); + setState(1650); ((ForClauseContext)_localctx).initStmt = simpleStmt(); } break; } - setState(1623); + setState(1653); eos(); - setState(1625); + setState(1655); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) { case 1: { - setState(1624); + setState(1654); expression(0); } break; } - setState(1627); + setState(1657); eos(); - setState(1629); + setState(1659); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1628); + setState(1658); ((ForClauseContext)_localctx).postStmt = simpleStmt(); } } @@ -10784,6 +11114,7 @@ public final ForClauseContext forClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class GoStmtContext extends ParserRuleContext { public TerminalNode GO() { return getToken(GobraParser.GO, 0); } public ExpressionContext expression() { @@ -10802,13 +11133,13 @@ public T accept(ParseTreeVisitor visitor) { public final GoStmtContext goStmt() throws RecognitionException { GoStmtContext _localctx = new GoStmtContext(_ctx, getState()); - enterRule(_localctx, 296, RULE_goStmt); + enterRule(_localctx, 298, RULE_goStmt); try { enterOuterAlt(_localctx, 1); { - setState(1631); + setState(1661); match(GO); - setState(1632); + setState(1662); expression(0); } } @@ -10823,6 +11154,7 @@ public final GoStmtContext goStmt() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeNameContext extends ParserRuleContext { public QualifiedIdentContext qualifiedIdent() { return getRuleContext(QualifiedIdentContext.class,0); @@ -10841,22 +11173,22 @@ public T accept(ParseTreeVisitor visitor) { public final TypeNameContext typeName() throws RecognitionException { TypeNameContext _localctx = new TypeNameContext(_ctx, getState()); - enterRule(_localctx, 298, RULE_typeName); + enterRule(_localctx, 300, RULE_typeName); try { - setState(1636); + setState(1666); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1634); + setState(1664); qualifiedIdent(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1635); + setState(1665); match(IDENTIFIER); } break; @@ -10873,6 +11205,7 @@ public final TypeNameContext typeName() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ArrayTypeContext extends ParserRuleContext { public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } public ArrayLengthContext arrayLength() { @@ -10895,17 +11228,17 @@ public T accept(ParseTreeVisitor visitor) { public final ArrayTypeContext arrayType() throws RecognitionException { ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState()); - enterRule(_localctx, 300, RULE_arrayType); + enterRule(_localctx, 302, RULE_arrayType); try { enterOuterAlt(_localctx, 1); { - setState(1638); + setState(1668); match(L_BRACKET); - setState(1639); + setState(1669); arrayLength(); - setState(1640); + setState(1670); match(R_BRACKET); - setState(1641); + setState(1671); elementType(); } } @@ -10920,6 +11253,7 @@ public final ArrayTypeContext arrayType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ArrayLengthContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -10937,11 +11271,11 @@ public T accept(ParseTreeVisitor visitor) { public final ArrayLengthContext arrayLength() throws RecognitionException { ArrayLengthContext _localctx = new ArrayLengthContext(_ctx, getState()); - enterRule(_localctx, 302, RULE_arrayLength); + enterRule(_localctx, 304, RULE_arrayLength); try { enterOuterAlt(_localctx, 1); { - setState(1643); + setState(1673); expression(0); } } @@ -10956,6 +11290,7 @@ public final ArrayLengthContext arrayLength() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ElementTypeContext extends ParserRuleContext { public Type_Context type_() { return getRuleContext(Type_Context.class,0); @@ -10973,11 +11308,11 @@ public T accept(ParseTreeVisitor visitor) { public final ElementTypeContext elementType() throws RecognitionException { ElementTypeContext _localctx = new ElementTypeContext(_ctx, getState()); - enterRule(_localctx, 304, RULE_elementType); + enterRule(_localctx, 306, RULE_elementType); try { enterOuterAlt(_localctx, 1); { - setState(1645); + setState(1675); type_(); } } @@ -10992,6 +11327,7 @@ public final ElementTypeContext elementType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class PointerTypeContext extends ParserRuleContext { public TerminalNode STAR() { return getToken(GobraParser.STAR, 0); } public Type_Context type_() { @@ -11010,13 +11346,13 @@ public T accept(ParseTreeVisitor visitor) { public final PointerTypeContext pointerType() throws RecognitionException { PointerTypeContext _localctx = new PointerTypeContext(_ctx, getState()); - enterRule(_localctx, 306, RULE_pointerType); + enterRule(_localctx, 308, RULE_pointerType); try { enterOuterAlt(_localctx, 1); { - setState(1647); + setState(1677); match(STAR); - setState(1648); + setState(1678); type_(); } } @@ -11031,6 +11367,7 @@ public final PointerTypeContext pointerType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SliceTypeContext extends ParserRuleContext { public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } public TerminalNode R_BRACKET() { return getToken(GobraParser.R_BRACKET, 0); } @@ -11050,15 +11387,15 @@ public T accept(ParseTreeVisitor visitor) { public final SliceTypeContext sliceType() throws RecognitionException { SliceTypeContext _localctx = new SliceTypeContext(_ctx, getState()); - enterRule(_localctx, 308, RULE_sliceType); + enterRule(_localctx, 310, RULE_sliceType); try { enterOuterAlt(_localctx, 1); { - setState(1650); + setState(1680); match(L_BRACKET); - setState(1651); + setState(1681); match(R_BRACKET); - setState(1652); + setState(1682); elementType(); } } @@ -11073,6 +11410,7 @@ public final SliceTypeContext sliceType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MapTypeContext extends ParserRuleContext { public TerminalNode MAP() { return getToken(GobraParser.MAP, 0); } public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } @@ -11096,19 +11434,19 @@ public T accept(ParseTreeVisitor visitor) { public final MapTypeContext mapType() throws RecognitionException { MapTypeContext _localctx = new MapTypeContext(_ctx, getState()); - enterRule(_localctx, 310, RULE_mapType); + enterRule(_localctx, 312, RULE_mapType); try { enterOuterAlt(_localctx, 1); { - setState(1654); + setState(1684); match(MAP); - setState(1655); + setState(1685); match(L_BRACKET); - setState(1656); + setState(1686); type_(); - setState(1657); + setState(1687); match(R_BRACKET); - setState(1658); + setState(1688); elementType(); } } @@ -11123,6 +11461,7 @@ public final MapTypeContext mapType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ChannelTypeContext extends ParserRuleContext { public ElementTypeContext elementType() { return getRuleContext(ElementTypeContext.class,0); @@ -11142,37 +11481,37 @@ public T accept(ParseTreeVisitor visitor) { public final ChannelTypeContext channelType() throws RecognitionException { ChannelTypeContext _localctx = new ChannelTypeContext(_ctx, getState()); - enterRule(_localctx, 312, RULE_channelType); + enterRule(_localctx, 314, RULE_channelType); try { enterOuterAlt(_localctx, 1); { - setState(1665); + setState(1695); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { case 1: { - setState(1660); + setState(1690); match(CHAN); } break; case 2: { - setState(1661); + setState(1691); match(CHAN); - setState(1662); + setState(1692); match(RECEIVE); } break; case 3: { - setState(1663); + setState(1693); match(RECEIVE); - setState(1664); + setState(1694); match(CHAN); } break; } - setState(1667); + setState(1697); elementType(); } } @@ -11187,6 +11526,7 @@ public final ChannelTypeContext channelType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FunctionTypeContext extends ParserRuleContext { public TerminalNode FUNC() { return getToken(GobraParser.FUNC, 0); } public SignatureContext signature() { @@ -11205,13 +11545,13 @@ public T accept(ParseTreeVisitor visitor) { public final FunctionTypeContext functionType() throws RecognitionException { FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState()); - enterRule(_localctx, 314, RULE_functionType); + enterRule(_localctx, 316, RULE_functionType); try { enterOuterAlt(_localctx, 1); { - setState(1669); + setState(1699); match(FUNC); - setState(1670); + setState(1700); signature(); } } @@ -11226,6 +11566,7 @@ public final FunctionTypeContext functionType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class SignatureContext extends ParserRuleContext { public ParametersContext parameters() { return getRuleContext(ParametersContext.class,0); @@ -11246,24 +11587,24 @@ public T accept(ParseTreeVisitor visitor) { public final SignatureContext signature() throws RecognitionException { SignatureContext _localctx = new SignatureContext(_ctx, getState()); - enterRule(_localctx, 316, RULE_signature); + enterRule(_localctx, 318, RULE_signature); try { - setState(1676); + setState(1706); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1672); + setState(1702); parameters(); - setState(1673); + setState(1703); result(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1675); + setState(1705); parameters(); } break; @@ -11280,6 +11621,7 @@ public final SignatureContext signature() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ResultContext extends ParserRuleContext { public ParametersContext parameters() { return getRuleContext(ParametersContext.class,0); @@ -11300,22 +11642,22 @@ public T accept(ParseTreeVisitor visitor) { public final ResultContext result() throws RecognitionException { ResultContext _localctx = new ResultContext(_ctx, getState()); - enterRule(_localctx, 318, RULE_result); + enterRule(_localctx, 320, RULE_result); try { - setState(1680); + setState(1710); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1678); + setState(1708); parameters(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1679); + setState(1709); type_(); } break; @@ -11332,6 +11674,7 @@ public final ResultContext result() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ParametersContext extends ParserRuleContext { public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } public TerminalNode R_PAREN() { return getToken(GobraParser.R_PAREN, 0); } @@ -11358,45 +11701,45 @@ public T accept(ParseTreeVisitor visitor) { public final ParametersContext parameters() throws RecognitionException { ParametersContext _localctx = new ParametersContext(_ctx, getState()); - enterRule(_localctx, 320, RULE_parameters); + enterRule(_localctx, 322, RULE_parameters); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1682); + setState(1712); match(L_PAREN); - setState(1694); + setState(1724); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << DOM) | (1L << ADT) | (1L << PRED))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (FUNC - 77)) | (1L << (INTERFACE - 77)) | (1L << (MAP - 77)) | (1L << (STRUCT - 77)) | (1L << (CHAN - 77)) | (1L << (IDENTIFIER - 77)) | (1L << (L_PAREN - 77)) | (1L << (L_BRACKET - 77)) | (1L << (ELLIPSIS - 77)) | (1L << (STAR - 77)) | (1L << (RECEIVE - 77)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 83350678101032960L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441152431101575619L) != 0)) { { - setState(1683); + setState(1713); parameterDecl(); - setState(1688); + setState(1718); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,164,_ctx); + _alt = getInterpreter().adaptivePredict(_input,170,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1684); + setState(1714); match(COMMA); - setState(1685); + setState(1715); parameterDecl(); } } } - setState(1690); + setState(1720); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,164,_ctx); + _alt = getInterpreter().adaptivePredict(_input,170,_ctx); } - setState(1692); + setState(1722); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1691); + setState(1721); match(COMMA); } } @@ -11404,7 +11747,7 @@ public final ParametersContext parameters() throws RecognitionException { } } - setState(1696); + setState(1726); match(R_PAREN); } } @@ -11419,6 +11762,7 @@ public final ParametersContext parameters() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ConversionContext extends ParserRuleContext { public NonNamedTypeContext nonNamedType() { return getRuleContext(NonNamedTypeContext.class,0); @@ -11442,28 +11786,28 @@ public T accept(ParseTreeVisitor visitor) { public final ConversionContext conversion() throws RecognitionException { ConversionContext _localctx = new ConversionContext(_ctx, getState()); - enterRule(_localctx, 322, RULE_conversion); + enterRule(_localctx, 324, RULE_conversion); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1698); + setState(1728); nonNamedType(); - setState(1699); + setState(1729); match(L_PAREN); - setState(1700); + setState(1730); expression(0); - setState(1702); + setState(1732); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1701); + setState(1731); match(COMMA); } } - setState(1704); + setState(1734); match(R_PAREN); } } @@ -11478,6 +11822,7 @@ public final ConversionContext conversion() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class NonNamedTypeContext extends ParserRuleContext { public TypeLitContext typeLit() { return getRuleContext(TypeLitContext.class,0); @@ -11500,9 +11845,9 @@ public T accept(ParseTreeVisitor visitor) { public final NonNamedTypeContext nonNamedType() throws RecognitionException { NonNamedTypeContext _localctx = new NonNamedTypeContext(_ctx, getState()); - enterRule(_localctx, 324, RULE_nonNamedType); + enterRule(_localctx, 326, RULE_nonNamedType); try { - setState(1711); + setState(1741); _errHandler.sync(this); switch (_input.LA(1)) { case PRED: @@ -11516,18 +11861,18 @@ public final NonNamedTypeContext nonNamedType() throws RecognitionException { case RECEIVE: enterOuterAlt(_localctx, 1); { - setState(1706); + setState(1736); typeLit(); } break; case L_PAREN: enterOuterAlt(_localctx, 2); { - setState(1707); + setState(1737); match(L_PAREN); - setState(1708); + setState(1738); nonNamedType(); - setState(1709); + setState(1739); match(R_PAREN); } break; @@ -11546,6 +11891,7 @@ public final NonNamedTypeContext nonNamedType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OperandContext extends ParserRuleContext { public LiteralContext literal() { return getRuleContext(LiteralContext.class,0); @@ -11571,33 +11917,33 @@ public T accept(ParseTreeVisitor visitor) { public final OperandContext operand() throws RecognitionException { OperandContext _localctx = new OperandContext(_ctx, getState()); - enterRule(_localctx, 326, RULE_operand); + enterRule(_localctx, 328, RULE_operand); try { - setState(1719); + setState(1749); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1713); + setState(1743); literal(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1714); + setState(1744); operandName(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1715); + setState(1745); match(L_PAREN); - setState(1716); + setState(1746); expression(0); - setState(1717); + setState(1747); match(R_PAREN); } break; @@ -11614,6 +11960,7 @@ public final OperandContext operand() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LiteralContext extends ParserRuleContext { public BasicLitContext basicLit() { return getRuleContext(BasicLitContext.class,0); @@ -11637,9 +11984,9 @@ public T accept(ParseTreeVisitor visitor) { public final LiteralContext literal() throws RecognitionException { LiteralContext _localctx = new LiteralContext(_ctx, getState()); - enterRule(_localctx, 328, RULE_literal); + enterRule(_localctx, 330, RULE_literal); try { - setState(1724); + setState(1754); _errHandler.sync(this); switch (_input.LA(1)) { case FLOAT_LIT: @@ -11656,7 +12003,7 @@ public final LiteralContext literal() throws RecognitionException { case INTERPRETED_STRING_LIT: enterOuterAlt(_localctx, 1); { - setState(1721); + setState(1751); basicLit(); } break; @@ -11674,7 +12021,7 @@ public final LiteralContext literal() throws RecognitionException { case L_BRACKET: enterOuterAlt(_localctx, 2); { - setState(1722); + setState(1752); compositeLit(); } break; @@ -11687,7 +12034,7 @@ public final LiteralContext literal() throws RecognitionException { case FUNC: enterOuterAlt(_localctx, 3); { - setState(1723); + setState(1753); functionLit(); } break; @@ -11706,6 +12053,7 @@ public final LiteralContext literal() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class IntegerContext extends ParserRuleContext { public TerminalNode DECIMAL_LIT() { return getToken(GobraParser.DECIMAL_LIT, 0); } public TerminalNode BINARY_LIT() { return getToken(GobraParser.BINARY_LIT, 0); } @@ -11726,14 +12074,14 @@ public T accept(ParseTreeVisitor visitor) { public final IntegerContext integer() throws RecognitionException { IntegerContext _localctx = new IntegerContext(_ctx, getState()); - enterRule(_localctx, 330, RULE_integer); + enterRule(_localctx, 332, RULE_integer); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1726); + setState(1756); _la = _input.LA(1); - if ( !(((((_la - 138)) & ~0x3f) == 0 && ((1L << (_la - 138)) & ((1L << (DECIMAL_LIT - 138)) | (1L << (BINARY_LIT - 138)) | (1L << (OCTAL_LIT - 138)) | (1L << (HEX_LIT - 138)) | (1L << (IMAGINARY_LIT - 138)) | (1L << (RUNE_LIT - 138)))) != 0)) ) { + if ( !(((((_la - 138)) & ~0x3f) == 0 && ((1L << (_la - 138)) & 111L) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -11754,6 +12102,7 @@ public final IntegerContext integer() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class OperandNameContext extends ParserRuleContext { public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } public OperandNameContext(ParserRuleContext parent, int invokingState) { @@ -11769,11 +12118,11 @@ public T accept(ParseTreeVisitor visitor) { public final OperandNameContext operandName() throws RecognitionException { OperandNameContext _localctx = new OperandNameContext(_ctx, getState()); - enterRule(_localctx, 332, RULE_operandName); + enterRule(_localctx, 334, RULE_operandName); try { enterOuterAlt(_localctx, 1); { - setState(1728); + setState(1758); match(IDENTIFIER); } } @@ -11788,6 +12137,7 @@ public final OperandNameContext operandName() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class QualifiedIdentContext extends ParserRuleContext { public List IDENTIFIER() { return getTokens(GobraParser.IDENTIFIER); } public TerminalNode IDENTIFIER(int i) { @@ -11807,15 +12157,15 @@ public T accept(ParseTreeVisitor visitor) { public final QualifiedIdentContext qualifiedIdent() throws RecognitionException { QualifiedIdentContext _localctx = new QualifiedIdentContext(_ctx, getState()); - enterRule(_localctx, 334, RULE_qualifiedIdent); + enterRule(_localctx, 336, RULE_qualifiedIdent); try { enterOuterAlt(_localctx, 1); { - setState(1730); + setState(1760); match(IDENTIFIER); - setState(1731); + setState(1761); match(DOT); - setState(1732); + setState(1762); match(IDENTIFIER); } } @@ -11830,6 +12180,7 @@ public final QualifiedIdentContext qualifiedIdent() throws RecognitionException return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class CompositeLitContext extends ParserRuleContext { public LiteralTypeContext literalType() { return getRuleContext(LiteralTypeContext.class,0); @@ -11850,13 +12201,13 @@ public T accept(ParseTreeVisitor visitor) { public final CompositeLitContext compositeLit() throws RecognitionException { CompositeLitContext _localctx = new CompositeLitContext(_ctx, getState()); - enterRule(_localctx, 336, RULE_compositeLit); + enterRule(_localctx, 338, RULE_compositeLit); try { enterOuterAlt(_localctx, 1); { - setState(1734); + setState(1764); literalType(); - setState(1735); + setState(1765); literalValue(); } } @@ -11871,6 +12222,7 @@ public final CompositeLitContext compositeLit() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class LiteralValueContext extends ParserRuleContext { public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } public TerminalNode R_CURLY() { return getToken(GobraParser.R_CURLY, 0); } @@ -11891,26 +12243,26 @@ public T accept(ParseTreeVisitor visitor) { public final LiteralValueContext literalValue() throws RecognitionException { LiteralValueContext _localctx = new LiteralValueContext(_ctx, getState()); - enterRule(_localctx, 338, RULE_literalValue); + enterRule(_localctx, 340, RULE_literalValue); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1737); + setState(1767); match(L_CURLY); - setState(1742); + setState(1772); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_CURLY - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2990104391687L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1738); + setState(1768); elementList(); - setState(1740); + setState(1770); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1739); + setState(1769); match(COMMA); } } @@ -11918,7 +12270,7 @@ public final LiteralValueContext literalValue() throws RecognitionException { } } - setState(1744); + setState(1774); match(R_CURLY); } } @@ -11933,6 +12285,7 @@ public final LiteralValueContext literalValue() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ElementListContext extends ParserRuleContext { public List keyedElement() { return getRuleContexts(KeyedElementContext.class); @@ -11957,30 +12310,30 @@ public T accept(ParseTreeVisitor visitor) { public final ElementListContext elementList() throws RecognitionException { ElementListContext _localctx = new ElementListContext(_ctx, getState()); - enterRule(_localctx, 340, RULE_elementList); + enterRule(_localctx, 342, RULE_elementList); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1746); + setState(1776); keyedElement(); - setState(1751); + setState(1781); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,173,_ctx); + _alt = getInterpreter().adaptivePredict(_input,179,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1747); + setState(1777); match(COMMA); - setState(1748); + setState(1778); keyedElement(); } } } - setState(1753); + setState(1783); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,173,_ctx); + _alt = getInterpreter().adaptivePredict(_input,179,_ctx); } } } @@ -11995,6 +12348,7 @@ public final ElementListContext elementList() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class KeyedElementContext extends ParserRuleContext { public ElementContext element() { return getRuleContext(ElementContext.class,0); @@ -12016,23 +12370,23 @@ public T accept(ParseTreeVisitor visitor) { public final KeyedElementContext keyedElement() throws RecognitionException { KeyedElementContext _localctx = new KeyedElementContext(_ctx, getState()); - enterRule(_localctx, 342, RULE_keyedElement); + enterRule(_localctx, 344, RULE_keyedElement); try { enterOuterAlt(_localctx, 1); { - setState(1757); + setState(1787); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) { case 1: { - setState(1754); + setState(1784); key(); - setState(1755); + setState(1785); match(COLON); } break; } - setState(1759); + setState(1789); element(); } } @@ -12047,6 +12401,7 @@ public final KeyedElementContext keyedElement() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class KeyContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -12067,9 +12422,9 @@ public T accept(ParseTreeVisitor visitor) { public final KeyContext key() throws RecognitionException { KeyContext _localctx = new KeyContext(_ctx, getState()); - enterRule(_localctx, 344, RULE_key); + enterRule(_localctx, 346, RULE_key); try { - setState(1763); + setState(1793); _errHandler.sync(this); switch (_input.LA(1)) { case FLOAT_LIT: @@ -12137,14 +12492,14 @@ public final KeyContext key() throws RecognitionException { case INTERPRETED_STRING_LIT: enterOuterAlt(_localctx, 1); { - setState(1761); + setState(1791); expression(0); } break; case L_CURLY: enterOuterAlt(_localctx, 2); { - setState(1762); + setState(1792); literalValue(); } break; @@ -12163,6 +12518,7 @@ public final KeyContext key() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ElementContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); @@ -12183,9 +12539,9 @@ public T accept(ParseTreeVisitor visitor) { public final ElementContext element() throws RecognitionException { ElementContext _localctx = new ElementContext(_ctx, getState()); - enterRule(_localctx, 346, RULE_element); + enterRule(_localctx, 348, RULE_element); try { - setState(1767); + setState(1797); _errHandler.sync(this); switch (_input.LA(1)) { case FLOAT_LIT: @@ -12253,14 +12609,14 @@ public final ElementContext element() throws RecognitionException { case INTERPRETED_STRING_LIT: enterOuterAlt(_localctx, 1); { - setState(1765); + setState(1795); expression(0); } break; case L_CURLY: enterOuterAlt(_localctx, 2); { - setState(1766); + setState(1796); literalValue(); } break; @@ -12279,6 +12635,7 @@ public final ElementContext element() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class StructTypeContext extends ParserRuleContext { public TerminalNode STRUCT() { return getToken(GobraParser.STRUCT, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } @@ -12308,32 +12665,32 @@ public T accept(ParseTreeVisitor visitor) { public final StructTypeContext structType() throws RecognitionException { StructTypeContext _localctx = new StructTypeContext(_ctx, getState()); - enterRule(_localctx, 348, RULE_structType); + enterRule(_localctx, 350, RULE_structType); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1769); + setState(1799); match(STRUCT); - setState(1770); + setState(1800); match(L_CURLY); - setState(1776); + setState(1806); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER || _la==STAR) { { { - setState(1771); + setState(1801); fieldDecl(); - setState(1772); + setState(1802); eos(); } } - setState(1778); + setState(1808); _errHandler.sync(this); _la = _input.LA(1); } - setState(1779); + setState(1809); match(R_CURLY); } } @@ -12348,6 +12705,7 @@ public final StructTypeContext structType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class FieldDeclContext extends ParserRuleContext { public String_Context tag; public IdentifierListContext identifierList() { @@ -12375,34 +12733,34 @@ public T accept(ParseTreeVisitor visitor) { public final FieldDeclContext fieldDecl() throws RecognitionException { FieldDeclContext _localctx = new FieldDeclContext(_ctx, getState()); - enterRule(_localctx, 350, RULE_fieldDecl); + enterRule(_localctx, 352, RULE_fieldDecl); try { enterOuterAlt(_localctx, 1); { - setState(1785); + setState(1815); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { case 1: { - setState(1781); + setState(1811); identifierList(); - setState(1782); + setState(1812); type_(); } break; case 2: { - setState(1784); + setState(1814); embeddedField(); } break; } - setState(1788); + setState(1818); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { case 1: { - setState(1787); + setState(1817); ((FieldDeclContext)_localctx).tag = string_(); } break; @@ -12420,6 +12778,7 @@ public final FieldDeclContext fieldDecl() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class String_Context extends ParserRuleContext { public TerminalNode RAW_STRING_LIT() { return getToken(GobraParser.RAW_STRING_LIT, 0); } public TerminalNode INTERPRETED_STRING_LIT() { return getToken(GobraParser.INTERPRETED_STRING_LIT, 0); } @@ -12436,12 +12795,12 @@ public T accept(ParseTreeVisitor visitor) { public final String_Context string_() throws RecognitionException { String_Context _localctx = new String_Context(_ctx, getState()); - enterRule(_localctx, 352, RULE_string_); + enterRule(_localctx, 354, RULE_string_); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1790); + setState(1820); _la = _input.LA(1); if ( !(_la==RAW_STRING_LIT || _la==INTERPRETED_STRING_LIT) ) { _errHandler.recoverInline(this); @@ -12464,6 +12823,7 @@ public final String_Context string_() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EmbeddedFieldContext extends ParserRuleContext { public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); @@ -12482,22 +12842,22 @@ public T accept(ParseTreeVisitor visitor) { public final EmbeddedFieldContext embeddedField() throws RecognitionException { EmbeddedFieldContext _localctx = new EmbeddedFieldContext(_ctx, getState()); - enterRule(_localctx, 354, RULE_embeddedField); + enterRule(_localctx, 356, RULE_embeddedField); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1793); + setState(1823); _errHandler.sync(this); _la = _input.LA(1); if (_la==STAR) { { - setState(1792); + setState(1822); match(STAR); } } - setState(1795); + setState(1825); typeName(); } } @@ -12512,6 +12872,7 @@ public final EmbeddedFieldContext embeddedField() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class IndexContext extends ParserRuleContext { public TerminalNode L_BRACKET() { return getToken(GobraParser.L_BRACKET, 0); } public ExpressionContext expression() { @@ -12531,15 +12892,15 @@ public T accept(ParseTreeVisitor visitor) { public final IndexContext index() throws RecognitionException { IndexContext _localctx = new IndexContext(_ctx, getState()); - enterRule(_localctx, 356, RULE_index); + enterRule(_localctx, 358, RULE_index); try { enterOuterAlt(_localctx, 1); { - setState(1797); + setState(1827); match(L_BRACKET); - setState(1798); + setState(1828); expression(0); - setState(1799); + setState(1829); match(R_BRACKET); } } @@ -12554,6 +12915,7 @@ public final IndexContext index() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class TypeAssertionContext extends ParserRuleContext { public TerminalNode DOT() { return getToken(GobraParser.DOT, 0); } public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } @@ -12574,17 +12936,17 @@ public T accept(ParseTreeVisitor visitor) { public final TypeAssertionContext typeAssertion() throws RecognitionException { TypeAssertionContext _localctx = new TypeAssertionContext(_ctx, getState()); - enterRule(_localctx, 358, RULE_typeAssertion); + enterRule(_localctx, 360, RULE_typeAssertion); try { enterOuterAlt(_localctx, 1); { - setState(1801); + setState(1831); match(DOT); - setState(1802); + setState(1832); match(L_PAREN); - setState(1803); + setState(1833); type_(); - setState(1804); + setState(1834); match(R_PAREN); } } @@ -12599,6 +12961,7 @@ public final TypeAssertionContext typeAssertion() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ArgumentsContext extends ParserRuleContext { public TerminalNode L_PAREN() { return getToken(GobraParser.L_PAREN, 0); } public TerminalNode R_PAREN() { return getToken(GobraParser.R_PAREN, 0); } @@ -12626,39 +12989,39 @@ public T accept(ParseTreeVisitor visitor) { public final ArgumentsContext arguments() throws RecognitionException { ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); - enterRule(_localctx, 360, RULE_arguments); + enterRule(_localctx, 362, RULE_arguments); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1806); + setState(1836); match(L_PAREN); - setState(1821); + setState(1851); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FLOAT_LIT) | (1L << TRUE) | (1L << FALSE) | (1L << PRE) | (1L << PRESERVES) | (1L << POST) | (1L << DEC) | (1L << PURE) | (1L << OLD) | (1L << BEFORE) | (1L << FORALL) | (1L << EXISTS) | (1L << ACCESS) | (1L << UNFOLDING) | (1L << LET) | (1L << GHOST) | (1L << SEQ) | (1L << SET) | (1L << MSET) | (1L << DICT) | (1L << OPT) | (1L << LEN) | (1L << NEW) | (1L << MAKE) | (1L << CAP) | (1L << SOME) | (1L << GET) | (1L << DOM) | (1L << ADT) | (1L << MATCH) | (1L << NONE) | (1L << PRED) | (1L << TYPE_OF) | (1L << IS_COMPARABLE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (WRITEPERM - 65)) | (1L << (NOPERM - 65)) | (1L << (TRUSTED - 65)) | (1L << (FUNC - 65)) | (1L << (INTERFACE - 65)) | (1L << (MAP - 65)) | (1L << (STRUCT - 65)) | (1L << (CHAN - 65)) | (1L << (RANGE - 65)) | (1L << (TYPE - 65)) | (1L << (NIL_LIT - 65)) | (1L << (IDENTIFIER - 65)) | (1L << (L_PAREN - 65)) | (1L << (L_BRACKET - 65)))) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & ((1L << (EXCLAMATION - 131)) | (1L << (PLUS - 131)) | (1L << (MINUS - 131)) | (1L << (CARET - 131)) | (1L << (STAR - 131)) | (1L << (AMPERSAND - 131)) | (1L << (RECEIVE - 131)) | (1L << (DECIMAL_LIT - 131)) | (1L << (BINARY_LIT - 131)) | (1L << (OCTAL_LIT - 131)) | (1L << (HEX_LIT - 131)) | (1L << (IMAGINARY_LIT - 131)) | (1L << (RUNE_LIT - 131)) | (1L << (RAW_STRING_LIT - 131)) | (1L << (INTERPRETED_STRING_LIT - 131)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1813); + setState(1843); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) { case 1: { - setState(1807); + setState(1837); expressionList(); } break; case 2: { - setState(1808); + setState(1838); nonNamedType(); - setState(1811); + setState(1841); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,187,_ctx) ) { case 1: { - setState(1809); + setState(1839); match(COMMA); - setState(1810); + setState(1840); expressionList(); } break; @@ -12666,22 +13029,22 @@ public final ArgumentsContext arguments() throws RecognitionException { } break; } - setState(1816); + setState(1846); _errHandler.sync(this); _la = _input.LA(1); if (_la==ELLIPSIS) { { - setState(1815); + setState(1845); match(ELLIPSIS); } } - setState(1819); + setState(1849); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1818); + setState(1848); match(COMMA); } } @@ -12689,7 +13052,7 @@ public final ArgumentsContext arguments() throws RecognitionException { } } - setState(1823); + setState(1853); match(R_PAREN); } } @@ -12704,6 +13067,7 @@ public final ArgumentsContext arguments() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class MethodExprContext extends ParserRuleContext { public NonNamedTypeContext nonNamedType() { return getRuleContext(NonNamedTypeContext.class,0); @@ -12723,15 +13087,15 @@ public T accept(ParseTreeVisitor visitor) { public final MethodExprContext methodExpr() throws RecognitionException { MethodExprContext _localctx = new MethodExprContext(_ctx, getState()); - enterRule(_localctx, 362, RULE_methodExpr); + enterRule(_localctx, 364, RULE_methodExpr); try { enterOuterAlt(_localctx, 1); { - setState(1825); + setState(1855); nonNamedType(); - setState(1826); + setState(1856); match(DOT); - setState(1827); + setState(1857); match(IDENTIFIER); } } @@ -12746,6 +13110,7 @@ public final MethodExprContext methodExpr() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class ReceiverTypeContext extends ParserRuleContext { public Type_Context type_() { return getRuleContext(Type_Context.class,0); @@ -12763,11 +13128,11 @@ public T accept(ParseTreeVisitor visitor) { public final ReceiverTypeContext receiverType() throws RecognitionException { ReceiverTypeContext _localctx = new ReceiverTypeContext(_ctx, getState()); - enterRule(_localctx, 364, RULE_receiverType); + enterRule(_localctx, 366, RULE_receiverType); try { enterOuterAlt(_localctx, 1); { - setState(1829); + setState(1859); type_(); } } @@ -12782,6 +13147,7 @@ public final ReceiverTypeContext receiverType() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") public static class EosContext extends ParserRuleContext { public TerminalNode SEMI() { return getToken(GobraParser.SEMI, 0); } public TerminalNode EOF() { return getToken(GobraParser.EOF, 0); } @@ -12799,37 +13165,37 @@ public T accept(ParseTreeVisitor visitor) { public final EosContext eos() throws RecognitionException { EosContext _localctx = new EosContext(_ctx, getState()); - enterRule(_localctx, 366, RULE_eos); + enterRule(_localctx, 368, RULE_eos); try { - setState(1835); + setState(1865); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1831); + setState(1861); match(SEMI); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1832); + setState(1862); match(EOF); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1833); + setState(1863); match(EOS); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1834); - if (!(closingBracket())) throw new FailedPredicateException(this, "closingBracket()"); + setState(1864); + if (!(this.closingBracket())) throw new FailedPredicateException(this, "this.closingBracket()"); } break; } @@ -12847,11 +13213,13 @@ public final EosContext eos() throws RecognitionException { public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { switch (ruleIndex) { - case 81: + case 82: return expression_sempred((ExpressionContext)_localctx, predIndex); - case 89: + case 90: return primaryExpr_sempred((PrimaryExprContext)_localctx, predIndex); - case 183: + case 120: + return statementList_sempred((StatementListContext)_localctx, predIndex); + case 184: return eos_sempred((EosContext)_localctx, predIndex); } return true; @@ -12902,751 +13270,1222 @@ private boolean primaryExpr_sempred(PrimaryExprContext _localctx, int predIndex) } return true; } - private boolean eos_sempred(EosContext _localctx, int predIndex) { + private boolean statementList_sempred(StatementListContext _localctx, int predIndex) { switch (predIndex) { case 18: - return closingBracket(); + return this.closingBracket(); + } + return true; + } + private boolean eos_sempred(EosContext _localctx, int predIndex) { + switch (predIndex) { + case 19: + return this.closingBracket(); } return true; } public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00a2\u0730\4\2\t"+ - "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ - "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ - "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ - "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ - "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ - "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ - "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ - "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ - "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+ - "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+ - "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+ - "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+ - "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+ - "\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+ - "\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+ - "\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+ - "\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\3\2\3\2\3\2\3\3\3\3\3"+ - "\3\3\4\3\4\3\4\3\5\3\5\3\5\7\5\u017f\n\5\f\5\16\5\u0182\13\5\3\6\3\6\5"+ - "\6\u0186\n\6\3\7\3\7\3\7\7\7\u018b\n\7\f\7\16\7\u018e\13\7\3\7\3\7\3\7"+ - "\3\7\3\7\7\7\u0195\n\7\f\7\16\7\u0198\13\7\3\7\3\7\3\7\5\7\u019d\n\7\3"+ - "\7\3\7\7\7\u01a1\n\7\f\7\16\7\u01a4\13\7\3\7\3\7\3\b\3\b\3\b\3\t\3\t\3"+ - "\t\3\n\3\n\3\n\7\n\u01b1\n\n\f\n\16\n\u01b4\13\n\3\n\5\n\u01b7\n\n\3\n"+ - "\3\n\3\13\3\13\3\13\7\13\u01be\n\13\f\13\16\13\u01c1\13\13\3\13\3\13\3"+ - "\13\3\13\3\13\3\13\3\13\7\13\u01ca\n\13\f\13\16\13\u01cd\13\13\3\13\5"+ - "\13\u01d0\n\13\3\f\3\f\3\f\3\f\5\f\u01d6\n\f\3\r\3\r\3\r\3\r\3\r\3\r\3"+ - "\r\5\r\u01df\n\r\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20\5\20\u01e9\n"+ - "\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3"+ - "\21\3\21\5\21\u01fa\n\21\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\3\24"+ - "\3\24\7\24\u0206\n\24\f\24\16\24\u0209\13\24\3\24\5\24\u020c\n\24\3\25"+ - "\3\25\3\25\7\25\u0211\n\25\f\25\16\25\u0214\13\25\3\25\3\25\3\26\7\26"+ - "\u0219\n\26\f\26\16\26\u021c\13\26\3\27\3\27\3\27\3\27\7\27\u0222\n\27"+ - "\f\27\16\27\u0225\13\27\3\27\3\27\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3"+ - "\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3"+ - "\34\3\35\3\35\3\35\3\35\3\35\5\35\u0244\n\35\3\35\3\35\3\35\3\35\3\36"+ - "\3\36\5\36\u024c\n\36\3\37\3\37\3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3\"\3\""+ - "\3\"\3\"\3\"\3#\3#\3#\3#\3#\5#\u0264\n#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%"+ - "\3%\3%\3%\3%\3%\7%\u0275\n%\f%\16%\u0278\13%\3%\3%\3&\3&\3&\3&\3\'\3\'"+ - "\3\'\3\'\7\'\u0284\n\'\f\'\16\'\u0287\13\'\3\'\3\'\3(\3(\3(\3(\3)\3)\3"+ - ")\3)\5)\u0293\n)\3*\3*\3*\3*\3*\7*\u029a\n*\f*\16*\u029d\13*\3*\3*\3+"+ - "\3+\3+\3+\3+\3+\3+\3+\3+\5+\u02aa\n+\3,\3,\3,\3,\3,\7,\u02b1\n,\f,\16"+ - ",\u02b4\13,\3,\3,\3-\3-\3-\3-\3-\7-\u02bd\n-\f-\16-\u02c0\13-\3-\3-\3"+ - ".\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u02d4\n/\3\60\3\60\3"+ - "\60\3\60\3\60\5\60\u02db\n\60\3\60\7\60\u02de\n\60\f\60\16\60\u02e1\13"+ - "\60\3\60\3\60\5\60\u02e5\n\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ - "\5\61\u02ef\n\61\3\62\5\62\u02f2\n\62\3\62\3\62\5\62\u02f6\n\62\3\63\3"+ - "\63\5\63\u02fa\n\63\3\64\3\64\3\64\3\64\7\64\u0300\n\64\f\64\16\64\u0303"+ - "\13\64\3\64\3\64\3\65\3\65\3\65\5\65\u030a\n\65\3\66\3\66\3\66\5\66\u030f"+ - "\n\66\3\67\3\67\3\67\3\67\3\67\3\67\5\67\u0317\n\67\5\67\u0319\n\67\3"+ - "\67\3\67\3\67\5\67\u031e\n\67\38\38\38\78\u0323\n8\f8\168\u0326\138\3"+ - "9\39\39\39\39\59\u032d\n9\39\59\u0330\n9\39\39\3:\3:\5:\u0336\n:\3:\3"+ - ":\3:\5:\u033b\n:\5:\u033d\n:\3:\5:\u0340\n:\3;\3;\3;\7;\u0345\n;\f;\16"+ - ";\u0348\13;\3<\3<\5<\u034c\n<\3<\3<\3=\3=\3=\3=\3=\3=\3>\3>\3>\3>\3>\3"+ - ">\3>\7>\u035d\n>\f>\16>\u0360\13>\3>\3>\3>\7>\u0365\n>\f>\16>\u0368\13"+ - ">\3>\5>\u036b\n>\3?\5?\u036e\n?\3?\3?\3?\3?\5?\u0374\n?\3@\3@\5@\u0378"+ - "\n@\3@\5@\u037b\n@\3@\3@\3@\3A\3A\3A\3A\3A\5A\u0385\nA\3B\3B\3B\3B\3B"+ - "\5B\u038c\nB\3C\3C\3C\3C\3C\5C\u0393\nC\3C\3C\3D\3D\3D\3D\3D\3E\3E\3E"+ - "\5E\u039f\nE\3F\3F\3F\3F\5F\u03a5\nF\3G\3G\3G\3G\3G\5G\u03ac\nG\3H\3H"+ - "\3H\5H\u03b1\nH\3I\3I\3I\3I\5I\u03b7\nI\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K"+ - "\5K\u03c3\nK\3L\3L\3L\3L\5L\u03c9\nL\3L\3L\5L\u03cd\nL\3M\3M\3M\3M\3N"+ - "\3N\5N\u03d5\nN\3N\3N\5N\u03d9\nN\3N\3N\3O\3O\5O\u03df\nO\3P\5P\u03e2"+ - "\nP\3P\3P\3Q\3Q\5Q\u03e8\nQ\3Q\3Q\3R\5R\u03ed\nR\3R\3R\3S\3S\3S\3S\3S"+ - "\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\5S\u0406\nS\3S\3S\3S"+ - "\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S"+ - "\3S\3S\3S\3S\3S\3S\3S\7S\u0429\nS\fS\16S\u042c\13S\3T\3T\3T\3T\3T\3T\3"+ - "T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\5T\u0442\nT\3U\3U\3U\3V\3V\3"+ - "V\5V\u044a\nV\3W\3W\3W\3X\3X\3X\3X\7X\u0453\nX\fX\16X\u0456\13X\3X\3X"+ - "\3X\3X\5X\u045c\nX\3Y\3Y\3Y\3Y\3Y\5Y\u0463\nY\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z"+ - "\5Z\u046d\nZ\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\5[\u047b\n[\3[\3[\3["+ - "\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\3[\7[\u0491\n[\f[\16"+ - "[\u0494\13[\3\\\3\\\3\\\3]\3]\5]\u049b\n]\3]\3]\5]\u049f\n]\3^\3^\5^\u04a3"+ - "\n^\3^\5^\u04a6\n^\3^\3^\3_\3_\3_\3_\3_\5_\u04af\n_\3_\3_\7_\u04b3\n_"+ - "\f_\16_\u04b6\13_\3_\3_\3`\3`\3`\3`\3a\5a\u04bf\na\3a\3a\3a\3a\3a\3a\5"+ - "a\u04c7\na\3a\3a\3a\3a\5a\u04cd\na\3b\3b\3b\3b\3b\3b\3b\5b\u04d6\nb\3"+ - "c\3c\3c\3c\3c\3c\3c\3c\3c\5c\u04e1\nc\3d\3d\3d\3e\3e\3e\3e\7e\u04ea\n"+ - "e\fe\16e\u04ed\13e\3e\5e\u04f0\ne\5e\u04f2\ne\3e\3e\3f\3f\3f\3f\3f\3f"+ - "\3f\5f\u04fd\nf\3g\3g\3g\3g\3g\3h\3h\5h\u0506\nh\3h\3h\5h\u050a\nh\3h"+ - "\5h\u050d\nh\3h\3h\3h\3h\3h\5h\u0514\nh\3h\3h\3i\3i\3j\3j\3k\3k\3l\5l"+ - "\u051f\nl\3l\3l\3m\3m\3m\3m\3m\3m\5m\u0529\nm\3m\3m\3m\3m\5m\u052f\nm"+ - "\5m\u0531\nm\3n\3n\3n\3o\3o\3p\3p\3p\5p\u053b\np\3q\3q\3q\3q\3q\3q\7q"+ - "\u0543\nq\fq\16q\u0546\13q\3q\5q\u0549\nq\3r\3r\5r\u054d\nr\3r\3r\5r\u0551"+ - "\nr\3s\3s\3s\7s\u0556\ns\fs\16s\u0559\13s\3t\3t\3t\7t\u055e\nt\ft\16t"+ - "\u0561\13t\3u\3u\3u\3u\3u\3u\7u\u0569\nu\fu\16u\u056c\13u\3u\5u\u056f"+ - "\nu\3v\3v\5v\u0573\nv\3v\3v\3w\3w\3w\3w\3w\3w\7w\u057d\nw\fw\16w\u0580"+ - "\13w\3w\5w\u0583\nw\3x\3x\5x\u0587\nx\3x\3x\3y\5y\u058c\ny\3y\3y\3y\6"+ - "y\u0591\ny\ry\16y\u0592\3z\3z\3z\3z\3z\5z\u059a\nz\3{\3{\3|\3|\3|\3|\3"+ - "}\3}\3}\3~\3~\3~\3~\3\177\3\177\3\u0080\3\u0080\3\u0080\5\u0080\u05ae"+ - "\n\u0080\3\u0081\3\u0081\5\u0081\u05b2\n\u0081\3\u0082\3\u0082\5\u0082"+ - "\u05b6\n\u0082\3\u0083\3\u0083\5\u0083\u05ba\n\u0083\3\u0084\3\u0084\3"+ - "\u0084\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086"+ - "\3\u0086\3\u0086\3\u0086\5\u0086\u05ca\n\u0086\3\u0086\3\u0086\3\u0086"+ - "\3\u0086\5\u0086\u05d0\n\u0086\5\u0086\u05d2\n\u0086\3\u0087\3\u0087\5"+ - "\u0087\u05d6\n\u0087\3\u0088\3\u0088\5\u0088\u05da\n\u0088\3\u0088\5\u0088"+ - "\u05dd\n\u0088\3\u0088\3\u0088\5\u0088\u05e1\n\u0088\5\u0088\u05e3\n\u0088"+ - "\3\u0088\3\u0088\7\u0088\u05e7\n\u0088\f\u0088\16\u0088\u05ea\13\u0088"+ - "\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\5\u0089\u05f1\n\u0089\3\u008a"+ - "\3\u008a\3\u008a\5\u008a\u05f6\n\u008a\3\u008b\3\u008b\3\u008b\3\u008b"+ - "\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\5\u008b\u0601\n\u008b\3\u008b"+ - "\3\u008b\7\u008b\u0605\n\u008b\f\u008b\16\u008b\u0608\13\u008b\3\u008b"+ - "\3\u008b\3\u008c\3\u008c\5\u008c\u060e\n\u008c\3\u008c\3\u008c\3\u008c"+ - "\3\u008c\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d\5\u008d\u0619\n\u008d"+ - "\3\u008e\3\u008e\3\u008e\5\u008e\u061e\n\u008e\3\u008f\3\u008f\5\u008f"+ - "\u0622\n\u008f\3\u008f\3\u008f\3\u008f\5\u008f\u0627\n\u008f\7\u008f\u0629"+ - "\n\u008f\f\u008f\16\u008f\u062c\13\u008f\3\u0090\3\u0090\3\u0090\7\u0090"+ - "\u0631\n\u0090\f\u0090\16\u0090\u0634\13\u0090\3\u0090\3\u0090\3\u0091"+ - "\3\u0091\3\u0091\5\u0091\u063b\n\u0091\3\u0092\3\u0092\3\u0092\5\u0092"+ - "\u0640\n\u0092\3\u0092\5\u0092\u0643\n\u0092\3\u0093\3\u0093\3\u0093\3"+ - "\u0093\3\u0093\3\u0093\5\u0093\u064b\n\u0093\3\u0093\3\u0093\3\u0094\3"+ - "\u0094\3\u0094\3\u0094\5\u0094\u0653\n\u0094\3\u0094\3\u0094\3\u0095\5"+ - "\u0095\u0658\n\u0095\3\u0095\3\u0095\5\u0095\u065c\n\u0095\3\u0095\3\u0095"+ - "\5\u0095\u0660\n\u0095\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097\5\u0097"+ - "\u0667\n\u0097\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099"+ - "\3\u009a\3\u009a\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c\3\u009c"+ - "\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3\u009e\3\u009e"+ - "\3\u009e\3\u009e\5\u009e\u0684\n\u009e\3\u009e\3\u009e\3\u009f\3\u009f"+ - "\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u068f\n\u00a0\3\u00a1"+ - "\3\u00a1\5\u00a1\u0693\n\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\7\u00a2"+ - "\u0699\n\u00a2\f\u00a2\16\u00a2\u069c\13\u00a2\3\u00a2\5\u00a2\u069f\n"+ - "\u00a2\5\u00a2\u06a1\n\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a3\3"+ - "\u00a3\5\u00a3\u06a9\n\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3"+ - "\u00a4\3\u00a4\5\u00a4\u06b2\n\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3"+ - "\u00a5\3\u00a5\5\u00a5\u06ba\n\u00a5\3\u00a6\3\u00a6\3\u00a6\5\u00a6\u06bf"+ - "\n\u00a6\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a9\3\u00a9\3\u00a9\3\u00a9"+ - "\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u06cf\n\u00ab"+ - "\5\u00ab\u06d1\n\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac\7\u00ac"+ - "\u06d8\n\u00ac\f\u00ac\16\u00ac\u06db\13\u00ac\3\u00ad\3\u00ad\3\u00ad"+ - "\5\u00ad\u06e0\n\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\5\u00ae\u06e6\n"+ - "\u00ae\3\u00af\3\u00af\5\u00af\u06ea\n\u00af\3\u00b0\3\u00b0\3\u00b0\3"+ - "\u00b0\3\u00b0\7\u00b0\u06f1\n\u00b0\f\u00b0\16\u00b0\u06f4\13\u00b0\3"+ - "\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b1\3\u00b1\5\u00b1\u06fc\n\u00b1\3"+ - "\u00b1\5\u00b1\u06ff\n\u00b1\3\u00b2\3\u00b2\3\u00b3\5\u00b3\u0704\n\u00b3"+ - "\3\u00b3\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5\3\u00b5"+ - "\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u0716"+ - "\n\u00b6\5\u00b6\u0718\n\u00b6\3\u00b6\5\u00b6\u071b\n\u00b6\3\u00b6\5"+ - "\u00b6\u071e\n\u00b6\5\u00b6\u0720\n\u00b6\3\u00b6\3\u00b6\3\u00b7\3\u00b7"+ - "\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\5\u00b9"+ - "\u072e\n\u00b9\3\u00b9\3\u02df\4\u00a4\u00b4\u00ba\2\4\6\b\n\f\16\20\22"+ - "\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnp"+ - "rtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094"+ - "\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac"+ - "\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4"+ - "\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc"+ - "\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4"+ - "\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c"+ - "\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124"+ - "\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c"+ - "\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154"+ - "\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c"+ - "\u016e\u0170\2\25\4\2ggrr\3\2\31\32\3\2\7\n\3\2CD\3\2*,\4\2*,..\3\2\u0085"+ - "\u008b\3\2\26\27\4\2\u0080\u0084\u0089\u008a\6\2%%ss\177\177\u0086\u0088"+ - "\3\2!#\3\2\36 \4\2JKy~\6\2//\62\62\65\65__\4\2\177\u0084\u0086\u008a\3"+ - "\2st\4\2pp\u00a1\u00a1\4\2\u008c\u008f\u0091\u0092\3\2\u0098\u0099\2\u0794"+ - "\2\u0172\3\2\2\2\4\u0175\3\2\2\2\6\u0178\3\2\2\2\b\u017b\3\2\2\2\n\u0183"+ - "\3\2\2\2\f\u018c\3\2\2\2\16\u01a7\3\2\2\2\20\u01aa\3\2\2\2\22\u01b2\3"+ - "\2\2\2\24\u01bf\3\2\2\2\26\u01d5\3\2\2\2\30\u01de\3\2\2\2\32\u01e0\3\2"+ - "\2\2\34\u01e2\3\2\2\2\36\u01e5\3\2\2\2 \u01f9\3\2\2\2\"\u01fb\3\2\2\2"+ - "$\u01fd\3\2\2\2&\u0202\3\2\2\2(\u020d\3\2\2\2*\u021a\3\2\2\2,\u021d\3"+ - "\2\2\2.\u0228\3\2\2\2\60\u022a\3\2\2\2\62\u022f\3\2\2\2\64\u0234\3\2\2"+ - "\2\66\u0239\3\2\2\28\u023e\3\2\2\2:\u024b\3\2\2\2<\u024d\3\2\2\2>\u024f"+ - "\3\2\2\2@\u0254\3\2\2\2B\u0259\3\2\2\2D\u025e\3\2\2\2F\u0267\3\2\2\2H"+ - "\u026e\3\2\2\2J\u027b\3\2\2\2L\u027f\3\2\2\2N\u028a\3\2\2\2P\u0292\3\2"+ - "\2\2R\u0294\3\2\2\2T\u02a9\3\2\2\2V\u02ab\3\2\2\2X\u02b7\3\2\2\2Z\u02c3"+ - "\3\2\2\2\\\u02d3\3\2\2\2^\u02df\3\2\2\2`\u02ee\3\2\2\2b\u02f1\3\2\2\2"+ - "d\u02f9\3\2\2\2f\u02fb\3\2\2\2h\u0306\3\2\2\2j\u030e\3\2\2\2l\u031d\3"+ - "\2\2\2n\u031f\3\2\2\2p\u0327\3\2\2\2r\u0335\3\2\2\2t\u0341\3\2\2\2v\u034b"+ - "\3\2\2\2x\u034f\3\2\2\2z\u0355\3\2\2\2|\u036d\3\2\2\2~\u0375\3\2\2\2\u0080"+ - "\u0384\3\2\2\2\u0082\u0386\3\2\2\2\u0084\u038d\3\2\2\2\u0086\u0396\3\2"+ - "\2\2\u0088\u039b\3\2\2\2\u008a\u03a0\3\2\2\2\u008c\u03a6\3\2\2\2\u008e"+ - "\u03ad\3\2\2\2\u0090\u03b2\3\2\2\2\u0092\u03b8\3\2\2\2\u0094\u03bd\3\2"+ - "\2\2\u0096\u03c4\3\2\2\2\u0098\u03ce\3\2\2\2\u009a\u03d2\3\2\2\2\u009c"+ - "\u03de\3\2\2\2\u009e\u03e1\3\2\2\2\u00a0\u03e5\3\2\2\2\u00a2\u03ec\3\2"+ - "\2\2\u00a4\u0405\3\2\2\2\u00a6\u0441\3\2\2\2\u00a8\u0443\3\2\2\2\u00aa"+ - "\u0446\3\2\2\2\u00ac\u044b\3\2\2\2\u00ae\u0454\3\2\2\2\u00b0\u0462\3\2"+ - "\2\2\u00b2\u046c\3\2\2\2\u00b4\u047a\3\2\2\2\u00b6\u0495\3\2\2\2\u00b8"+ - "\u0498\3\2\2\2\u00ba\u04a0\3\2\2\2\u00bc\u04a9\3\2\2\2\u00be\u04b9\3\2"+ - "\2\2\u00c0\u04cc\3\2\2\2\u00c2\u04d5\3\2\2\2\u00c4\u04e0\3\2\2\2\u00c6"+ - "\u04e2\3\2\2\2\u00c8\u04e5\3\2\2\2\u00ca\u04fc\3\2\2\2\u00cc\u04fe\3\2"+ - "\2\2\u00ce\u0503\3\2\2\2\u00d0\u0517\3\2\2\2\u00d2\u0519\3\2\2\2\u00d4"+ - "\u051b\3\2\2\2\u00d6\u051e\3\2\2\2\u00d8\u0528\3\2\2\2\u00da\u0532\3\2"+ - "\2\2\u00dc\u0535\3\2\2\2\u00de\u053a\3\2\2\2\u00e0\u053c\3\2\2\2\u00e2"+ - "\u054a\3\2\2\2\u00e4\u0552\3\2\2\2\u00e6\u055a\3\2\2\2\u00e8\u0562\3\2"+ - "\2\2\u00ea\u0570\3\2\2\2\u00ec\u0576\3\2\2\2\u00ee\u0584\3\2\2\2\u00f0"+ - "\u0590\3\2\2\2\u00f2\u0599\3\2\2\2\u00f4\u059b\3\2\2\2\u00f6\u059d\3\2"+ - "\2\2\u00f8\u05a1\3\2\2\2\u00fa\u05a4\3\2\2\2\u00fc\u05a8\3\2\2\2\u00fe"+ - "\u05aa\3\2\2\2\u0100\u05af\3\2\2\2\u0102\u05b3\3\2\2\2\u0104\u05b7\3\2"+ - "\2\2\u0106\u05bb\3\2\2\2\u0108\u05be\3\2\2\2\u010a\u05c0\3\2\2\2\u010c"+ - "\u05d5\3\2\2\2\u010e\u05d7\3\2\2\2\u0110\u05ed\3\2\2\2\u0112\u05f5\3\2"+ - "\2\2\u0114\u05f7\3\2\2\2\u0116\u060d\3\2\2\2\u0118\u0615\3\2\2\2\u011a"+ - "\u061d\3\2\2\2\u011c\u0621\3\2\2\2\u011e\u062d\3\2\2\2\u0120\u0637\3\2"+ - "\2\2\u0122\u0642\3\2\2\2\u0124\u064a\3\2\2\2\u0126\u064e\3\2\2\2\u0128"+ - "\u0657\3\2\2\2\u012a\u0661\3\2\2\2\u012c\u0666\3\2\2\2\u012e\u0668\3\2"+ - "\2\2\u0130\u066d\3\2\2\2\u0132\u066f\3\2\2\2\u0134\u0671\3\2\2\2\u0136"+ - "\u0674\3\2\2\2\u0138\u0678\3\2\2\2\u013a\u0683\3\2\2\2\u013c\u0687\3\2"+ - "\2\2\u013e\u068e\3\2\2\2\u0140\u0692\3\2\2\2\u0142\u0694\3\2\2\2\u0144"+ - "\u06a4\3\2\2\2\u0146\u06b1\3\2\2\2\u0148\u06b9\3\2\2\2\u014a\u06be\3\2"+ - "\2\2\u014c\u06c0\3\2\2\2\u014e\u06c2\3\2\2\2\u0150\u06c4\3\2\2\2\u0152"+ - "\u06c8\3\2\2\2\u0154\u06cb\3\2\2\2\u0156\u06d4\3\2\2\2\u0158\u06df\3\2"+ - "\2\2\u015a\u06e5\3\2\2\2\u015c\u06e9\3\2\2\2\u015e\u06eb\3\2\2\2\u0160"+ - "\u06fb\3\2\2\2\u0162\u0700\3\2\2\2\u0164\u0703\3\2\2\2\u0166\u0707\3\2"+ - "\2\2\u0168\u070b\3\2\2\2\u016a\u0710\3\2\2\2\u016c\u0723\3\2\2\2\u016e"+ - "\u0727\3\2\2\2\u0170\u072d\3\2\2\2\u0172\u0173\5\u00a4S\2\u0173\u0174"+ - "\7\2\2\3\u0174\3\3\2\2\2\u0175\u0176\5\u00a6T\2\u0176\u0177\7\2\2\3\u0177"+ - "\5\3\2\2\2\u0178\u0179\5\u00c2b\2\u0179\u017a\7\2\2\3\u017a\7\3\2\2\2"+ - "\u017b\u0180\5\n\6\2\u017c\u017d\7o\2\2\u017d\u017f\5\n\6\2\u017e\u017c"+ - "\3\2\2\2\u017f\u0182\3\2\2\2\u0180\u017e\3\2\2\2\u0180\u0181\3\2\2\2\u0181"+ - "\t\3\2\2\2\u0182\u0180\3\2\2\2\u0183\u0185\7g\2\2\u0184\u0186\7>\2\2\u0185"+ - "\u0184\3\2\2\2\u0185\u0186\3\2\2\2\u0186\13\3\2\2\2\u0187\u0188\5\16\b"+ - "\2\u0188\u0189\5\u0170\u00b9\2\u0189\u018b\3\2\2\2\u018a\u0187\3\2\2\2"+ - "\u018b\u018e\3\2\2\2\u018c\u018a\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f"+ - "\3\2\2\2\u018e\u018c\3\2\2\2\u018f\u0190\5\u00dan\2\u0190\u0196\5\u0170"+ - "\u00b9\2\u0191\u0192\5\24\13\2\u0192\u0193\5\u0170\u00b9\2\u0193\u0195"+ - "\3\2\2\2\u0194\u0191\3\2\2\2\u0195\u0198\3\2\2\2\u0196\u0194\3\2\2\2\u0196"+ - "\u0197\3\2\2\2\u0197\u01a2\3\2\2\2\u0198\u0196\3\2\2\2\u0199\u019d\5\u0088"+ - "E\2\u019a\u019d\5\u00dep\2\u019b\u019d\5\26\f\2\u019c\u0199\3\2\2\2\u019c"+ - "\u019a\3\2\2\2\u019c\u019b\3\2\2\2\u019d\u019e\3\2\2\2\u019e\u019f\5\u0170"+ - "\u00b9\2\u019f\u01a1\3\2\2\2\u01a0\u019c\3\2\2\2\u01a1\u01a4\3\2\2\2\u01a2"+ - "\u01a0\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3\u01a5\3\2\2\2\u01a4\u01a2\3\2"+ - "\2\2\u01a5\u01a6\7\2\2\3\u01a6\r\3\2\2\2\u01a7\u01a8\7G\2\2\u01a8\u01a9"+ - "\5\u00a4S\2\u01a9\17\3\2\2\2\u01aa\u01ab\7H\2\2\u01ab\u01ac\5\u00a4S\2"+ - "\u01ac\21\3\2\2\2\u01ad\u01ae\5\20\t\2\u01ae\u01af\5\u0170\u00b9\2\u01af"+ - "\u01b1\3\2\2\2\u01b0\u01ad\3\2\2\2\u01b1\u01b4\3\2\2\2\u01b2\u01b0\3\2"+ - "\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01b6\3\2\2\2\u01b4\u01b2\3\2\2\2\u01b5"+ - "\u01b7\t\2\2\2\u01b6\u01b5\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7\u01b8\3\2"+ - "\2\2\u01b8\u01b9\5\u00dco\2\u01b9\23\3\2\2\2\u01ba\u01bb\5\20\t\2\u01bb"+ - "\u01bc\5\u0170\u00b9\2\u01bc\u01be\3\2\2\2\u01bd\u01ba\3\2\2\2\u01be\u01c1"+ - "\3\2\2\2\u01bf\u01bd\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01cf\3\2\2\2\u01c1"+ - "\u01bf\3\2\2\2\u01c2\u01c3\7c\2\2\u01c3\u01d0\5\22\n\2\u01c4\u01c5\7c"+ - "\2\2\u01c5\u01cb\7h\2\2\u01c6\u01c7\5\22\n\2\u01c7\u01c8\5\u0170\u00b9"+ - "\2\u01c8\u01ca\3\2\2\2\u01c9\u01c6\3\2\2\2\u01ca\u01cd\3\2\2\2\u01cb\u01c9"+ - "\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01ce\3\2\2\2\u01cd\u01cb\3\2\2\2\u01ce"+ - "\u01d0\7i\2\2\u01cf\u01c2\3\2\2\2\u01cf\u01c4\3\2\2\2\u01d0\25\3\2\2\2"+ - "\u01d1\u01d6\5z>\2\u01d2\u01d6\5\u0090I\2\u01d3\u01d6\5\u0094K\2\u01d4"+ - "\u01d6\5\u008eH\2\u01d5\u01d1\3\2\2\2\u01d5\u01d2\3\2\2\2\u01d5\u01d3"+ - "\3\2\2\2\u01d5\u01d4\3\2\2\2\u01d6\27\3\2\2\2\u01d7\u01d8\7\35\2\2\u01d8"+ - "\u01df\5\u00a6T\2\u01d9\u01da\t\3\2\2\u01da\u01df\5.\30\2\u01db\u01dc"+ - "\t\4\2\2\u01dc\u01df\5\u00a4S\2\u01dd\u01df\5f\64\2\u01de\u01d7\3\2\2"+ - "\2\u01de\u01d9\3\2\2\2\u01de\u01db\3\2\2\2\u01de\u01dd\3\2\2\2\u01df\31"+ - "\3\2\2\2\u01e0\u01e1\5\34\17\2\u01e1\33\3\2\2\2\u01e2\u01e3\5^\60\2\u01e3"+ - "\u01e4\5\36\20\2\u01e4\35\3\2\2\2\u01e5\u01e6\7F\2\2\u01e6\u01e8\7h\2"+ - "\2\u01e7\u01e9\5\u00f0y\2\u01e8\u01e7\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9"+ - "\u01ea\3\2\2\2\u01ea\u01eb\7i\2\2\u01eb\37\3\2\2\2\u01ec\u01fa\5F$\2\u01ed"+ - "\u01fa\5D#\2\u01ee\u01fa\5B\"\2\u01ef\u01fa\5$\23\2\u01f0\u01fa\5@!\2"+ - "\u01f1\u01fa\58\35\2\u01f2\u01fa\5> \2\u01f3\u01fa\5\66\34\2\u01f4\u01fa"+ - "\5\62\32\2\u01f5\u01fa\5\60\31\2\u01f6\u01fa\5\64\33\2\u01f7\u01fa\5\""+ - "\22\2\u01f8\u01fa\5H%\2\u01f9\u01ec\3\2\2\2\u01f9\u01ed\3\2\2\2\u01f9"+ - "\u01ee\3\2\2\2\u01f9\u01ef\3\2\2\2\u01f9\u01f0\3\2\2\2\u01f9\u01f1\3\2"+ - "\2\2\u01f9\u01f2\3\2\2\2\u01f9\u01f3\3\2\2\2\u01f9\u01f4\3\2\2\2\u01f9"+ - "\u01f5\3\2\2\2\u01f9\u01f6\3\2\2\2\u01f9\u01f7\3\2\2\2\u01f9\u01f8\3\2"+ - "\2\2\u01fa!\3\2\2\2\u01fb\u01fc\t\5\2\2\u01fc#\3\2\2\2\u01fd\u01fe\7`"+ - "\2\2\u01fe\u01ff\7l\2\2\u01ff\u0200\5\u00c2b\2\u0200\u0201\7m\2\2\u0201"+ - "%\3\2\2\2\u0202\u0207\5(\25\2\u0203\u0204\7o\2\2\u0204\u0206\5(\25\2\u0205"+ - "\u0203\3\2\2\2\u0206\u0209\3\2\2\2\u0207\u0205\3\2\2\2\u0207\u0208\3\2"+ - "\2\2\u0208\u020b\3\2\2\2\u0209\u0207\3\2\2\2\u020a\u020c\7o\2\2\u020b"+ - "\u020a\3\2\2\2\u020b\u020c\3\2\2\2\u020c\'\3\2\2\2\u020d\u0212\7g\2\2"+ - "\u020e\u020f\7o\2\2\u020f\u0211\7g\2\2\u0210\u020e\3\2\2\2\u0211\u0214"+ - "\3\2\2\2\u0212\u0210\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0215\3\2\2\2\u0214"+ - "\u0212\3\2\2\2\u0215\u0216\5\u0132\u009a\2\u0216)\3\2\2\2\u0217\u0219"+ - "\5,\27\2\u0218\u0217\3\2\2\2\u0219\u021c\3\2\2\2\u021a\u0218\3\2\2\2\u021a"+ - "\u021b\3\2\2\2\u021b+\3\2\2\2\u021c\u021a\3\2\2\2\u021d\u021e\7j\2\2\u021e"+ - "\u0223\5\u00a4S\2\u021f\u0220\7o\2\2\u0220\u0222\5\u00a4S\2\u0221\u021f"+ - "\3\2\2\2\u0222\u0225\3\2\2\2\u0223\u0221\3\2\2\2\u0223\u0224\3\2\2\2\u0224"+ - "\u0226\3\2\2\2\u0225\u0223\3\2\2\2\u0226\u0227\7k\2\2\u0227-\3\2\2\2\u0228"+ - "\u0229\5\u00b4[\2\u0229/\3\2\2\2\u022a\u022b\7\63\2\2\u022b\u022c\7h\2"+ - "\2\u022c\u022d\5\u00a4S\2\u022d\u022e\7i\2\2\u022e\61\3\2\2\2\u022f\u0230"+ - "\79\2\2\u0230\u0231\7l\2\2\u0231\u0232\5\u00c2b\2\u0232\u0233\7m\2\2\u0233"+ - "\63\3\2\2\2\u0234\u0235\7\64\2\2\u0235\u0236\7h\2\2\u0236\u0237\5\u00a4"+ - "S\2\u0237\u0238\7i\2\2\u0238\65\3\2\2\2\u0239\u023a\t\6\2\2\u023a\u023b"+ - "\7h\2\2\u023b\u023c\5\u00a4S\2\u023c\u023d\7i\2\2\u023d\67\3\2\2\2\u023e"+ - "\u0243\7\23\2\2\u023f\u0240\7l\2\2\u0240\u0241\5:\36\2\u0241\u0242\7m"+ - "\2\2\u0242\u0244\3\2\2\2\u0243\u023f\3\2\2\2\u0243\u0244\3\2\2\2\u0244"+ - "\u0245\3\2\2\2\u0245\u0246\7h\2\2\u0246\u0247\5\u00a4S\2\u0247\u0248\7"+ - "i\2\2\u02489\3\2\2\2\u0249\u024c\5<\37\2\u024a\u024c\7\25\2\2\u024b\u0249"+ - "\3\2\2\2\u024b\u024a\3\2\2\2\u024c;\3\2\2\2\u024d\u024e\7g\2\2\u024e="+ - "\3\2\2\2\u024f\u0250\7\24\2\2\u0250\u0251\7h\2\2\u0251\u0252\5\u00a4S"+ - "\2\u0252\u0253\7i\2\2\u0253?\3\2\2\2\u0254\u0255\7<\2\2\u0255\u0256\7"+ - "h\2\2\u0256\u0257\5\u00a4S\2\u0257\u0258\7i\2\2\u0258A\3\2\2\2\u0259\u025a"+ - "\7;\2\2\u025a\u025b\7h\2\2\u025b\u025c\5\u00a4S\2\u025c\u025d\7i\2\2\u025d"+ - "C\3\2\2\2\u025e\u025f\7\30\2\2\u025f\u0260\7h\2\2\u0260\u0263\5\u00a4"+ - "S\2\u0261\u0262\7o\2\2\u0262\u0264\5\u00a4S\2\u0263\u0261\3\2\2\2\u0263"+ - "\u0264\3\2\2\2\u0264\u0265\3\2\2\2\u0265\u0266\7i\2\2\u0266E\3\2\2\2\u0267"+ - "\u0268\t\6\2\2\u0268\u0269\7l\2\2\u0269\u026a\5\u00a4S\2\u026a\u026b\7"+ - "?\2\2\u026b\u026c\5\u00a4S\2\u026c\u026d\7m\2\2\u026dG\3\2\2\2\u026e\u026f"+ - "\78\2\2\u026f\u0270\5\u00a4S\2\u0270\u0276\7j\2\2\u0271\u0272\5J&\2\u0272"+ - "\u0273\5\u0170\u00b9\2\u0273\u0275\3\2\2\2\u0274\u0271\3\2\2\2\u0275\u0278"+ - "\3\2\2\2\u0276\u0274\3\2\2\2\u0276\u0277\3\2\2\2\u0277\u0279\3\2\2\2\u0278"+ - "\u0276\3\2\2\2\u0279\u027a\7k\2\2\u027aI\3\2\2\2\u027b\u027c\5j\66\2\u027c"+ - "\u027d\7q\2\2\u027d\u027e\5\u00a4S\2\u027eK\3\2\2\2\u027f\u0280\7l\2\2"+ - "\u0280\u0285\5N(\2\u0281\u0282\7o\2\2\u0282\u0284\5N(\2\u0283\u0281\3"+ - "\2\2\2\u0284\u0287\3\2\2\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286"+ - "\u0288\3\2\2\2\u0287\u0285\3\2\2\2\u0288\u0289\7m\2\2\u0289M\3\2\2\2\u028a"+ - "\u028b\5\u00a4S\2\u028b\u028c\7n\2\2\u028c\u028d\5\u00a4S\2\u028dO\3\2"+ - "\2\2\u028e\u0293\5\\/\2\u028f\u0293\5Z.\2\u0290\u0293\5R*\2\u0291\u0293"+ - "\5V,\2\u0292\u028e\3\2\2\2\u0292\u028f\3\2\2\2\u0292\u0290\3\2\2\2\u0292"+ - "\u0291\3\2\2\2\u0293Q\3\2\2\2\u0294\u0295\7\65\2\2\u0295\u029b\7j\2\2"+ - "\u0296\u0297\5T+\2\u0297\u0298\5\u0170\u00b9\2\u0298\u029a\3\2\2\2\u0299"+ - "\u0296\3\2\2\2\u029a\u029d\3\2\2\2\u029b\u0299\3\2\2\2\u029b\u029c\3\2"+ - "\2\2\u029c\u029e\3\2\2\2\u029d\u029b\3\2\2\2\u029e\u029f\7k\2\2\u029f"+ - "S\3\2\2\2\u02a0\u02a1\7O\2\2\u02a1\u02a2\7g\2\2\u02a2\u02aa\5\u013e\u00a0"+ - "\2\u02a3\u02a4\7\66\2\2\u02a4\u02a5\7j\2\2\u02a5\u02a6\5\u00a4S\2\u02a6"+ - "\u02a7\5\u0170\u00b9\2\u02a7\u02a8\7k\2\2\u02a8\u02aa\3\2\2\2\u02a9\u02a0"+ - "\3\2\2\2\u02a9\u02a3\3\2\2\2\u02aaU\3\2\2\2\u02ab\u02ac\7\67\2\2\u02ac"+ - "\u02b2\7j\2\2\u02ad\u02ae\5X-\2\u02ae\u02af\5\u0170\u00b9\2\u02af\u02b1"+ - "\3\2\2\2\u02b0\u02ad\3\2\2\2\u02b1\u02b4\3\2\2\2\u02b2\u02b0\3\2\2\2\u02b2"+ - "\u02b3\3\2\2\2\u02b3\u02b5\3\2\2\2\u02b4\u02b2\3\2\2\2\u02b5\u02b6\7k"+ - "\2\2\u02b6W\3\2\2\2\u02b7\u02b8\7g\2\2\u02b8\u02be\7j\2\2\u02b9\u02ba"+ - "\5\u0160\u00b1\2\u02ba\u02bb\5\u0170\u00b9\2\u02bb\u02bd\3\2\2\2\u02bc"+ - "\u02b9\3\2\2\2\u02bd\u02c0\3\2\2\2\u02be\u02bc\3\2\2\2\u02be\u02bf\3\2"+ - "\2\2\u02bf\u02c1\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1\u02c2\7k\2\2\u02c2"+ - "Y\3\2\2\2\u02c3\u02c4\7\35\2\2\u02c4\u02c5\7l\2\2\u02c5\u02c6\7m\2\2\u02c6"+ - "\u02c7\5\u0132\u009a\2\u02c7[\3\2\2\2\u02c8\u02c9\t\7\2\2\u02c9\u02ca"+ - "\7l\2\2\u02ca\u02cb\5\u00c2b\2\u02cb\u02cc\7m\2\2\u02cc\u02d4\3\2\2\2"+ - "\u02cd\u02ce\7-\2\2\u02ce\u02cf\7l\2\2\u02cf\u02d0\5\u00c2b\2\u02d0\u02d1"+ - "\7m\2\2\u02d1\u02d2\5\u00c2b\2\u02d2\u02d4\3\2\2\2\u02d3\u02c8\3\2\2\2"+ - "\u02d3\u02cd\3\2\2\2\u02d4]\3\2\2\2\u02d5\u02db\5`\61\2\u02d6\u02d7\7"+ - "\20\2\2\u02d7\u02db\b\60\1\2\u02d8\u02d9\7E\2\2\u02d9\u02db\b\60\1\2\u02da"+ - "\u02d5\3\2\2\2\u02da\u02d6\3\2\2\2\u02da\u02d8\3\2\2\2\u02db\u02dc\3\2"+ - "\2\2\u02dc\u02de\5\u0170\u00b9\2\u02dd\u02da\3\2\2\2\u02de\u02e1\3\2\2"+ - "\2\u02df\u02e0\3\2\2\2\u02df\u02dd\3\2\2\2\u02e0\u02e4\3\2\2\2\u02e1\u02df"+ - "\3\2\2\2\u02e2\u02e3\7\20\2\2\u02e3\u02e5\b\60\1\2\u02e4\u02e2\3\2\2\2"+ - "\u02e4\u02e5\3\2\2\2\u02e5_\3\2\2\2\u02e6\u02e7\7\13\2\2\u02e7\u02ef\5"+ - "d\63\2\u02e8\u02e9\7\f\2\2\u02e9\u02ef\5d\63\2\u02ea\u02eb\7\r\2\2\u02eb"+ - "\u02ef\5d\63\2\u02ec\u02ed\7\17\2\2\u02ed\u02ef\5b\62\2\u02ee\u02e6\3"+ - "\2\2\2\u02ee\u02e8\3\2\2\2\u02ee\u02ea\3\2\2\2\u02ee\u02ec\3\2\2\2\u02ef"+ - "a\3\2\2\2\u02f0\u02f2\5\u00e6t\2\u02f1\u02f0\3\2\2\2\u02f1\u02f2\3\2\2"+ - "\2\u02f2\u02f5\3\2\2\2\u02f3\u02f4\7^\2\2\u02f4\u02f6\5\u00a4S\2\u02f5"+ - "\u02f3\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6c\3\2\2\2\u02f7\u02fa\3\2\2\2"+ - "\u02f8\u02fa\5\u00a4S\2\u02f9\u02f7\3\2\2\2\u02f9\u02f8\3\2\2\2\u02fa"+ - "e\3\2\2\2\u02fb\u02fc\78\2\2\u02fc\u02fd\5\u00a4S\2\u02fd\u0301\7j\2\2"+ - "\u02fe\u0300\5h\65\2\u02ff\u02fe\3\2\2\2\u0300\u0303\3\2\2\2\u0301\u02ff"+ - "\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0304\3\2\2\2\u0303\u0301\3\2\2\2\u0304"+ - "\u0305\7k\2\2\u0305g\3\2\2\2\u0306\u0307\5j\66\2\u0307\u0309\7q\2\2\u0308"+ - "\u030a\5\u00f0y\2\u0309\u0308\3\2\2\2\u0309\u030a\3\2\2\2\u030ai\3\2\2"+ - "\2\u030b\u030c\7R\2\2\u030c\u030f\5l\67\2\u030d\u030f\7N\2\2\u030e\u030b"+ - "\3\2\2\2\u030e\u030d\3\2\2\2\u030fk\3\2\2\2\u0310\u0311\7\'\2\2\u0311"+ - "\u031e\7g\2\2\u0312\u0313\5\u00caf\2\u0313\u0318\7j\2\2\u0314\u0316\5"+ - "n8\2\u0315\u0317\7o\2\2\u0316\u0315\3\2\2\2\u0316\u0317\3\2\2\2\u0317"+ - "\u0319\3\2\2\2\u0318\u0314\3\2\2\2\u0318\u0319\3\2\2\2\u0319\u031a\3\2"+ - "\2\2\u031a\u031b\7k\2\2\u031b\u031e\3\2\2\2\u031c\u031e\5\u00a4S\2\u031d"+ - "\u0310\3\2\2\2\u031d\u0312\3\2\2\2\u031d\u031c\3\2\2\2\u031em\3\2\2\2"+ - "\u031f\u0324\5l\67\2\u0320\u0321\7o\2\2\u0321\u0323\5l\67\2\u0322\u0320"+ - "\3\2\2\2\u0323\u0326\3\2\2\2\u0324\u0322\3\2\2\2\u0324\u0325\3\2\2\2\u0325"+ - "o\3\2\2\2\u0326\u0324\3\2\2\2\u0327\u032c\7j\2\2\u0328\u0329\7=\2\2\u0329"+ - "\u032a\5\u00e4s\2\u032a\u032b\5\u0170\u00b9\2\u032b\u032d\3\2\2\2\u032c"+ - "\u0328\3\2\2\2\u032c\u032d\3\2\2\2\u032d\u032f\3\2\2\2\u032e\u0330\5\u00f0"+ - "y\2\u032f\u032e\3\2\2\2\u032f\u0330\3\2\2\2\u0330\u0331\3\2\2\2\u0331"+ - "\u0332\7k\2\2\u0332q\3\2\2\2\u0333\u0336\5\u0150\u00a9\2\u0334\u0336\7"+ - "g\2\2\u0335\u0333\3\2\2\2\u0335\u0334\3\2\2\2\u0336\u033f\3\2\2\2\u0337"+ - "\u033c\7j\2\2\u0338\u033a\5t;\2\u0339\u033b\7o\2\2\u033a\u0339\3\2\2\2"+ - "\u033a\u033b\3\2\2\2\u033b\u033d\3\2\2\2\u033c\u0338\3\2\2\2\u033c\u033d"+ - "\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u0340\7k\2\2\u033f\u0337\3\2\2\2\u033f"+ - "\u0340\3\2\2\2\u0340s\3\2\2\2\u0341\u0346\5v<\2\u0342\u0343\7o\2\2\u0343"+ - "\u0345\5v<\2\u0344\u0342\3\2\2\2\u0345\u0348\3\2\2\2\u0346\u0344\3\2\2"+ - "\2\u0346\u0347\3\2\2\2\u0347u\3\2\2\2\u0348\u0346\3\2\2\2\u0349\u034a"+ - "\7g\2\2\u034a\u034c\7q\2\2\u034b\u0349\3\2\2\2\u034b\u034c\3\2\2\2\u034c"+ - "\u034d\3\2\2\2\u034d\u034e\5\u00a4S\2\u034ew\3\2\2\2\u034f\u0350\7I\2"+ - "\2\u0350\u0351\5\u00a4S\2\u0351\u0352\7\21\2\2\u0352\u0353\5r:\2\u0353"+ - "\u0354\5\u00eex\2\u0354y\3\2\2\2\u0355\u0356\5\u00c2b\2\u0356\u0357\7"+ - "\21\2\2\u0357\u036a\5\u00c2b\2\u0358\u035e\7j\2\2\u0359\u035a\5\u0082"+ - "B\2\u035a\u035b\5\u0170\u00b9\2\u035b\u035d\3\2\2\2\u035c\u0359\3\2\2"+ - "\2\u035d\u0360\3\2\2\2\u035e\u035c\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0366"+ - "\3\2\2\2\u0360\u035e\3\2\2\2\u0361\u0362\5|?\2\u0362\u0363\5\u0170\u00b9"+ - "\2\u0363\u0365\3\2\2\2\u0364\u0361\3\2\2\2\u0365\u0368\3\2\2\2\u0366\u0364"+ - "\3\2\2\2\u0366\u0367\3\2\2\2\u0367\u0369\3\2\2\2\u0368\u0366\3\2\2\2\u0369"+ - "\u036b\7k\2\2\u036a\u0358\3\2\2\2\u036a\u036b\3\2\2\2\u036b{\3\2\2\2\u036c"+ - "\u036e\7\20\2\2\u036d\u036c\3\2\2\2\u036d\u036e\3\2\2\2\u036e\u036f\3"+ - "\2\2\2\u036f\u0370\5~@\2\u0370\u0371\7g\2\2\u0371\u0373\5\u013e\u00a0"+ - "\2\u0372\u0374\5\u00eex\2\u0373\u0372\3\2\2\2\u0373\u0374\3\2\2\2\u0374"+ - "}\3\2\2\2\u0375\u0377\7h\2\2\u0376\u0378\7g\2\2\u0377\u0376\3\2\2\2\u0377"+ - "\u0378\3\2\2\2\u0378\u037a\3\2\2\2\u0379\u037b\7\u0089\2\2\u037a\u0379"+ - "\3\2\2\2\u037a\u037b\3\2\2\2\u037b\u037c\3\2\2\2\u037c\u037d\5\u012c\u0097"+ - "\2\u037d\u037e\7i\2\2\u037e\177\3\2\2\2\u037f\u0385\5\u00b4[\2\u0380\u0381"+ - "\5\u00c2b\2\u0381\u0382\7r\2\2\u0382\u0383\7g\2\2\u0383\u0385\3\2\2\2"+ - "\u0384\u037f\3\2\2\2\u0384\u0380\3\2\2\2\u0385\u0081\3\2\2\2\u0386\u0387"+ - "\7:\2\2\u0387\u0388\7g\2\2\u0388\u038b\7u\2\2\u0389\u038c\5\u0080A\2\u038a"+ - "\u038c\5\u014e\u00a8\2\u038b\u0389\3\2\2\2\u038b\u038a\3\2\2\2\u038c\u0083"+ - "\3\2\2\2\u038d\u038e\7\61\2\2\u038e\u038f\7h\2\2\u038f\u0392\5\u00c2b"+ - "\2\u0390\u0391\7o\2\2\u0391\u0393\5\u00e6t\2\u0392\u0390\3\2\2\2\u0392"+ - "\u0393\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u0395\7i\2\2\u0395\u0085\3\2"+ - "\2\2\u0396\u0397\7\60\2\2\u0397\u0398\7h\2\2\u0398\u0399\5\u00c2b\2\u0399"+ - "\u039a\7i\2\2\u039a\u0087\3\2\2\2\u039b\u039e\5^\60\2\u039c\u039f\5\u008a"+ - "F\2\u039d\u039f\5\u008cG\2\u039e\u039c\3\2\2\2\u039e\u039d\3\2\2\2\u039f"+ - "\u0089\3\2\2\2\u03a0\u03a1\7O\2\2\u03a1\u03a2\7g\2\2\u03a2\u03a4\5\u013e"+ - "\u00a0\2\u03a3\u03a5\5p9\2\u03a4\u03a3\3\2\2\2\u03a4\u03a5\3\2\2\2\u03a5"+ - "\u008b\3\2\2\2\u03a6\u03a7\7O\2\2\u03a7\u03a8\5\u009aN\2\u03a8\u03a9\7"+ - "g\2\2\u03a9\u03ab\5\u013e\u00a0\2\u03aa\u03ac\5p9\2\u03ab\u03aa\3\2\2"+ - "\2\u03ab\u03ac\3\2\2\2\u03ac\u008d\3\2\2\2\u03ad\u03b0\7\35\2\2\u03ae"+ - "\u03b1\5\u0088E\2\u03af\u03b1\5\u00dep\2\u03b0\u03ae\3\2\2\2\u03b0\u03af"+ - "\3\2\2\2\u03b1\u008f\3\2\2\2\u03b2\u03b3\7:\2\2\u03b3\u03b4\7g\2\2\u03b4"+ - "\u03b6\5\u0142\u00a2\2\u03b5\u03b7\5\u0092J\2\u03b6\u03b5\3\2\2\2\u03b6"+ - "\u03b7\3\2\2\2\u03b7\u0091\3\2\2\2\u03b8\u03b9\7j\2\2\u03b9\u03ba\5\u00a4"+ - "S\2\u03ba\u03bb\5\u0170\u00b9\2\u03bb\u03bc\7k\2\2\u03bc\u0093\3\2\2\2"+ - "\u03bd\u03be\7:\2\2\u03be\u03bf\5\u009aN\2\u03bf\u03c0\7g\2\2\u03c0\u03c2"+ - "\5\u0142\u00a2\2\u03c1\u03c3\5\u0092J\2\u03c2\u03c1\3\2\2\2\u03c2\u03c3"+ - "\3\2\2\2\u03c3\u0095\3\2\2\2\u03c4\u03cc\5\b\5\2\u03c5\u03c8\5\u00c2b"+ - "\2\u03c6\u03c7\7n\2\2\u03c7\u03c9\5\u00e6t\2\u03c8\u03c6\3\2\2\2\u03c8"+ - "\u03c9\3\2\2\2\u03c9\u03cd\3\2\2\2\u03ca\u03cb\7n\2\2\u03cb\u03cd\5\u00e6"+ - "t\2\u03cc\u03c5\3\2\2\2\u03cc\u03ca\3\2\2\2\u03cd\u0097\3\2\2\2\u03ce"+ - "\u03cf\5\b\5\2\u03cf\u03d0\7u\2\2\u03d0\u03d1\5\u00e6t\2\u03d1\u0099\3"+ - "\2\2\2\u03d2\u03d4\7h\2\2\u03d3\u03d5\5\n\6\2\u03d4\u03d3\3\2\2\2\u03d4"+ - "\u03d5\3\2\2\2\u03d5\u03d6\3\2\2\2\u03d6\u03d8\5\u00c2b\2\u03d7\u03d9"+ - "\7o\2\2\u03d8\u03d7\3\2\2\2\u03d8\u03d9\3\2\2\2\u03d9\u03da\3\2\2\2\u03da"+ - "\u03db\7i\2\2\u03db\u009b\3\2\2\2\u03dc\u03df\5\u009eP\2\u03dd\u03df\5"+ - "\u00a0Q\2\u03de\u03dc\3\2\2\2\u03de\u03dd\3\2\2\2\u03df\u009d\3\2\2\2"+ - "\u03e0\u03e2\5\u00e4s\2\u03e1\u03e0\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2"+ - "\u03e3\3\2\2\2\u03e3\u03e4\5\u00a2R\2\u03e4\u009f\3\2\2\2\u03e5\u03e7"+ - "\7\35\2\2\u03e6\u03e8\5\u00e4s\2\u03e7\u03e6\3\2\2\2\u03e7\u03e8\3\2\2"+ - "\2\u03e8\u03e9\3\2\2\2\u03e9\u03ea\5\u00a2R\2\u03ea\u00a1\3\2\2\2\u03eb"+ - "\u03ed\7v\2\2\u03ec\u03eb\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed\u03ee\3\2"+ - "\2\2\u03ee\u03ef\5\u00c2b\2\u03ef\u00a3\3\2\2\2\u03f0\u03f1\bS\1\2\u03f1"+ - "\u03f2\t\b\2\2\u03f2\u0406\5\u00a4S\21\u03f3\u0406\5\u00b4[\2\u03f4\u03f5"+ - "\7\33\2\2\u03f5\u03f6\5.\30\2\u03f6\u03f7\7\36\2\2\u03f7\u03f8\5\u00a4"+ - "S\5\u03f8\u0406\3\2\2\2\u03f9\u03fa\7\34\2\2\u03fa\u03fb\5\u0098M\2\u03fb"+ - "\u03fc\7\36\2\2\u03fc\u03fd\5\u00a4S\4\u03fd\u0406\3\2\2\2\u03fe\u03ff"+ - "\t\t\2\2\u03ff\u0400\5&\24\2\u0400\u0401\7q\2\2\u0401\u0402\7q\2\2\u0402"+ - "\u0403\5*\26\2\u0403\u0404\5\u00a4S\3\u0404\u0406\3\2\2\2\u0405\u03f0"+ - "\3\2\2\2\u0405\u03f3\3\2\2\2\u0405\u03f4\3\2\2\2\u0405\u03f9\3\2\2\2\u0405"+ - "\u03fe\3\2\2\2\u0406\u042a\3\2\2\2\u0407\u0408\f\17\2\2\u0408\u0409\t"+ - "\n\2\2\u0409\u0429\5\u00a4S\20\u040a\u040b\f\16\2\2\u040b\u040c\t\13\2"+ - "\2\u040c\u0429\5\u00a4S\17\u040d\u040e\f\r\2\2\u040e\u040f\t\f\2\2\u040f"+ - "\u0429\5\u00a4S\16\u0410\u0411\f\f\2\2\u0411\u0412\t\r\2\2\u0412\u0429"+ - "\5\u00a4S\r\u0413\u0414\f\13\2\2\u0414\u0415\t\16\2\2\u0415\u0429\5\u00a4"+ - "S\f\u0416\u0417\f\t\2\2\u0417\u0418\7x\2\2\u0418\u0429\5\u00a4S\n\u0419"+ - "\u041a\f\b\2\2\u041a\u041b\7w\2\2\u041b\u0429\5\u00a4S\t\u041c\u041d\f"+ - "\7\2\2\u041d\u041e\7$\2\2\u041e\u0429\5\u00a4S\7\u041f\u0420\f\6\2\2\u0420"+ - "\u0421\7\'\2\2\u0421\u0422\5\u00a4S\2\u0422\u0423\7q\2\2\u0423\u0424\5"+ - "\u00a4S\6\u0424\u0429\3\2\2\2\u0425\u0426\f\n\2\2\u0426\u0427\7\21\2\2"+ - "\u0427\u0429\5r:\2\u0428\u0407\3\2\2\2\u0428\u040a\3\2\2\2\u0428\u040d"+ - "\3\2\2\2\u0428\u0410\3\2\2\2\u0428\u0413\3\2\2\2\u0428\u0416\3\2\2\2\u0428"+ - "\u0419\3\2\2\2\u0428\u041c\3\2\2\2\u0428\u041f\3\2\2\2\u0428\u0425\3\2"+ - "\2\2\u0429\u042c\3\2\2\2\u042a\u0428\3\2\2\2\u042a\u042b\3\2\2\2\u042b"+ - "\u00a5\3\2\2\2\u042c\u042a\3\2\2\2\u042d\u0442\5\30\r\2\u042e\u0442\5"+ - "\32\16\2\u042f\u0442\5\u00aaV\2\u0430\u0442\5\u00a8U\2\u0431\u0442\5\u00de"+ - "p\2\u0432\u0442\5\u00fe\u0080\2\u0433\u0442\5\u00f2z\2\u0434\u0442\5\u012a"+ - "\u0096\2\u0435\u0442\5\u0100\u0081\2\u0436\u0442\5\u0102\u0082\2\u0437"+ - "\u0442\5\u0104\u0083\2\u0438\u0442\5\u0106\u0084\2\u0439\u0442\5\u0108"+ - "\u0085\2\u043a\u0442\5\u00eex\2\u043b\u0442\5\u010a\u0086\2\u043c\u0442"+ - "\5\u010c\u0087\2\u043d\u0442\5\u011e\u0090\2\u043e\u0442\5\u00acW\2\u043f"+ - "\u0442\5\u00b0Y\2\u0440\u0442\5x=\2\u0441\u042d\3\2\2\2\u0441\u042e\3"+ - "\2\2\2\u0441\u042f\3\2\2\2\u0441\u0430\3\2\2\2\u0441\u0431\3\2\2\2\u0441"+ - "\u0432\3\2\2\2\u0441\u0433\3\2\2\2\u0441\u0434\3\2\2\2\u0441\u0435\3\2"+ - "\2\2\u0441\u0436\3\2\2\2\u0441\u0437\3\2\2\2\u0441\u0438\3\2\2\2\u0441"+ - "\u0439\3\2\2\2\u0441\u043a\3\2\2\2\u0441\u043b\3\2\2\2\u0441\u043c\3\2"+ - "\2\2\u0441\u043d\3\2\2\2\u0441\u043e\3\2\2\2\u0441\u043f\3\2\2\2\u0441"+ - "\u0440\3\2\2\2\u0442\u00a7\3\2\2\2\u0443\u0444\7&\2\2\u0444\u0445\5\u00a4"+ - "S\2\u0445\u00a9\3\2\2\2\u0446\u0447\7Z\2\2\u0447\u0449\5\u00a4S\2\u0448"+ - "\u044a\5\u00eex\2\u0449\u0448\3\2\2\2\u0449\u044a\3\2\2\2\u044a\u00ab"+ - "\3\2\2\2\u044b\u044c\5\u00aeX\2\u044c\u044d\5\u0126\u0094\2\u044d\u00ad"+ - "\3\2\2\2\u044e\u044f\7\16\2\2\u044f\u0450\5\u00a4S\2\u0450\u0451\5\u0170"+ - "\u00b9\2\u0451\u0453\3\2\2\2\u0452\u044e\3\2\2\2\u0453\u0456\3\2\2\2\u0454"+ - "\u0452\3\2\2\2\u0454\u0455\3\2\2\2\u0455\u045b\3\2\2\2\u0456\u0454\3\2"+ - "\2\2\u0457\u0458\7\17\2\2\u0458\u0459\5b\62\2\u0459\u045a\5\u0170\u00b9"+ - "\2\u045a\u045c\3\2\2\2\u045b\u0457\3\2\2\2\u045b\u045c\3\2\2\2\u045c\u00af"+ - "\3\2\2\2\u045d\u045e\7S\2\2\u045e\u0463\5\u00a4S\2\u045f\u0460\7S\2\2"+ - "\u0460\u0461\t\3\2\2\u0461\u0463\5.\30\2\u0462\u045d\3\2\2\2\u0462\u045f"+ - "\3\2\2\2\u0463\u00b1\3\2\2\2\u0464\u046d\7\5\2\2\u0465\u046d\7\6\2\2\u0466"+ - "\u046d\7f\2\2\u0467\u046d\5\u014c\u00a7\2\u0468\u046d\5\u0162\u00b2\2"+ - "\u0469\u046d\7\3\2\2\u046a\u046d\7\u0091\2\2\u046b\u046d\7\u0092\2\2\u046c"+ - "\u0464\3\2\2\2\u046c\u0465\3\2\2\2\u046c\u0466\3\2\2\2\u046c\u0467\3\2"+ - "\2\2\u046c\u0468\3\2\2\2\u046c\u0469\3\2\2\2\u046c\u046a\3\2\2\2\u046c"+ - "\u046b\3\2\2\2\u046d\u00b3\3\2\2\2\u046e\u046f\b[\1\2\u046f\u047b\5\u0148"+ - "\u00a5\2\u0470\u047b\5\u0144\u00a3\2\u0471\u047b\5\u016c\u00b7\2\u0472"+ - "\u047b\5 \21\2\u0473\u047b\5\u0086D\2\u0474\u047b\5\u0084C\2\u0475\u0476"+ - "\t\17\2\2\u0476\u0477\7h\2\2\u0477\u0478\5\u00a4S\2\u0478\u0479\7i\2\2"+ - "\u0479\u047b\3\2\2\2\u047a\u046e\3\2\2\2\u047a\u0470\3\2\2\2\u047a\u0471"+ - "\3\2\2\2\u047a\u0472\3\2\2\2\u047a\u0473\3\2\2\2\u047a\u0474\3\2\2\2\u047a"+ - "\u0475\3\2\2\2\u047b\u0492\3\2\2\2\u047c\u047d\f\13\2\2\u047d\u047e\7"+ - "r\2\2\u047e\u0491\7g\2\2\u047f\u0480\f\n\2\2\u0480\u0491\5\u0166\u00b4"+ - "\2\u0481\u0482\f\t\2\2\u0482\u0491\5\u00ceh\2\u0483\u0484\f\b\2\2\u0484"+ - "\u0491\5L\'\2\u0485\u0486\f\7\2\2\u0486\u0491\5\u0168\u00b5\2\u0487\u0488"+ - "\f\6\2\2\u0488\u0491\5\u016a\u00b6\2\u0489\u048a\f\5\2\2\u048a\u048b\5"+ - "\u016a\u00b6\2\u048b\u048c\7\22\2\2\u048c\u048d\5r:\2\u048d\u0491\3\2"+ - "\2\2\u048e\u048f\f\4\2\2\u048f\u0491\5\u00ba^\2\u0490\u047c\3\2\2\2\u0490"+ - "\u047f\3\2\2\2\u0490\u0481\3\2\2\2\u0490\u0483\3\2\2\2\u0490\u0485\3\2"+ - "\2\2\u0490\u0487\3\2\2\2\u0490\u0489\3\2\2\2\u0490\u048e\3\2\2\2\u0491"+ - "\u0494\3\2\2\2\u0492\u0490\3\2\2\2\u0492\u0493\3\2\2\2\u0493\u00b5\3\2"+ - "\2\2\u0494\u0492\3\2\2\2\u0495\u0496\5^\60\2\u0496\u0497\5\u00b8]\2\u0497"+ - "\u00b7\3\2\2\2\u0498\u049a\7O\2\2\u0499\u049b\7g\2\2\u049a\u0499\3\2\2"+ - "\2\u049a\u049b\3\2\2\2\u049b\u049c\3\2\2\2\u049c\u049e\5\u013e\u00a0\2"+ - "\u049d\u049f\5p9\2\u049e\u049d\3\2\2\2\u049e\u049f\3\2\2\2\u049f\u00b9"+ - "\3\2\2\2\u04a0\u04a2\7(\2\2\u04a1\u04a3\5\u00e6t\2\u04a2\u04a1\3\2\2\2"+ - "\u04a2\u04a3\3\2\2\2\u04a3\u04a5\3\2\2\2\u04a4\u04a6\7o\2\2\u04a5\u04a4"+ - "\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04a8\7)\2\2\u04a8"+ - "\u00bb\3\2\2\2\u04a9\u04aa\7P\2\2\u04aa\u04b4\7j\2\2\u04ab\u04af\5\u00c0"+ - "a\2\u04ac\u04af\5\u012c\u0097\2\u04ad\u04af\5\u00be`\2\u04ae\u04ab\3\2"+ - "\2\2\u04ae\u04ac\3\2\2\2\u04ae\u04ad\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0"+ - "\u04b1\5\u0170\u00b9\2\u04b1\u04b3\3\2\2\2\u04b2\u04ae\3\2\2\2\u04b3\u04b6"+ - "\3\2\2\2\u04b4\u04b2\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5\u04b7\3\2\2\2\u04b6"+ - "\u04b4\3\2\2\2\u04b7\u04b8\7k\2\2\u04b8\u00bd\3\2\2\2\u04b9\u04ba\7:\2"+ - "\2\u04ba\u04bb\7g\2\2\u04bb\u04bc\5\u0142\u00a2\2\u04bc\u00bf\3\2\2\2"+ - "\u04bd\u04bf\7\35\2\2\u04be\u04bd\3\2\2\2\u04be\u04bf\3\2\2\2\u04bf\u04c0"+ - "\3\2\2\2\u04c0\u04c1\5^\60\2\u04c1\u04c2\7g\2\2\u04c2\u04c3\5\u0142\u00a2"+ - "\2\u04c3\u04c4\5\u0140\u00a1\2\u04c4\u04cd\3\2\2\2\u04c5\u04c7\7\35\2"+ - "\2\u04c6\u04c5\3\2\2\2\u04c6\u04c7\3\2\2\2\u04c7\u04c8\3\2\2\2\u04c8\u04c9"+ - "\5^\60\2\u04c9\u04ca\7g\2\2\u04ca\u04cb\5\u0142\u00a2\2\u04cb\u04cd\3"+ - "\2\2\2\u04cc\u04be\3\2\2\2\u04cc\u04c6\3\2\2\2\u04cd\u00c1\3\2\2\2\u04ce"+ - "\u04d6\5\u012c\u0097\2\u04cf\u04d6\5\u00c4c\2\u04d0\u04d6\5P)\2\u04d1"+ - "\u04d2\7h\2\2\u04d2\u04d3\5\u00c2b\2\u04d3\u04d4\7i\2\2\u04d4\u04d6\3"+ - "\2\2\2\u04d5\u04ce\3\2\2\2\u04d5\u04cf\3\2\2\2\u04d5\u04d0\3\2\2\2\u04d5"+ - "\u04d1\3\2\2\2\u04d6\u00c3\3\2\2\2\u04d7\u04e1\5\u012e\u0098\2\u04d8\u04e1"+ - "\5\u015e\u00b0\2\u04d9\u04e1\5\u0134\u009b\2\u04da\u04e1\5\u013c\u009f"+ - "\2\u04db\u04e1\5\u00bc_\2\u04dc\u04e1\5\u0136\u009c\2\u04dd\u04e1\5\u0138"+ - "\u009d\2\u04de\u04e1\5\u013a\u009e\2\u04df\u04e1\5\u00c6d\2\u04e0\u04d7"+ - "\3\2\2\2\u04e0\u04d8\3\2\2\2\u04e0\u04d9\3\2\2\2\u04e0\u04da\3\2\2\2\u04e0"+ - "\u04db\3\2\2\2\u04e0\u04dc\3\2\2\2\u04e0\u04dd\3\2\2\2\u04e0\u04de\3\2"+ - "\2\2\u04e0\u04df\3\2\2\2\u04e1\u00c5\3\2\2\2\u04e2\u04e3\7:\2\2\u04e3"+ - "\u04e4\5\u00c8e\2\u04e4\u00c7\3\2\2\2\u04e5\u04f1\7h\2\2\u04e6\u04eb\5"+ - "\u00c2b\2\u04e7\u04e8\7o\2\2\u04e8\u04ea\5\u00c2b\2\u04e9\u04e7\3\2\2"+ - "\2\u04ea\u04ed\3\2\2\2\u04eb\u04e9\3\2\2\2\u04eb\u04ec\3\2\2\2\u04ec\u04ef"+ - "\3\2\2\2\u04ed\u04eb\3\2\2\2\u04ee\u04f0\7o\2\2\u04ef\u04ee\3\2\2\2\u04ef"+ - "\u04f0\3\2\2\2\u04f0\u04f2\3\2\2\2\u04f1\u04e6\3\2\2\2\u04f1\u04f2\3\2"+ - "\2\2\u04f2\u04f3\3\2\2\2\u04f3\u04f4\7i\2\2\u04f4\u00c9\3\2\2\2\u04f5"+ - "\u04fd\5\u015e\u00b0\2\u04f6\u04fd\5\u012e\u0098\2\u04f7\u04fd\5\u00cc"+ - "g\2\u04f8\u04fd\5\u0136\u009c\2\u04f9\u04fd\5\u0138\u009d\2\u04fa\u04fd"+ - "\5P)\2\u04fb\u04fd\5\u012c\u0097\2\u04fc\u04f5\3\2\2\2\u04fc\u04f6\3\2"+ - "\2\2\u04fc\u04f7\3\2\2\2\u04fc\u04f8\3\2\2\2\u04fc\u04f9\3\2\2\2\u04fc"+ - "\u04fa\3\2\2\2\u04fc\u04fb\3\2\2\2\u04fd\u00cb\3\2\2\2\u04fe\u04ff\7l"+ - "\2\2\u04ff\u0500\7v\2\2\u0500\u0501\7m\2\2\u0501\u0502\5\u0132\u009a\2"+ - "\u0502\u00cd\3\2\2\2\u0503\u0513\7l\2\2\u0504\u0506\5\u00d0i\2\u0505\u0504"+ - "\3\2\2\2\u0505\u0506\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u0509\7q\2\2\u0508"+ - "\u050a\5\u00d2j\2\u0509\u0508\3\2\2\2\u0509\u050a\3\2\2\2\u050a\u0514"+ - "\3\2\2\2\u050b\u050d\5\u00d0i\2\u050c\u050b\3\2\2\2\u050c\u050d\3\2\2"+ - "\2\u050d\u050e\3\2\2\2\u050e\u050f\7q\2\2\u050f\u0510\5\u00d2j\2\u0510"+ - "\u0511\7q\2\2\u0511\u0512\5\u00d4k\2\u0512\u0514\3\2\2\2\u0513\u0505\3"+ - "\2\2\2\u0513\u050c\3\2\2\2\u0514\u0515\3\2\2\2\u0515\u0516\7m\2\2\u0516"+ - "\u00cf\3\2\2\2\u0517\u0518\5\u00a4S\2\u0518\u00d1\3\2\2\2\u0519\u051a"+ - "\5\u00a4S\2\u051a\u00d3\3\2\2\2\u051b\u051c\5\u00a4S\2\u051c\u00d5\3\2"+ - "\2\2\u051d\u051f\t\20\2\2\u051e\u051d\3\2\2\2\u051e\u051f\3\2\2\2\u051f"+ - "\u0520\3\2\2\2\u0520\u0521\7n\2\2\u0521\u00d7\3\2\2\2\u0522\u0523\5\u00e6"+ - "t\2\u0523\u0524\7n\2\2\u0524\u0529\3\2\2\2\u0525\u0526\5\b\5\2\u0526\u0527"+ - "\7u\2\2\u0527\u0529\3\2\2\2\u0528\u0522\3\2\2\2\u0528\u0525\3\2\2\2\u0528"+ - "\u0529\3\2\2\2\u0529\u052a\3\2\2\2\u052a\u052b\7_\2\2\u052b\u0530\5\u00a4"+ - "S\2\u052c\u052e\7L\2\2\u052d\u052f\7g\2\2\u052e\u052d\3\2\2\2\u052e\u052f"+ - "\3\2\2\2\u052f\u0531\3\2\2\2\u0530\u052c\3\2\2\2\u0530\u0531\3\2\2\2\u0531"+ - "\u00d9\3\2\2\2\u0532\u0533\7Z\2\2\u0533\u0534\7g\2\2\u0534\u00db\3\2\2"+ - "\2\u0535\u0536\5\u0162\u00b2\2\u0536\u00dd\3\2\2\2\u0537\u053b\5\u00e0"+ - "q\2\u0538\u053b\5\u00e8u\2\u0539\u053b\5\u00ecw\2\u053a\u0537\3\2\2\2"+ - "\u053a\u0538\3\2\2\2\u053a\u0539\3\2\2\2\u053b\u00df\3\2\2\2\u053c\u0548"+ - "\7\\\2\2\u053d\u0549\5\u00e2r\2\u053e\u0544\7h\2\2\u053f\u0540\5\u00e2"+ - "r\2\u0540\u0541\5\u0170\u00b9\2\u0541\u0543\3\2\2\2\u0542\u053f\3\2\2"+ - "\2\u0543\u0546\3\2\2\2\u0544\u0542\3\2\2\2\u0544\u0545\3\2\2\2\u0545\u0547"+ - "\3\2\2\2\u0546\u0544\3\2\2\2\u0547\u0549\7i\2\2\u0548\u053d\3\2\2\2\u0548"+ - "\u053e\3\2\2\2\u0549\u00e1\3\2\2\2\u054a\u0550\5\u00e4s\2\u054b\u054d"+ - "\5\u00c2b\2\u054c\u054b\3\2\2\2\u054c\u054d\3\2\2\2\u054d\u054e\3\2\2"+ - "\2\u054e\u054f\7n\2\2\u054f\u0551\5\u00e6t\2\u0550\u054c\3\2\2\2\u0550"+ - "\u0551\3\2\2\2\u0551\u00e3\3\2\2\2\u0552\u0557\7g\2\2\u0553\u0554\7o\2"+ - "\2\u0554\u0556\7g\2\2\u0555\u0553\3\2\2\2\u0556\u0559\3\2\2\2\u0557\u0555"+ - "\3\2\2\2\u0557\u0558\3\2\2\2\u0558\u00e5\3\2\2\2\u0559\u0557\3\2\2\2\u055a"+ - "\u055f\5\u00a4S\2\u055b\u055c\7o\2\2\u055c\u055e\5\u00a4S\2\u055d\u055b"+ - "\3\2\2\2\u055e\u0561\3\2\2\2\u055f\u055d\3\2\2\2\u055f\u0560\3\2\2\2\u0560"+ - "\u00e7\3\2\2\2\u0561\u055f\3\2\2\2\u0562\u056e\7`\2\2\u0563\u056f\5\u00ea"+ - "v\2\u0564\u056a\7h\2\2\u0565\u0566\5\u00eav\2\u0566\u0567\5\u0170\u00b9"+ - "\2\u0567\u0569\3\2\2\2\u0568\u0565\3\2\2\2\u0569\u056c\3\2\2\2\u056a\u0568"+ - "\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u056d\3\2\2\2\u056c\u056a\3\2\2\2\u056d"+ - "\u056f\7i\2\2\u056e\u0563\3\2\2\2\u056e\u0564\3\2\2\2\u056f\u00e9\3\2"+ - "\2\2\u0570\u0572\7g\2\2\u0571\u0573\7n\2\2\u0572\u0571\3\2\2\2\u0572\u0573"+ - "\3\2\2\2\u0573\u0574\3\2\2\2\u0574\u0575\5\u00c2b\2\u0575\u00eb\3\2\2"+ - "\2\u0576\u0582\7e\2\2\u0577\u0583\5\u0096L\2\u0578\u057e\7h\2\2\u0579"+ - "\u057a\5\u0096L\2\u057a\u057b\5\u0170\u00b9\2\u057b\u057d\3\2\2\2\u057c"+ - "\u0579\3\2\2\2\u057d\u0580\3\2\2\2\u057e\u057c\3\2\2\2\u057e\u057f\3\2"+ - "\2\2\u057f\u0581\3\2\2\2\u0580\u057e\3\2\2\2\u0581\u0583\7i\2\2\u0582"+ - "\u0577\3\2\2\2\u0582\u0578\3\2\2\2\u0583\u00ed\3\2\2\2\u0584\u0586\7j"+ - "\2\2\u0585\u0587\5\u00f0y\2\u0586\u0585\3\2\2\2\u0586\u0587\3\2\2\2\u0587"+ - "\u0588\3\2\2\2\u0588\u0589\7k\2\2\u0589\u00ef\3\2\2\2\u058a\u058c\5\u0170"+ - "\u00b9\2\u058b\u058a\3\2\2\2\u058b\u058c\3\2\2\2\u058c\u058d\3\2\2\2\u058d"+ - "\u058e\5\u00a6T\2\u058e\u058f\5\u0170\u00b9\2\u058f\u0591\3\2\2\2\u0590"+ - "\u058b\3\2\2\2\u0591\u0592\3\2\2\2\u0592\u0590\3\2\2\2\u0592\u0593\3\2"+ - "\2\2\u0593\u00f1\3\2\2\2\u0594\u059a\5\u00f6|\2\u0595\u059a\5\u00f8}\2"+ - "\u0596\u059a\5\u00fa~\2\u0597\u059a\5\u00f4{\2\u0598\u059a\5\u0098M\2"+ - "\u0599\u0594\3\2\2\2\u0599\u0595\3\2\2\2\u0599\u0596\3\2\2\2\u0599\u0597"+ - "\3\2\2\2\u0599\u0598\3\2\2\2\u059a\u00f3\3\2\2\2\u059b\u059c\5\u00a4S"+ - "\2\u059c\u00f5\3\2\2\2\u059d\u059e\5\u00a4S\2\u059e\u059f\7\u008b\2\2"+ - "\u059f\u05a0\5\u00a4S\2\u05a0\u00f7\3\2\2\2\u05a1\u05a2\5\u00a4S\2\u05a2"+ - "\u05a3\t\21\2\2\u05a3\u00f9\3\2\2\2\u05a4\u05a5\5\u00e6t\2\u05a5\u05a6"+ - "\5\u00d6l\2\u05a6\u05a7\5\u00e6t\2\u05a7\u00fb\3\2\2\2\u05a8\u05a9\t\22"+ - "\2\2\u05a9\u00fd\3\2\2\2\u05aa\u05ab\7g\2\2\u05ab\u05ad\7q\2\2\u05ac\u05ae"+ - "\5\u00a6T\2\u05ad\u05ac\3\2\2\2\u05ad\u05ae\3\2\2\2\u05ae\u00ff\3\2\2"+ - "\2\u05af\u05b1\7d\2\2\u05b0\u05b2\5\u00e6t\2\u05b1\u05b0\3\2\2\2\u05b1"+ - "\u05b2\3\2\2\2\u05b2\u0101\3\2\2\2\u05b3\u05b5\7M\2\2\u05b4\u05b6\7g\2"+ - "\2\u05b5\u05b4\3\2\2\2\u05b5\u05b6\3\2\2\2\u05b6\u0103\3\2\2\2\u05b7\u05b9"+ - "\7a\2\2\u05b8\u05ba\7g\2\2\u05b9\u05b8\3\2\2\2\u05b9\u05ba\3\2\2\2\u05ba"+ - "\u0105\3\2\2\2\u05bb\u05bc\7Y\2\2\u05bc\u05bd\7g\2\2\u05bd\u0107\3\2\2"+ - "\2\u05be\u05bf\7]\2\2\u05bf\u0109\3\2\2\2\u05c0\u05c9\7^\2\2\u05c1\u05ca"+ - "\5\u00a4S\2\u05c2\u05c3\5\u0170\u00b9\2\u05c3\u05c4\5\u00a4S\2\u05c4\u05ca"+ - "\3\2\2\2\u05c5\u05c6\5\u00f2z\2\u05c6\u05c7\5\u0170\u00b9\2\u05c7\u05c8"+ - "\5\u00a4S\2\u05c8\u05ca\3\2\2\2\u05c9\u05c1\3\2\2\2\u05c9\u05c2\3\2\2"+ - "\2\u05c9\u05c5\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05d1\5\u00eex\2\u05cc"+ - "\u05cf\7X\2\2\u05cd\u05d0\5\u010a\u0086\2\u05ce\u05d0\5\u00eex\2\u05cf"+ - "\u05cd\3\2\2\2\u05cf\u05ce\3\2\2\2\u05d0\u05d2\3\2\2\2\u05d1\u05cc\3\2"+ - "\2\2\u05d1\u05d2\3\2\2\2\u05d2\u010b\3\2\2\2\u05d3\u05d6\5\u010e\u0088"+ - "\2\u05d4\u05d6\5\u0114\u008b\2\u05d5\u05d3\3\2\2\2\u05d5\u05d4\3\2\2\2"+ - "\u05d6\u010d\3\2\2\2\u05d7\u05e2\7[\2\2\u05d8\u05da\5\u00a4S\2\u05d9\u05d8"+ - "\3\2\2\2\u05d9\u05da\3\2\2\2\u05da\u05e3\3\2\2\2\u05db\u05dd\5\u00f2z"+ - "\2\u05dc\u05db\3\2\2\2\u05dc\u05dd\3\2\2\2\u05dd\u05de\3\2\2\2\u05de\u05e0"+ - "\5\u0170\u00b9\2\u05df\u05e1\5\u00a4S\2\u05e0\u05df\3\2\2\2\u05e0\u05e1"+ - "\3\2\2\2\u05e1\u05e3\3\2\2\2\u05e2\u05d9\3\2\2\2\u05e2\u05dc\3\2\2\2\u05e3"+ - "\u05e4\3\2\2\2\u05e4\u05e8\7j\2\2\u05e5\u05e7\5\u0110\u0089\2\u05e6\u05e5"+ - "\3\2\2\2\u05e7\u05ea\3\2\2\2\u05e8\u05e6\3\2\2\2\u05e8\u05e9\3\2\2\2\u05e9"+ - "\u05eb\3\2\2\2\u05ea\u05e8\3\2\2\2\u05eb\u05ec\7k\2\2\u05ec\u010f\3\2"+ - "\2\2\u05ed\u05ee\5\u0112\u008a\2\u05ee\u05f0\7q\2\2\u05ef\u05f1\5\u00f0"+ - "y\2\u05f0\u05ef\3\2\2\2\u05f0\u05f1\3\2\2\2\u05f1\u0111\3\2\2\2\u05f2"+ - "\u05f3\7R\2\2\u05f3\u05f6\5\u00e6t\2\u05f4\u05f6\7N\2\2\u05f5\u05f2\3"+ - "\2\2\2\u05f5\u05f4\3\2\2\2\u05f6\u0113\3\2\2\2\u05f7\u0600\7[\2\2\u05f8"+ - "\u0601\5\u0116\u008c\2\u05f9\u05fa\5\u0170\u00b9\2\u05fa\u05fb\5\u0116"+ - "\u008c\2\u05fb\u0601\3\2\2\2\u05fc\u05fd\5\u00f2z\2\u05fd\u05fe\5\u0170"+ - "\u00b9\2\u05fe\u05ff\5\u0116\u008c\2\u05ff\u0601\3\2\2\2\u0600\u05f8\3"+ - "\2\2\2\u0600\u05f9\3\2\2\2\u0600\u05fc\3\2\2\2\u0601\u0602\3\2\2\2\u0602"+ - "\u0606\7j\2\2\u0603\u0605\5\u0118\u008d\2\u0604\u0603\3\2\2\2\u0605\u0608"+ - "\3\2\2\2\u0606\u0604\3\2\2\2\u0606\u0607\3\2\2\2\u0607\u0609\3\2\2\2\u0608"+ - "\u0606\3\2\2\2\u0609\u060a\7k\2\2\u060a\u0115\3\2\2\2\u060b\u060c\7g\2"+ - "\2\u060c\u060e\7u\2\2\u060d\u060b\3\2\2\2\u060d\u060e\3\2\2\2\u060e\u060f"+ - "\3\2\2\2\u060f\u0610\5\u00b4[\2\u0610\u0611\7r\2\2\u0611\u0612\7h\2\2"+ - "\u0612\u0613\7`\2\2\u0613\u0614\7i\2\2\u0614\u0117\3\2\2\2\u0615\u0616"+ - "\5\u011a\u008e\2\u0616\u0618\7q\2\2\u0617\u0619\5\u00f0y\2\u0618\u0617"+ - "\3\2\2\2\u0618\u0619\3\2\2\2\u0619\u0119\3\2\2\2\u061a\u061b\7R\2\2\u061b"+ - "\u061e\5\u011c\u008f\2\u061c\u061e\7N\2\2\u061d\u061a\3\2\2\2\u061d\u061c"+ - "\3\2\2\2\u061e\u011b\3\2\2\2\u061f\u0622\5\u00c2b\2\u0620\u0622\7f\2\2"+ - "\u0621\u061f\3\2\2\2\u0621\u0620\3\2\2\2\u0622\u062a\3\2\2\2\u0623\u0626"+ - "\7o\2\2\u0624\u0627\5\u00c2b\2\u0625\u0627\7f\2\2\u0626\u0624\3\2\2\2"+ - "\u0626\u0625\3\2\2\2\u0627\u0629\3\2\2\2\u0628\u0623\3\2\2\2\u0629\u062c"+ - "\3\2\2\2\u062a\u0628\3\2\2\2\u062a\u062b\3\2\2\2\u062b\u011d\3\2\2\2\u062c"+ - "\u062a\3\2\2\2\u062d\u062e\7Q\2\2\u062e\u0632\7j\2\2\u062f\u0631\5\u0120"+ - "\u0091\2\u0630\u062f\3\2\2\2\u0631\u0634\3\2\2\2\u0632\u0630\3\2\2\2\u0632"+ - "\u0633\3\2\2\2\u0633\u0635\3\2\2\2\u0634\u0632\3\2\2\2\u0635\u0636\7k"+ - "\2\2\u0636\u011f\3\2\2\2\u0637\u0638\5\u0122\u0092\2\u0638\u063a\7q\2"+ - "\2\u0639\u063b\5\u00f0y\2\u063a\u0639\3\2\2\2\u063a\u063b\3\2\2\2\u063b"+ - "\u0121\3\2\2\2\u063c\u063f\7R\2\2\u063d\u0640\5\u00f6|\2\u063e\u0640\5"+ - "\u0124\u0093\2\u063f\u063d\3\2\2\2\u063f\u063e\3\2\2\2\u0640\u0643\3\2"+ - "\2\2\u0641\u0643\7N\2\2\u0642\u063c\3\2\2\2\u0642\u0641\3\2\2\2\u0643"+ - "\u0123\3\2\2\2\u0644\u0645\5\u00e6t\2\u0645\u0646\7n\2\2\u0646\u064b\3"+ - "\2\2\2\u0647\u0648\5\u00e4s\2\u0648\u0649\7u\2\2\u0649\u064b\3\2\2\2\u064a"+ - "\u0644\3\2\2\2\u064a\u0647\3\2\2\2\u064a\u064b\3\2\2\2\u064b\u064c\3\2"+ - "\2\2\u064c\u064d\5\u00a4S\2\u064d\u0125\3\2\2\2\u064e\u0652\7b\2\2\u064f"+ - "\u0653\5\u00a4S\2\u0650\u0653\5\u0128\u0095\2\u0651\u0653\5\u00d8m\2\u0652"+ - "\u064f\3\2\2\2\u0652\u0650\3\2\2\2\u0652\u0651\3\2\2\2\u0652\u0653\3\2"+ - "\2\2\u0653\u0654\3\2\2\2\u0654\u0655\5\u00eex\2\u0655\u0127\3\2\2\2\u0656"+ - "\u0658\5\u00f2z\2\u0657\u0656\3\2\2\2\u0657\u0658\3\2\2\2\u0658\u0659"+ - "\3\2\2\2\u0659\u065b\5\u0170\u00b9\2\u065a\u065c\5\u00a4S\2\u065b\u065a"+ - "\3\2\2\2\u065b\u065c\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u065f\5\u0170\u00b9"+ - "\2\u065e\u0660\5\u00f2z\2\u065f\u065e\3\2\2\2\u065f\u0660\3\2\2\2\u0660"+ - "\u0129\3\2\2\2\u0661\u0662\7T\2\2\u0662\u0663\5\u00a4S\2\u0663\u012b\3"+ - "\2\2\2\u0664\u0667\5\u0150\u00a9\2\u0665\u0667\7g\2\2\u0666\u0664\3\2"+ - "\2\2\u0666\u0665\3\2\2\2\u0667\u012d\3\2\2\2\u0668\u0669\7l\2\2\u0669"+ - "\u066a\5\u0130\u0099\2\u066a\u066b\7m\2\2\u066b\u066c\5\u0132\u009a\2"+ - "\u066c\u012f\3\2\2\2\u066d\u066e\5\u00a4S\2\u066e\u0131\3\2\2\2\u066f"+ - "\u0670\5\u00c2b\2\u0670\u0133\3\2\2\2\u0671\u0672\7\u0089\2\2\u0672\u0673"+ - "\5\u00c2b\2\u0673\u0135\3\2\2\2\u0674\u0675\7l\2\2\u0675\u0676\7m\2\2"+ - "\u0676\u0677\5\u0132\u009a\2\u0677\u0137\3\2\2\2\u0678\u0679\7U\2\2\u0679"+ - "\u067a\7l\2\2\u067a\u067b\5\u00c2b\2\u067b\u067c\7m\2\2\u067c\u067d\5"+ - "\u0132\u009a\2\u067d\u0139\3\2\2\2\u067e\u0684\7W\2\2\u067f\u0680\7W\2"+ - "\2\u0680\u0684\7\u008b\2\2\u0681\u0682\7\u008b\2\2\u0682\u0684\7W\2\2"+ - "\u0683\u067e\3\2\2\2\u0683\u067f\3\2\2\2\u0683\u0681\3\2\2\2\u0684\u0685"+ - "\3\2\2\2\u0685\u0686\5\u0132\u009a\2\u0686\u013b\3\2\2\2\u0687\u0688\7"+ - "O\2\2\u0688\u0689\5\u013e\u00a0\2\u0689\u013d\3\2\2\2\u068a\u068b\5\u0142"+ - "\u00a2\2\u068b\u068c\5\u0140\u00a1\2\u068c\u068f\3\2\2\2\u068d\u068f\5"+ - "\u0142\u00a2\2\u068e\u068a\3\2\2\2\u068e\u068d\3\2\2\2\u068f\u013f\3\2"+ - "\2\2\u0690\u0693\5\u0142\u00a2\2\u0691\u0693\5\u00c2b\2\u0692\u0690\3"+ - "\2\2\2\u0692\u0691\3\2\2\2\u0693\u0141\3\2\2\2\u0694\u06a0\7h\2\2\u0695"+ - "\u069a\5\u009cO\2\u0696\u0697\7o\2\2\u0697\u0699\5\u009cO\2\u0698\u0696"+ - "\3\2\2\2\u0699\u069c\3\2\2\2\u069a\u0698\3\2\2\2\u069a\u069b\3\2\2\2\u069b"+ - "\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069d\u069f\7o\2\2\u069e\u069d\3\2"+ - "\2\2\u069e\u069f\3\2\2\2\u069f\u06a1\3\2\2\2\u06a0\u0695\3\2\2\2\u06a0"+ - "\u06a1\3\2\2\2\u06a1\u06a2\3\2\2\2\u06a2\u06a3\7i\2\2\u06a3\u0143\3\2"+ - "\2\2\u06a4\u06a5\5\u0146\u00a4\2\u06a5\u06a6\7h\2\2\u06a6\u06a8\5\u00a4"+ - "S\2\u06a7\u06a9\7o\2\2\u06a8\u06a7\3\2\2\2\u06a8\u06a9\3\2\2\2\u06a9\u06aa"+ - "\3\2\2\2\u06aa\u06ab\7i\2\2\u06ab\u0145\3\2\2\2\u06ac\u06b2\5\u00c4c\2"+ - "\u06ad\u06ae\7h\2\2\u06ae\u06af\5\u0146\u00a4\2\u06af\u06b0\7i\2\2\u06b0"+ - "\u06b2\3\2\2\2\u06b1\u06ac\3\2\2\2\u06b1\u06ad\3\2\2\2\u06b2\u0147\3\2"+ - "\2\2\u06b3\u06ba\5\u014a\u00a6\2\u06b4\u06ba\5\u014e\u00a8\2\u06b5\u06b6"+ - "\7h\2\2\u06b6\u06b7\5\u00a4S\2\u06b7\u06b8\7i\2\2\u06b8\u06ba\3\2\2\2"+ - "\u06b9\u06b3\3\2\2\2\u06b9\u06b4\3\2\2\2\u06b9\u06b5\3\2\2\2\u06ba\u0149"+ - "\3\2\2\2\u06bb\u06bf\5\u00b2Z\2\u06bc\u06bf\5\u0152\u00aa\2\u06bd\u06bf"+ - "\5\u00b6\\\2\u06be\u06bb\3\2\2\2\u06be\u06bc\3\2\2\2\u06be\u06bd\3\2\2"+ - "\2\u06bf\u014b\3\2\2\2\u06c0\u06c1\t\23\2\2\u06c1\u014d\3\2\2\2\u06c2"+ - "\u06c3\7g\2\2\u06c3\u014f\3\2\2\2\u06c4\u06c5\7g\2\2\u06c5\u06c6\7r\2"+ - "\2\u06c6\u06c7\7g\2\2\u06c7\u0151\3\2\2\2\u06c8\u06c9\5\u00caf\2\u06c9"+ - "\u06ca\5\u0154\u00ab\2\u06ca\u0153\3\2\2\2\u06cb\u06d0\7j\2\2\u06cc\u06ce"+ - "\5\u0156\u00ac\2\u06cd\u06cf\7o\2\2\u06ce\u06cd\3\2\2\2\u06ce\u06cf\3"+ - "\2\2\2\u06cf\u06d1\3\2\2\2\u06d0\u06cc\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ - "\u06d2\3\2\2\2\u06d2\u06d3\7k\2\2\u06d3\u0155\3\2\2\2\u06d4\u06d9\5\u0158"+ - "\u00ad\2\u06d5\u06d6\7o\2\2\u06d6\u06d8\5\u0158\u00ad\2\u06d7\u06d5\3"+ - "\2\2\2\u06d8\u06db\3\2\2\2\u06d9\u06d7\3\2\2\2\u06d9\u06da\3\2\2\2\u06da"+ - "\u0157\3\2\2\2\u06db\u06d9\3\2\2\2\u06dc\u06dd\5\u015a\u00ae\2\u06dd\u06de"+ - "\7q\2\2\u06de\u06e0\3\2\2\2\u06df\u06dc\3\2\2\2\u06df\u06e0\3\2\2\2\u06e0"+ - "\u06e1\3\2\2\2\u06e1\u06e2\5\u015c\u00af\2\u06e2\u0159\3\2\2\2\u06e3\u06e6"+ - "\5\u00a4S\2\u06e4\u06e6\5\u0154\u00ab\2\u06e5\u06e3\3\2\2\2\u06e5\u06e4"+ - "\3\2\2\2\u06e6\u015b\3\2\2\2\u06e7\u06ea\5\u00a4S\2\u06e8\u06ea\5\u0154"+ - "\u00ab\2\u06e9\u06e7\3\2\2\2\u06e9\u06e8\3\2\2\2\u06ea\u015d\3\2\2\2\u06eb"+ - "\u06ec\7V\2\2\u06ec\u06f2\7j\2\2\u06ed\u06ee\5\u0160\u00b1\2\u06ee\u06ef"+ - "\5\u0170\u00b9\2\u06ef\u06f1\3\2\2\2\u06f0\u06ed\3\2\2\2\u06f1\u06f4\3"+ - "\2\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f5\3\2\2\2\u06f4"+ - "\u06f2\3\2\2\2\u06f5\u06f6\7k\2\2\u06f6\u015f\3\2\2\2\u06f7\u06f8\5\u00e4"+ - "s\2\u06f8\u06f9\5\u00c2b\2\u06f9\u06fc\3\2\2\2\u06fa\u06fc\5\u0164\u00b3"+ - "\2\u06fb\u06f7\3\2\2\2\u06fb\u06fa\3\2\2\2\u06fc\u06fe\3\2\2\2\u06fd\u06ff"+ - "\5\u0162\u00b2\2\u06fe\u06fd\3\2\2\2\u06fe\u06ff\3\2\2\2\u06ff\u0161\3"+ - "\2\2\2\u0700\u0701\t\24\2\2\u0701\u0163\3\2\2\2\u0702\u0704\7\u0089\2"+ - "\2\u0703\u0702\3\2\2\2\u0703\u0704\3\2\2\2\u0704\u0705\3\2\2\2\u0705\u0706"+ - "\5\u012c\u0097\2\u0706\u0165\3\2\2\2\u0707\u0708\7l\2\2\u0708\u0709\5"+ - "\u00a4S\2\u0709\u070a\7m\2\2\u070a\u0167\3\2\2\2\u070b\u070c\7r\2\2\u070c"+ - "\u070d\7h\2\2\u070d\u070e\5\u00c2b\2\u070e\u070f\7i\2\2\u070f\u0169\3"+ - "\2\2\2\u0710\u071f\7h\2\2\u0711\u0718\5\u00e6t\2\u0712\u0715\5\u0146\u00a4"+ - "\2\u0713\u0714\7o\2\2\u0714\u0716\5\u00e6t\2\u0715\u0713\3\2\2\2\u0715"+ - "\u0716\3\2\2\2\u0716\u0718\3\2\2\2\u0717\u0711\3\2\2\2\u0717\u0712\3\2"+ - "\2\2\u0718\u071a\3\2\2\2\u0719\u071b\7v\2\2\u071a\u0719\3\2\2\2\u071a"+ - "\u071b\3\2\2\2\u071b\u071d\3\2\2\2\u071c\u071e\7o\2\2\u071d\u071c\3\2"+ - "\2\2\u071d\u071e\3\2\2\2\u071e\u0720\3\2\2\2\u071f\u0717\3\2\2\2\u071f"+ - "\u0720\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u0722\7i\2\2\u0722\u016b\3\2"+ - "\2\2\u0723\u0724\5\u0146\u00a4\2\u0724\u0725\7r\2\2\u0725\u0726\7g\2\2"+ - "\u0726\u016d\3\2\2\2\u0727\u0728\5\u00c2b\2\u0728\u016f\3\2\2\2\u0729"+ - "\u072e\7p\2\2\u072a\u072e\7\2\2\3\u072b\u072e\7\u00a1\2\2\u072c\u072e"+ - "\6\u00b9\24\2\u072d\u0729\3\2\2\2\u072d\u072a\3\2\2\2\u072d\u072b\3\2"+ - "\2\2\u072d\u072c\3\2\2\2\u072e\u0171\3\2\2\2\u00bd\u0180\u0185\u018c\u0196"+ - "\u019c\u01a2\u01b2\u01b6\u01bf\u01cb\u01cf\u01d5\u01de\u01e8\u01f9\u0207"+ - "\u020b\u0212\u021a\u0223\u0243\u024b\u0263\u0276\u0285\u0292\u029b\u02a9"+ - "\u02b2\u02be\u02d3\u02da\u02df\u02e4\u02ee\u02f1\u02f5\u02f9\u0301\u0309"+ - "\u030e\u0316\u0318\u031d\u0324\u032c\u032f\u0335\u033a\u033c\u033f\u0346"+ - "\u034b\u035e\u0366\u036a\u036d\u0373\u0377\u037a\u0384\u038b\u0392\u039e"+ - "\u03a4\u03ab\u03b0\u03b6\u03c2\u03c8\u03cc\u03d4\u03d8\u03de\u03e1\u03e7"+ - "\u03ec\u0405\u0428\u042a\u0441\u0449\u0454\u045b\u0462\u046c\u047a\u0490"+ - "\u0492\u049a\u049e\u04a2\u04a5\u04ae\u04b4\u04be\u04c6\u04cc\u04d5\u04e0"+ - "\u04eb\u04ef\u04f1\u04fc\u0505\u0509\u050c\u0513\u051e\u0528\u052e\u0530"+ - "\u053a\u0544\u0548\u054c\u0550\u0557\u055f\u056a\u056e\u0572\u057e\u0582"+ - "\u0586\u058b\u0592\u0599\u05ad\u05b1\u05b5\u05b9\u05c9\u05cf\u05d1\u05d5"+ - "\u05d9\u05dc\u05e0\u05e2\u05e8\u05f0\u05f5\u0600\u0606\u060d\u0618\u061d"+ - "\u0621\u0626\u062a\u0632\u063a\u063f\u0642\u064a\u0652\u0657\u065b\u065f"+ - "\u0666\u0683\u068e\u0692\u069a\u069e\u06a0\u06a8\u06b1\u06b9\u06be\u06ce"+ - "\u06d0\u06d9\u06df\u06e5\u06e9\u06f2\u06fb\u06fe\u0703\u0715\u0717\u071a"+ - "\u071d\u071f\u072d"; + "\u0004\u0001\u00a0\u074c\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+ + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+ + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+ + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+ + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+ + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+ + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+ + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+ + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+ + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+ + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+ + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+ + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+ + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+ + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+ + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+ + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+ + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+ + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+ + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+ + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+ + "Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+ + "^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+ + "c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+ + "h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007"+ + "m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007"+ + "r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007"+ + "w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007"+ + "|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007"+ + "\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007"+ + "\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007"+ + "\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007"+ + "\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007"+ + "\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007"+ + "\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007"+ + "\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007"+ + "\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007"+ + "\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007"+ + "\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007"+ + "\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007"+ + "\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007"+ + "\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007"+ + "\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007"+ + "\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007"+ + "\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007"+ + "\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007"+ + "\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007"+ + "\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0001\u0000\u0001"+ + "\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001"+ + "\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0005\u0003\u017f"+ + "\b\u0003\n\u0003\f\u0003\u0182\t\u0003\u0001\u0004\u0001\u0004\u0003\u0004"+ + "\u0186\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u018b\b"+ + "\u0005\n\u0005\f\u0005\u018e\t\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+ + "\u0001\u0005\u0001\u0005\u0005\u0005\u0195\b\u0005\n\u0005\f\u0005\u0198"+ + "\t\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u019d\b\u0005"+ + "\u0001\u0005\u0001\u0005\u0005\u0005\u01a1\b\u0005\n\u0005\f\u0005\u01a4"+ + "\t\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0005"+ + "\u0006\u01ab\b\u0006\n\u0006\f\u0006\u01ae\t\u0006\u0001\u0006\u0001\u0006"+ + "\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u01b5\b\u0006\n\u0006"+ + "\f\u0006\u01b8\t\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001"+ + "\b\u0001\b\u0001\t\u0001\t\u0001\t\u0005\t\u01c3\b\t\n\t\f\t\u01c6\t\t"+ + "\u0001\t\u0003\t\u01c9\b\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0005"+ + "\n\u01d0\b\n\n\n\f\n\u01d3\t\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n"+ + "\u0001\n\u0001\n\u0005\n\u01dc\b\n\n\n\f\n\u01df\t\n\u0001\n\u0003\n\u01e2"+ + "\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u01e8"+ + "\b\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0003"+ + "\f\u01f1\b\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ + "\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u01fb\b\u000f\u0001\u000f\u0001"+ + "\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0010\u0003\u0010\u020c\b\u0010\u0001\u0011\u0001\u0011\u0001"+ + "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0005\u0013\u0218\b\u0013\n\u0013\f\u0013\u021b\t\u0013"+ + "\u0001\u0013\u0003\u0013\u021e\b\u0013\u0001\u0014\u0001\u0014\u0001\u0014"+ + "\u0005\u0014\u0223\b\u0014\n\u0014\f\u0014\u0226\t\u0014\u0001\u0014\u0001"+ + "\u0014\u0001\u0015\u0005\u0015\u022b\b\u0015\n\u0015\f\u0015\u022e\t\u0015"+ + "\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0005\u0016\u0234\b\u0016"+ + "\n\u0016\f\u0016\u0237\t\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001"+ + "\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001"+ + "\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001"+ + "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001"+ + "\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0003\u001c\u0256\b\u001c\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0003\u001d\u025e\b\u001d\u0001"+ + "\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ + "\u001f\u0001 \u0001 \u0001 \u0001 \u0001 \u0001!\u0001!\u0001!\u0001!"+ + "\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0003\"\u0276\b\"\u0001"+ + "\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001"+ + "$\u0001$\u0001$\u0001$\u0001$\u0005$\u0287\b$\n$\f$\u028a\t$\u0001$\u0001"+ + "$\u0001%\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001&\u0005&\u0296"+ + "\b&\n&\f&\u0299\t&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ + "(\u0001(\u0001(\u0001(\u0003(\u02a5\b(\u0001)\u0001)\u0001)\u0001)\u0001"+ + ")\u0005)\u02ac\b)\n)\f)\u02af\t)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001"+ + "*\u0001*\u0001*\u0001*\u0001*\u0001*\u0003*\u02bc\b*\u0001+\u0001+\u0001"+ + "+\u0001+\u0001+\u0005+\u02c3\b+\n+\f+\u02c6\t+\u0001+\u0001+\u0001,\u0001"+ + ",\u0001,\u0001,\u0001,\u0005,\u02cf\b,\n,\f,\u02d2\t,\u0001,\u0001,\u0001"+ + "-\u0001-\u0001-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001.\u0001.\u0001"+ + ".\u0001.\u0001.\u0001.\u0001.\u0001.\u0003.\u02e6\b.\u0001/\u0001/\u0001"+ + "/\u0001/\u0001/\u0003/\u02ed\b/\u0001/\u0005/\u02f0\b/\n/\f/\u02f3\t/"+ + "\u0001/\u0001/\u0003/\u02f7\b/\u00010\u00010\u00010\u00010\u00010\u0001"+ + "0\u00010\u00010\u00030\u0301\b0\u00011\u00031\u0304\b1\u00011\u00011\u0003"+ + "1\u0308\b1\u00012\u00012\u00032\u030c\b2\u00013\u00013\u00013\u00013\u0005"+ + "3\u0312\b3\n3\f3\u0315\t3\u00013\u00013\u00014\u00014\u00014\u00034\u031c"+ + "\b4\u00015\u00015\u00015\u00035\u0321\b5\u00016\u00016\u00016\u00016\u0001"+ + "6\u00016\u00036\u0329\b6\u00036\u032b\b6\u00016\u00016\u00016\u00036\u0330"+ + "\b6\u00017\u00017\u00017\u00057\u0335\b7\n7\f7\u0338\t7\u00018\u00018"+ + "\u00018\u00018\u00018\u00038\u033f\b8\u00018\u00038\u0342\b8\u00018\u0001"+ + "8\u00019\u00019\u00039\u0348\b9\u00019\u00019\u00019\u00039\u034d\b9\u0003"+ + "9\u034f\b9\u00019\u00039\u0352\b9\u0001:\u0001:\u0001:\u0005:\u0357\b"+ + ":\n:\f:\u035a\t:\u0001;\u0001;\u0003;\u035e\b;\u0001;\u0001;\u0001<\u0001"+ + "<\u0001<\u0001<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001"+ + "=\u0001=\u0005=\u036f\b=\n=\f=\u0372\t=\u0001=\u0001=\u0001=\u0005=\u0377"+ + "\b=\n=\f=\u037a\t=\u0001=\u0003=\u037d\b=\u0001>\u0003>\u0380\b>\u0001"+ + ">\u0001>\u0001>\u0001>\u0003>\u0386\b>\u0001?\u0001?\u0003?\u038a\b?\u0001"+ + "?\u0003?\u038d\b?\u0001?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001@\u0001"+ + "@\u0003@\u0397\b@\u0001A\u0001A\u0001A\u0001A\u0001A\u0003A\u039e\bA\u0001"+ + "B\u0001B\u0001B\u0001B\u0001B\u0003B\u03a5\bB\u0001B\u0001B\u0001C\u0001"+ + "C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0003D\u03b1\bD\u0001E\u0001"+ + "E\u0001E\u0001E\u0003E\u03b7\bE\u0001F\u0001F\u0001F\u0001F\u0001F\u0003"+ + "F\u03be\bF\u0001G\u0001G\u0001G\u0003G\u03c3\bG\u0001H\u0001H\u0001H\u0001"+ + "H\u0003H\u03c9\bH\u0001I\u0001I\u0001I\u0001I\u0001I\u0001J\u0001J\u0001"+ + "J\u0001J\u0001J\u0003J\u03d5\bJ\u0001K\u0001K\u0001K\u0001K\u0003K\u03db"+ + "\bK\u0001K\u0001K\u0003K\u03df\bK\u0001L\u0001L\u0001L\u0001L\u0001M\u0001"+ + "M\u0003M\u03e7\bM\u0001M\u0001M\u0003M\u03eb\bM\u0001M\u0001M\u0001N\u0001"+ + "N\u0003N\u03f1\bN\u0001O\u0003O\u03f4\bO\u0001O\u0001O\u0001P\u0001P\u0003"+ + "P\u03fa\bP\u0001P\u0001P\u0001Q\u0003Q\u03ff\bQ\u0001Q\u0001Q\u0001R\u0001"+ + "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ + "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0003"+ + "R\u0418\bR\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ + "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ + "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ + "R\u0001R\u0001R\u0001R\u0001R\u0005R\u043b\bR\nR\fR\u043e\tR\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0003S\u0454"+ + "\bS\u0001T\u0001T\u0001T\u0001U\u0001U\u0001U\u0003U\u045c\bU\u0001V\u0001"+ + "V\u0001V\u0001W\u0001W\u0001W\u0001W\u0005W\u0465\bW\nW\fW\u0468\tW\u0001"+ + "W\u0001W\u0001W\u0001W\u0003W\u046e\bW\u0001X\u0001X\u0001X\u0001X\u0001"+ + "X\u0003X\u0475\bX\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ + "Y\u0003Y\u047f\bY\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ + "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u048d\bZ\u0001Z\u0001Z\u0001Z\u0001"+ + "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ + "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0005Z\u04a3\bZ\nZ\fZ\u04a6"+ + "\tZ\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0003\\\u04ad\b\\\u0001\\\u0001"+ + "\\\u0003\\\u04b1\b\\\u0001]\u0001]\u0003]\u04b5\b]\u0001]\u0003]\u04b8"+ + "\b]\u0001]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001^\u0003^\u04c1\b^\u0001"+ + "^\u0001^\u0005^\u04c5\b^\n^\f^\u04c8\t^\u0001^\u0001^\u0001_\u0001_\u0001"+ + "_\u0001_\u0001`\u0003`\u04d1\b`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001"+ + "`\u0003`\u04d9\b`\u0001`\u0001`\u0001`\u0001`\u0003`\u04df\b`\u0001a\u0001"+ + "a\u0001a\u0001a\u0001a\u0001a\u0001a\u0003a\u04e8\ba\u0001b\u0001b\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0003b\u04f3\bb\u0001c\u0001"+ + "c\u0001c\u0001d\u0001d\u0001d\u0001d\u0005d\u04fc\bd\nd\fd\u04ff\td\u0001"+ + "d\u0003d\u0502\bd\u0003d\u0504\bd\u0001d\u0001d\u0001e\u0001e\u0001e\u0001"+ + "e\u0001e\u0001e\u0001e\u0003e\u050f\be\u0001f\u0001f\u0001f\u0001f\u0001"+ + "f\u0001g\u0001g\u0003g\u0518\bg\u0001g\u0001g\u0003g\u051c\bg\u0001g\u0003"+ + "g\u051f\bg\u0001g\u0001g\u0001g\u0001g\u0001g\u0003g\u0526\bg\u0001g\u0001"+ + "g\u0001h\u0001h\u0001i\u0001i\u0001j\u0001j\u0001k\u0003k\u0531\bk\u0001"+ + "k\u0001k\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0003l\u053b\bl\u0001"+ + "l\u0001l\u0001l\u0001l\u0003l\u0541\bl\u0003l\u0543\bl\u0001m\u0001m\u0001"+ + "m\u0001n\u0001n\u0001o\u0001o\u0001o\u0003o\u054d\bo\u0001p\u0001p\u0001"+ + "p\u0001p\u0001p\u0001p\u0005p\u0555\bp\np\fp\u0558\tp\u0001p\u0003p\u055b"+ + "\bp\u0001q\u0001q\u0003q\u055f\bq\u0001q\u0001q\u0003q\u0563\bq\u0001"+ + "r\u0001r\u0001r\u0005r\u0568\br\nr\fr\u056b\tr\u0001s\u0001s\u0001s\u0005"+ + "s\u0570\bs\ns\fs\u0573\ts\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0005"+ + "t\u057b\bt\nt\ft\u057e\tt\u0001t\u0003t\u0581\bt\u0001u\u0001u\u0003u"+ + "\u0585\bu\u0001u\u0001u\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0005"+ + "v\u058f\bv\nv\fv\u0592\tv\u0001v\u0003v\u0595\bv\u0001w\u0001w\u0003w"+ + "\u0599\bw\u0001w\u0001w\u0001x\u0003x\u059e\bx\u0001x\u0003x\u05a1\bx"+ + "\u0001x\u0003x\u05a4\bx\u0001x\u0001x\u0001x\u0004x\u05a9\bx\u000bx\f"+ + "x\u05aa\u0001y\u0001y\u0001y\u0001y\u0001y\u0003y\u05b2\by\u0001z\u0001"+ + "z\u0001{\u0001{\u0001{\u0001{\u0001|\u0001|\u0001|\u0001}\u0001}\u0001"+ + "}\u0001}\u0001~\u0001~\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f"+ + "\u05c6\b\u007f\u0001\u0080\u0001\u0080\u0003\u0080\u05ca\b\u0080\u0001"+ + "\u0081\u0001\u0081\u0003\u0081\u05ce\b\u0081\u0001\u0082\u0001\u0082\u0003"+ + "\u0082\u05d2\b\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0084\u0001"+ + "\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001"+ + "\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u05e2\b\u0085\u0001"+ + "\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u05e8\b\u0085\u0003"+ + "\u0085\u05ea\b\u0085\u0001\u0086\u0001\u0086\u0003\u0086\u05ee\b\u0086"+ + "\u0001\u0087\u0001\u0087\u0003\u0087\u05f2\b\u0087\u0001\u0087\u0003\u0087"+ + "\u05f5\b\u0087\u0001\u0087\u0001\u0087\u0003\u0087\u05f9\b\u0087\u0003"+ + "\u0087\u05fb\b\u0087\u0001\u0087\u0001\u0087\u0005\u0087\u05ff\b\u0087"+ + "\n\u0087\f\u0087\u0602\t\u0087\u0001\u0087\u0001\u0087\u0001\u0088\u0001"+ + "\u0088\u0001\u0088\u0003\u0088\u0609\b\u0088\u0001\u0089\u0001\u0089\u0001"+ + "\u0089\u0003\u0089\u060e\b\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0001"+ + "\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0003"+ + "\u008a\u0619\b\u008a\u0001\u008a\u0001\u008a\u0005\u008a\u061d\b\u008a"+ + "\n\u008a\f\u008a\u0620\t\u008a\u0001\u008a\u0001\u008a\u0001\u008b\u0001"+ + "\u008b\u0003\u008b\u0626\b\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+ + "\u008b\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c\u0001\u008c\u0003"+ + "\u008c\u0631\b\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0003\u008d\u0636"+ + "\b\u008d\u0001\u008e\u0001\u008e\u0003\u008e\u063a\b\u008e\u0001\u008e"+ + "\u0001\u008e\u0001\u008e\u0003\u008e\u063f\b\u008e\u0005\u008e\u0641\b"+ + "\u008e\n\u008e\f\u008e\u0644\t\u008e\u0001\u008f\u0001\u008f\u0001\u008f"+ + "\u0005\u008f\u0649\b\u008f\n\u008f\f\u008f\u064c\t\u008f\u0001\u008f\u0001"+ + "\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0653\b\u0090\u0001"+ + "\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u0658\b\u0091\u0001\u0091\u0003"+ + "\u0091\u065b\b\u0091\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+ + "\u0092\u0001\u0092\u0003\u0092\u0663\b\u0092\u0001\u0092\u0001\u0092\u0001"+ + "\u0093\u0001\u0093\u0003\u0093\u0669\b\u0093\u0001\u0093\u0001\u0093\u0003"+ + "\u0093\u066d\b\u0093\u0003\u0093\u066f\b\u0093\u0001\u0093\u0001\u0093"+ + "\u0001\u0094\u0003\u0094\u0674\b\u0094\u0001\u0094\u0001\u0094\u0003\u0094"+ + "\u0678\b\u0094\u0001\u0094\u0001\u0094\u0003\u0094\u067c\b\u0094\u0001"+ + "\u0095\u0001\u0095\u0001\u0095\u0001\u0096\u0001\u0096\u0003\u0096\u0683"+ + "\b\u0096\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001"+ + "\u0098\u0001\u0098\u0001\u0099\u0001\u0099\u0001\u009a\u0001\u009a\u0001"+ + "\u009a\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009c\u0001"+ + "\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009d\u0001"+ + "\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0003\u009d\u06a0\b\u009d\u0001"+ + "\u009d\u0001\u009d\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009f\u0001"+ + "\u009f\u0001\u009f\u0001\u009f\u0003\u009f\u06ab\b\u009f\u0001\u00a0\u0001"+ + "\u00a0\u0003\u00a0\u06af\b\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+ + "\u00a1\u0005\u00a1\u06b5\b\u00a1\n\u00a1\f\u00a1\u06b8\t\u00a1\u0001\u00a1"+ + "\u0003\u00a1\u06bb\b\u00a1\u0003\u00a1\u06bd\b\u00a1\u0001\u00a1\u0001"+ + "\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0003\u00a2\u06c5"+ + "\b\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001"+ + "\u00a3\u0001\u00a3\u0003\u00a3\u06ce\b\u00a3\u0001\u00a4\u0001\u00a4\u0001"+ + "\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0003\u00a4\u06d6\b\u00a4\u0001"+ + "\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u06db\b\u00a5\u0001\u00a6\u0001"+ + "\u00a6\u0001\u00a7\u0001\u00a7\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001"+ + "\u00a8\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00aa\u0001\u00aa\u0001"+ + "\u00aa\u0003\u00aa\u06eb\b\u00aa\u0003\u00aa\u06ed\b\u00aa\u0001\u00aa"+ + "\u0001\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0005\u00ab\u06f4\b\u00ab"+ + "\n\u00ab\f\u00ab\u06f7\t\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003"+ + "\u00ac\u06fc\b\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0003"+ + "\u00ad\u0702\b\u00ad\u0001\u00ae\u0001\u00ae\u0003\u00ae\u0706\b\u00ae"+ + "\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0005\u00af"+ + "\u070d\b\u00af\n\u00af\f\u00af\u0710\t\u00af\u0001\u00af\u0001\u00af\u0001"+ + "\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0\u0718\b\u00b0\u0001"+ + "\u00b0\u0003\u00b0\u071b\b\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b2\u0003"+ + "\u00b2\u0720\b\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b3\u0001\u00b3\u0001"+ + "\u00b3\u0001\u00b3\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001"+ + "\u00b4\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0003"+ + "\u00b5\u0732\b\u00b5\u0003\u00b5\u0734\b\u00b5\u0001\u00b5\u0003\u00b5"+ + "\u0737\b\u00b5\u0001\u00b5\u0003\u00b5\u073a\b\u00b5\u0003\u00b5\u073c"+ + "\b\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001"+ + "\u00b6\u0001\u00b7\u0001\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001"+ + "\u00b8\u0003\u00b8\u074a\b\u00b8\u0001\u00b8\u0001\u02f1\u0002\u00a4\u00b4"+ + "\u00b9\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018"+ + "\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080"+ + "\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098"+ + "\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0"+ + "\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8"+ + "\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0"+ + "\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8"+ + "\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110"+ + "\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128"+ + "\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140"+ + "\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158"+ + "\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170"+ + "\u0000\u0013\u0002\u0000eepp\u0001\u0000\u0017\u0018\u0001\u0000\u0005"+ + "\b\u0001\u0000AB\u0001\u0000(*\u0002\u0000(*,,\u0001\u0000\u0083\u0089"+ + "\u0001\u0000\u0014\u0015\u0002\u0000~\u0082\u0087\u0088\u0004\u0000##"+ + "qq}}\u0084\u0086\u0001\u0000\u001f!\u0001\u0000\u001c\u001e\u0002\u0000"+ + "HIw|\u0004\u0000--0033]]\u0002\u0000}\u0082\u0084\u0088\u0001\u0000qr"+ + "\u0002\u0000nn\u009f\u009f\u0002\u0000\u008a\u008d\u008f\u0090\u0001\u0000"+ + "\u0096\u0097\u07b5\u0000\u0172\u0001\u0000\u0000\u0000\u0002\u0175\u0001"+ + "\u0000\u0000\u0000\u0004\u0178\u0001\u0000\u0000\u0000\u0006\u017b\u0001"+ + "\u0000\u0000\u0000\b\u0183\u0001\u0000\u0000\u0000\n\u018c\u0001\u0000"+ + "\u0000\u0000\f\u01ac\u0001\u0000\u0000\u0000\u000e\u01b9\u0001\u0000\u0000"+ + "\u0000\u0010\u01bc\u0001\u0000\u0000\u0000\u0012\u01c4\u0001\u0000\u0000"+ + "\u0000\u0014\u01d1\u0001\u0000\u0000\u0000\u0016\u01e7\u0001\u0000\u0000"+ + "\u0000\u0018\u01f0\u0001\u0000\u0000\u0000\u001a\u01f2\u0001\u0000\u0000"+ + "\u0000\u001c\u01f4\u0001\u0000\u0000\u0000\u001e\u01f7\u0001\u0000\u0000"+ + "\u0000 \u020b\u0001\u0000\u0000\u0000\"\u020d\u0001\u0000\u0000\u0000"+ + "$\u020f\u0001\u0000\u0000\u0000&\u0214\u0001\u0000\u0000\u0000(\u021f"+ + "\u0001\u0000\u0000\u0000*\u022c\u0001\u0000\u0000\u0000,\u022f\u0001\u0000"+ + "\u0000\u0000.\u023a\u0001\u0000\u0000\u00000\u023c\u0001\u0000\u0000\u0000"+ + "2\u0241\u0001\u0000\u0000\u00004\u0246\u0001\u0000\u0000\u00006\u024b"+ + "\u0001\u0000\u0000\u00008\u0250\u0001\u0000\u0000\u0000:\u025d\u0001\u0000"+ + "\u0000\u0000<\u025f\u0001\u0000\u0000\u0000>\u0261\u0001\u0000\u0000\u0000"+ + "@\u0266\u0001\u0000\u0000\u0000B\u026b\u0001\u0000\u0000\u0000D\u0270"+ + "\u0001\u0000\u0000\u0000F\u0279\u0001\u0000\u0000\u0000H\u0280\u0001\u0000"+ + "\u0000\u0000J\u028d\u0001\u0000\u0000\u0000L\u0291\u0001\u0000\u0000\u0000"+ + "N\u029c\u0001\u0000\u0000\u0000P\u02a4\u0001\u0000\u0000\u0000R\u02a6"+ + "\u0001\u0000\u0000\u0000T\u02bb\u0001\u0000\u0000\u0000V\u02bd\u0001\u0000"+ + "\u0000\u0000X\u02c9\u0001\u0000\u0000\u0000Z\u02d5\u0001\u0000\u0000\u0000"+ + "\\\u02e5\u0001\u0000\u0000\u0000^\u02f1\u0001\u0000\u0000\u0000`\u0300"+ + "\u0001\u0000\u0000\u0000b\u0303\u0001\u0000\u0000\u0000d\u030b\u0001\u0000"+ + "\u0000\u0000f\u030d\u0001\u0000\u0000\u0000h\u0318\u0001\u0000\u0000\u0000"+ + "j\u0320\u0001\u0000\u0000\u0000l\u032f\u0001\u0000\u0000\u0000n\u0331"+ + "\u0001\u0000\u0000\u0000p\u0339\u0001\u0000\u0000\u0000r\u0347\u0001\u0000"+ + "\u0000\u0000t\u0353\u0001\u0000\u0000\u0000v\u035d\u0001\u0000\u0000\u0000"+ + "x\u0361\u0001\u0000\u0000\u0000z\u0367\u0001\u0000\u0000\u0000|\u037f"+ + "\u0001\u0000\u0000\u0000~\u0387\u0001\u0000\u0000\u0000\u0080\u0396\u0001"+ + "\u0000\u0000\u0000\u0082\u0398\u0001\u0000\u0000\u0000\u0084\u039f\u0001"+ + "\u0000\u0000\u0000\u0086\u03a8\u0001\u0000\u0000\u0000\u0088\u03ad\u0001"+ + "\u0000\u0000\u0000\u008a\u03b2\u0001\u0000\u0000\u0000\u008c\u03b8\u0001"+ + "\u0000\u0000\u0000\u008e\u03bf\u0001\u0000\u0000\u0000\u0090\u03c4\u0001"+ + "\u0000\u0000\u0000\u0092\u03ca\u0001\u0000\u0000\u0000\u0094\u03cf\u0001"+ + "\u0000\u0000\u0000\u0096\u03d6\u0001\u0000\u0000\u0000\u0098\u03e0\u0001"+ + "\u0000\u0000\u0000\u009a\u03e4\u0001\u0000\u0000\u0000\u009c\u03f0\u0001"+ + "\u0000\u0000\u0000\u009e\u03f3\u0001\u0000\u0000\u0000\u00a0\u03f7\u0001"+ + "\u0000\u0000\u0000\u00a2\u03fe\u0001\u0000\u0000\u0000\u00a4\u0417\u0001"+ + "\u0000\u0000\u0000\u00a6\u0453\u0001\u0000\u0000\u0000\u00a8\u0455\u0001"+ + "\u0000\u0000\u0000\u00aa\u0458\u0001\u0000\u0000\u0000\u00ac\u045d\u0001"+ + "\u0000\u0000\u0000\u00ae\u0466\u0001\u0000\u0000\u0000\u00b0\u0474\u0001"+ + "\u0000\u0000\u0000\u00b2\u047e\u0001\u0000\u0000\u0000\u00b4\u048c\u0001"+ + "\u0000\u0000\u0000\u00b6\u04a7\u0001\u0000\u0000\u0000\u00b8\u04aa\u0001"+ + "\u0000\u0000\u0000\u00ba\u04b2\u0001\u0000\u0000\u0000\u00bc\u04bb\u0001"+ + "\u0000\u0000\u0000\u00be\u04cb\u0001\u0000\u0000\u0000\u00c0\u04de\u0001"+ + "\u0000\u0000\u0000\u00c2\u04e7\u0001\u0000\u0000\u0000\u00c4\u04f2\u0001"+ + "\u0000\u0000\u0000\u00c6\u04f4\u0001\u0000\u0000\u0000\u00c8\u04f7\u0001"+ + "\u0000\u0000\u0000\u00ca\u050e\u0001\u0000\u0000\u0000\u00cc\u0510\u0001"+ + "\u0000\u0000\u0000\u00ce\u0515\u0001\u0000\u0000\u0000\u00d0\u0529\u0001"+ + "\u0000\u0000\u0000\u00d2\u052b\u0001\u0000\u0000\u0000\u00d4\u052d\u0001"+ + "\u0000\u0000\u0000\u00d6\u0530\u0001\u0000\u0000\u0000\u00d8\u053a\u0001"+ + "\u0000\u0000\u0000\u00da\u0544\u0001\u0000\u0000\u0000\u00dc\u0547\u0001"+ + "\u0000\u0000\u0000\u00de\u054c\u0001\u0000\u0000\u0000\u00e0\u054e\u0001"+ + "\u0000\u0000\u0000\u00e2\u055c\u0001\u0000\u0000\u0000\u00e4\u0564\u0001"+ + "\u0000\u0000\u0000\u00e6\u056c\u0001\u0000\u0000\u0000\u00e8\u0574\u0001"+ + "\u0000\u0000\u0000\u00ea\u0582\u0001\u0000\u0000\u0000\u00ec\u0588\u0001"+ + "\u0000\u0000\u0000\u00ee\u0596\u0001\u0000\u0000\u0000\u00f0\u05a8\u0001"+ + "\u0000\u0000\u0000\u00f2\u05b1\u0001\u0000\u0000\u0000\u00f4\u05b3\u0001"+ + "\u0000\u0000\u0000\u00f6\u05b5\u0001\u0000\u0000\u0000\u00f8\u05b9\u0001"+ + "\u0000\u0000\u0000\u00fa\u05bc\u0001\u0000\u0000\u0000\u00fc\u05c0\u0001"+ + "\u0000\u0000\u0000\u00fe\u05c2\u0001\u0000\u0000\u0000\u0100\u05c7\u0001"+ + "\u0000\u0000\u0000\u0102\u05cb\u0001\u0000\u0000\u0000\u0104\u05cf\u0001"+ + "\u0000\u0000\u0000\u0106\u05d3\u0001\u0000\u0000\u0000\u0108\u05d6\u0001"+ + "\u0000\u0000\u0000\u010a\u05d8\u0001\u0000\u0000\u0000\u010c\u05ed\u0001"+ + "\u0000\u0000\u0000\u010e\u05ef\u0001\u0000\u0000\u0000\u0110\u0605\u0001"+ + "\u0000\u0000\u0000\u0112\u060d\u0001\u0000\u0000\u0000\u0114\u060f\u0001"+ + "\u0000\u0000\u0000\u0116\u0625\u0001\u0000\u0000\u0000\u0118\u062d\u0001"+ + "\u0000\u0000\u0000\u011a\u0635\u0001\u0000\u0000\u0000\u011c\u0639\u0001"+ + "\u0000\u0000\u0000\u011e\u0645\u0001\u0000\u0000\u0000\u0120\u064f\u0001"+ + "\u0000\u0000\u0000\u0122\u065a\u0001\u0000\u0000\u0000\u0124\u0662\u0001"+ + "\u0000\u0000\u0000\u0126\u0666\u0001\u0000\u0000\u0000\u0128\u0673\u0001"+ + "\u0000\u0000\u0000\u012a\u067d\u0001\u0000\u0000\u0000\u012c\u0682\u0001"+ + "\u0000\u0000\u0000\u012e\u0684\u0001\u0000\u0000\u0000\u0130\u0689\u0001"+ + "\u0000\u0000\u0000\u0132\u068b\u0001\u0000\u0000\u0000\u0134\u068d\u0001"+ + "\u0000\u0000\u0000\u0136\u0690\u0001\u0000\u0000\u0000\u0138\u0694\u0001"+ + "\u0000\u0000\u0000\u013a\u069f\u0001\u0000\u0000\u0000\u013c\u06a3\u0001"+ + "\u0000\u0000\u0000\u013e\u06aa\u0001\u0000\u0000\u0000\u0140\u06ae\u0001"+ + "\u0000\u0000\u0000\u0142\u06b0\u0001\u0000\u0000\u0000\u0144\u06c0\u0001"+ + "\u0000\u0000\u0000\u0146\u06cd\u0001\u0000\u0000\u0000\u0148\u06d5\u0001"+ + "\u0000\u0000\u0000\u014a\u06da\u0001\u0000\u0000\u0000\u014c\u06dc\u0001"+ + "\u0000\u0000\u0000\u014e\u06de\u0001\u0000\u0000\u0000\u0150\u06e0\u0001"+ + "\u0000\u0000\u0000\u0152\u06e4\u0001\u0000\u0000\u0000\u0154\u06e7\u0001"+ + "\u0000\u0000\u0000\u0156\u06f0\u0001\u0000\u0000\u0000\u0158\u06fb\u0001"+ + "\u0000\u0000\u0000\u015a\u0701\u0001\u0000\u0000\u0000\u015c\u0705\u0001"+ + "\u0000\u0000\u0000\u015e\u0707\u0001\u0000\u0000\u0000\u0160\u0717\u0001"+ + "\u0000\u0000\u0000\u0162\u071c\u0001\u0000\u0000\u0000\u0164\u071f\u0001"+ + "\u0000\u0000\u0000\u0166\u0723\u0001\u0000\u0000\u0000\u0168\u0727\u0001"+ + "\u0000\u0000\u0000\u016a\u072c\u0001\u0000\u0000\u0000\u016c\u073f\u0001"+ + "\u0000\u0000\u0000\u016e\u0743\u0001\u0000\u0000\u0000\u0170\u0749\u0001"+ + "\u0000\u0000\u0000\u0172\u0173\u0003\u00a4R\u0000\u0173\u0174\u0005\u0000"+ + "\u0000\u0001\u0174\u0001\u0001\u0000\u0000\u0000\u0175\u0176\u0003\u00a6"+ + "S\u0000\u0176\u0177\u0005\u0000\u0000\u0001\u0177\u0003\u0001\u0000\u0000"+ + "\u0000\u0178\u0179\u0003\u00c2a\u0000\u0179\u017a\u0005\u0000\u0000\u0001"+ + "\u017a\u0005\u0001\u0000\u0000\u0000\u017b\u0180\u0003\b\u0004\u0000\u017c"+ + "\u017d\u0005m\u0000\u0000\u017d\u017f\u0003\b\u0004\u0000\u017e\u017c"+ + "\u0001\u0000\u0000\u0000\u017f\u0182\u0001\u0000\u0000\u0000\u0180\u017e"+ + "\u0001\u0000\u0000\u0000\u0180\u0181\u0001\u0000\u0000\u0000\u0181\u0007"+ + "\u0001\u0000\u0000\u0000\u0182\u0180\u0001\u0000\u0000\u0000\u0183\u0185"+ + "\u0005e\u0000\u0000\u0184\u0186\u0005<\u0000\u0000\u0185\u0184\u0001\u0000"+ + "\u0000\u0000\u0185\u0186\u0001\u0000\u0000\u0000\u0186\t\u0001\u0000\u0000"+ + "\u0000\u0187\u0188\u0003\u000e\u0007\u0000\u0188\u0189\u0003\u0170\u00b8"+ + "\u0000\u0189\u018b\u0001\u0000\u0000\u0000\u018a\u0187\u0001\u0000\u0000"+ + "\u0000\u018b\u018e\u0001\u0000\u0000\u0000\u018c\u018a\u0001\u0000\u0000"+ + "\u0000\u018c\u018d\u0001\u0000\u0000\u0000\u018d\u018f\u0001\u0000\u0000"+ + "\u0000\u018e\u018c\u0001\u0000\u0000\u0000\u018f\u0190\u0003\u00dam\u0000"+ + "\u0190\u0196\u0003\u0170\u00b8\u0000\u0191\u0192\u0003\u0014\n\u0000\u0192"+ + "\u0193\u0003\u0170\u00b8\u0000\u0193\u0195\u0001\u0000\u0000\u0000\u0194"+ + "\u0191\u0001\u0000\u0000\u0000\u0195\u0198\u0001\u0000\u0000\u0000\u0196"+ + "\u0194\u0001\u0000\u0000\u0000\u0196\u0197\u0001\u0000\u0000\u0000\u0197"+ + "\u01a2\u0001\u0000\u0000\u0000\u0198\u0196\u0001\u0000\u0000\u0000\u0199"+ + "\u019d\u0003\u0088D\u0000\u019a\u019d\u0003\u00deo\u0000\u019b\u019d\u0003"+ + "\u0016\u000b\u0000\u019c\u0199\u0001\u0000\u0000\u0000\u019c\u019a\u0001"+ + "\u0000\u0000\u0000\u019c\u019b\u0001\u0000\u0000\u0000\u019d\u019e\u0001"+ + "\u0000\u0000\u0000\u019e\u019f\u0003\u0170\u00b8\u0000\u019f\u01a1\u0001"+ + "\u0000\u0000\u0000\u01a0\u019c\u0001\u0000\u0000\u0000\u01a1\u01a4\u0001"+ + "\u0000\u0000\u0000\u01a2\u01a0\u0001\u0000\u0000\u0000\u01a2\u01a3\u0001"+ + "\u0000\u0000\u0000\u01a3\u01a5\u0001\u0000\u0000\u0000\u01a4\u01a2\u0001"+ + "\u0000\u0000\u0000\u01a5\u01a6\u0005\u0000\u0000\u0001\u01a6\u000b\u0001"+ + "\u0000\u0000\u0000\u01a7\u01a8\u0003\u000e\u0007\u0000\u01a8\u01a9\u0003"+ + "\u0170\u00b8\u0000\u01a9\u01ab\u0001\u0000\u0000\u0000\u01aa\u01a7\u0001"+ + "\u0000\u0000\u0000\u01ab\u01ae\u0001\u0000\u0000\u0000\u01ac\u01aa\u0001"+ + "\u0000\u0000\u0000\u01ac\u01ad\u0001\u0000\u0000\u0000\u01ad\u01af\u0001"+ + "\u0000\u0000\u0000\u01ae\u01ac\u0001\u0000\u0000\u0000\u01af\u01b0\u0003"+ + "\u00dam\u0000\u01b0\u01b6\u0003\u0170\u00b8\u0000\u01b1\u01b2\u0003\u0014"+ + "\n\u0000\u01b2\u01b3\u0003\u0170\u00b8\u0000\u01b3\u01b5\u0001\u0000\u0000"+ + "\u0000\u01b4\u01b1\u0001\u0000\u0000\u0000\u01b5\u01b8\u0001\u0000\u0000"+ + "\u0000\u01b6\u01b4\u0001\u0000\u0000\u0000\u01b6\u01b7\u0001\u0000\u0000"+ + "\u0000\u01b7\r\u0001\u0000\u0000\u0000\u01b8\u01b6\u0001\u0000\u0000\u0000"+ + "\u01b9\u01ba\u0005E\u0000\u0000\u01ba\u01bb\u0003\u00a4R\u0000\u01bb\u000f"+ + "\u0001\u0000\u0000\u0000\u01bc\u01bd\u0005F\u0000\u0000\u01bd\u01be\u0003"+ + "\u00a4R\u0000\u01be\u0011\u0001\u0000\u0000\u0000\u01bf\u01c0\u0003\u0010"+ + "\b\u0000\u01c0\u01c1\u0003\u0170\u00b8\u0000\u01c1\u01c3\u0001\u0000\u0000"+ + "\u0000\u01c2\u01bf\u0001\u0000\u0000\u0000\u01c3\u01c6\u0001\u0000\u0000"+ + "\u0000\u01c4\u01c2\u0001\u0000\u0000\u0000\u01c4\u01c5\u0001\u0000\u0000"+ + "\u0000\u01c5\u01c8\u0001\u0000\u0000\u0000\u01c6\u01c4\u0001\u0000\u0000"+ + "\u0000\u01c7\u01c9\u0007\u0000\u0000\u0000\u01c8\u01c7\u0001\u0000\u0000"+ + "\u0000\u01c8\u01c9\u0001\u0000\u0000\u0000\u01c9\u01ca\u0001\u0000\u0000"+ + "\u0000\u01ca\u01cb\u0003\u00dcn\u0000\u01cb\u0013\u0001\u0000\u0000\u0000"+ + "\u01cc\u01cd\u0003\u0010\b\u0000\u01cd\u01ce\u0003\u0170\u00b8\u0000\u01ce"+ + "\u01d0\u0001\u0000\u0000\u0000\u01cf\u01cc\u0001\u0000\u0000\u0000\u01d0"+ + "\u01d3\u0001\u0000\u0000\u0000\u01d1\u01cf\u0001\u0000\u0000\u0000\u01d1"+ + "\u01d2\u0001\u0000\u0000\u0000\u01d2\u01e1\u0001\u0000\u0000\u0000\u01d3"+ + "\u01d1\u0001\u0000\u0000\u0000\u01d4\u01d5\u0005a\u0000\u0000\u01d5\u01e2"+ + "\u0003\u0012\t\u0000\u01d6\u01d7\u0005a\u0000\u0000\u01d7\u01dd\u0005"+ + "f\u0000\u0000\u01d8\u01d9\u0003\u0012\t\u0000\u01d9\u01da\u0003\u0170"+ + "\u00b8\u0000\u01da\u01dc\u0001\u0000\u0000\u0000\u01db\u01d8\u0001\u0000"+ + "\u0000\u0000\u01dc\u01df\u0001\u0000\u0000\u0000\u01dd\u01db\u0001\u0000"+ + "\u0000\u0000\u01dd\u01de\u0001\u0000\u0000\u0000\u01de\u01e0\u0001\u0000"+ + "\u0000\u0000\u01df\u01dd\u0001\u0000\u0000\u0000\u01e0\u01e2\u0005g\u0000"+ + "\u0000\u01e1\u01d4\u0001\u0000\u0000\u0000\u01e1\u01d6\u0001\u0000\u0000"+ + "\u0000\u01e2\u0015\u0001\u0000\u0000\u0000\u01e3\u01e8\u0003z=\u0000\u01e4"+ + "\u01e8\u0003\u0090H\u0000\u01e5\u01e8\u0003\u0094J\u0000\u01e6\u01e8\u0003"+ + "\u008eG\u0000\u01e7\u01e3\u0001\u0000\u0000\u0000\u01e7\u01e4\u0001\u0000"+ + "\u0000\u0000\u01e7\u01e5\u0001\u0000\u0000\u0000\u01e7\u01e6\u0001\u0000"+ + "\u0000\u0000\u01e8\u0017\u0001\u0000\u0000\u0000\u01e9\u01ea\u0005\u001b"+ + "\u0000\u0000\u01ea\u01f1\u0003\u00a6S\u0000\u01eb\u01ec\u0007\u0001\u0000"+ + "\u0000\u01ec\u01f1\u0003.\u0017\u0000\u01ed\u01ee\u0007\u0002\u0000\u0000"+ + "\u01ee\u01f1\u0003\u00a4R\u0000\u01ef\u01f1\u0003f3\u0000\u01f0\u01e9"+ + "\u0001\u0000\u0000\u0000\u01f0\u01eb\u0001\u0000\u0000\u0000\u01f0\u01ed"+ + "\u0001\u0000\u0000\u0000\u01f0\u01ef\u0001\u0000\u0000\u0000\u01f1\u0019"+ + "\u0001\u0000\u0000\u0000\u01f2\u01f3\u0003\u001c\u000e\u0000\u01f3\u001b"+ + "\u0001\u0000\u0000\u0000\u01f4\u01f5\u0003^/\u0000\u01f5\u01f6\u0003\u001e"+ + "\u000f\u0000\u01f6\u001d\u0001\u0000\u0000\u0000\u01f7\u01f8\u0005D\u0000"+ + "\u0000\u01f8\u01fa\u0005f\u0000\u0000\u01f9\u01fb\u0003\u00f0x\u0000\u01fa"+ + "\u01f9\u0001\u0000\u0000\u0000\u01fa\u01fb\u0001\u0000\u0000\u0000\u01fb"+ + "\u01fc\u0001\u0000\u0000\u0000\u01fc\u01fd\u0005g\u0000\u0000\u01fd\u001f"+ + "\u0001\u0000\u0000\u0000\u01fe\u020c\u0003F#\u0000\u01ff\u020c\u0003D"+ + "\"\u0000\u0200\u020c\u0003B!\u0000\u0201\u020c\u0003$\u0012\u0000\u0202"+ + "\u020c\u0003@ \u0000\u0203\u020c\u00038\u001c\u0000\u0204\u020c\u0003"+ + ">\u001f\u0000\u0205\u020c\u00036\u001b\u0000\u0206\u020c\u00032\u0019"+ + "\u0000\u0207\u020c\u00030\u0018\u0000\u0208\u020c\u00034\u001a\u0000\u0209"+ + "\u020c\u0003\"\u0011\u0000\u020a\u020c\u0003H$\u0000\u020b\u01fe\u0001"+ + "\u0000\u0000\u0000\u020b\u01ff\u0001\u0000\u0000\u0000\u020b\u0200\u0001"+ + "\u0000\u0000\u0000\u020b\u0201\u0001\u0000\u0000\u0000\u020b\u0202\u0001"+ + "\u0000\u0000\u0000\u020b\u0203\u0001\u0000\u0000\u0000\u020b\u0204\u0001"+ + "\u0000\u0000\u0000\u020b\u0205\u0001\u0000\u0000\u0000\u020b\u0206\u0001"+ + "\u0000\u0000\u0000\u020b\u0207\u0001\u0000\u0000\u0000\u020b\u0208\u0001"+ + "\u0000\u0000\u0000\u020b\u0209\u0001\u0000\u0000\u0000\u020b\u020a\u0001"+ + "\u0000\u0000\u0000\u020c!\u0001\u0000\u0000\u0000\u020d\u020e\u0007\u0003"+ + "\u0000\u0000\u020e#\u0001\u0000\u0000\u0000\u020f\u0210\u0005^\u0000\u0000"+ + "\u0210\u0211\u0005j\u0000\u0000\u0211\u0212\u0003\u00c2a\u0000\u0212\u0213"+ + "\u0005k\u0000\u0000\u0213%\u0001\u0000\u0000\u0000\u0214\u0219\u0003("+ + "\u0014\u0000\u0215\u0216\u0005m\u0000\u0000\u0216\u0218\u0003(\u0014\u0000"+ + "\u0217\u0215\u0001\u0000\u0000\u0000\u0218\u021b\u0001\u0000\u0000\u0000"+ + "\u0219\u0217\u0001\u0000\u0000\u0000\u0219\u021a\u0001\u0000\u0000\u0000"+ + "\u021a\u021d\u0001\u0000\u0000\u0000\u021b\u0219\u0001\u0000\u0000\u0000"+ + "\u021c\u021e\u0005m\u0000\u0000\u021d\u021c\u0001\u0000\u0000\u0000\u021d"+ + "\u021e\u0001\u0000\u0000\u0000\u021e\'\u0001\u0000\u0000\u0000\u021f\u0224"+ + "\u0005e\u0000\u0000\u0220\u0221\u0005m\u0000\u0000\u0221\u0223\u0005e"+ + "\u0000\u0000\u0222\u0220\u0001\u0000\u0000\u0000\u0223\u0226\u0001\u0000"+ + "\u0000\u0000\u0224\u0222\u0001\u0000\u0000\u0000\u0224\u0225\u0001\u0000"+ + "\u0000\u0000\u0225\u0227\u0001\u0000\u0000\u0000\u0226\u0224\u0001\u0000"+ + "\u0000\u0000\u0227\u0228\u0003\u0132\u0099\u0000\u0228)\u0001\u0000\u0000"+ + "\u0000\u0229\u022b\u0003,\u0016\u0000\u022a\u0229\u0001\u0000\u0000\u0000"+ + "\u022b\u022e\u0001\u0000\u0000\u0000\u022c\u022a\u0001\u0000\u0000\u0000"+ + "\u022c\u022d\u0001\u0000\u0000\u0000\u022d+\u0001\u0000\u0000\u0000\u022e"+ + "\u022c\u0001\u0000\u0000\u0000\u022f\u0230\u0005h\u0000\u0000\u0230\u0235"+ + "\u0003\u00a4R\u0000\u0231\u0232\u0005m\u0000\u0000\u0232\u0234\u0003\u00a4"+ + "R\u0000\u0233\u0231\u0001\u0000\u0000\u0000\u0234\u0237\u0001\u0000\u0000"+ + "\u0000\u0235\u0233\u0001\u0000\u0000\u0000\u0235\u0236\u0001\u0000\u0000"+ + "\u0000\u0236\u0238\u0001\u0000\u0000\u0000\u0237\u0235\u0001\u0000\u0000"+ + "\u0000\u0238\u0239\u0005i\u0000\u0000\u0239-\u0001\u0000\u0000\u0000\u023a"+ + "\u023b\u0003\u00b4Z\u0000\u023b/\u0001\u0000\u0000\u0000\u023c\u023d\u0005"+ + "1\u0000\u0000\u023d\u023e\u0005f\u0000\u0000\u023e\u023f\u0003\u00a4R"+ + "\u0000\u023f\u0240\u0005g\u0000\u0000\u02401\u0001\u0000\u0000\u0000\u0241"+ + "\u0242\u00057\u0000\u0000\u0242\u0243\u0005j\u0000\u0000\u0243\u0244\u0003"+ + "\u00c2a\u0000\u0244\u0245\u0005k\u0000\u0000\u02453\u0001\u0000\u0000"+ + "\u0000\u0246\u0247\u00052\u0000\u0000\u0247\u0248\u0005f\u0000\u0000\u0248"+ + "\u0249\u0003\u00a4R\u0000\u0249\u024a\u0005g\u0000\u0000\u024a5\u0001"+ + "\u0000\u0000\u0000\u024b\u024c\u0007\u0004\u0000\u0000\u024c\u024d\u0005"+ + "f\u0000\u0000\u024d\u024e\u0003\u00a4R\u0000\u024e\u024f\u0005g\u0000"+ + "\u0000\u024f7\u0001\u0000\u0000\u0000\u0250\u0255\u0005\u0011\u0000\u0000"+ + "\u0251\u0252\u0005j\u0000\u0000\u0252\u0253\u0003:\u001d\u0000\u0253\u0254"+ + "\u0005k\u0000\u0000\u0254\u0256\u0001\u0000\u0000\u0000\u0255\u0251\u0001"+ + "\u0000\u0000\u0000\u0255\u0256\u0001\u0000\u0000\u0000\u0256\u0257\u0001"+ + "\u0000\u0000\u0000\u0257\u0258\u0005f\u0000\u0000\u0258\u0259\u0003\u00a4"+ + "R\u0000\u0259\u025a\u0005g\u0000\u0000\u025a9\u0001\u0000\u0000\u0000"+ + "\u025b\u025e\u0003<\u001e\u0000\u025c\u025e\u0005\u0013\u0000\u0000\u025d"+ + "\u025b\u0001\u0000\u0000\u0000\u025d\u025c\u0001\u0000\u0000\u0000\u025e"+ + ";\u0001\u0000\u0000\u0000\u025f\u0260\u0005e\u0000\u0000\u0260=\u0001"+ + "\u0000\u0000\u0000\u0261\u0262\u0005\u0012\u0000\u0000\u0262\u0263\u0005"+ + "f\u0000\u0000\u0263\u0264\u0003\u00a4R\u0000\u0264\u0265\u0005g\u0000"+ + "\u0000\u0265?\u0001\u0000\u0000\u0000\u0266\u0267\u0005:\u0000\u0000\u0267"+ + "\u0268\u0005f\u0000\u0000\u0268\u0269\u0003\u00a4R\u0000\u0269\u026a\u0005"+ + "g\u0000\u0000\u026aA\u0001\u0000\u0000\u0000\u026b\u026c\u00059\u0000"+ + "\u0000\u026c\u026d\u0005f\u0000\u0000\u026d\u026e\u0003\u00a4R\u0000\u026e"+ + "\u026f\u0005g\u0000\u0000\u026fC\u0001\u0000\u0000\u0000\u0270\u0271\u0005"+ + "\u0016\u0000\u0000\u0271\u0272\u0005f\u0000\u0000\u0272\u0275\u0003\u00a4"+ + "R\u0000\u0273\u0274\u0005m\u0000\u0000\u0274\u0276\u0003\u00a4R\u0000"+ + "\u0275\u0273\u0001\u0000\u0000\u0000\u0275\u0276\u0001\u0000\u0000\u0000"+ + "\u0276\u0277\u0001\u0000\u0000\u0000\u0277\u0278\u0005g\u0000\u0000\u0278"+ + "E\u0001\u0000\u0000\u0000\u0279\u027a\u0007\u0004\u0000\u0000\u027a\u027b"+ + "\u0005j\u0000\u0000\u027b\u027c\u0003\u00a4R\u0000\u027c\u027d\u0005="+ + "\u0000\u0000\u027d\u027e\u0003\u00a4R\u0000\u027e\u027f\u0005k\u0000\u0000"+ + "\u027fG\u0001\u0000\u0000\u0000\u0280\u0281\u00056\u0000\u0000\u0281\u0282"+ + "\u0003\u00a4R\u0000\u0282\u0288\u0005h\u0000\u0000\u0283\u0284\u0003J"+ + "%\u0000\u0284\u0285\u0003\u0170\u00b8\u0000\u0285\u0287\u0001\u0000\u0000"+ + "\u0000\u0286\u0283\u0001\u0000\u0000\u0000\u0287\u028a\u0001\u0000\u0000"+ + "\u0000\u0288\u0286\u0001\u0000\u0000\u0000\u0288\u0289\u0001\u0000\u0000"+ + "\u0000\u0289\u028b\u0001\u0000\u0000\u0000\u028a\u0288\u0001\u0000\u0000"+ + "\u0000\u028b\u028c\u0005i\u0000\u0000\u028cI\u0001\u0000\u0000\u0000\u028d"+ + "\u028e\u0003j5\u0000\u028e\u028f\u0005o\u0000\u0000\u028f\u0290\u0003"+ + "\u00a4R\u0000\u0290K\u0001\u0000\u0000\u0000\u0291\u0292\u0005j\u0000"+ + "\u0000\u0292\u0297\u0003N\'\u0000\u0293\u0294\u0005m\u0000\u0000\u0294"+ + "\u0296\u0003N\'\u0000\u0295\u0293\u0001\u0000\u0000\u0000\u0296\u0299"+ + "\u0001\u0000\u0000\u0000\u0297\u0295\u0001\u0000\u0000\u0000\u0297\u0298"+ + "\u0001\u0000\u0000\u0000\u0298\u029a\u0001\u0000\u0000\u0000\u0299\u0297"+ + "\u0001\u0000\u0000\u0000\u029a\u029b\u0005k\u0000\u0000\u029bM\u0001\u0000"+ + "\u0000\u0000\u029c\u029d\u0003\u00a4R\u0000\u029d\u029e\u0005l\u0000\u0000"+ + "\u029e\u029f\u0003\u00a4R\u0000\u029fO\u0001\u0000\u0000\u0000\u02a0\u02a5"+ + "\u0003\\.\u0000\u02a1\u02a5\u0003Z-\u0000\u02a2\u02a5\u0003R)\u0000\u02a3"+ + "\u02a5\u0003V+\u0000\u02a4\u02a0\u0001\u0000\u0000\u0000\u02a4\u02a1\u0001"+ + "\u0000\u0000\u0000\u02a4\u02a2\u0001\u0000\u0000\u0000\u02a4\u02a3\u0001"+ + "\u0000\u0000\u0000\u02a5Q\u0001\u0000\u0000\u0000\u02a6\u02a7\u00053\u0000"+ + "\u0000\u02a7\u02ad\u0005h\u0000\u0000\u02a8\u02a9\u0003T*\u0000\u02a9"+ + "\u02aa\u0003\u0170\u00b8\u0000\u02aa\u02ac\u0001\u0000\u0000\u0000\u02ab"+ + "\u02a8\u0001\u0000\u0000\u0000\u02ac\u02af\u0001\u0000\u0000\u0000\u02ad"+ + "\u02ab\u0001\u0000\u0000\u0000\u02ad\u02ae\u0001\u0000\u0000\u0000\u02ae"+ + "\u02b0\u0001\u0000\u0000\u0000\u02af\u02ad\u0001\u0000\u0000\u0000\u02b0"+ + "\u02b1\u0005i\u0000\u0000\u02b1S\u0001\u0000\u0000\u0000\u02b2\u02b3\u0005"+ + "M\u0000\u0000\u02b3\u02b4\u0005e\u0000\u0000\u02b4\u02bc\u0003\u013e\u009f"+ + "\u0000\u02b5\u02b6\u00054\u0000\u0000\u02b6\u02b7\u0005h\u0000\u0000\u02b7"+ + "\u02b8\u0003\u00a4R\u0000\u02b8\u02b9\u0003\u0170\u00b8\u0000\u02b9\u02ba"+ + "\u0005i\u0000\u0000\u02ba\u02bc\u0001\u0000\u0000\u0000\u02bb\u02b2\u0001"+ + "\u0000\u0000\u0000\u02bb\u02b5\u0001\u0000\u0000\u0000\u02bcU\u0001\u0000"+ + "\u0000\u0000\u02bd\u02be\u00055\u0000\u0000\u02be\u02c4\u0005h\u0000\u0000"+ + "\u02bf\u02c0\u0003X,\u0000\u02c0\u02c1\u0003\u0170\u00b8\u0000\u02c1\u02c3"+ + "\u0001\u0000\u0000\u0000\u02c2\u02bf\u0001\u0000\u0000\u0000\u02c3\u02c6"+ + "\u0001\u0000\u0000\u0000\u02c4\u02c2\u0001\u0000\u0000\u0000\u02c4\u02c5"+ + "\u0001\u0000\u0000\u0000\u02c5\u02c7\u0001\u0000\u0000\u0000\u02c6\u02c4"+ + "\u0001\u0000\u0000\u0000\u02c7\u02c8\u0005i\u0000\u0000\u02c8W\u0001\u0000"+ + "\u0000\u0000\u02c9\u02ca\u0005e\u0000\u0000\u02ca\u02d0\u0005h\u0000\u0000"+ + "\u02cb\u02cc\u0003\u0160\u00b0\u0000\u02cc\u02cd\u0003\u0170\u00b8\u0000"+ + "\u02cd\u02cf\u0001\u0000\u0000\u0000\u02ce\u02cb\u0001\u0000\u0000\u0000"+ + "\u02cf\u02d2\u0001\u0000\u0000\u0000\u02d0\u02ce\u0001\u0000\u0000\u0000"+ + "\u02d0\u02d1\u0001\u0000\u0000\u0000\u02d1\u02d3\u0001\u0000\u0000\u0000"+ + "\u02d2\u02d0\u0001\u0000\u0000\u0000\u02d3\u02d4\u0005i\u0000\u0000\u02d4"+ + "Y\u0001\u0000\u0000\u0000\u02d5\u02d6\u0005\u001b\u0000\u0000\u02d6\u02d7"+ + "\u0005j\u0000\u0000\u02d7\u02d8\u0005k\u0000\u0000\u02d8\u02d9\u0003\u0132"+ + "\u0099\u0000\u02d9[\u0001\u0000\u0000\u0000\u02da\u02db\u0007\u0005\u0000"+ + "\u0000\u02db\u02dc\u0005j\u0000\u0000\u02dc\u02dd\u0003\u00c2a\u0000\u02dd"+ + "\u02de\u0005k\u0000\u0000\u02de\u02e6\u0001\u0000\u0000\u0000\u02df\u02e0"+ + "\u0005+\u0000\u0000\u02e0\u02e1\u0005j\u0000\u0000\u02e1\u02e2\u0003\u00c2"+ + "a\u0000\u02e2\u02e3\u0005k\u0000\u0000\u02e3\u02e4\u0003\u00c2a\u0000"+ + "\u02e4\u02e6\u0001\u0000\u0000\u0000\u02e5\u02da\u0001\u0000\u0000\u0000"+ + "\u02e5\u02df\u0001\u0000\u0000\u0000\u02e6]\u0001\u0000\u0000\u0000\u02e7"+ + "\u02ed\u0003`0\u0000\u02e8\u02e9\u0005\u000e\u0000\u0000\u02e9\u02ed\u0006"+ + "/\uffff\uffff\u0000\u02ea\u02eb\u0005C\u0000\u0000\u02eb\u02ed\u0006/"+ + "\uffff\uffff\u0000\u02ec\u02e7\u0001\u0000\u0000\u0000\u02ec\u02e8\u0001"+ + "\u0000\u0000\u0000\u02ec\u02ea\u0001\u0000\u0000\u0000\u02ed\u02ee\u0001"+ + "\u0000\u0000\u0000\u02ee\u02f0\u0003\u0170\u00b8\u0000\u02ef\u02ec\u0001"+ + "\u0000\u0000\u0000\u02f0\u02f3\u0001\u0000\u0000\u0000\u02f1\u02f2\u0001"+ + "\u0000\u0000\u0000\u02f1\u02ef\u0001\u0000\u0000\u0000\u02f2\u02f6\u0001"+ + "\u0000\u0000\u0000\u02f3\u02f1\u0001\u0000\u0000\u0000\u02f4\u02f5\u0005"+ + "\u000e\u0000\u0000\u02f5\u02f7\u0006/\uffff\uffff\u0000\u02f6\u02f4\u0001"+ + "\u0000\u0000\u0000\u02f6\u02f7\u0001\u0000\u0000\u0000\u02f7_\u0001\u0000"+ + "\u0000\u0000\u02f8\u02f9\u0005\t\u0000\u0000\u02f9\u0301\u0003d2\u0000"+ + "\u02fa\u02fb\u0005\n\u0000\u0000\u02fb\u0301\u0003d2\u0000\u02fc\u02fd"+ + "\u0005\u000b\u0000\u0000\u02fd\u0301\u0003d2\u0000\u02fe\u02ff\u0005\r"+ + "\u0000\u0000\u02ff\u0301\u0003b1\u0000\u0300\u02f8\u0001\u0000\u0000\u0000"+ + "\u0300\u02fa\u0001\u0000\u0000\u0000\u0300\u02fc\u0001\u0000\u0000\u0000"+ + "\u0300\u02fe\u0001\u0000\u0000\u0000\u0301a\u0001\u0000\u0000\u0000\u0302"+ + "\u0304\u0003\u00e6s\u0000\u0303\u0302\u0001\u0000\u0000\u0000\u0303\u0304"+ + "\u0001\u0000\u0000\u0000\u0304\u0307\u0001\u0000\u0000\u0000\u0305\u0306"+ + "\u0005\\\u0000\u0000\u0306\u0308\u0003\u00a4R\u0000\u0307\u0305\u0001"+ + "\u0000\u0000\u0000\u0307\u0308\u0001\u0000\u0000\u0000\u0308c\u0001\u0000"+ + "\u0000\u0000\u0309\u030c\u0001\u0000\u0000\u0000\u030a\u030c\u0003\u00a4"+ + "R\u0000\u030b\u0309\u0001\u0000\u0000\u0000\u030b\u030a\u0001\u0000\u0000"+ + "\u0000\u030ce\u0001\u0000\u0000\u0000\u030d\u030e\u00056\u0000\u0000\u030e"+ + "\u030f\u0003\u00a4R\u0000\u030f\u0313\u0005h\u0000\u0000\u0310\u0312\u0003"+ + "h4\u0000\u0311\u0310\u0001\u0000\u0000\u0000\u0312\u0315\u0001\u0000\u0000"+ + "\u0000\u0313\u0311\u0001\u0000\u0000\u0000\u0313\u0314\u0001\u0000\u0000"+ + "\u0000\u0314\u0316\u0001\u0000\u0000\u0000\u0315\u0313\u0001\u0000\u0000"+ + "\u0000\u0316\u0317\u0005i\u0000\u0000\u0317g\u0001\u0000\u0000\u0000\u0318"+ + "\u0319\u0003j5\u0000\u0319\u031b\u0005o\u0000\u0000\u031a\u031c\u0003"+ + "\u00f0x\u0000\u031b\u031a\u0001\u0000\u0000\u0000\u031b\u031c\u0001\u0000"+ + "\u0000\u0000\u031ci\u0001\u0000\u0000\u0000\u031d\u031e\u0005P\u0000\u0000"+ + "\u031e\u0321\u0003l6\u0000\u031f\u0321\u0005L\u0000\u0000\u0320\u031d"+ + "\u0001\u0000\u0000\u0000\u0320\u031f\u0001\u0000\u0000\u0000\u0321k\u0001"+ + "\u0000\u0000\u0000\u0322\u0323\u0005%\u0000\u0000\u0323\u0330\u0005e\u0000"+ + "\u0000\u0324\u0325\u0003\u00cae\u0000\u0325\u032a\u0005h\u0000\u0000\u0326"+ + "\u0328\u0003n7\u0000\u0327\u0329\u0005m\u0000\u0000\u0328\u0327\u0001"+ + "\u0000\u0000\u0000\u0328\u0329\u0001\u0000\u0000\u0000\u0329\u032b\u0001"+ + "\u0000\u0000\u0000\u032a\u0326\u0001\u0000\u0000\u0000\u032a\u032b\u0001"+ + "\u0000\u0000\u0000\u032b\u032c\u0001\u0000\u0000\u0000\u032c\u032d\u0005"+ + "i\u0000\u0000\u032d\u0330\u0001\u0000\u0000\u0000\u032e\u0330\u0003\u00a4"+ + "R\u0000\u032f\u0322\u0001\u0000\u0000\u0000\u032f\u0324\u0001\u0000\u0000"+ + "\u0000\u032f\u032e\u0001\u0000\u0000\u0000\u0330m\u0001\u0000\u0000\u0000"+ + "\u0331\u0336\u0003l6\u0000\u0332\u0333\u0005m\u0000\u0000\u0333\u0335"+ + "\u0003l6\u0000\u0334\u0332\u0001\u0000\u0000\u0000\u0335\u0338\u0001\u0000"+ + "\u0000\u0000\u0336\u0334\u0001\u0000\u0000\u0000\u0336\u0337\u0001\u0000"+ + "\u0000\u0000\u0337o\u0001\u0000\u0000\u0000\u0338\u0336\u0001\u0000\u0000"+ + "\u0000\u0339\u033e\u0005h\u0000\u0000\u033a\u033b\u0005;\u0000\u0000\u033b"+ + "\u033c\u0003\u00e4r\u0000\u033c\u033d\u0003\u0170\u00b8\u0000\u033d\u033f"+ + "\u0001\u0000\u0000\u0000\u033e\u033a\u0001\u0000\u0000\u0000\u033e\u033f"+ + "\u0001\u0000\u0000\u0000\u033f\u0341\u0001\u0000\u0000\u0000\u0340\u0342"+ + "\u0003\u00f0x\u0000\u0341\u0340\u0001\u0000\u0000\u0000\u0341\u0342\u0001"+ + "\u0000\u0000\u0000\u0342\u0343\u0001\u0000\u0000\u0000\u0343\u0344\u0005"+ + "i\u0000\u0000\u0344q\u0001\u0000\u0000\u0000\u0345\u0348\u0003\u0150\u00a8"+ + "\u0000\u0346\u0348\u0005e\u0000\u0000\u0347\u0345\u0001\u0000\u0000\u0000"+ + "\u0347\u0346\u0001\u0000\u0000\u0000\u0348\u0351\u0001\u0000\u0000\u0000"+ + "\u0349\u034e\u0005h\u0000\u0000\u034a\u034c\u0003t:\u0000\u034b\u034d"+ + "\u0005m\u0000\u0000\u034c\u034b\u0001\u0000\u0000\u0000\u034c\u034d\u0001"+ + "\u0000\u0000\u0000\u034d\u034f\u0001\u0000\u0000\u0000\u034e\u034a\u0001"+ + "\u0000\u0000\u0000\u034e\u034f\u0001\u0000\u0000\u0000\u034f\u0350\u0001"+ + "\u0000\u0000\u0000\u0350\u0352\u0005i\u0000\u0000\u0351\u0349\u0001\u0000"+ + "\u0000\u0000\u0351\u0352\u0001\u0000\u0000\u0000\u0352s\u0001\u0000\u0000"+ + "\u0000\u0353\u0358\u0003v;\u0000\u0354\u0355\u0005m\u0000\u0000\u0355"+ + "\u0357\u0003v;\u0000\u0356\u0354\u0001\u0000\u0000\u0000\u0357\u035a\u0001"+ + "\u0000\u0000\u0000\u0358\u0356\u0001\u0000\u0000\u0000\u0358\u0359\u0001"+ + "\u0000\u0000\u0000\u0359u\u0001\u0000\u0000\u0000\u035a\u0358\u0001\u0000"+ + "\u0000\u0000\u035b\u035c\u0005e\u0000\u0000\u035c\u035e\u0005o\u0000\u0000"+ + "\u035d\u035b\u0001\u0000\u0000\u0000\u035d\u035e\u0001\u0000\u0000\u0000"+ + "\u035e\u035f\u0001\u0000\u0000\u0000\u035f\u0360\u0003\u00a4R\u0000\u0360"+ + "w\u0001\u0000\u0000\u0000\u0361\u0362\u0005G\u0000\u0000\u0362\u0363\u0003"+ + "\u00a4R\u0000\u0363\u0364\u0005\u000f\u0000\u0000\u0364\u0365\u0003r9"+ + "\u0000\u0365\u0366\u0003\u00eew\u0000\u0366y\u0001\u0000\u0000\u0000\u0367"+ + "\u0368\u0003\u00c2a\u0000\u0368\u0369\u0005\u000f\u0000\u0000\u0369\u037c"+ + "\u0003\u00c2a\u0000\u036a\u0370\u0005h\u0000\u0000\u036b\u036c\u0003\u0082"+ + "A\u0000\u036c\u036d\u0003\u0170\u00b8\u0000\u036d\u036f\u0001\u0000\u0000"+ + "\u0000\u036e\u036b\u0001\u0000\u0000\u0000\u036f\u0372\u0001\u0000\u0000"+ + "\u0000\u0370\u036e\u0001\u0000\u0000\u0000\u0370\u0371\u0001\u0000\u0000"+ + "\u0000\u0371\u0378\u0001\u0000\u0000\u0000\u0372\u0370\u0001\u0000\u0000"+ + "\u0000\u0373\u0374\u0003|>\u0000\u0374\u0375\u0003\u0170\u00b8\u0000\u0375"+ + "\u0377\u0001\u0000\u0000\u0000\u0376\u0373\u0001\u0000\u0000\u0000\u0377"+ + "\u037a\u0001\u0000\u0000\u0000\u0378\u0376\u0001\u0000\u0000\u0000\u0378"+ + "\u0379\u0001\u0000\u0000\u0000\u0379\u037b\u0001\u0000\u0000\u0000\u037a"+ + "\u0378\u0001\u0000\u0000\u0000\u037b\u037d\u0005i\u0000\u0000\u037c\u036a"+ + "\u0001\u0000\u0000\u0000\u037c\u037d\u0001\u0000\u0000\u0000\u037d{\u0001"+ + "\u0000\u0000\u0000\u037e\u0380\u0005\u000e\u0000\u0000\u037f\u037e\u0001"+ + "\u0000\u0000\u0000\u037f\u0380\u0001\u0000\u0000\u0000\u0380\u0381\u0001"+ + "\u0000\u0000\u0000\u0381\u0382\u0003~?\u0000\u0382\u0383\u0005e\u0000"+ + "\u0000\u0383\u0385\u0003\u013e\u009f\u0000\u0384\u0386\u0003\u00eew\u0000"+ + "\u0385\u0384\u0001\u0000\u0000\u0000\u0385\u0386\u0001\u0000\u0000\u0000"+ + "\u0386}\u0001\u0000\u0000\u0000\u0387\u0389\u0005f\u0000\u0000\u0388\u038a"+ + "\u0005e\u0000\u0000\u0389\u0388\u0001\u0000\u0000\u0000\u0389\u038a\u0001"+ + "\u0000\u0000\u0000\u038a\u038c\u0001\u0000\u0000\u0000\u038b\u038d\u0005"+ + "\u0087\u0000\u0000\u038c\u038b\u0001\u0000\u0000\u0000\u038c\u038d\u0001"+ + "\u0000\u0000\u0000\u038d\u038e\u0001\u0000\u0000\u0000\u038e\u038f\u0003"+ + "\u012c\u0096\u0000\u038f\u0390\u0005g\u0000\u0000\u0390\u007f\u0001\u0000"+ + "\u0000\u0000\u0391\u0397\u0003\u00b4Z\u0000\u0392\u0393\u0003\u00c2a\u0000"+ + "\u0393\u0394\u0005p\u0000\u0000\u0394\u0395\u0005e\u0000\u0000\u0395\u0397"+ + "\u0001\u0000\u0000\u0000\u0396\u0391\u0001\u0000\u0000\u0000\u0396\u0392"+ + "\u0001\u0000\u0000\u0000\u0397\u0081\u0001\u0000\u0000\u0000\u0398\u0399"+ + "\u00058\u0000\u0000\u0399\u039a\u0005e\u0000\u0000\u039a\u039d\u0005s"+ + "\u0000\u0000\u039b\u039e\u0003\u0080@\u0000\u039c\u039e\u0003\u014e\u00a7"+ + "\u0000\u039d\u039b\u0001\u0000\u0000\u0000\u039d\u039c\u0001\u0000\u0000"+ + "\u0000\u039e\u0083\u0001\u0000\u0000\u0000\u039f\u03a0\u0005/\u0000\u0000"+ + "\u03a0\u03a1\u0005f\u0000\u0000\u03a1\u03a4\u0003\u00c2a\u0000\u03a2\u03a3"+ + "\u0005m\u0000\u0000\u03a3\u03a5\u0003\u00e6s\u0000\u03a4\u03a2\u0001\u0000"+ + "\u0000\u0000\u03a4\u03a5\u0001\u0000\u0000\u0000\u03a5\u03a6\u0001\u0000"+ + "\u0000\u0000\u03a6\u03a7\u0005g\u0000\u0000\u03a7\u0085\u0001\u0000\u0000"+ + "\u0000\u03a8\u03a9\u0005.\u0000\u0000\u03a9\u03aa\u0005f\u0000\u0000\u03aa"+ + "\u03ab\u0003\u00c2a\u0000\u03ab\u03ac\u0005g\u0000\u0000\u03ac\u0087\u0001"+ + "\u0000\u0000\u0000\u03ad\u03b0\u0003^/\u0000\u03ae\u03b1\u0003\u008aE"+ + "\u0000\u03af\u03b1\u0003\u008cF\u0000\u03b0\u03ae\u0001\u0000\u0000\u0000"+ + "\u03b0\u03af\u0001\u0000\u0000\u0000\u03b1\u0089\u0001\u0000\u0000\u0000"+ + "\u03b2\u03b3\u0005M\u0000\u0000\u03b3\u03b4\u0005e\u0000\u0000\u03b4\u03b6"+ + "\u0003\u013e\u009f\u0000\u03b5\u03b7\u0003p8\u0000\u03b6\u03b5\u0001\u0000"+ + "\u0000\u0000\u03b6\u03b7\u0001\u0000\u0000\u0000\u03b7\u008b\u0001\u0000"+ + "\u0000\u0000\u03b8\u03b9\u0005M\u0000\u0000\u03b9\u03ba\u0003\u009aM\u0000"+ + "\u03ba\u03bb\u0005e\u0000\u0000\u03bb\u03bd\u0003\u013e\u009f\u0000\u03bc"+ + "\u03be\u0003p8\u0000\u03bd\u03bc\u0001\u0000\u0000\u0000\u03bd\u03be\u0001"+ + "\u0000\u0000\u0000\u03be\u008d\u0001\u0000\u0000\u0000\u03bf\u03c2\u0005"+ + "\u001b\u0000\u0000\u03c0\u03c3\u0003\u0088D\u0000\u03c1\u03c3\u0003\u00de"+ + "o\u0000\u03c2\u03c0\u0001\u0000\u0000\u0000\u03c2\u03c1\u0001\u0000\u0000"+ + "\u0000\u03c3\u008f\u0001\u0000\u0000\u0000\u03c4\u03c5\u00058\u0000\u0000"+ + "\u03c5\u03c6\u0005e\u0000\u0000\u03c6\u03c8\u0003\u0142\u00a1\u0000\u03c7"+ + "\u03c9\u0003\u0092I\u0000\u03c8\u03c7\u0001\u0000\u0000\u0000\u03c8\u03c9"+ + "\u0001\u0000\u0000\u0000\u03c9\u0091\u0001\u0000\u0000\u0000\u03ca\u03cb"+ + "\u0005h\u0000\u0000\u03cb\u03cc\u0003\u00a4R\u0000\u03cc\u03cd\u0003\u0170"+ + "\u00b8\u0000\u03cd\u03ce\u0005i\u0000\u0000\u03ce\u0093\u0001\u0000\u0000"+ + "\u0000\u03cf\u03d0\u00058\u0000\u0000\u03d0\u03d1\u0003\u009aM\u0000\u03d1"+ + "\u03d2\u0005e\u0000\u0000\u03d2\u03d4\u0003\u0142\u00a1\u0000\u03d3\u03d5"+ + "\u0003\u0092I\u0000\u03d4\u03d3\u0001\u0000\u0000\u0000\u03d4\u03d5\u0001"+ + "\u0000\u0000\u0000\u03d5\u0095\u0001\u0000\u0000\u0000\u03d6\u03de\u0003"+ + "\u0006\u0003\u0000\u03d7\u03da\u0003\u00c2a\u0000\u03d8\u03d9\u0005l\u0000"+ + "\u0000\u03d9\u03db\u0003\u00e6s\u0000\u03da\u03d8\u0001\u0000\u0000\u0000"+ + "\u03da\u03db\u0001\u0000\u0000\u0000\u03db\u03df\u0001\u0000\u0000\u0000"+ + "\u03dc\u03dd\u0005l\u0000\u0000\u03dd\u03df\u0003\u00e6s\u0000\u03de\u03d7"+ + "\u0001\u0000\u0000\u0000\u03de\u03dc\u0001\u0000\u0000\u0000\u03df\u0097"+ + "\u0001\u0000\u0000\u0000\u03e0\u03e1\u0003\u0006\u0003\u0000\u03e1\u03e2"+ + "\u0005s\u0000\u0000\u03e2\u03e3\u0003\u00e6s\u0000\u03e3\u0099\u0001\u0000"+ + "\u0000\u0000\u03e4\u03e6\u0005f\u0000\u0000\u03e5\u03e7\u0003\b\u0004"+ + "\u0000\u03e6\u03e5\u0001\u0000\u0000\u0000\u03e6\u03e7\u0001\u0000\u0000"+ + "\u0000\u03e7\u03e8\u0001\u0000\u0000\u0000\u03e8\u03ea\u0003\u00c2a\u0000"+ + "\u03e9\u03eb\u0005m\u0000\u0000\u03ea\u03e9\u0001\u0000\u0000\u0000\u03ea"+ + "\u03eb\u0001\u0000\u0000\u0000\u03eb\u03ec\u0001\u0000\u0000\u0000\u03ec"+ + "\u03ed\u0005g\u0000\u0000\u03ed\u009b\u0001\u0000\u0000\u0000\u03ee\u03f1"+ + "\u0003\u009eO\u0000\u03ef\u03f1\u0003\u00a0P\u0000\u03f0\u03ee\u0001\u0000"+ + "\u0000\u0000\u03f0\u03ef\u0001\u0000\u0000\u0000\u03f1\u009d\u0001\u0000"+ + "\u0000\u0000\u03f2\u03f4\u0003\u00e4r\u0000\u03f3\u03f2\u0001\u0000\u0000"+ + "\u0000\u03f3\u03f4\u0001\u0000\u0000\u0000\u03f4\u03f5\u0001\u0000\u0000"+ + "\u0000\u03f5\u03f6\u0003\u00a2Q\u0000\u03f6\u009f\u0001\u0000\u0000\u0000"+ + "\u03f7\u03f9\u0005\u001b\u0000\u0000\u03f8\u03fa\u0003\u00e4r\u0000\u03f9"+ + "\u03f8\u0001\u0000\u0000\u0000\u03f9\u03fa\u0001\u0000\u0000\u0000\u03fa"+ + "\u03fb\u0001\u0000\u0000\u0000\u03fb\u03fc\u0003\u00a2Q\u0000\u03fc\u00a1"+ + "\u0001\u0000\u0000\u0000\u03fd\u03ff\u0005t\u0000\u0000\u03fe\u03fd\u0001"+ + "\u0000\u0000\u0000\u03fe\u03ff\u0001\u0000\u0000\u0000\u03ff\u0400\u0001"+ + "\u0000\u0000\u0000\u0400\u0401\u0003\u00c2a\u0000\u0401\u00a3\u0001\u0000"+ + "\u0000\u0000\u0402\u0403\u0006R\uffff\uffff\u0000\u0403\u0404\u0007\u0006"+ + "\u0000\u0000\u0404\u0418\u0003\u00a4R\u000f\u0405\u0418\u0003\u00b4Z\u0000"+ + "\u0406\u0407\u0005\u0019\u0000\u0000\u0407\u0408\u0003.\u0017\u0000\u0408"+ + "\u0409\u0005\u001c\u0000\u0000\u0409\u040a\u0003\u00a4R\u0003\u040a\u0418"+ + "\u0001\u0000\u0000\u0000\u040b\u040c\u0005\u001a\u0000\u0000\u040c\u040d"+ + "\u0003\u0098L\u0000\u040d\u040e\u0005\u001c\u0000\u0000\u040e\u040f\u0003"+ + "\u00a4R\u0002\u040f\u0418\u0001\u0000\u0000\u0000\u0410\u0411\u0007\u0007"+ + "\u0000\u0000\u0411\u0412\u0003&\u0013\u0000\u0412\u0413\u0005o\u0000\u0000"+ + "\u0413\u0414\u0005o\u0000\u0000\u0414\u0415\u0003*\u0015\u0000\u0415\u0416"+ + "\u0003\u00a4R\u0001\u0416\u0418\u0001\u0000\u0000\u0000\u0417\u0402\u0001"+ + "\u0000\u0000\u0000\u0417\u0405\u0001\u0000\u0000\u0000\u0417\u0406\u0001"+ + "\u0000\u0000\u0000\u0417\u040b\u0001\u0000\u0000\u0000\u0417\u0410\u0001"+ + "\u0000\u0000\u0000\u0418\u043c\u0001\u0000\u0000\u0000\u0419\u041a\n\r"+ + "\u0000\u0000\u041a\u041b\u0007\b\u0000\u0000\u041b\u043b\u0003\u00a4R"+ + "\u000e\u041c\u041d\n\f\u0000\u0000\u041d\u041e\u0007\t\u0000\u0000\u041e"+ + "\u043b\u0003\u00a4R\r\u041f\u0420\n\u000b\u0000\u0000\u0420\u0421\u0007"+ + "\n\u0000\u0000\u0421\u043b\u0003\u00a4R\f\u0422\u0423\n\n\u0000\u0000"+ + "\u0423\u0424\u0007\u000b\u0000\u0000\u0424\u043b\u0003\u00a4R\u000b\u0425"+ + "\u0426\n\t\u0000\u0000\u0426\u0427\u0007\f\u0000\u0000\u0427\u043b\u0003"+ + "\u00a4R\n\u0428\u0429\n\u0007\u0000\u0000\u0429\u042a\u0005v\u0000\u0000"+ + "\u042a\u043b\u0003\u00a4R\b\u042b\u042c\n\u0006\u0000\u0000\u042c\u042d"+ + "\u0005u\u0000\u0000\u042d\u043b\u0003\u00a4R\u0007\u042e\u042f\n\u0005"+ + "\u0000\u0000\u042f\u0430\u0005\"\u0000\u0000\u0430\u043b\u0003\u00a4R"+ + "\u0005\u0431\u0432\n\u0004\u0000\u0000\u0432\u0433\u0005%\u0000\u0000"+ + "\u0433\u0434\u0003\u00a4R\u0000\u0434\u0435\u0005o\u0000\u0000\u0435\u0436"+ + "\u0003\u00a4R\u0004\u0436\u043b\u0001\u0000\u0000\u0000\u0437\u0438\n"+ + "\b\u0000\u0000\u0438\u0439\u0005\u000f\u0000\u0000\u0439\u043b\u0003r"+ + "9\u0000\u043a\u0419\u0001\u0000\u0000\u0000\u043a\u041c\u0001\u0000\u0000"+ + "\u0000\u043a\u041f\u0001\u0000\u0000\u0000\u043a\u0422\u0001\u0000\u0000"+ + "\u0000\u043a\u0425\u0001\u0000\u0000\u0000\u043a\u0428\u0001\u0000\u0000"+ + "\u0000\u043a\u042b\u0001\u0000\u0000\u0000\u043a\u042e\u0001\u0000\u0000"+ + "\u0000\u043a\u0431\u0001\u0000\u0000\u0000\u043a\u0437\u0001\u0000\u0000"+ + "\u0000\u043b\u043e\u0001\u0000\u0000\u0000\u043c\u043a\u0001\u0000\u0000"+ + "\u0000\u043c\u043d\u0001\u0000\u0000\u0000\u043d\u00a5\u0001\u0000\u0000"+ + "\u0000\u043e\u043c\u0001\u0000\u0000\u0000\u043f\u0454\u0003\u0018\f\u0000"+ + "\u0440\u0454\u0003\u001a\r\u0000\u0441\u0454\u0003\u00aaU\u0000\u0442"+ + "\u0454\u0003\u00a8T\u0000\u0443\u0454\u0003\u00deo\u0000\u0444\u0454\u0003"+ + "\u00fe\u007f\u0000\u0445\u0454\u0003\u00f2y\u0000\u0446\u0454\u0003\u012a"+ + "\u0095\u0000\u0447\u0454\u0003\u0100\u0080\u0000\u0448\u0454\u0003\u0102"+ + "\u0081\u0000\u0449\u0454\u0003\u0104\u0082\u0000\u044a\u0454\u0003\u0106"+ + "\u0083\u0000\u044b\u0454\u0003\u0108\u0084\u0000\u044c\u0454\u0003\u00ee"+ + "w\u0000\u044d\u0454\u0003\u010a\u0085\u0000\u044e\u0454\u0003\u010c\u0086"+ + "\u0000\u044f\u0454\u0003\u011e\u008f\u0000\u0450\u0454\u0003\u00acV\u0000"+ + "\u0451\u0454\u0003\u00b0X\u0000\u0452\u0454\u0003x<\u0000\u0453\u043f"+ + "\u0001\u0000\u0000\u0000\u0453\u0440\u0001\u0000\u0000\u0000\u0453\u0441"+ + "\u0001\u0000\u0000\u0000\u0453\u0442\u0001\u0000\u0000\u0000\u0453\u0443"+ + "\u0001\u0000\u0000\u0000\u0453\u0444\u0001\u0000\u0000\u0000\u0453\u0445"+ + "\u0001\u0000\u0000\u0000\u0453\u0446\u0001\u0000\u0000\u0000\u0453\u0447"+ + "\u0001\u0000\u0000\u0000\u0453\u0448\u0001\u0000\u0000\u0000\u0453\u0449"+ + "\u0001\u0000\u0000\u0000\u0453\u044a\u0001\u0000\u0000\u0000\u0453\u044b"+ + "\u0001\u0000\u0000\u0000\u0453\u044c\u0001\u0000\u0000\u0000\u0453\u044d"+ + "\u0001\u0000\u0000\u0000\u0453\u044e\u0001\u0000\u0000\u0000\u0453\u044f"+ + "\u0001\u0000\u0000\u0000\u0453\u0450\u0001\u0000\u0000\u0000\u0453\u0451"+ + "\u0001\u0000\u0000\u0000\u0453\u0452\u0001\u0000\u0000\u0000\u0454\u00a7"+ + "\u0001\u0000\u0000\u0000\u0455\u0456\u0005$\u0000\u0000\u0456\u0457\u0003"+ + "\u00a4R\u0000\u0457\u00a9\u0001\u0000\u0000\u0000\u0458\u0459\u0005X\u0000"+ + "\u0000\u0459\u045b\u0003\u00a4R\u0000\u045a\u045c\u0003\u00eew\u0000\u045b"+ + "\u045a\u0001\u0000\u0000\u0000\u045b\u045c\u0001\u0000\u0000\u0000\u045c"+ + "\u00ab\u0001\u0000\u0000\u0000\u045d\u045e\u0003\u00aeW\u0000\u045e\u045f"+ + "\u0003\u0126\u0093\u0000\u045f\u00ad\u0001\u0000\u0000\u0000\u0460\u0461"+ + "\u0005\f\u0000\u0000\u0461\u0462\u0003\u00a4R\u0000\u0462\u0463\u0003"+ + "\u0170\u00b8\u0000\u0463\u0465\u0001\u0000\u0000\u0000\u0464\u0460\u0001"+ + "\u0000\u0000\u0000\u0465\u0468\u0001\u0000\u0000\u0000\u0466\u0464\u0001"+ + "\u0000\u0000\u0000\u0466\u0467\u0001\u0000\u0000\u0000\u0467\u046d\u0001"+ + "\u0000\u0000\u0000\u0468\u0466\u0001\u0000\u0000\u0000\u0469\u046a\u0005"+ + "\r\u0000\u0000\u046a\u046b\u0003b1\u0000\u046b\u046c\u0003\u0170\u00b8"+ + "\u0000\u046c\u046e\u0001\u0000\u0000\u0000\u046d\u0469\u0001\u0000\u0000"+ + "\u0000\u046d\u046e\u0001\u0000\u0000\u0000\u046e\u00af\u0001\u0000\u0000"+ + "\u0000\u046f\u0470\u0005Q\u0000\u0000\u0470\u0475\u0003\u00a4R\u0000\u0471"+ + "\u0472\u0005Q\u0000\u0000\u0472\u0473\u0007\u0001\u0000\u0000\u0473\u0475"+ + "\u0003.\u0017\u0000\u0474\u046f\u0001\u0000\u0000\u0000\u0474\u0471\u0001"+ + "\u0000\u0000\u0000\u0475\u00b1\u0001\u0000\u0000\u0000\u0476\u047f\u0005"+ + "\u0003\u0000\u0000\u0477\u047f\u0005\u0004\u0000\u0000\u0478\u047f\u0005"+ + "d\u0000\u0000\u0479\u047f\u0003\u014c\u00a6\u0000\u047a\u047f\u0003\u0162"+ + "\u00b1\u0000\u047b\u047f\u0005\u0001\u0000\u0000\u047c\u047f\u0005\u008f"+ + "\u0000\u0000\u047d\u047f\u0005\u0090\u0000\u0000\u047e\u0476\u0001\u0000"+ + "\u0000\u0000\u047e\u0477\u0001\u0000\u0000\u0000\u047e\u0478\u0001\u0000"+ + "\u0000\u0000\u047e\u0479\u0001\u0000\u0000\u0000\u047e\u047a\u0001\u0000"+ + "\u0000\u0000\u047e\u047b\u0001\u0000\u0000\u0000\u047e\u047c\u0001\u0000"+ + "\u0000\u0000\u047e\u047d\u0001\u0000\u0000\u0000\u047f\u00b3\u0001\u0000"+ + "\u0000\u0000\u0480\u0481\u0006Z\uffff\uffff\u0000\u0481\u048d\u0003\u0148"+ + "\u00a4\u0000\u0482\u048d\u0003\u0144\u00a2\u0000\u0483\u048d\u0003\u016c"+ + "\u00b6\u0000\u0484\u048d\u0003 \u0010\u0000\u0485\u048d\u0003\u0086C\u0000"+ + "\u0486\u048d\u0003\u0084B\u0000\u0487\u0488\u0007\r\u0000\u0000\u0488"+ + "\u0489\u0005f\u0000\u0000\u0489\u048a\u0003\u00a4R\u0000\u048a\u048b\u0005"+ + "g\u0000\u0000\u048b\u048d\u0001\u0000\u0000\u0000\u048c\u0480\u0001\u0000"+ + "\u0000\u0000\u048c\u0482\u0001\u0000\u0000\u0000\u048c\u0483\u0001\u0000"+ + "\u0000\u0000\u048c\u0484\u0001\u0000\u0000\u0000\u048c\u0485\u0001\u0000"+ + "\u0000\u0000\u048c\u0486\u0001\u0000\u0000\u0000\u048c\u0487\u0001\u0000"+ + "\u0000\u0000\u048d\u04a4\u0001\u0000\u0000\u0000\u048e\u048f\n\t\u0000"+ + "\u0000\u048f\u0490\u0005p\u0000\u0000\u0490\u04a3\u0005e\u0000\u0000\u0491"+ + "\u0492\n\b\u0000\u0000\u0492\u04a3\u0003\u0166\u00b3\u0000\u0493\u0494"+ + "\n\u0007\u0000\u0000\u0494\u04a3\u0003\u00ceg\u0000\u0495\u0496\n\u0006"+ + "\u0000\u0000\u0496\u04a3\u0003L&\u0000\u0497\u0498\n\u0005\u0000\u0000"+ + "\u0498\u04a3\u0003\u0168\u00b4\u0000\u0499\u049a\n\u0004\u0000\u0000\u049a"+ + "\u04a3\u0003\u016a\u00b5\u0000\u049b\u049c\n\u0003\u0000\u0000\u049c\u049d"+ + "\u0003\u016a\u00b5\u0000\u049d\u049e\u0005\u0010\u0000\u0000\u049e\u049f"+ + "\u0003r9\u0000\u049f\u04a3\u0001\u0000\u0000\u0000\u04a0\u04a1\n\u0002"+ + "\u0000\u0000\u04a1\u04a3\u0003\u00ba]\u0000\u04a2\u048e\u0001\u0000\u0000"+ + "\u0000\u04a2\u0491\u0001\u0000\u0000\u0000\u04a2\u0493\u0001\u0000\u0000"+ + "\u0000\u04a2\u0495\u0001\u0000\u0000\u0000\u04a2\u0497\u0001\u0000\u0000"+ + "\u0000\u04a2\u0499\u0001\u0000\u0000\u0000\u04a2\u049b\u0001\u0000\u0000"+ + "\u0000\u04a2\u04a0\u0001\u0000\u0000\u0000\u04a3\u04a6\u0001\u0000\u0000"+ + "\u0000\u04a4\u04a2\u0001\u0000\u0000\u0000\u04a4\u04a5\u0001\u0000\u0000"+ + "\u0000\u04a5\u00b5\u0001\u0000\u0000\u0000\u04a6\u04a4\u0001\u0000\u0000"+ + "\u0000\u04a7\u04a8\u0003^/\u0000\u04a8\u04a9\u0003\u00b8\\\u0000\u04a9"+ + "\u00b7\u0001\u0000\u0000\u0000\u04aa\u04ac\u0005M\u0000\u0000\u04ab\u04ad"+ + "\u0005e\u0000\u0000\u04ac\u04ab\u0001\u0000\u0000\u0000\u04ac\u04ad\u0001"+ + "\u0000\u0000\u0000\u04ad\u04ae\u0001\u0000\u0000\u0000\u04ae\u04b0\u0003"+ + "\u013e\u009f\u0000\u04af\u04b1\u0003p8\u0000\u04b0\u04af\u0001\u0000\u0000"+ + "\u0000\u04b0\u04b1\u0001\u0000\u0000\u0000\u04b1\u00b9\u0001\u0000\u0000"+ + "\u0000\u04b2\u04b4\u0005&\u0000\u0000\u04b3\u04b5\u0003\u00e6s\u0000\u04b4"+ + "\u04b3\u0001\u0000\u0000\u0000\u04b4\u04b5\u0001\u0000\u0000\u0000\u04b5"+ + "\u04b7\u0001\u0000\u0000\u0000\u04b6\u04b8\u0005m\u0000\u0000\u04b7\u04b6"+ + "\u0001\u0000\u0000\u0000\u04b7\u04b8\u0001\u0000\u0000\u0000\u04b8\u04b9"+ + "\u0001\u0000\u0000\u0000\u04b9\u04ba\u0005\'\u0000\u0000\u04ba\u00bb\u0001"+ + "\u0000\u0000\u0000\u04bb\u04bc\u0005N\u0000\u0000\u04bc\u04c6\u0005h\u0000"+ + "\u0000\u04bd\u04c1\u0003\u00c0`\u0000\u04be\u04c1\u0003\u012c\u0096\u0000"+ + "\u04bf\u04c1\u0003\u00be_\u0000\u04c0\u04bd\u0001\u0000\u0000\u0000\u04c0"+ + "\u04be\u0001\u0000\u0000\u0000\u04c0\u04bf\u0001\u0000\u0000\u0000\u04c1"+ + "\u04c2\u0001\u0000\u0000\u0000\u04c2\u04c3\u0003\u0170\u00b8\u0000\u04c3"+ + "\u04c5\u0001\u0000\u0000\u0000\u04c4\u04c0\u0001\u0000\u0000\u0000\u04c5"+ + "\u04c8\u0001\u0000\u0000\u0000\u04c6\u04c4\u0001\u0000\u0000\u0000\u04c6"+ + "\u04c7\u0001\u0000\u0000\u0000\u04c7\u04c9\u0001\u0000\u0000\u0000\u04c8"+ + "\u04c6\u0001\u0000\u0000\u0000\u04c9\u04ca\u0005i\u0000\u0000\u04ca\u00bd"+ + "\u0001\u0000\u0000\u0000\u04cb\u04cc\u00058\u0000\u0000\u04cc\u04cd\u0005"+ + "e\u0000\u0000\u04cd\u04ce\u0003\u0142\u00a1\u0000\u04ce\u00bf\u0001\u0000"+ + "\u0000\u0000\u04cf\u04d1\u0005\u001b\u0000\u0000\u04d0\u04cf\u0001\u0000"+ + "\u0000\u0000\u04d0\u04d1\u0001\u0000\u0000\u0000\u04d1\u04d2\u0001\u0000"+ + "\u0000\u0000\u04d2\u04d3\u0003^/\u0000\u04d3\u04d4\u0005e\u0000\u0000"+ + "\u04d4\u04d5\u0003\u0142\u00a1\u0000\u04d5\u04d6\u0003\u0140\u00a0\u0000"+ + "\u04d6\u04df\u0001\u0000\u0000\u0000\u04d7\u04d9\u0005\u001b\u0000\u0000"+ + "\u04d8\u04d7\u0001\u0000\u0000\u0000\u04d8\u04d9\u0001\u0000\u0000\u0000"+ + "\u04d9\u04da\u0001\u0000\u0000\u0000\u04da\u04db\u0003^/\u0000\u04db\u04dc"+ + "\u0005e\u0000\u0000\u04dc\u04dd\u0003\u0142\u00a1\u0000\u04dd\u04df\u0001"+ + "\u0000\u0000\u0000\u04de\u04d0\u0001\u0000\u0000\u0000\u04de\u04d8\u0001"+ + "\u0000\u0000\u0000\u04df\u00c1\u0001\u0000\u0000\u0000\u04e0\u04e8\u0003"+ + "\u012c\u0096\u0000\u04e1\u04e8\u0003\u00c4b\u0000\u04e2\u04e8\u0003P("+ + "\u0000\u04e3\u04e4\u0005f\u0000\u0000\u04e4\u04e5\u0003\u00c2a\u0000\u04e5"+ + "\u04e6\u0005g\u0000\u0000\u04e6\u04e8\u0001\u0000\u0000\u0000\u04e7\u04e0"+ + "\u0001\u0000\u0000\u0000\u04e7\u04e1\u0001\u0000\u0000\u0000\u04e7\u04e2"+ + "\u0001\u0000\u0000\u0000\u04e7\u04e3\u0001\u0000\u0000\u0000\u04e8\u00c3"+ + "\u0001\u0000\u0000\u0000\u04e9\u04f3\u0003\u012e\u0097\u0000\u04ea\u04f3"+ + "\u0003\u015e\u00af\u0000\u04eb\u04f3\u0003\u0134\u009a\u0000\u04ec\u04f3"+ + "\u0003\u013c\u009e\u0000\u04ed\u04f3\u0003\u00bc^\u0000\u04ee\u04f3\u0003"+ + "\u0136\u009b\u0000\u04ef\u04f3\u0003\u0138\u009c\u0000\u04f0\u04f3\u0003"+ + "\u013a\u009d\u0000\u04f1\u04f3\u0003\u00c6c\u0000\u04f2\u04e9\u0001\u0000"+ + "\u0000\u0000\u04f2\u04ea\u0001\u0000\u0000\u0000\u04f2\u04eb\u0001\u0000"+ + "\u0000\u0000\u04f2\u04ec\u0001\u0000\u0000\u0000\u04f2\u04ed\u0001\u0000"+ + "\u0000\u0000\u04f2\u04ee\u0001\u0000\u0000\u0000\u04f2\u04ef\u0001\u0000"+ + "\u0000\u0000\u04f2\u04f0\u0001\u0000\u0000\u0000\u04f2\u04f1\u0001\u0000"+ + "\u0000\u0000\u04f3\u00c5\u0001\u0000\u0000\u0000\u04f4\u04f5\u00058\u0000"+ + "\u0000\u04f5\u04f6\u0003\u00c8d\u0000\u04f6\u00c7\u0001\u0000\u0000\u0000"+ + "\u04f7\u0503\u0005f\u0000\u0000\u04f8\u04fd\u0003\u00c2a\u0000\u04f9\u04fa"+ + "\u0005m\u0000\u0000\u04fa\u04fc\u0003\u00c2a\u0000\u04fb\u04f9\u0001\u0000"+ + "\u0000\u0000\u04fc\u04ff\u0001\u0000\u0000\u0000\u04fd\u04fb\u0001\u0000"+ + "\u0000\u0000\u04fd\u04fe\u0001\u0000\u0000\u0000\u04fe\u0501\u0001\u0000"+ + "\u0000\u0000\u04ff\u04fd\u0001\u0000\u0000\u0000\u0500\u0502\u0005m\u0000"+ + "\u0000\u0501\u0500\u0001\u0000\u0000\u0000\u0501\u0502\u0001\u0000\u0000"+ + "\u0000\u0502\u0504\u0001\u0000\u0000\u0000\u0503\u04f8\u0001\u0000\u0000"+ + "\u0000\u0503\u0504\u0001\u0000\u0000\u0000\u0504\u0505\u0001\u0000\u0000"+ + "\u0000\u0505\u0506\u0005g\u0000\u0000\u0506\u00c9\u0001\u0000\u0000\u0000"+ + "\u0507\u050f\u0003\u015e\u00af\u0000\u0508\u050f\u0003\u012e\u0097\u0000"+ + "\u0509\u050f\u0003\u00ccf\u0000\u050a\u050f\u0003\u0136\u009b\u0000\u050b"+ + "\u050f\u0003\u0138\u009c\u0000\u050c\u050f\u0003P(\u0000\u050d\u050f\u0003"+ + "\u012c\u0096\u0000\u050e\u0507\u0001\u0000\u0000\u0000\u050e\u0508\u0001"+ + "\u0000\u0000\u0000\u050e\u0509\u0001\u0000\u0000\u0000\u050e\u050a\u0001"+ + "\u0000\u0000\u0000\u050e\u050b\u0001\u0000\u0000\u0000\u050e\u050c\u0001"+ + "\u0000\u0000\u0000\u050e\u050d\u0001\u0000\u0000\u0000\u050f\u00cb\u0001"+ + "\u0000\u0000\u0000\u0510\u0511\u0005j\u0000\u0000\u0511\u0512\u0005t\u0000"+ + "\u0000\u0512\u0513\u0005k\u0000\u0000\u0513\u0514\u0003\u0132\u0099\u0000"+ + "\u0514\u00cd\u0001\u0000\u0000\u0000\u0515\u0525\u0005j\u0000\u0000\u0516"+ + "\u0518\u0003\u00d0h\u0000\u0517\u0516\u0001\u0000\u0000\u0000\u0517\u0518"+ + "\u0001\u0000\u0000\u0000\u0518\u0519\u0001\u0000\u0000\u0000\u0519\u051b"+ + "\u0005o\u0000\u0000\u051a\u051c\u0003\u00d2i\u0000\u051b\u051a\u0001\u0000"+ + "\u0000\u0000\u051b\u051c\u0001\u0000\u0000\u0000\u051c\u0526\u0001\u0000"+ + "\u0000\u0000\u051d\u051f\u0003\u00d0h\u0000\u051e\u051d\u0001\u0000\u0000"+ + "\u0000\u051e\u051f\u0001\u0000\u0000\u0000\u051f\u0520\u0001\u0000\u0000"+ + "\u0000\u0520\u0521\u0005o\u0000\u0000\u0521\u0522\u0003\u00d2i\u0000\u0522"+ + "\u0523\u0005o\u0000\u0000\u0523\u0524\u0003\u00d4j\u0000\u0524\u0526\u0001"+ + "\u0000\u0000\u0000\u0525\u0517\u0001\u0000\u0000\u0000\u0525\u051e\u0001"+ + "\u0000\u0000\u0000\u0526\u0527\u0001\u0000\u0000\u0000\u0527\u0528\u0005"+ + "k\u0000\u0000\u0528\u00cf\u0001\u0000\u0000\u0000\u0529\u052a\u0003\u00a4"+ + "R\u0000\u052a\u00d1\u0001\u0000\u0000\u0000\u052b\u052c\u0003\u00a4R\u0000"+ + "\u052c\u00d3\u0001\u0000\u0000\u0000\u052d\u052e\u0003\u00a4R\u0000\u052e"+ + "\u00d5\u0001\u0000\u0000\u0000\u052f\u0531\u0007\u000e\u0000\u0000\u0530"+ + "\u052f\u0001\u0000\u0000\u0000\u0530\u0531\u0001\u0000\u0000\u0000\u0531"+ + "\u0532\u0001\u0000\u0000\u0000\u0532\u0533\u0005l\u0000\u0000\u0533\u00d7"+ + "\u0001\u0000\u0000\u0000\u0534\u0535\u0003\u00e6s\u0000\u0535\u0536\u0005"+ + "l\u0000\u0000\u0536\u053b\u0001\u0000\u0000\u0000\u0537\u0538\u0003\u0006"+ + "\u0003\u0000\u0538\u0539\u0005s\u0000\u0000\u0539\u053b\u0001\u0000\u0000"+ + "\u0000\u053a\u0534\u0001\u0000\u0000\u0000\u053a\u0537\u0001\u0000\u0000"+ + "\u0000\u053a\u053b\u0001\u0000\u0000\u0000\u053b\u053c\u0001\u0000\u0000"+ + "\u0000\u053c\u053d\u0005]\u0000\u0000\u053d\u0542\u0003\u00a4R\u0000\u053e"+ + "\u0540\u0005J\u0000\u0000\u053f\u0541\u0005e\u0000\u0000\u0540\u053f\u0001"+ + "\u0000\u0000\u0000\u0540\u0541\u0001\u0000\u0000\u0000\u0541\u0543\u0001"+ + "\u0000\u0000\u0000\u0542\u053e\u0001\u0000\u0000\u0000\u0542\u0543\u0001"+ + "\u0000\u0000\u0000\u0543\u00d9\u0001\u0000\u0000\u0000\u0544\u0545\u0005"+ + "X\u0000\u0000\u0545\u0546\u0005e\u0000\u0000\u0546\u00db\u0001\u0000\u0000"+ + "\u0000\u0547\u0548\u0003\u0162\u00b1\u0000\u0548\u00dd\u0001\u0000\u0000"+ + "\u0000\u0549\u054d\u0003\u00e0p\u0000\u054a\u054d\u0003\u00e8t\u0000\u054b"+ + "\u054d\u0003\u00ecv\u0000\u054c\u0549\u0001\u0000\u0000\u0000\u054c\u054a"+ + "\u0001\u0000\u0000\u0000\u054c\u054b\u0001\u0000\u0000\u0000\u054d\u00df"+ + "\u0001\u0000\u0000\u0000\u054e\u055a\u0005Z\u0000\u0000\u054f\u055b\u0003"+ + "\u00e2q\u0000\u0550\u0556\u0005f\u0000\u0000\u0551\u0552\u0003\u00e2q"+ + "\u0000\u0552\u0553\u0003\u0170\u00b8\u0000\u0553\u0555\u0001\u0000\u0000"+ + "\u0000\u0554\u0551\u0001\u0000\u0000\u0000\u0555\u0558\u0001\u0000\u0000"+ + "\u0000\u0556\u0554\u0001\u0000\u0000\u0000\u0556\u0557\u0001\u0000\u0000"+ + "\u0000\u0557\u0559\u0001\u0000\u0000\u0000\u0558\u0556\u0001\u0000\u0000"+ + "\u0000\u0559\u055b\u0005g\u0000\u0000\u055a\u054f\u0001\u0000\u0000\u0000"+ + "\u055a\u0550\u0001\u0000\u0000\u0000\u055b\u00e1\u0001\u0000\u0000\u0000"+ + "\u055c\u0562\u0003\u00e4r\u0000\u055d\u055f\u0003\u00c2a\u0000\u055e\u055d"+ + "\u0001\u0000\u0000\u0000\u055e\u055f\u0001\u0000\u0000\u0000\u055f\u0560"+ + "\u0001\u0000\u0000\u0000\u0560\u0561\u0005l\u0000\u0000\u0561\u0563\u0003"+ + "\u00e6s\u0000\u0562\u055e\u0001\u0000\u0000\u0000\u0562\u0563\u0001\u0000"+ + "\u0000\u0000\u0563\u00e3\u0001\u0000\u0000\u0000\u0564\u0569\u0005e\u0000"+ + "\u0000\u0565\u0566\u0005m\u0000\u0000\u0566\u0568\u0005e\u0000\u0000\u0567"+ + "\u0565\u0001\u0000\u0000\u0000\u0568\u056b\u0001\u0000\u0000\u0000\u0569"+ + "\u0567\u0001\u0000\u0000\u0000\u0569\u056a\u0001\u0000\u0000\u0000\u056a"+ + "\u00e5\u0001\u0000\u0000\u0000\u056b\u0569\u0001\u0000\u0000\u0000\u056c"+ + "\u0571\u0003\u00a4R\u0000\u056d\u056e\u0005m\u0000\u0000\u056e\u0570\u0003"+ + "\u00a4R\u0000\u056f\u056d\u0001\u0000\u0000\u0000\u0570\u0573\u0001\u0000"+ + "\u0000\u0000\u0571\u056f\u0001\u0000\u0000\u0000\u0571\u0572\u0001\u0000"+ + "\u0000\u0000\u0572\u00e7\u0001\u0000\u0000\u0000\u0573\u0571\u0001\u0000"+ + "\u0000\u0000\u0574\u0580\u0005^\u0000\u0000\u0575\u0581\u0003\u00eau\u0000"+ + "\u0576\u057c\u0005f\u0000\u0000\u0577\u0578\u0003\u00eau\u0000\u0578\u0579"+ + "\u0003\u0170\u00b8\u0000\u0579\u057b\u0001\u0000\u0000\u0000\u057a\u0577"+ + "\u0001\u0000\u0000\u0000\u057b\u057e\u0001\u0000\u0000\u0000\u057c\u057a"+ + "\u0001\u0000\u0000\u0000\u057c\u057d\u0001\u0000\u0000\u0000\u057d\u057f"+ + "\u0001\u0000\u0000\u0000\u057e\u057c\u0001\u0000\u0000\u0000\u057f\u0581"+ + "\u0005g\u0000\u0000\u0580\u0575\u0001\u0000\u0000\u0000\u0580\u0576\u0001"+ + "\u0000\u0000\u0000\u0581\u00e9\u0001\u0000\u0000\u0000\u0582\u0584\u0005"+ + "e\u0000\u0000\u0583\u0585\u0005l\u0000\u0000\u0584\u0583\u0001\u0000\u0000"+ + "\u0000\u0584\u0585\u0001\u0000\u0000\u0000\u0585\u0586\u0001\u0000\u0000"+ + "\u0000\u0586\u0587\u0003\u00c2a\u0000\u0587\u00eb\u0001\u0000\u0000\u0000"+ + "\u0588\u0594\u0005c\u0000\u0000\u0589\u0595\u0003\u0096K\u0000\u058a\u0590"+ + "\u0005f\u0000\u0000\u058b\u058c\u0003\u0096K\u0000\u058c\u058d\u0003\u0170"+ + "\u00b8\u0000\u058d\u058f\u0001\u0000\u0000\u0000\u058e\u058b\u0001\u0000"+ + "\u0000\u0000\u058f\u0592\u0001\u0000\u0000\u0000\u0590\u058e\u0001\u0000"+ + "\u0000\u0000\u0590\u0591\u0001\u0000\u0000\u0000\u0591\u0593\u0001\u0000"+ + "\u0000\u0000\u0592\u0590\u0001\u0000\u0000\u0000\u0593\u0595\u0005g\u0000"+ + "\u0000\u0594\u0589\u0001\u0000\u0000\u0000\u0594\u058a\u0001\u0000\u0000"+ + "\u0000\u0595\u00ed\u0001\u0000\u0000\u0000\u0596\u0598\u0005h\u0000\u0000"+ + "\u0597\u0599\u0003\u00f0x\u0000\u0598\u0597\u0001\u0000\u0000\u0000\u0598"+ + "\u0599\u0001\u0000\u0000\u0000\u0599\u059a\u0001\u0000\u0000\u0000\u059a"+ + "\u059b\u0005i\u0000\u0000\u059b\u00ef\u0001\u0000\u0000\u0000\u059c\u059e"+ + "\u0005n\u0000\u0000\u059d\u059c\u0001\u0000\u0000\u0000\u059d\u059e\u0001"+ + "\u0000\u0000\u0000\u059e\u05a4\u0001\u0000\u0000\u0000\u059f\u05a1\u0005"+ + "\u009f\u0000\u0000\u05a0\u059f\u0001\u0000\u0000\u0000\u05a0\u05a1\u0001"+ + "\u0000\u0000\u0000\u05a1\u05a4\u0001\u0000\u0000\u0000\u05a2\u05a4\u0004"+ + "x\u0012\u0000\u05a3\u059d\u0001\u0000\u0000\u0000\u05a3\u05a0\u0001\u0000"+ + "\u0000\u0000\u05a3\u05a2\u0001\u0000\u0000\u0000\u05a4\u05a5\u0001\u0000"+ + "\u0000\u0000\u05a5\u05a6\u0003\u00a6S\u0000\u05a6\u05a7\u0003\u0170\u00b8"+ + "\u0000\u05a7\u05a9\u0001\u0000\u0000\u0000\u05a8\u05a3\u0001\u0000\u0000"+ + "\u0000\u05a9\u05aa\u0001\u0000\u0000\u0000\u05aa\u05a8\u0001\u0000\u0000"+ + "\u0000\u05aa\u05ab\u0001\u0000\u0000\u0000\u05ab\u00f1\u0001\u0000\u0000"+ + "\u0000\u05ac\u05b2\u0003\u00f6{\u0000\u05ad\u05b2\u0003\u00f8|\u0000\u05ae"+ + "\u05b2\u0003\u00fa}\u0000\u05af\u05b2\u0003\u00f4z\u0000\u05b0\u05b2\u0003"+ + "\u0098L\u0000\u05b1\u05ac\u0001\u0000\u0000\u0000\u05b1\u05ad\u0001\u0000"+ + "\u0000\u0000\u05b1\u05ae\u0001\u0000\u0000\u0000\u05b1\u05af\u0001\u0000"+ + "\u0000\u0000\u05b1\u05b0\u0001\u0000\u0000\u0000\u05b2\u00f3\u0001\u0000"+ + "\u0000\u0000\u05b3\u05b4\u0003\u00a4R\u0000\u05b4\u00f5\u0001\u0000\u0000"+ + "\u0000\u05b5\u05b6\u0003\u00a4R\u0000\u05b6\u05b7\u0005\u0089\u0000\u0000"+ + "\u05b7\u05b8\u0003\u00a4R\u0000\u05b8\u00f7\u0001\u0000\u0000\u0000\u05b9"+ + "\u05ba\u0003\u00a4R\u0000\u05ba\u05bb\u0007\u000f\u0000\u0000\u05bb\u00f9"+ + "\u0001\u0000\u0000\u0000\u05bc\u05bd\u0003\u00e6s\u0000\u05bd\u05be\u0003"+ + "\u00d6k\u0000\u05be\u05bf\u0003\u00e6s\u0000\u05bf\u00fb\u0001\u0000\u0000"+ + "\u0000\u05c0\u05c1\u0007\u0010\u0000\u0000\u05c1\u00fd\u0001\u0000\u0000"+ + "\u0000\u05c2\u05c3\u0005e\u0000\u0000\u05c3\u05c5\u0005o\u0000\u0000\u05c4"+ + "\u05c6\u0003\u00a6S\u0000\u05c5\u05c4\u0001\u0000\u0000\u0000\u05c5\u05c6"+ + "\u0001\u0000\u0000\u0000\u05c6\u00ff\u0001\u0000\u0000\u0000\u05c7\u05c9"+ + "\u0005b\u0000\u0000\u05c8\u05ca\u0003\u00e6s\u0000\u05c9\u05c8\u0001\u0000"+ + "\u0000\u0000\u05c9\u05ca\u0001\u0000\u0000\u0000\u05ca\u0101\u0001\u0000"+ + "\u0000\u0000\u05cb\u05cd\u0005K\u0000\u0000\u05cc\u05ce\u0005e\u0000\u0000"+ + "\u05cd\u05cc\u0001\u0000\u0000\u0000\u05cd\u05ce\u0001\u0000\u0000\u0000"+ + "\u05ce\u0103\u0001\u0000\u0000\u0000\u05cf\u05d1\u0005_\u0000\u0000\u05d0"+ + "\u05d2\u0005e\u0000\u0000\u05d1\u05d0\u0001\u0000\u0000\u0000\u05d1\u05d2"+ + "\u0001\u0000\u0000\u0000\u05d2\u0105\u0001\u0000\u0000\u0000\u05d3\u05d4"+ + "\u0005W\u0000\u0000\u05d4\u05d5\u0005e\u0000\u0000\u05d5\u0107\u0001\u0000"+ + "\u0000\u0000\u05d6\u05d7\u0005[\u0000\u0000\u05d7\u0109\u0001\u0000\u0000"+ + "\u0000\u05d8\u05e1\u0005\\\u0000\u0000\u05d9\u05e2\u0003\u00a4R\u0000"+ + "\u05da\u05db\u0003\u0170\u00b8\u0000\u05db\u05dc\u0003\u00a4R\u0000\u05dc"+ + "\u05e2\u0001\u0000\u0000\u0000\u05dd\u05de\u0003\u00f2y\u0000\u05de\u05df"+ + "\u0003\u0170\u00b8\u0000\u05df\u05e0\u0003\u00a4R\u0000\u05e0\u05e2\u0001"+ + "\u0000\u0000\u0000\u05e1\u05d9\u0001\u0000\u0000\u0000\u05e1\u05da\u0001"+ + "\u0000\u0000\u0000\u05e1\u05dd\u0001\u0000\u0000\u0000\u05e2\u05e3\u0001"+ + "\u0000\u0000\u0000\u05e3\u05e9\u0003\u00eew\u0000\u05e4\u05e7\u0005V\u0000"+ + "\u0000\u05e5\u05e8\u0003\u010a\u0085\u0000\u05e6\u05e8\u0003\u00eew\u0000"+ + "\u05e7\u05e5\u0001\u0000\u0000\u0000\u05e7\u05e6\u0001\u0000\u0000\u0000"+ + "\u05e8\u05ea\u0001\u0000\u0000\u0000\u05e9\u05e4\u0001\u0000\u0000\u0000"+ + "\u05e9\u05ea\u0001\u0000\u0000\u0000\u05ea\u010b\u0001\u0000\u0000\u0000"+ + "\u05eb\u05ee\u0003\u010e\u0087\u0000\u05ec\u05ee\u0003\u0114\u008a\u0000"+ + "\u05ed\u05eb\u0001\u0000\u0000\u0000\u05ed\u05ec\u0001\u0000\u0000\u0000"+ + "\u05ee\u010d\u0001\u0000\u0000\u0000\u05ef\u05fa\u0005Y\u0000\u0000\u05f0"+ + "\u05f2\u0003\u00a4R\u0000\u05f1\u05f0\u0001\u0000\u0000\u0000\u05f1\u05f2"+ + "\u0001\u0000\u0000\u0000\u05f2\u05fb\u0001\u0000\u0000\u0000\u05f3\u05f5"+ + "\u0003\u00f2y\u0000\u05f4\u05f3\u0001\u0000\u0000\u0000\u05f4\u05f5\u0001"+ + "\u0000\u0000\u0000\u05f5\u05f6\u0001\u0000\u0000\u0000\u05f6\u05f8\u0003"+ + "\u0170\u00b8\u0000\u05f7\u05f9\u0003\u00a4R\u0000\u05f8\u05f7\u0001\u0000"+ + "\u0000\u0000\u05f8\u05f9\u0001\u0000\u0000\u0000\u05f9\u05fb\u0001\u0000"+ + "\u0000\u0000\u05fa\u05f1\u0001\u0000\u0000\u0000\u05fa\u05f4\u0001\u0000"+ + "\u0000\u0000\u05fb\u05fc\u0001\u0000\u0000\u0000\u05fc\u0600\u0005h\u0000"+ + "\u0000\u05fd\u05ff\u0003\u0110\u0088\u0000\u05fe\u05fd\u0001\u0000\u0000"+ + "\u0000\u05ff\u0602\u0001\u0000\u0000\u0000\u0600\u05fe\u0001\u0000\u0000"+ + "\u0000\u0600\u0601\u0001\u0000\u0000\u0000\u0601\u0603\u0001\u0000\u0000"+ + "\u0000\u0602\u0600\u0001\u0000\u0000\u0000\u0603\u0604\u0005i\u0000\u0000"+ + "\u0604\u010f\u0001\u0000\u0000\u0000\u0605\u0606\u0003\u0112\u0089\u0000"+ + "\u0606\u0608\u0005o\u0000\u0000\u0607\u0609\u0003\u00f0x\u0000\u0608\u0607"+ + "\u0001\u0000\u0000\u0000\u0608\u0609\u0001\u0000\u0000\u0000\u0609\u0111"+ + "\u0001\u0000\u0000\u0000\u060a\u060b\u0005P\u0000\u0000\u060b\u060e\u0003"+ + "\u00e6s\u0000\u060c\u060e\u0005L\u0000\u0000\u060d\u060a\u0001\u0000\u0000"+ + "\u0000\u060d\u060c\u0001\u0000\u0000\u0000\u060e\u0113\u0001\u0000\u0000"+ + "\u0000\u060f\u0618\u0005Y\u0000\u0000\u0610\u0619\u0003\u0116\u008b\u0000"+ + "\u0611\u0612\u0003\u0170\u00b8\u0000\u0612\u0613\u0003\u0116\u008b\u0000"+ + "\u0613\u0619\u0001\u0000\u0000\u0000\u0614\u0615\u0003\u00f2y\u0000\u0615"+ + "\u0616\u0003\u0170\u00b8\u0000\u0616\u0617\u0003\u0116\u008b\u0000\u0617"+ + "\u0619\u0001\u0000\u0000\u0000\u0618\u0610\u0001\u0000\u0000\u0000\u0618"+ + "\u0611\u0001\u0000\u0000\u0000\u0618\u0614\u0001\u0000\u0000\u0000\u0619"+ + "\u061a\u0001\u0000\u0000\u0000\u061a\u061e\u0005h\u0000\u0000\u061b\u061d"+ + "\u0003\u0118\u008c\u0000\u061c\u061b\u0001\u0000\u0000\u0000\u061d\u0620"+ + "\u0001\u0000\u0000\u0000\u061e\u061c\u0001\u0000\u0000\u0000\u061e\u061f"+ + "\u0001\u0000\u0000\u0000\u061f\u0621\u0001\u0000\u0000\u0000\u0620\u061e"+ + "\u0001\u0000\u0000\u0000\u0621\u0622\u0005i\u0000\u0000\u0622\u0115\u0001"+ + "\u0000\u0000\u0000\u0623\u0624\u0005e\u0000\u0000\u0624\u0626\u0005s\u0000"+ + "\u0000\u0625\u0623\u0001\u0000\u0000\u0000\u0625\u0626\u0001\u0000\u0000"+ + "\u0000\u0626\u0627\u0001\u0000\u0000\u0000\u0627\u0628\u0003\u00b4Z\u0000"+ + "\u0628\u0629\u0005p\u0000\u0000\u0629\u062a\u0005f\u0000\u0000\u062a\u062b"+ + "\u0005^\u0000\u0000\u062b\u062c\u0005g\u0000\u0000\u062c\u0117\u0001\u0000"+ + "\u0000\u0000\u062d\u062e\u0003\u011a\u008d\u0000\u062e\u0630\u0005o\u0000"+ + "\u0000\u062f\u0631\u0003\u00f0x\u0000\u0630\u062f\u0001\u0000\u0000\u0000"+ + "\u0630\u0631\u0001\u0000\u0000\u0000\u0631\u0119\u0001\u0000\u0000\u0000"+ + "\u0632\u0633\u0005P\u0000\u0000\u0633\u0636\u0003\u011c\u008e\u0000\u0634"+ + "\u0636\u0005L\u0000\u0000\u0635\u0632\u0001\u0000\u0000\u0000\u0635\u0634"+ + "\u0001\u0000\u0000\u0000\u0636\u011b\u0001\u0000\u0000\u0000\u0637\u063a"+ + "\u0003\u00c2a\u0000\u0638\u063a\u0005d\u0000\u0000\u0639\u0637\u0001\u0000"+ + "\u0000\u0000\u0639\u0638\u0001\u0000\u0000\u0000\u063a\u0642\u0001\u0000"+ + "\u0000\u0000\u063b\u063e\u0005m\u0000\u0000\u063c\u063f\u0003\u00c2a\u0000"+ + "\u063d\u063f\u0005d\u0000\u0000\u063e\u063c\u0001\u0000\u0000\u0000\u063e"+ + "\u063d\u0001\u0000\u0000\u0000\u063f\u0641\u0001\u0000\u0000\u0000\u0640"+ + "\u063b\u0001\u0000\u0000\u0000\u0641\u0644\u0001\u0000\u0000\u0000\u0642"+ + "\u0640\u0001\u0000\u0000\u0000\u0642\u0643\u0001\u0000\u0000\u0000\u0643"+ + "\u011d\u0001\u0000\u0000\u0000\u0644\u0642\u0001\u0000\u0000\u0000\u0645"+ + "\u0646\u0005O\u0000\u0000\u0646\u064a\u0005h\u0000\u0000\u0647\u0649\u0003"+ + "\u0120\u0090\u0000\u0648\u0647\u0001\u0000\u0000\u0000\u0649\u064c\u0001"+ + "\u0000\u0000\u0000\u064a\u0648\u0001\u0000\u0000\u0000\u064a\u064b\u0001"+ + "\u0000\u0000\u0000\u064b\u064d\u0001\u0000\u0000\u0000\u064c\u064a\u0001"+ + "\u0000\u0000\u0000\u064d\u064e\u0005i\u0000\u0000\u064e\u011f\u0001\u0000"+ + "\u0000\u0000\u064f\u0650\u0003\u0122\u0091\u0000\u0650\u0652\u0005o\u0000"+ + "\u0000\u0651\u0653\u0003\u00f0x\u0000\u0652\u0651\u0001\u0000\u0000\u0000"+ + "\u0652\u0653\u0001\u0000\u0000\u0000\u0653\u0121\u0001\u0000\u0000\u0000"+ + "\u0654\u0657\u0005P\u0000\u0000\u0655\u0658\u0003\u00f6{\u0000\u0656\u0658"+ + "\u0003\u0124\u0092\u0000\u0657\u0655\u0001\u0000\u0000\u0000\u0657\u0656"+ + "\u0001\u0000\u0000\u0000\u0658\u065b\u0001\u0000\u0000\u0000\u0659\u065b"+ + "\u0005L\u0000\u0000\u065a\u0654\u0001\u0000\u0000\u0000\u065a\u0659\u0001"+ + "\u0000\u0000\u0000\u065b\u0123\u0001\u0000\u0000\u0000\u065c\u065d\u0003"+ + "\u00e6s\u0000\u065d\u065e\u0005l\u0000\u0000\u065e\u0663\u0001\u0000\u0000"+ + "\u0000\u065f\u0660\u0003\u00e4r\u0000\u0660\u0661\u0005s\u0000\u0000\u0661"+ + "\u0663\u0001\u0000\u0000\u0000\u0662\u065c\u0001\u0000\u0000\u0000\u0662"+ + "\u065f\u0001\u0000\u0000\u0000\u0662\u0663\u0001\u0000\u0000\u0000\u0663"+ + "\u0664\u0001\u0000\u0000\u0000\u0664\u0665\u0003\u00a4R\u0000\u0665\u0125"+ + "\u0001\u0000\u0000\u0000\u0666\u066e\u0005`\u0000\u0000\u0667\u0669\u0003"+ + "\u00a4R\u0000\u0668\u0667\u0001\u0000\u0000\u0000\u0668\u0669\u0001\u0000"+ + "\u0000\u0000\u0669\u066f\u0001\u0000\u0000\u0000\u066a\u066f\u0003\u0128"+ + "\u0094\u0000\u066b\u066d\u0003\u00d8l\u0000\u066c\u066b\u0001\u0000\u0000"+ + "\u0000\u066c\u066d\u0001\u0000\u0000\u0000\u066d\u066f\u0001\u0000\u0000"+ + "\u0000\u066e\u0668\u0001\u0000\u0000\u0000\u066e\u066a\u0001\u0000\u0000"+ + "\u0000\u066e\u066c\u0001\u0000\u0000\u0000\u066f\u0670\u0001\u0000\u0000"+ + "\u0000\u0670\u0671\u0003\u00eew\u0000\u0671\u0127\u0001\u0000\u0000\u0000"+ + "\u0672\u0674\u0003\u00f2y\u0000\u0673\u0672\u0001\u0000\u0000\u0000\u0673"+ + "\u0674\u0001\u0000\u0000\u0000\u0674\u0675\u0001\u0000\u0000\u0000\u0675"+ + "\u0677\u0003\u0170\u00b8\u0000\u0676\u0678\u0003\u00a4R\u0000\u0677\u0676"+ + "\u0001\u0000\u0000\u0000\u0677\u0678\u0001\u0000\u0000\u0000\u0678\u0679"+ + "\u0001\u0000\u0000\u0000\u0679\u067b\u0003\u0170\u00b8\u0000\u067a\u067c"+ + "\u0003\u00f2y\u0000\u067b\u067a\u0001\u0000\u0000\u0000\u067b\u067c\u0001"+ + "\u0000\u0000\u0000\u067c\u0129\u0001\u0000\u0000\u0000\u067d\u067e\u0005"+ + "R\u0000\u0000\u067e\u067f\u0003\u00a4R\u0000\u067f\u012b\u0001\u0000\u0000"+ + "\u0000\u0680\u0683\u0003\u0150\u00a8\u0000\u0681\u0683\u0005e\u0000\u0000"+ + "\u0682\u0680\u0001\u0000\u0000\u0000\u0682\u0681\u0001\u0000\u0000\u0000"+ + "\u0683\u012d\u0001\u0000\u0000\u0000\u0684\u0685\u0005j\u0000\u0000\u0685"+ + "\u0686\u0003\u0130\u0098\u0000\u0686\u0687\u0005k\u0000\u0000\u0687\u0688"+ + "\u0003\u0132\u0099\u0000\u0688\u012f\u0001\u0000\u0000\u0000\u0689\u068a"+ + "\u0003\u00a4R\u0000\u068a\u0131\u0001\u0000\u0000\u0000\u068b\u068c\u0003"+ + "\u00c2a\u0000\u068c\u0133\u0001\u0000\u0000\u0000\u068d\u068e\u0005\u0087"+ + "\u0000\u0000\u068e\u068f\u0003\u00c2a\u0000\u068f\u0135\u0001\u0000\u0000"+ + "\u0000\u0690\u0691\u0005j\u0000\u0000\u0691\u0692\u0005k\u0000\u0000\u0692"+ + "\u0693\u0003\u0132\u0099\u0000\u0693\u0137\u0001\u0000\u0000\u0000\u0694"+ + "\u0695\u0005S\u0000\u0000\u0695\u0696\u0005j\u0000\u0000\u0696\u0697\u0003"+ + "\u00c2a\u0000\u0697\u0698\u0005k\u0000\u0000\u0698\u0699\u0003\u0132\u0099"+ + "\u0000\u0699\u0139\u0001\u0000\u0000\u0000\u069a\u06a0\u0005U\u0000\u0000"+ + "\u069b\u069c\u0005U\u0000\u0000\u069c\u06a0\u0005\u0089\u0000\u0000\u069d"+ + "\u069e\u0005\u0089\u0000\u0000\u069e\u06a0\u0005U\u0000\u0000\u069f\u069a"+ + "\u0001\u0000\u0000\u0000\u069f\u069b\u0001\u0000\u0000\u0000\u069f\u069d"+ + "\u0001\u0000\u0000\u0000\u06a0\u06a1\u0001\u0000\u0000\u0000\u06a1\u06a2"+ + "\u0003\u0132\u0099\u0000\u06a2\u013b\u0001\u0000\u0000\u0000\u06a3\u06a4"+ + "\u0005M\u0000\u0000\u06a4\u06a5\u0003\u013e\u009f\u0000\u06a5\u013d\u0001"+ + "\u0000\u0000\u0000\u06a6\u06a7\u0003\u0142\u00a1\u0000\u06a7\u06a8\u0003"+ + "\u0140\u00a0\u0000\u06a8\u06ab\u0001\u0000\u0000\u0000\u06a9\u06ab\u0003"+ + "\u0142\u00a1\u0000\u06aa\u06a6\u0001\u0000\u0000\u0000\u06aa\u06a9\u0001"+ + "\u0000\u0000\u0000\u06ab\u013f\u0001\u0000\u0000\u0000\u06ac\u06af\u0003"+ + "\u0142\u00a1\u0000\u06ad\u06af\u0003\u00c2a\u0000\u06ae\u06ac\u0001\u0000"+ + "\u0000\u0000\u06ae\u06ad\u0001\u0000\u0000\u0000\u06af\u0141\u0001\u0000"+ + "\u0000\u0000\u06b0\u06bc\u0005f\u0000\u0000\u06b1\u06b6\u0003\u009cN\u0000"+ + "\u06b2\u06b3\u0005m\u0000\u0000\u06b3\u06b5\u0003\u009cN\u0000\u06b4\u06b2"+ + "\u0001\u0000\u0000\u0000\u06b5\u06b8\u0001\u0000\u0000\u0000\u06b6\u06b4"+ + "\u0001\u0000\u0000\u0000\u06b6\u06b7\u0001\u0000\u0000\u0000\u06b7\u06ba"+ + "\u0001\u0000\u0000\u0000\u06b8\u06b6\u0001\u0000\u0000\u0000\u06b9\u06bb"+ + "\u0005m\u0000\u0000\u06ba\u06b9\u0001\u0000\u0000\u0000\u06ba\u06bb\u0001"+ + "\u0000\u0000\u0000\u06bb\u06bd\u0001\u0000\u0000\u0000\u06bc\u06b1\u0001"+ + "\u0000\u0000\u0000\u06bc\u06bd\u0001\u0000\u0000\u0000\u06bd\u06be\u0001"+ + "\u0000\u0000\u0000\u06be\u06bf\u0005g\u0000\u0000\u06bf\u0143\u0001\u0000"+ + "\u0000\u0000\u06c0\u06c1\u0003\u0146\u00a3\u0000\u06c1\u06c2\u0005f\u0000"+ + "\u0000\u06c2\u06c4\u0003\u00a4R\u0000\u06c3\u06c5\u0005m\u0000\u0000\u06c4"+ + "\u06c3\u0001\u0000\u0000\u0000\u06c4\u06c5\u0001\u0000\u0000\u0000\u06c5"+ + "\u06c6\u0001\u0000\u0000\u0000\u06c6\u06c7\u0005g\u0000\u0000\u06c7\u0145"+ + "\u0001\u0000\u0000\u0000\u06c8\u06ce\u0003\u00c4b\u0000\u06c9\u06ca\u0005"+ + "f\u0000\u0000\u06ca\u06cb\u0003\u0146\u00a3\u0000\u06cb\u06cc\u0005g\u0000"+ + "\u0000\u06cc\u06ce\u0001\u0000\u0000\u0000\u06cd\u06c8\u0001\u0000\u0000"+ + "\u0000\u06cd\u06c9\u0001\u0000\u0000\u0000\u06ce\u0147\u0001\u0000\u0000"+ + "\u0000\u06cf\u06d6\u0003\u014a\u00a5\u0000\u06d0\u06d6\u0003\u014e\u00a7"+ + "\u0000\u06d1\u06d2\u0005f\u0000\u0000\u06d2\u06d3\u0003\u00a4R\u0000\u06d3"+ + "\u06d4\u0005g\u0000\u0000\u06d4\u06d6\u0001\u0000\u0000\u0000\u06d5\u06cf"+ + "\u0001\u0000\u0000\u0000\u06d5\u06d0\u0001\u0000\u0000\u0000\u06d5\u06d1"+ + "\u0001\u0000\u0000\u0000\u06d6\u0149\u0001\u0000\u0000\u0000\u06d7\u06db"+ + "\u0003\u00b2Y\u0000\u06d8\u06db\u0003\u0152\u00a9\u0000\u06d9\u06db\u0003"+ + "\u00b6[\u0000\u06da\u06d7\u0001\u0000\u0000\u0000\u06da\u06d8\u0001\u0000"+ + "\u0000\u0000\u06da\u06d9\u0001\u0000\u0000\u0000\u06db\u014b\u0001\u0000"+ + "\u0000\u0000\u06dc\u06dd\u0007\u0011\u0000\u0000\u06dd\u014d\u0001\u0000"+ + "\u0000\u0000\u06de\u06df\u0005e\u0000\u0000\u06df\u014f\u0001\u0000\u0000"+ + "\u0000\u06e0\u06e1\u0005e\u0000\u0000\u06e1\u06e2\u0005p\u0000\u0000\u06e2"+ + "\u06e3\u0005e\u0000\u0000\u06e3\u0151\u0001\u0000\u0000\u0000\u06e4\u06e5"+ + "\u0003\u00cae\u0000\u06e5\u06e6\u0003\u0154\u00aa\u0000\u06e6\u0153\u0001"+ + "\u0000\u0000\u0000\u06e7\u06ec\u0005h\u0000\u0000\u06e8\u06ea\u0003\u0156"+ + "\u00ab\u0000\u06e9\u06eb\u0005m\u0000\u0000\u06ea\u06e9\u0001\u0000\u0000"+ + "\u0000\u06ea\u06eb\u0001\u0000\u0000\u0000\u06eb\u06ed\u0001\u0000\u0000"+ + "\u0000\u06ec\u06e8\u0001\u0000\u0000\u0000\u06ec\u06ed\u0001\u0000\u0000"+ + "\u0000\u06ed\u06ee\u0001\u0000\u0000\u0000\u06ee\u06ef\u0005i\u0000\u0000"+ + "\u06ef\u0155\u0001\u0000\u0000\u0000\u06f0\u06f5\u0003\u0158\u00ac\u0000"+ + "\u06f1\u06f2\u0005m\u0000\u0000\u06f2\u06f4\u0003\u0158\u00ac\u0000\u06f3"+ + "\u06f1\u0001\u0000\u0000\u0000\u06f4\u06f7\u0001\u0000\u0000\u0000\u06f5"+ + "\u06f3\u0001\u0000\u0000\u0000\u06f5\u06f6\u0001\u0000\u0000\u0000\u06f6"+ + "\u0157\u0001\u0000\u0000\u0000\u06f7\u06f5\u0001\u0000\u0000\u0000\u06f8"+ + "\u06f9\u0003\u015a\u00ad\u0000\u06f9\u06fa\u0005o\u0000\u0000\u06fa\u06fc"+ + "\u0001\u0000\u0000\u0000\u06fb\u06f8\u0001\u0000\u0000\u0000\u06fb\u06fc"+ + "\u0001\u0000\u0000\u0000\u06fc\u06fd\u0001\u0000\u0000\u0000\u06fd\u06fe"+ + "\u0003\u015c\u00ae\u0000\u06fe\u0159\u0001\u0000\u0000\u0000\u06ff\u0702"+ + "\u0003\u00a4R\u0000\u0700\u0702\u0003\u0154\u00aa\u0000\u0701\u06ff\u0001"+ + "\u0000\u0000\u0000\u0701\u0700\u0001\u0000\u0000\u0000\u0702\u015b\u0001"+ + "\u0000\u0000\u0000\u0703\u0706\u0003\u00a4R\u0000\u0704\u0706\u0003\u0154"+ + "\u00aa\u0000\u0705\u0703\u0001\u0000\u0000\u0000\u0705\u0704\u0001\u0000"+ + "\u0000\u0000\u0706\u015d\u0001\u0000\u0000\u0000\u0707\u0708\u0005T\u0000"+ + "\u0000\u0708\u070e\u0005h\u0000\u0000\u0709\u070a\u0003\u0160\u00b0\u0000"+ + "\u070a\u070b\u0003\u0170\u00b8\u0000\u070b\u070d\u0001\u0000\u0000\u0000"+ + "\u070c\u0709\u0001\u0000\u0000\u0000\u070d\u0710\u0001\u0000\u0000\u0000"+ + "\u070e\u070c\u0001\u0000\u0000\u0000\u070e\u070f\u0001\u0000\u0000\u0000"+ + "\u070f\u0711\u0001\u0000\u0000\u0000\u0710\u070e\u0001\u0000\u0000\u0000"+ + "\u0711\u0712\u0005i\u0000\u0000\u0712\u015f\u0001\u0000\u0000\u0000\u0713"+ + "\u0714\u0003\u00e4r\u0000\u0714\u0715\u0003\u00c2a\u0000\u0715\u0718\u0001"+ + "\u0000\u0000\u0000\u0716\u0718\u0003\u0164\u00b2\u0000\u0717\u0713\u0001"+ + "\u0000\u0000\u0000\u0717\u0716\u0001\u0000\u0000\u0000\u0718\u071a\u0001"+ + "\u0000\u0000\u0000\u0719\u071b\u0003\u0162\u00b1\u0000\u071a\u0719\u0001"+ + "\u0000\u0000\u0000\u071a\u071b\u0001\u0000\u0000\u0000\u071b\u0161\u0001"+ + "\u0000\u0000\u0000\u071c\u071d\u0007\u0012\u0000\u0000\u071d\u0163\u0001"+ + "\u0000\u0000\u0000\u071e\u0720\u0005\u0087\u0000\u0000\u071f\u071e\u0001"+ + "\u0000\u0000\u0000\u071f\u0720\u0001\u0000\u0000\u0000\u0720\u0721\u0001"+ + "\u0000\u0000\u0000\u0721\u0722\u0003\u012c\u0096\u0000\u0722\u0165\u0001"+ + "\u0000\u0000\u0000\u0723\u0724\u0005j\u0000\u0000\u0724\u0725\u0003\u00a4"+ + "R\u0000\u0725\u0726\u0005k\u0000\u0000\u0726\u0167\u0001\u0000\u0000\u0000"+ + "\u0727\u0728\u0005p\u0000\u0000\u0728\u0729\u0005f\u0000\u0000\u0729\u072a"+ + "\u0003\u00c2a\u0000\u072a\u072b\u0005g\u0000\u0000\u072b\u0169\u0001\u0000"+ + "\u0000\u0000\u072c\u073b\u0005f\u0000\u0000\u072d\u0734\u0003\u00e6s\u0000"+ + "\u072e\u0731\u0003\u0146\u00a3\u0000\u072f\u0730\u0005m\u0000\u0000\u0730"+ + "\u0732\u0003\u00e6s\u0000\u0731\u072f\u0001\u0000\u0000\u0000\u0731\u0732"+ + "\u0001\u0000\u0000\u0000\u0732\u0734\u0001\u0000\u0000\u0000\u0733\u072d"+ + "\u0001\u0000\u0000\u0000\u0733\u072e\u0001\u0000\u0000\u0000\u0734\u0736"+ + "\u0001\u0000\u0000\u0000\u0735\u0737\u0005t\u0000\u0000\u0736\u0735\u0001"+ + "\u0000\u0000\u0000\u0736\u0737\u0001\u0000\u0000\u0000\u0737\u0739\u0001"+ + "\u0000\u0000\u0000\u0738\u073a\u0005m\u0000\u0000\u0739\u0738\u0001\u0000"+ + "\u0000\u0000\u0739\u073a\u0001\u0000\u0000\u0000\u073a\u073c\u0001\u0000"+ + "\u0000\u0000\u073b\u0733\u0001\u0000\u0000\u0000\u073b\u073c\u0001\u0000"+ + "\u0000\u0000\u073c\u073d\u0001\u0000\u0000\u0000\u073d\u073e\u0005g\u0000"+ + "\u0000\u073e\u016b\u0001\u0000\u0000\u0000\u073f\u0740\u0003\u0146\u00a3"+ + "\u0000\u0740\u0741\u0005p\u0000\u0000\u0741\u0742\u0005e\u0000\u0000\u0742"+ + "\u016d\u0001\u0000\u0000\u0000\u0743\u0744\u0003\u00c2a\u0000\u0744\u016f"+ + "\u0001\u0000\u0000\u0000\u0745\u074a\u0005n\u0000\u0000\u0746\u074a\u0005"+ + "\u0000\u0000\u0001\u0747\u074a\u0005\u009f\u0000\u0000\u0748\u074a\u0004"+ + "\u00b8\u0013\u0000\u0749\u0745\u0001\u0000\u0000\u0000\u0749\u0746\u0001"+ + "\u0000\u0000\u0000\u0749\u0747\u0001\u0000\u0000\u0000\u0749\u0748\u0001"+ + "\u0000\u0000\u0000\u074a\u0171\u0001\u0000\u0000\u0000\u00c1\u0180\u0185"+ + "\u018c\u0196\u019c\u01a2\u01ac\u01b6\u01c4\u01c8\u01d1\u01dd\u01e1\u01e7"+ + "\u01f0\u01fa\u020b\u0219\u021d\u0224\u022c\u0235\u0255\u025d\u0275\u0288"+ + "\u0297\u02a4\u02ad\u02bb\u02c4\u02d0\u02e5\u02ec\u02f1\u02f6\u0300\u0303"+ + "\u0307\u030b\u0313\u031b\u0320\u0328\u032a\u032f\u0336\u033e\u0341\u0347"+ + "\u034c\u034e\u0351\u0358\u035d\u0370\u0378\u037c\u037f\u0385\u0389\u038c"+ + "\u0396\u039d\u03a4\u03b0\u03b6\u03bd\u03c2\u03c8\u03d4\u03da\u03de\u03e6"+ + "\u03ea\u03f0\u03f3\u03f9\u03fe\u0417\u043a\u043c\u0453\u045b\u0466\u046d"+ + "\u0474\u047e\u048c\u04a2\u04a4\u04ac\u04b0\u04b4\u04b7\u04c0\u04c6\u04d0"+ + "\u04d8\u04de\u04e7\u04f2\u04fd\u0501\u0503\u050e\u0517\u051b\u051e\u0525"+ + "\u0530\u053a\u0540\u0542\u054c\u0556\u055a\u055e\u0562\u0569\u0571\u057c"+ + "\u0580\u0584\u0590\u0594\u0598\u059d\u05a0\u05a3\u05aa\u05b1\u05c5\u05c9"+ + "\u05cd\u05d1\u05e1\u05e7\u05e9\u05ed\u05f1\u05f4\u05f8\u05fa\u0600\u0608"+ + "\u060d\u0618\u061e\u0625\u0630\u0635\u0639\u063e\u0642\u064a\u0652\u0657"+ + "\u065a\u0662\u0668\u066c\u066e\u0673\u0677\u067b\u0682\u069f\u06aa\u06ae"+ + "\u06b6\u06ba\u06bc\u06c4\u06cd\u06d5\u06da\u06ea\u06ec\u06f5\u06fb\u0701"+ + "\u0705\u070e\u0717\u071a\u071f\u0731\u0733\u0736\u0739\u073b\u0749"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); static { @@ -13655,4 +14494,4 @@ private boolean eos_sempred(EosContext _localctx, int predIndex) { _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); } } -} +} \ No newline at end of file diff --git a/src/main/java/viper/gobra/frontend/GobraParserBaseVisitor.java b/src/main/java/viper/gobra/frontend/GobraParserBaseVisitor.java index 27688feeb..52b9990df 100644 --- a/src/main/java/viper/gobra/frontend/GobraParserBaseVisitor.java +++ b/src/main/java/viper/gobra/frontend/GobraParserBaseVisitor.java @@ -1,3 +1,4 @@ +// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.12.0 package viper.gobra.frontend; import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; @@ -9,6 +10,7 @@ * @param The return type of the visit operation. Use {@link Void} for * operations with no return type. */ +@SuppressWarnings("CheckReturnValue") public class GobraParserBaseVisitor extends AbstractParseTreeVisitor implements GobraParserVisitor { /** * {@inheritDoc} @@ -52,6 +54,13 @@ public class GobraParserBaseVisitor extends AbstractParseTreeVisitor imple * {@link #visitChildren} on {@code ctx}.

*/ @Override public T visitSourceFile(GobraParser.SourceFileContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPreamble(GobraParser.PreambleContext ctx) { return visitChildren(ctx); } /** * {@inheritDoc} * @@ -1529,4 +1538,4 @@ public class GobraParserBaseVisitor extends AbstractParseTreeVisitor imple * {@link #visitChildren} on {@code ctx}.

*/ @Override public T visitEos(GobraParser.EosContext ctx) { return visitChildren(ctx); } -} +} \ No newline at end of file diff --git a/src/main/java/viper/gobra/frontend/GobraParserVisitor.java b/src/main/java/viper/gobra/frontend/GobraParserVisitor.java index 79f5cf002..352f76c5e 100644 --- a/src/main/java/viper/gobra/frontend/GobraParserVisitor.java +++ b/src/main/java/viper/gobra/frontend/GobraParserVisitor.java @@ -1,3 +1,4 @@ +// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.12.0 package viper.gobra.frontend; import org.antlr.v4.runtime.tree.ParseTreeVisitor; @@ -45,6 +46,12 @@ public interface GobraParserVisitor extends ParseTreeVisitor { * @return the visitor result */ T visitSourceFile(GobraParser.SourceFileContext ctx); + /** + * Visit a parse tree produced by {@link GobraParser#preamble}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPreamble(GobraParser.PreambleContext ctx); /** * Visit a parse tree produced by {@link GobraParser#initPost}. * @param ctx the parse tree @@ -1348,4 +1355,4 @@ public interface GobraParserVisitor extends ParseTreeVisitor { * @return the visitor result */ T visitEos(GobraParser.EosContext ctx); -} +} \ No newline at end of file diff --git a/src/main/scala/viper/gobra/Gobra.scala b/src/main/scala/viper/gobra/Gobra.scala index a391465f8..f83c0deaf 100644 --- a/src/main/scala/viper/gobra/Gobra.scala +++ b/src/main/scala/viper/gobra/Gobra.scala @@ -12,11 +12,11 @@ import java.nio.file.Paths import java.util.concurrent.ExecutionException import com.typesafe.scalalogging.StrictLogging import org.slf4j.LoggerFactory -import viper.gobra.ast.frontend.PPackage import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.{CGEdgesTerminationTransform, ConstantPropagation, InternalTransform, OverflowChecksTransform} import viper.gobra.backend.BackendVerifier -import viper.gobra.frontend.info.Info.Context +import viper.gobra.frontend.PackageResolver.{AbstractPackage, RegularPackage} +import viper.gobra.frontend.Parser.ParseSuccessResult import viper.gobra.frontend.info.{Info, TypeInfo} import viper.gobra.frontend.{Config, Desugar, PackageInfo, Parser, ScallopGobraConfig} import viper.gobra.reporting._ @@ -28,6 +28,7 @@ import viper.silver.{ast => vpr} import java.time.format.DateTimeFormatter import java.time.LocalTime +import scala.annotation.unused import scala.concurrent.{Await, Future, TimeoutException} object GoVerifier { @@ -158,11 +159,11 @@ class Gobra extends GoVerifier with GoIdeVerifier { for { finalConfig <- getAndMergeInFileConfig(config, pkgInfo) _ = setLogLevel(finalConfig) - parsedPackage <- performParsing(pkgInfo, finalConfig) - typeInfo <- performTypeChecking(parsedPackage, executor, finalConfig) - program <- performDesugaring(parsedPackage, typeInfo, finalConfig) - program <- performInternalTransformations(program, finalConfig, pkgInfo) - viperTask <- performViperEncoding(program, finalConfig, pkgInfo) + parseResults <- performParsing(finalConfig, pkgInfo)(executor) + typeInfo <- performTypeChecking(finalConfig, pkgInfo, parseResults)(executor) + program <- performDesugaring(finalConfig, typeInfo)(executor) + program <- performInternalTransformations(finalConfig, pkgInfo, program)(executor) + viperTask <- performViperEncoding(finalConfig, pkgInfo, program)(executor) } yield (viperTask, finalConfig) } @@ -177,7 +178,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { // directly declaring the parameter implicit somehow does not work as the compiler is unable to spot the inheritance implicit val _executor: GobraExecutionContext = executor val viperTask = BackendVerifier.Task(ast, backtrack) - performVerification(viperTask, config, pkgInfo) + performVerification(config, pkgInfo, viperTask) .map(BackTranslator.backTranslate(_)(config)) .recoverWith { case e: ExecutionException if isKnownZ3Bug(e) => @@ -242,31 +243,46 @@ class Gobra extends GoVerifier with GoIdeVerifier { .setLevel(config.logLevel) } - private def performParsing(pkgInfo: PackageInfo, config: Config): Either[Vector[VerifierError], PPackage] = { + private def performParsing(config: Config, pkgInfo: PackageInfo)(executor: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseSuccessResult]] = { if (config.shouldParse) { val startMs = System.currentTimeMillis() - val sourcesToParse = config.packageInfoInputMap(pkgInfo) - val res = Parser.parse(sourcesToParse, pkgInfo)(config) + val res = Parser.parse(config, pkgInfo)(executor) val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" println(s"parser phase done, took ${durationS}s") res + /* + val sourcesToParse = config.packageInfoInputMap(pkgInfo) + val res = Parser.parse(sourcesToParse, pkgInfo)(config) + */ + /* + val parseManager = Parser.parse(pkgInfo)(config, executionContext) + config.typeCheckMode match { + case TypeCheckMode.Lazy => // don't do anything + case TypeCheckMode.Sequential | TypeCheckMode.Parallel => + parseManager.awaitResults() + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + println(s"parser phase done, took ${durationS}s") + println(s"parsed packages: ${parseManager.getResults.map{ case (pkg, _) => pkg }.mkString(", ")}") + } + Right(parseManager) + */ } else { Left(Vector()) } } - private def performTypeChecking(parsedPackage: PPackage, executionContext: GobraExecutionContext, config: Config): Either[Vector[VerifierError], TypeInfo] = { + private def performTypeChecking(config: Config, pkgInfo: PackageInfo, parseResults: Map[AbstractPackage, ParseSuccessResult])(executor: GobraExecutionContext): Either[Vector[VerifierError], TypeInfo] = { if (config.shouldTypeCheck) { - Info.check(parsedPackage, config.packageInfoInputMap(parsedPackage.info), isMainContext = true, context = new Context(executionContext, config))(config) + Info.check(config, RegularPackage(pkgInfo.id), parseResults)(executor) } else { Left(Vector()) } } - private def performDesugaring(parsedPackage: PPackage, typeInfo: TypeInfo, config: Config): Either[Vector[VerifierError], Program] = { + private def performDesugaring(config: Config, typeInfo: TypeInfo)(@unused executor: GobraExecutionContext): Either[Vector[VerifierError], Program] = { if (config.shouldDesugar) { val startMs = System.currentTimeMillis() - val res = Right(Desugar.desugar(parsedPackage, typeInfo)(config)) + val res = Right(Desugar.desugar(typeInfo.tree.root, typeInfo)(config)) val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" println(s"desugaring done, took ${durationS}s") res @@ -275,19 +291,11 @@ class Gobra extends GoVerifier with GoIdeVerifier { } } - private def performVerification(config: Config, pkgInfo: PackageInfo, ast: vpr.Program, backtrack: BackTranslator.BackTrackInfo)(executor: GobraExecutionContext): Future[VerifierResult] = { - if (config.noVerify) { - Future(VerifierResult.Success)(executor) - } else { - verifyAst(config, pkgInfo, ast, backtrack)(executor) - } - } - /** * Applies transformations to programs in the internal language. Currently, only adds overflow checks but it can * be easily extended to perform more transformations */ - private def performInternalTransformations(program: Program, config: Config, pkgInfo: PackageInfo): Either[Vector[VerifierError], Program] = { + private def performInternalTransformations(config: Config, pkgInfo: PackageInfo, program: Program)(@unused executor: GobraExecutionContext): Either[Vector[VerifierError], Program] = { // constant propagation does not cause duplication of verification errors caused // by overflow checks (if enabled) because all overflows in constant declarations // can be found by the well-formedness checks. @@ -303,7 +311,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { Right(result) } - private def performViperEncoding(program: Program, config: Config, pkgInfo: PackageInfo): Either[Vector[VerifierError], BackendVerifier.Task] = { + private def performViperEncoding(config: Config, pkgInfo: PackageInfo, program: Program)(@unused executor: GobraExecutionContext): Either[Vector[VerifierError], BackendVerifier.Task] = { if (config.shouldViperEncode) { val startMs = System.currentTimeMillis() val res = Right(Translator.translate(program, pkgInfo)(config)) @@ -315,7 +323,15 @@ class Gobra extends GoVerifier with GoIdeVerifier { } } - private def performVerification(viperTask: BackendVerifier.Task, config: Config, pkgInfo: PackageInfo)(implicit executor: GobraExecutionContext): Future[BackendVerifier.Result] = { + private def performVerification(config: Config, pkgInfo: PackageInfo, ast: vpr.Program, backtrack: BackTranslator.BackTrackInfo)(executor: GobraExecutionContext): Future[VerifierResult] = { + if (config.noVerify) { + Future(VerifierResult.Success)(executor) + } else { + verifyAst(config, pkgInfo, ast, backtrack)(executor) + } + } + + private def performVerification(config: Config, pkgInfo: PackageInfo, viperTask: BackendVerifier.Task)(implicit executor: GobraExecutionContext): Future[BackendVerifier.Result] = { if (config.shouldVerify) { BackendVerifier.verify(viperTask, pkgInfo)(config) } else { diff --git a/src/main/scala/viper/gobra/ast/frontend/Ast.scala b/src/main/scala/viper/gobra/ast/frontend/Ast.scala index dcc5c3a65..e6819f68c 100644 --- a/src/main/scala/viper/gobra/ast/frontend/Ast.scala +++ b/src/main/scala/viper/gobra/ast/frontend/Ast.scala @@ -61,6 +61,15 @@ case class PProgram( ) extends PNode with PUnorderedScope // imports are in program scopes +case class PPreamble( + packageClause: PPackageClause, + // init postconditions describe the state and resources right + // after this program is initialized + initPosts: Vector[PExpression], + imports: Vector[PImport], + ) extends PNode with PUnorderedScope // imports are in program scopes + + class PositionManager(val positions: Positions) extends Messaging(positions) { def translate[E <: VerifierError]( diff --git a/src/main/scala/viper/gobra/frontend/Config.scala b/src/main/scala/viper/gobra/frontend/Config.scala index f9a1c9c59..cd2c80df7 100644 --- a/src/main/scala/viper/gobra/frontend/Config.scala +++ b/src/main/scala/viper/gobra/frontend/Config.scala @@ -16,8 +16,7 @@ import viper.gobra.backend.{ViperBackend, ViperBackends} import viper.gobra.GoVerifier import viper.gobra.frontend.PackageResolver.FileResource import viper.gobra.frontend.Source.getPackageInfo -import viper.gobra.frontend.info.Info.TypeCheckMode -import viper.gobra.frontend.info.Info.TypeCheckMode.TypeCheckMode +import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential, TaskManagerMode} import viper.gobra.reporting.{FileWriterReporter, GobraReporter, StdIOReporter} import viper.gobra.util.{TypeBounds, Violation} import viper.silver.ast.SourcePosition @@ -70,7 +69,7 @@ object ConfigDefaults { lazy val DefaultEnableLazyImports: Boolean = false lazy val DefaultNoVerify: Boolean = false lazy val DefaultNoStreamErrors: Boolean = false - lazy val DefaultTypeCheckMode: TypeCheckMode = TypeCheckMode.Parallel + lazy val DefaultTypeCheckMode: TaskManagerMode = TaskManagerMode.Parallel } case class Config( @@ -122,7 +121,7 @@ case class Config( enableLazyImports: Boolean = ConfigDefaults.DefaultEnableLazyImports, noVerify: Boolean = ConfigDefaults.DefaultNoVerify, noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors, - typeCheckMode: TypeCheckMode = ConfigDefaults.DefaultTypeCheckMode, + typeCheckMode: TaskManagerMode = ConfigDefaults.DefaultTypeCheckMode, ) { def merge(other: Config): Config = { @@ -219,7 +218,7 @@ case class BaseConfig(gobraDirectory: Path = ConfigDefaults.DefaultGobraDirector enableLazyImports: Boolean = ConfigDefaults.DefaultEnableLazyImports, noVerify: Boolean = ConfigDefaults.DefaultNoVerify, noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors, - typeCheckMode: TypeCheckMode = ConfigDefaults.DefaultTypeCheckMode, + typeCheckMode: TaskManagerMode = ConfigDefaults.DefaultTypeCheckMode, ) { def shouldParse: Boolean = true def shouldTypeCheck: Boolean = !shouldParseOnly @@ -646,16 +645,16 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals noshort = true, ) - val typeCheckMode: ScallopOption[TypeCheckMode] = choice( + val typeCheckMode: ScallopOption[TaskManagerMode] = choice( name = "typeCheckMode", choices = Seq("LAZY", "SEQUENTIAL", "PARALLEL"), descr = "Specifies the mode in which type-checking is performed.", default = Some("PARALLEL"), noshort = true ).map { - case "LAZY" => TypeCheckMode.Lazy - case "SEQUENTIAL" => TypeCheckMode.Sequential - case "PARALLEL" => TypeCheckMode.Parallel + case "LAZY" => Lazy + case "SEQUENTIAL" => Sequential + case "PARALLEL" => Parallel case _ => ConfigDefaults.DefaultTypeCheckMode } diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index 96a372934..3bdc63c0d 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -32,8 +32,11 @@ object Desugar { val importsCollector = new PackageInitSpecCollector // independently desugar each imported package. val importedDesugaringStartMs = System.currentTimeMillis() - val importedPrograms = info.context.getContexts map { tI => { - val typeInfo: TypeInfo = tI.getTypeInfo + // val importedPrograms = info.context.getContexts map { tI => { + // val importedPrograms = info.dependentTypeInfo.map { case (abstractPackage, tIFn) => { + val importedPrograms = info.getTransitiveTypeInfos.map { tI => { + val typeInfo = tI.getTypeInfo + // val typeInfo: TypeInfo = tIFn().map(_.getTypeInfo).getOrElse(Violation.violation(s"cannot desugar package $abstractPackage for which type-checking failed")) // tI.getTypeInfo val importedPackage = typeInfo.tree.originalRoot val d = new Desugarer(importedPackage.positions, typeInfo) // registers a package to generate proof obligations for its init code @@ -3460,8 +3463,11 @@ object Desugar { } // Collect and register all import-preconditions - pkg.imports.foreach{ imp => - info.context.getTypeInfo(RegularImport(imp.importPath))(config) match { + pkg.imports.foreach{ imp => { + val importedPackage = RegularImport(imp.importPath) + Violation.violation(info.dependentTypeInfo.contains(importedPackage), s"Desugarer expects to have acess to the type information of all imported packages but could not find $importedPackage") + // info.context.getTypeInfo(RegularImport(imp.importPath))(config) match { + info.dependentTypeInfo(importedPackage)() match { // case Some(Right(tI)) => case Right(tI) => val desugaredPre = imp.importPres.map(specificationD(FunctionContext.empty(), info)) @@ -3469,7 +3475,7 @@ object Desugar { specCollector.addImportPres(tI.getTypeInfo.tree.originalRoot, desugaredPre) case e => Violation.violation(config.enableLazyImports, s"Unexpected value found $e while importing ${imp.importPath} - type information is assumed to be available for all packages when Gobra is executed with lazy imports disabled") } - } + }} // Collect and register all postconditions of all PPrograms (i.e., files) in pkg val pkgPost = pkg.programs.flatMap(_.initPosts).map(specificationD(FunctionContext.empty(), info)) diff --git a/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala b/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala index 73425dd07..b498a1db2 100644 --- a/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala +++ b/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala @@ -2188,6 +2188,13 @@ class ParseTreeTranslator(pom: PositionManager, source: Source, specOnly : Boole PProgram(packageClause, initPosts, importDecls, members ++ decls ++ ghostMembers).at(ctx) } + override def visitPreamble(ctx: GobraParser.PreambleContext): PPreamble = { + val packageClause: PPackageClause = visitNode(ctx.packageClause()) + val initPosts: Vector[PExpression] = visitListNode[PExpression](ctx.initPost()) + val importDecls = ctx.importDecl().asScala.toVector.flatMap(visitImportDecl) + PPreamble(packageClause, initPosts, importDecls).at(ctx) + } + /** * Visists an init postcondition * @param ctx the parse tree diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index 947840d11..ba88bac41 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -17,7 +17,9 @@ import viper.gobra.reporting.{Source => _, _} import org.antlr.v4.runtime.{CharStreams, CommonTokenStream, DefaultErrorStrategy, ParserRuleContext} import org.antlr.v4.runtime.atn.PredictionMode import org.antlr.v4.runtime.misc.ParseCancellationException -import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} +import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} +import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} +import viper.gobra.util.GobraExecutionContext import viper.silver.ast.SourcePosition import scala.collection.mutable.ListBuffer @@ -26,6 +28,100 @@ import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} object Parser { + type ParseSuccessResult = (Vector[Source], PPackage) + type ParseResult = Either[Vector[VerifierError], ParseSuccessResult] + class ParseManager(config: Config, executionContext: GobraExecutionContext) { + private val manager = new TaskManager[AbstractPackage, ParseResult](TaskManagerMode.Parallel) + + def parse(pkgInfo: PackageInfo): Unit = { + val pkg = RegularPackage(pkgInfo.id) + val parseJob = ParseInfoJob(pkgInfo) + manager.addIfAbsent(pkg, parseJob)(executionContext) + // trigger and wait for parsing of at least this package (which will ensure that parse jobs for all dependent packages are created too) + manager.getResult(pkg) + } + + trait ParseJob extends Job[ParseResult] { + def pkgInfo: PackageInfo + def pkgSources: Vector[Source] + + override def compute(): ParseResult = { + require(pkgSources.nonEmpty) + + val startPreambleParsingMs = System.currentTimeMillis() + var endPreambleParsingMs: Option[Long] = None + // before parsing, get imports and add these parse jobs + fastParse(pkgSources) + .map(directImportTarget => { + if (endPreambleParsingMs.isEmpty) { + endPreambleParsingMs = Some(System.currentTimeMillis()) + } + val directImportPackage = AbstractPackage(directImportTarget)(config) + val pkgSources = PackageResolver.resolveSources(directImportTarget)(config) + .getOrElse(Vector()) + .map(_.source) + if (pkgSources.isEmpty) { + manager.addIfAbsent(directImportPackage, ParseFailureJob(Vector(NotFoundError(s"No source files for package '$directImportTarget found"))))(executionContext) + } else { + manager.addIfAbsent(directImportPackage, ParseSourcesJob(pkgSources, directImportPackage))(executionContext) + } + }) + + val startMs = System.currentTimeMillis() + val res = for { + parsedProgram <- Parser.parse(pkgSources, pkgInfo, specOnly = true)(config) + } yield (pkgSources, parsedProgram) + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + val preambleParsingRatio = f"${100f * (endPreambleParsingMs.get - startPreambleParsingMs) / (System.currentTimeMillis() - startMs)}%.1f" + println(s"parsing ${pkgInfo.id} done (took ${durationS}s; parsing preamble takes ${preambleParsingRatio}%)") + res + } + + private def fastParse(sources: Vector[Source]): Set[AbstractImport] = { + def getImportPaths(source: Source): Set[AbstractImport] = { + parsePreamble(source)(config) + .map(_.imports.toSet.map[AbstractImport](importNode => RegularImport(importNode.importPath))) + // we do not handle parser errors here but defer this to the time point when we actually + // parse this source + .getOrElse(Set.empty) + } + + sources.flatMap(getImportPaths).toSet + BuiltInImport + } + } + + case class ParseInfoJob(override val pkgInfo: PackageInfo) extends ParseJob { + lazy val pkgSources: Vector[Source] = config.packageInfoInputMap(pkgInfo) + } + + case class ParseSourcesJob(override val pkgSources: Vector[Source], pkg: AbstractPackage) extends ParseJob { + require(pkgSources.nonEmpty) + lazy val pkgInfo: PackageInfo = Source.getPackageInfo(pkgSources.head, config.projectRoot) + } + + case class ParseFailureJob(errs: Vector[NotFoundError]) extends Job[ParseResult] { + override def compute(): ParseResult = Left(errs) + } + /* + def awaitResults(): Iterable[ParseResult] = manager.getAllResults(executionContext) + + def getResult(pkgInfo: PackageInfo): ParseResult = + getResult(RegularPackage(pkgInfo.id)) + + def getResult(abstractPackage: AbstractPackage): ParseResult = + manager.getResult(abstractPackage) + + def getResults: Iterable[(AbstractPackage, ParseResult)] = + manager.getAllResultsWithKeys + */ + def getParseResults(executionContext: GobraExecutionContext): Either[Map[AbstractPackage, Vector[VerifierError]], Map[AbstractPackage, ParseSuccessResult]] = { + val (failedResults, successfulResults) = manager.getAllResultsWithKeys(executionContext) + .partitionMap { case (key, eitherResult) => eitherResult.fold[Either[(AbstractPackage, Vector[VerifierError]), (AbstractPackage, ParseSuccessResult)]](errs => Left((key, errs)), result => Right((key, result))) } + if (failedResults.isEmpty) Right(successfulResults.toMap) + else Left(failedResults.toMap) + } + } + /** * Parses files and returns either the parsed program if the file was parsed successfully, * otherwise returns list of error messages. @@ -42,6 +138,13 @@ object Parser { * */ + def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseSuccessResult]] = { + val parseManager = new ParseManager(config, executionContext) + parseManager.parse(pkgInfo) + val res = parseManager.getParseResults(executionContext).left.map(errMap => errMap.values.flatten.toVector) + res + } + def parse(input: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean = false)(config: Config): Either[Vector[VerifierError], PPackage] = { val sources = input.map(Gobrafier.gobrafy) sources.foreach { s => config.reporter report PreprocessedInputMessage(s.name, () => s.content) } @@ -60,7 +163,8 @@ object Parser { type SourceCacheKey = String // cache maps a key (obtained by hasing file path and file content) to the parse result - private var sourceCache: ConcurrentMap[SourceCacheKey, (Either[Vector[ParserError], PProgram], Positions)] = new ConcurrentHashMap() + private val sourceCache: ConcurrentMap[SourceCacheKey, (Either[Vector[ParserError], PProgram], Positions)] = new ConcurrentHashMap() + private val preambleCache: ConcurrentMap[SourceCacheKey, Either[Vector[ParserError], PPreamble]] = new ConcurrentHashMap() /** computes the key for caching a particular source. This takes the name, the specOnly flag, and the file's contents into account */ private def getCacheKey(source: Source, specOnly: Boolean): SourceCacheKey = { @@ -72,6 +176,7 @@ object Parser { def flushCache(): Unit = { sourceCache.clear() + preambleCache.clear() } private def parseSources(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { @@ -94,8 +199,6 @@ object Parser { } } - - def parseSourceCached(source: Source): Either[Vector[ParserError], PProgram] = { var cacheHit = true def parseAndStore(): (Either[Vector[ParserError], PProgram], Positions) = { @@ -183,6 +286,27 @@ object Parser { parser.parse(parser.sourceFile()) } + /** parses a source's preamble containing all (file-level) imports */ + def parsePreamble(source: Source)(config: Config): Either[Vector[ParserError], PPreamble] = { + // TODO: gobrafy only once + val positions = new Positions + val pom = new PositionManager(positions) + + def parseSource(source: Source): Either[Vector[ParserError], PPreamble] = { + val parser = new SyntaxAnalyzer[PreambleContext, PPreamble](Gobrafier.gobrafy(source), ListBuffer.empty[ParserError], pom, specOnly = true) + parser.parse(parser.preamble) + } + + def parseSourceCached(source: Source): Either[Vector[ParserError], PPreamble] = { + def parseAndStore(): Either[Vector[ParserError], PPreamble] = + parseSource(source) + + preambleCache.computeIfAbsent(getCacheKey(source, specOnly = true), _ => parseAndStore()) + } + + if (config.cacheParser) parseSourceCached(source) else parseSource(source) + } + def parseFunction(source: Source, specOnly: Boolean = false): Either[Vector[ParserError], PMember] = { val positions = new Positions val pom = new PositionManager(positions) diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index 8413d396b..1efd6d496 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -1,6 +1,6 @@ package viper.gobra.frontend -import viper.gobra.frontend.info.Info.TypeCheckMode +import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential, TaskManagerMode} import viper.gobra.util.{GobraExecutionContext, Violation} import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} @@ -9,13 +9,52 @@ import scala.concurrent.{Await, Future, Promise} import scala.util.{Failure, Success} import scala.jdk.CollectionConverters._ +object TaskManagerMode extends Enumeration { + type TaskManagerMode = Value + val Lazy, Sequential, Parallel = Value +} + trait Job[R] { private var compututationStarted = false private val promise: Promise[R] = Promise() def getFuture: Future[R] = promise.future protected def compute(): R + // private val lock: Object = new AnyRef def call(): R = { + // lock.synchronized { + getFuture.value match { + case Some(Success(res)) => return res // return already computed type-checker result + case Some(Failure(exception)) => Violation.violation(s"Job resulted in exception: $exception") + case _ => + } + Violation.violation(!compututationStarted, s"Job $this is already on-going") + compututationStarted = true + val res = compute() + promise.success(res) + res + } + // } +} + +/* +trait Job[R] extends DependentJob[Nothing, R] { + val dependencies = Set.empty + protected def compute(): R + + override protected def compute(dependentResults: Map[Nothing, R]): R = compute() +} + +trait DependentJob[K, R] { + val dependencies: Set[K] + private val promise: Promise[R] = Promise() + private var compututationStarted = false + + def getFuture: Future[R] = promise.future + + protected def compute(dependentResults: Map[K, R]): R + + def call(dependentResults: Map[K, R]): R = { getFuture.value match { case Some(Success(res)) => return res // return already computed type-checker result case Some(Failure(exception)) => Violation.violation(s"Job resulted in exception: $exception") @@ -23,13 +62,14 @@ trait Job[R] { } Violation.violation(!compututationStarted, s"Job is already on-going") compututationStarted = true - val res = compute() + val res = compute(dependentResults) promise.success(res) res } } + */ -class TaskManager[K, R](config: Config) { +class TaskManager[K, R](mode: TaskManagerMode) { private val jobs: ConcurrentMap[K, Job[R]] = new ConcurrentHashMap() /** @@ -44,33 +84,70 @@ class TaskManager[K, R](config: Config) { }) // now run it but only if it's a new job: if (isAbsent && !insertOnly) { - config.typeCheckMode match { - case TypeCheckMode.Lazy => // don't do anything as of now - case TypeCheckMode.Sequential => job.call() - case TypeCheckMode.Parallel => Future{ job.call() }(executionContext) + mode match { + case Lazy => // don't do anything as of now + case Sequential => job.call() + case Parallel => Future{ job.call() }(executionContext) } } isAbsent } + def getFuture(id: K): Future[R] = { + val job = jobs.get(id) + Violation.violation(job != null, s"Task $id not found") + job.getFuture + } + def getResult(id: K): R = { val job = jobs.get(id) Violation.violation(job != null, s"Task $id not found") getResultFromJob(job) } - def getAllResults: Iterable[R] = - jobs.values().asScala.map(getResultFromJob) + def getAllResults(executionContext: GobraExecutionContext): Iterable[R] = mode match { + case Lazy | Sequential => jobs.values().asScala.map(getResultFromJob) + case Parallel => + val futs = jobs.values().asScala.map(_.getFuture) + implicit val executor: GobraExecutionContext = executionContext + Await.result(Future.sequence(futs), Duration.Inf) + } - def getAllResultsWithKeys: Iterable[(K, R)] = - jobs.asScala.toVector.map { case (key, job) => (key, getResultFromJob(job)) } + def getAllResultsWithKeys(executionContext: GobraExecutionContext): Iterable[(K, R)] = mode match { + case Lazy | Sequential => jobs.asScala.toVector.map { case (key, job) => (key, getResultFromJob(job)) } + case Parallel => + implicit val executor: GobraExecutionContext = executionContext + val futs = jobs.asScala.toVector.map { case (key, job) => job.getFuture.map(res => (key, res)) } + Await.result(Future.sequence(futs), Duration.Inf) + } - private def getResultFromJob(job: Job[R]): R = config.typeCheckMode match { - case TypeCheckMode.Lazy => job.call() // we perform the computation now that we need the result - case TypeCheckMode.Sequential => + private def getResultFromJob(job: Job[R]): R = mode match { + case Lazy => job.call() // we perform the computation now that we need the result + case Sequential => // note that we cannot await the future here as type-checking of this package might not have started yet. // Thus, we use `.call()` that either returns a previously calculated type-checking result or will calculate it. job.call() - case TypeCheckMode.Parallel => Await.result(job.getFuture, Duration.Inf) + case Parallel => + Await.result(job.getFuture, Duration.Inf) + } +} + +class FutureManager[K, R]() { + private val futures: ConcurrentMap[K, Future[R]] = new ConcurrentHashMap() + + def addIfAbsent(id: K, futFn: () => Future[R]): Future[R] = { + // first insert job, then run it (if necessary) + futures.computeIfAbsent(id, _ => futFn()) + } + + def getFuture(id: K): Future[R] = { + val fut = futures.get(id) + Violation.violation(fut != null, s"Task $id not found") + fut + } + + def getAllResults(executionContext: GobraExecutionContext): Iterable[R] = { + implicit val executor: GobraExecutionContext = executionContext + Await.result(Future.sequence(futures.values().asScala), Duration.Inf) } } diff --git a/src/main/scala/viper/gobra/frontend/info/ExternalTypeInfo.scala b/src/main/scala/viper/gobra/frontend/info/ExternalTypeInfo.scala index 57dc3c174..d4a19fd8f 100644 --- a/src/main/scala/viper/gobra/frontend/info/ExternalTypeInfo.scala +++ b/src/main/scala/viper/gobra/frontend/info/ExternalTypeInfo.scala @@ -8,17 +8,23 @@ package viper.gobra.frontend.info import viper.gobra.ast.frontend.{PCodeRoot, PEmbeddedDecl, PExpression, PFieldDecl, PFunctionDecl, PFunctionOrMethodDecl, PGeneralForStmt, PIdnNode, PIdnUse, PKeyedElement, PLabelUse, PMPredicateDecl, PMPredicateSig, PMember, PMethodDecl, PMethodSig, PMisc, PNode, PParameter, PPkgDef, PScope, PType} import viper.gobra.frontend.PackageInfo +import viper.gobra.frontend.PackageResolver.AbstractImport import viper.gobra.frontend.info.base.BuiltInMemberTag.BuiltInMemberTag import viper.gobra.frontend.info.base.Type.{AbstractType, InterfaceT, StructT, Type} import viper.gobra.frontend.info.base.SymbolTable import viper.gobra.frontend.info.base.SymbolTable.{Embbed, Field, MPredicateImpl, MPredicateSpec, MethodImpl, MethodSpec, Regular, TypeMember} import viper.gobra.frontend.info.implementation.resolution.{AdvancedMemberSet, MemberPath} import viper.gobra.frontend.info.implementation.typing.ghost.separation.GhostType +import viper.gobra.reporting.VerifierError trait ExternalTypeInfo { def pkgName: PPkgDef def pkgInfo: PackageInfo + def dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]] + + /** returns this and the type information of directly and transitively dependent packages */ + def getTransitiveTypeInfos: Set[ExternalTypeInfo] /** * Gets called by the type checker to perform a symbol table lookup in an imported package diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 9c0ef6a77..3f43cebf6 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -7,26 +7,37 @@ package viper.gobra.frontend.info import org.bitbucket.inkytonik.kiama.relation.Tree -import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, message, noMessages} +import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, message} import org.bitbucket.inkytonik.kiama.util.{Position, Source} import viper.gobra.ast.frontend.{PImport, PNode, PPackage} -import viper.gobra.frontend.{Config, Job, PackageResolver, Parser, Source, TaskManager} -import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} -import viper.gobra.frontend.info.Info.TypeCheckMode.TypeCheckMode +import viper.gobra.frontend.{Config, Job, TaskManager} +import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport} +import viper.gobra.frontend.Parser.ParseSuccessResult +import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.{GhostLessPrinter, GoifyingPrinter} -import viper.gobra.reporting.{CyclicImportError, NotFoundError, TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} +import viper.gobra.reporting.{TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} import viper.gobra.util.{GobraExecutionContext, Violation} -import java.util.concurrent.Callable -import scala.collection.immutable.ListMap +import java.security.MessageDigest +import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} import scala.concurrent.duration.Duration -import scala.concurrent.{Await, Future, Promise} -import scala.util.{Failure, Success} +import scala.concurrent.{Await, Future} object Info { type GoTree = Tree[PNode, PPackage] + type TypeCheckResult = Either[Vector[VerifierError], TypeInfo with ExternalTypeInfo] + type DependentTypeInfo = Map[AbstractImport, () => TypeCheckResult] // values are functions such that laziness is possible + + trait GetParseResult { + def parseResults: Map[AbstractPackage, ParseSuccessResult] + + protected def getParseResult(abstractPackage: AbstractPackage): ParseSuccessResult = { + Violation.violation(parseResults.contains(abstractPackage), s"GetParseResult: expects that $abstractPackage has been parsed") + parseResults(abstractPackage) + } + } /** * ImportCycle describes a cyclic import. `importClosingCycle` is the AST node that closes the cycle and @@ -34,22 +45,59 @@ object Info { */ case class ImportCycle(importNodeCausingCycle: PImport, importNodeStart: Option[Position], cyclicPackages: Vector[AbstractImport]) - object TypeCheckMode extends Enumeration { - type TypeCheckMode = Value - val Lazy, Sequential, Parallel = Value + class CycleChecker(val config: Config, val parseResults: Map[AbstractPackage, ParseSuccessResult]) extends GetParseResult { + /** keeps track of the package dependencies that are currently resolved. This information is used to detect cycles */ + private var parserPendingPackages: Vector[AbstractImport] = Vector() + + def check(abstractPackage: AbstractPackage): Messages = { + val (_, ast) = getParseResult(abstractPackage) + ast.imports.flatMap(importNode => { + val cycles = getCycles(RegularImport(importNode.importPath)) + createImportError(importNode, cycles) + }) + } + + /** + * returns all parser errors and cyclic errors transitively found in imported packages + */ + private def getCycles(importTarget: AbstractImport): Vector[ImportCycle] = { + parserPendingPackages = parserPendingPackages :+ importTarget + val abstractPackage = AbstractPackage(importTarget)(config) + val (_, ast) = getParseResult(abstractPackage) + val res = ast.imports.flatMap(importNode => { + val directlyImportedTarget = RegularImport(importNode.importPath) + if (parserPendingPackages.contains(directlyImportedTarget)) { + // package cycle detected + val importNodeStart = ast.positions.positions.getStart(importNode) + Vector(ImportCycle(importNode, importNodeStart, parserPendingPackages)) + } else { + getCycles(directlyImportedTarget) + } + }) + parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) + res + } + + private def createImportError(importNode: PImport, cycles: Vector[ImportCycle]): Messages = { + val importTarget = RegularImport(importNode.importPath) + cycles.flatMap(cycle => { + val positionalInfo = cycle.importNodeStart.map(pos => s" at ${pos.format}").getOrElse("") + message(importNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}$positionalInfo: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") + }) + } } /** * All TypeInfo instances share a single context instance. * Therefore, package management is centralized. */ - class Context(executionContext: GobraExecutionContext, config: Config) { + class Context(val config: Config, val parseResults: Map[AbstractPackage, ParseSuccessResult])(val executionContext: GobraExecutionContext) extends GetParseResult { /** stores the results of all imported packages that have been parsed so far */ - private var parserContextMap: Map[AbstractPackage, Either[Vector[VerifierError], (Vector[Source], PPackage)]] = ListMap() + // private var parserContextMap: Map[AbstractPackage, Either[Vector[VerifierError], (Vector[Source], PPackage)]] = ListMap() /** keeps track of the package dependencies that are currently resolved. This information is used to detect cycles */ - private var parserPendingPackages: Vector[AbstractImport] = Vector() + // private var parserPendingPackages: Vector[AbstractImport] = Vector() /** stores all cycles that have been discovered so far */ - var parserKnownImportCycles: Set[ImportCycle] = Set() + // var parserKnownImportCycles: Set[ImportCycle] = Set() /* def parseRecursively(importTarget: AbstractImport)(config: Config): Either[Vector[VerifierError], PPackage] = { @@ -82,6 +130,7 @@ object Info { res } */ + /* def parseRecursively(importTarget: AbstractImport)(config: Config): Either[Vector[VerifierError], PPackage] = { val packageTarget = AbstractPackage(importTarget)(config) @@ -103,7 +152,7 @@ object Info { nonEmptyPkgSources <- if (pkgSources.isEmpty) Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) // Left(message(importNode, s"No source files for package '$importTarget' found")) - else Right(pkgSources) + else Right(pkgSources) parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) errorsInTransitivePackages = parsedProgram.imports .map(importNode => { @@ -151,10 +200,11 @@ object Info { parserContextMap = parserContextMap + (packageTarget -> res.map(pkg => (pkgSources, pkg))) res } - + */ /** * returns all parser errors and cyclic errors transitively found in imported packages */ + /* def computeCycles(importTarget: AbstractImport): Vector[VerifierError] = { parserPendingPackages = parserPendingPackages :+ importTarget val abstractPackage = AbstractPackage(importTarget)(config) @@ -181,6 +231,7 @@ object Info { parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) res.left.getOrElse(Vector.empty) } + */ /* def parseRecursively(pkg: PPackage)(config: Config): Either[Vector[VerifierError], PPackage] = { val imports = Seq(BuiltInImport) ++ @@ -203,11 +254,14 @@ object Info { /** * Returns all package names that lie on the cycle of imports or none if no cycle was found */ + /* def getParserImportCycle(importTarget: AbstractImport): Option[ImportCycle] = parserKnownImportCycles.find(_.cyclicPackages.contains(importTarget)) + */ + /* case class ParseJob(importTarget: AbstractImport) extends Job[Either[Vector[VerifierError], (Vector[Source], PPackage)]] { - def compute(): Either[Vector[VerifierError], (Vector[Source], PPackage)] = { + override def compute(): Either[Vector[VerifierError], (Vector[Source], PPackage)] = { println(s"start parsing $importTarget") val startMs = System.currentTimeMillis() val pkgSources = PackageResolver.resolveSources(importTarget)(config) @@ -218,39 +272,311 @@ object Info { Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) // Left(message(importNode, s"No source files for package '$importTarget' found")) else Right(pkgSources) + + // before parsing, get imports and add these parse jobs + _ = fastParse(nonEmptyPkgSources) + .map(directImportTarget => { + val directImportPackage = AbstractPackage(directImportTarget)(config) + parseManager.addIfAbsent(directImportPackage, ParseJob(directImportTarget))(executionContext) + }) + parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" _ = println(s"parsing $importTarget done (took ${durationS}s)") + /* // submit jobs to parse dependent packages: _ = parsedProgram.imports.foreach(importNode => { val directImportTarget = RegularImport(importNode.importPath) val directImportPackage = AbstractPackage(directImportTarget)(config) parseManager.addIfAbsent(directImportPackage, ParseJob(directImportTarget))(executionContext) }) + */ } yield (pkgSources, parsedProgram) } } - val parseManager = new TaskManager[AbstractPackage, Either[Vector[VerifierError], (Vector[Source], PPackage)]](config) + case class SuccessParseJob(sources: Vector[Source], pkg: PPackage) extends Job[Either[Vector[VerifierError], (Vector[Source], PPackage)]] { + override def compute(): Either[Vector[VerifierError], (Vector[Source], PPackage)] = + Right((sources, pkg)) + } + + // val parseManager = new TaskManager[AbstractPackage, Either[Vector[VerifierError], (Vector[Source], PPackage)]](config) def parse(importTarget: AbstractImport): Unit = { val abstractPackage = AbstractPackage(importTarget)(config) val parseJob = ParseJob(importTarget) parseManager.addIfAbsent(abstractPackage, parseJob)(executionContext) } - - case class TypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] { - def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { + */ + trait TypeCheckJob { + protected def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isMainContext: Boolean = false): TypeCheckResult = { println(s"start type-checking ${pkg.info.id}") val startMs = System.currentTimeMillis() - val res = Info.check(pkg, pkgSources, context)(config) + val res = Info.checkSources(pkgSources, pkg, dependentTypeInfo, isMainContext = isMainContext)(config) val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" println(s"type-checking ${pkg.info.id} done (took ${durationS}s)") res } } + /* + case class SimpleTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { + override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = typeCheck(pkgSources, pkg, context) + } + */ + /* + case class DependentTypeCheckJob(importTarget: AbstractImport, context: Context) extends Job[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] with TypeCheckJob { + override def toString: String = s"DependentTypeCheckJob for $importTarget" - case class FailureJob(errs: Vector[VerifierError]) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] { - def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = Left(errs) + override def compute(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + val abstractPackage = AbstractPackage(importTarget)(config) + val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) + val isBuiltIn = importTarget == BuiltInImport + val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets + val dependentJobsFuts = dependencies + .map(DependentTypeCheckJob(_, context)) + // add to manager & typecheck them if not present yet + .map(dependentJob => { + val dependentAbstractPackage = AbstractPackage(dependentJob.importTarget)(config) + typeCheckManager.addIfAbsent(dependentAbstractPackage, dependentJob)(executionContext) + typeCheckManager.getFuture(dependentAbstractPackage).flatten + }) + implicit val executor: GobraExecutionContext = executionContext + val dependentJobsFut = Future.sequence(dependentJobsFuts) + dependentJobsFut.map(_ => typeCheck(sources, ast, context)) + } + } + */ + /* + case class LazyTypeCheckJob(importTarget: AbstractImport, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { + override def toString: String = s"LazyTypeCheckJob for $importTarget" + + override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { + // in lazy mode, this function is called exactly when this package needs to be type-checked + // we also do not care about any dependent packages, because they will be lazily type-checked + val abstractPackage = AbstractPackage(importTarget)(config) + val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + typeCheck(sources, ast, context) + } + } + */ + + case class LazyTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[TypeCheckResult] with TypeCheckJob { + override def toString: String = s"LazyTypeCheckJob for $abstractPackage" + + override def compute(): TypeCheckResult = { + // in lazy mode, this function is called exactly when this package needs to be type-checked + // we also do not care about any dependent packages, because they will be lazily type-checked + val (sources, ast) = getParseResult(abstractPackage) + // we assume that all packages have been registered with the typeCheckManager + val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) + val isBuiltIn = abstractPackage == BuiltInPackage + val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets + val dependentTypeInfo: DependentTypeInfo = dependencies + .map(importTarget => (importTarget, () => typeCheckManager.getResult(AbstractPackage(importTarget)(config)))) + .toMap + typeCheck(sources, ast, dependentTypeInfo, isMainContext = isMainContext) + } + } + /* + case class LazyTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { + override def toString: String = s"LazyTypeCheckJob for ${pkg.info.id}" + + override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { + // in lazy mode, this function is called exactly when this package needs to be type-checked + // we also do not care about any dependent packages, because they will be lazily type-checked + // val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $abstractPackage failed")) + typeCheck(pkgSources, pkg, context) + } + } + */ + /* + case class SequentialTypeCheckJob(importTarget: AbstractImport, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { + override def toString: String = s"SequentialTypeCheckJob for $importTarget" + + override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { + // in lazy mode, this function is called exactly when this package needs to be type-checked + // we also do not care about any dependent packages, because they will be lazily type-checked + val abstractPackage = AbstractPackage(importTarget)(config) + val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) + val isBuiltIn = importTarget == BuiltInImport + val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets + // first type-check dependent packages: + dependencies + .map(SequentialTypeCheckJob(_, context)) + // add to manager & typecheck them if not present yet + .foreach(dependentJob => { + val dependentAbstractPackage = AbstractPackage(dependentJob.importTarget)(config) + typeCheckManager.addIfAbsent(dependentAbstractPackage, dependentJob)(executionContext) + }) + typeCheck(sources, ast, context) + // typeCheck(abstractPackage, context) + } + } + */ + case class SequentialTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[TypeCheckResult] with TypeCheckJob { + override def toString: String = s"SequentialTypeCheckJob for $abstractPackage" + + override def compute(): TypeCheckResult = { + val (sources, ast) = getParseResult(abstractPackage) + val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) + val isBuiltIn = abstractPackage == BuiltInPackage + val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets + // first type-check dependent packages: + val dependentTypeInfos = dependencies + .map(importTarget => { + val dependentPackage = AbstractPackage(importTarget)(config) + // add to manager & typecheck them if not present yet + val job = SequentialTypeCheckJob(dependentPackage) + typeCheckManager.addIfAbsent(dependentPackage, job)(executionContext) + (importTarget, () => typeCheckManager.getResult(dependentPackage)) + }) + + typeCheck(sources, ast, dependentTypeInfos.toMap, isMainContext = isMainContext) + } + } + /* + case class ParallelTypeCheckJob(importTarget: AbstractImport, context: Context) extends Job[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] with TypeCheckJob { + override def toString: String = s"ParallelTypeCheckJob for $importTarget" + + override def compute(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + // in lazy mode, this function is called exactly when this package needs to be type-checked + // we also do not care about any dependent packages, because they will be lazily type-checked + val abstractPackage = AbstractPackage(importTarget)(config) + val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) + val isBuiltIn = importTarget == BuiltInImport + val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets + // first type-check dependent packages: + val dependentJobsFuts = dependencies + .map(ParallelTypeCheckJob(_, context)) + // add to manager & typecheck them if not present yet + .map(dependentJob => { + val dependentAbstractPackage = AbstractPackage(dependentJob.importTarget)(config) + parallelTypeCheckManager.addIfAbsent(dependentAbstractPackage, dependentJob)(executionContext) + parallelTypeCheckManager.getFuture(dependentAbstractPackage).flatten + }) + implicit val executor: GobraExecutionContext = executionContext + val dependentJobsFut = Future.sequence(dependentJobsFuts) + dependentJobsFut.map(_ => typeCheck(sources, ast, context)) + } + } + */ + case class ParallelTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[Future[TypeCheckResult]] with TypeCheckJob { + override def toString: String = s"ParallelTypeCheckJob for $abstractPackage" + + override def compute(): Future[TypeCheckResult] = { + val (sources, ast) = getParseResult(abstractPackage) + val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) + val isBuiltIn = abstractPackage == BuiltInPackage + val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets + // first type-check dependent packages: + val dependentJobsFuts = dependencies + .map(importTarget => { + val dependentPackage = AbstractPackage(importTarget)(config) + // add to manager & typecheck them if not present yet + val job = ParallelTypeCheckJob(dependentPackage) + parallelTypeCheckManager.addIfAbsent(dependentPackage, job)(executionContext) + parallelTypeCheckManager.getFuture(dependentPackage).flatten + .map(typeInfo => (importTarget, () => typeInfo))(executionContext) + }) + implicit val executor: GobraExecutionContext = executionContext + val dependentJobsFut = Future.sequence(dependentJobsFuts) + dependentJobsFut.map(dependentTypeInfo => typeCheck(sources, ast, dependentTypeInfo.toMap, isMainContext = isMainContext)) + } + } + /* + case class ChainingTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] with TypeCheckJob { + // case class ChainingTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { + // case class ChainingTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends TypeCheckJob { + override def toString: String = s"ChainingTypeCheckJob for ${pkg.info.id}" + + private def lookupPackage(importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + val abstractPackage = AbstractPackage(importTarget)(config) + val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + val job = ChainingTypeCheckJob(sources, ast, context) + // typeCheckManager.addIfAbsent(abstractPackage, job)(executionContext) + // typeCheckManager.getFuture(abstractPackage) + // typeCheckManager.getResult(abstractPackage) + typeCheckManager.addIfAbsent(abstractPackage,() => job.compute()) + } + + // override def compute(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + // override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { + def compute(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + println(s"$this compute()") + implicit val executor: GobraExecutionContext = executionContext + // val abstractPackage = AbstractPackage(importTarget)(config) + // val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + // for type-checking this package, we need type information for imported packages: + val importedTypeInfoFutures = // ast.imports.map(tuplesTypeCheck) + pkg.imports.map(importNode => lookupPackage(RegularImport(importNode.importPath))) + // add `BuiltInImport` since it's implicitly imported by every package + val (_, builtInAst) = parseManager.getResult(BuiltInPackage).getOrElse(() => Violation.violation(s"parsing $BuiltInImport failed")) + val isBuiltIn = pkg == builtInAst + val dependentFutures = if (isBuiltIn) importedTypeInfoFutures else lookupPackage(BuiltInImport) +: importedTypeInfoFutures + // execute call synchronously if there are no dependencies: + // if (dependentFutures.isEmpty) { + // Future { typeCheck(pkgSources, pkg, context) } + // } else { + Future.sequence(dependentFutures) + .map(packageResults => { + val errsInImportedPackages = packageResults + .collect { case Left(errs) => errs } + .flatten + if (errsInImportedPackages.isEmpty) { + typeCheck(pkgSources, pkg, context) + } else { + Left(errsInImportedPackages) + } + }) + // Await.result(fut, Duration.Inf) + // } + } + } + */ + /* + case class ChainingTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends TypeCheckJob { + private def lookupPackage(importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + val abstractPackage = AbstractPackage(importTarget)(config) + val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + val job = ChainingTypeCheckJob(sources, ast, context) + typeCheckManager.addIfAbsent(abstractPackage, job)(executionContext) + typeCheckManager.getFuture(abstractPackage) + } + + override def getFuture: Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + implicit val executor: GobraExecutionContext = executionContext + // val abstractPackage = AbstractPackage(importTarget)(config) + // val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + // for type-checking this package, we need type information for imported packages: + val importedTypeInfoFutures = // ast.imports.map(tuplesTypeCheck) + pkg.imports.map(importNode => lookupPackage(RegularImport(importNode.importPath))) + // add `BuiltInImport` since it's implicitly imported by every package + val (builtInSources, builtInAst) = parseManager.getResult(BuiltInPackage).getOrElse(() => Violation.violation(s"parsing $BuiltInImport failed")) + val isBuiltIn = pkg == builtInAst + val dependentFutures = if (isBuiltIn) importedTypeInfoFutures else lookupPackage(BuiltInImport) +: importedTypeInfoFutures + Future.sequence(dependentFutures) + .map(packageResults => { + val errsInImportedPackages = packageResults + .collect { case Left(errs) => errs } + .flatten + if (errsInImportedPackages.isEmpty) { + typeCheck + } else { + Left(errsInImportedPackages) + } + }) + } + + override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { + println(s"ERROR: compute called job ${pkg.info.id}") + Left(Vector.empty) + } + } + */ + case class FailureJob(errs: Vector[VerifierError]) extends Job[TypeCheckResult] { + override def compute(): TypeCheckResult = Left(errs) } /* @@ -268,28 +594,201 @@ object Info { case Left(errs) => Future.successful(Left(errs)) })} */ - private val typeCheckManager = new TaskManager[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]](config) - def typeCheck(): Unit = { - /*parserContextMap.foreach { case (abstractPackage, parseResult) => - val typeCheckJob = parseResult match { - case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) - case Left(errs) => FailureJob(errs) - } - println(s"adding task $abstractPackage") - typeCheckManager.addIfAbsent(abstractPackage, typeCheckJob)(executionContext) + private val typeCheckManager = new TaskManager[AbstractPackage, TypeCheckResult](config.typeCheckMode) + private val parallelTypeCheckManager = new TaskManager[AbstractPackage, Future[TypeCheckResult]](config.typeCheckMode) + // private val typeCheckManager = new TaskManager[AbstractPackage, Future[Either[Vector[VerifierError], ExternalTypeInfo]]](config) + // private val typeCheckManager = new FutureManager[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]] + + // def typeCheck(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + def typeCheck(pkg: AbstractPackage): TypeCheckResult = { + config.typeCheckMode match { + case Lazy => + // we have to transitively add all packages to the typeCheckManager: + lazyTypeCheckRecursively(pkg, isMainContext = true) + typeCheckManager.getResult(pkg) + case Sequential => + typeCheckManager.addIfAbsent(pkg, SequentialTypeCheckJob(pkg, isMainContext = true))(executionContext) + typeCheckManager.getResult(pkg) + case Parallel => + parallelTypeCheckManager.addIfAbsent(pkg, ParallelTypeCheckJob(pkg, isMainContext = true))(executionContext) + // wait for result: + val fut = parallelTypeCheckManager.getResult(pkg) + Await.result(fut, Duration.Inf) } - */ - parseManager.getAllResultsWithKeys.foreach { case (abstractPackage, parseResult) => - val typeCheckJob = parseResult match { - case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) - case Left(errs) => FailureJob(errs) - } - println(s"adding task $abstractPackage") - // since we're adding the packages in arbitrary order, we cannot directly run the task in SEQUENTIAL mode because - // depending packages might not have been inserted yet - typeCheckManager.addIfAbsent(abstractPackage, typeCheckJob, insertOnly = config.typeCheckMode == TypeCheckMode.Sequential)(executionContext) + // typeCheckManager.addIfAbsent(mainPackage, DependentTypeCheckJob(RegularImport(""), this))(executionContext) + // typeCheckManager.getFuture(mainPackage).flatten + // typeCheckManager.getFuture(mainPackage) + } + + /* + def lazyTypeCheckRecursively(importTarget: AbstractImport): Unit = { + def allImports(importTarget: AbstractImport): Set[AbstractImport] = { + val abstractPackage = AbstractPackage(importTarget)(config) + val (_, ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $abstractPackage failed")) + ast.imports.toSet.flatMap[AbstractImport](importNode => allImports(RegularImport(importNode.importPath))) + importTarget } + + val packages = allImports(importTarget) + BuiltInImport + packages.foreach(importTarget => typeCheckManager.addIfAbsent(AbstractPackage(importTarget)(config), LazyTypeCheckJob(importTarget, this))(executionContext)) + println(s"packages added to typeCheckManager: ${packages.mkString("\n")}") } + */ + /* + def lazyTypeCheckRecursively(abstractPackage: AbstractPackage): Unit = { + def allImports(abstractPackage: AbstractPackage): Set[AbstractPackage] = { + val (_, ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $abstractPackage failed")) + ast.imports.toSet.flatMap[AbstractPackage](importNode => allImports(AbstractPackage(RegularImport(importNode.importPath))(config))) + abstractPackage + } + + val packages = allImports(abstractPackage) + BuiltInPackage + packages.foreach(pkg => typeCheckManager.addIfAbsent(pkg, LazyTypeCheckJob(pkg, this))(executionContext)) + println(s"packages added to typeCheckManager: ${packages.mkString("\n")}") + } + */ + def lazyTypeCheckRecursively(abstractPackage: AbstractPackage, isMainContext: Boolean = false): Unit = { + /** returns all transitively imported packages. However, `abstractPackage` is not included in the returned set! */ + def allImports(abstractPackage: AbstractPackage): Set[AbstractPackage] = { + val (_, ast: PPackage) = getParseResult(abstractPackage) + ast.imports + .map(importNode => AbstractPackage(RegularImport(importNode.importPath))(config)) + .toSet + .flatMap[AbstractPackage](directlyImportedPackage => allImports(directlyImportedPackage) + directlyImportedPackage) + } + + val dependentPackages = allImports(abstractPackage) + BuiltInPackage + // create jobs for all dependent packages + dependentPackages.foreach(pkg => typeCheckManager.addIfAbsent(pkg, LazyTypeCheckJob(pkg))(executionContext)) + // create job for this package: + typeCheckManager.addIfAbsent(abstractPackage, LazyTypeCheckJob(abstractPackage, isMainContext = isMainContext))(executionContext) + // println(s"packages added to typeCheckManager: ${(dependentPackages + abstractPackage).mkString("\n")}") + } +// def typeCheck(sources: Vector[Source], pkg: PPackage, importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { +// /*parserContextMap.foreach { case (abstractPackage, parseResult) => +// val typeCheckJob = parseResult match { +// case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) +// case Left(errs) => FailureJob(errs) +// } +// println(s"adding task $abstractPackage") +// typeCheckManager.addIfAbsent(abstractPackage, typeCheckJob)(executionContext) +// } +// */ +// /* +// parseManager.getAllResultsWithKeys.foreach { case (abstractPackage, parseResult) => +// val typeCheckJob = parseResult match { +// case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) +// case Left(errs) => FailureJob(errs) +// } +// println(s"adding task $abstractPackage") +// // since we're adding the packages in arbitrary order, we cannot directly run the task in SEQUENTIAL mode because +// // depending packages might not have been inserted yet +// typeCheckManager.addIfAbsent(abstractPackage, typeCheckJob, insertOnly = config.typeCheckMode == TypeCheckMode.Sequential)(executionContext) +// } +// +// */ +// /* +// val job = ChainingTypeCheckJob(sources, pkg, this) +// /** this is a bit artificial as this is the top-level package, i.e. the one we want to verify */ +// val abstractPackage = AbstractPackage(RegularImport(""))(config) +// // typeCheckManager.addIfAbsent(abstractPackage, job)(executionContext) +// // typeCheckManager.getResult(abstractPackage) +// // typeCheckManager.getFuture(abstractPackage) +// typeCheckManager.addIfAbsent(abstractPackage, () => job.compute()) +// */ +// +// /* +// pkg.imports +// .map(importNode => RegularImport(importNode.importPath)) +// .map(typeCheckInternal) +// */ +// +// // TODO perform lookup in typeCheckManager before re-checking every dependent package +// val dependentTypeCheckFuts = pkg.imports +// .map(importNode => RegularImport(importNode.importPath)) +// .map(typeCheckInternal) +// +// val job = ChainingTypeCheckJob(sources, pkg, this) +// +// implicit val executor: GobraExecutionContext = executionContext +// val fut = for { +// dependentTypeChecks <- Future.sequence(dependentTypeCheckFuts) +// dependentErrs = dependentTypeChecks.flatMap { +// case Right(_) => Vector.empty +// case Left(errs) => errs +// } +// res = if (dependentErrs.isEmpty) { +// println(s"start type-checking ${pkg.info.id}") +// val startMs = System.currentTimeMillis() +// val typeCheckRes = Info.check(pkg, sources, this)(config) +// val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" +// println(s"type-checking ${pkg.info.id} done (took ${durationS}s)") +// typeCheckRes +// } else Left(dependentErrs) +// } yield res +// typeCheckManager.addIfAbsent(AbstractPackage(importTarget)(config), () => fut) +// } +// +// private def typeCheckInternal(importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { +// // we iterate down to the package having no dependencies and register futures bottom up +// val parseRes = parseManager.getResult(AbstractPackage(importTarget)(config)) +// parseRes.fold(errs => Future.successful(Left(errs)), { case (sources, pkg) => typeCheck(sources, pkg, importTarget) }) +// /* +// for { +// (sources: Vector[Source], pkg: PPackage) <- parseManager.getResult(AbstractPackage(importTarget)(config)) +// // .left.map(errs => Future.successful(Left(errs))) +// dependentTypeCheckFuts = pkg.imports +// .map(importNode => RegularImport(importNode.importPath)) +// .map(typeCheckInternal) +// fut = for { +// dependentTypeChecks <- Future.sequence(dependentTypeCheckFuts) +// dependentErrs = dependentTypeChecks.flatMap { +// case Right(_) => Vector.empty +// case Left(errs) => errs +// } +// res = if (dependentErrs.isEmpty) { +// println(s"start type-checking ${pkg.info.id}") +// val startMs = System.currentTimeMillis() +// val typeCheckRes = Info.check(pkg, sources, this)(config) +// val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" +// println(s"type-checking ${pkg.info.id} done (took ${durationS}s)") +// typeCheckRes +// } else Left(dependentErrs) +// } yield res +// } yield fut +// */ +// } + + /* + def typeCheck(importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { + implicit val executor: GobraExecutionContext = executionContext + *//* + def tuplesTypeCheck(importNode: PImport): Future[(PImport, Either[Vector[VerifierError], ExternalTypeInfo])] = { + val abstractPackage = RegularImport(importNode.importPath) + typeCheck(abstractPackage) + .map(res => (importNode, res)) + } + *//* + val abstractPackage = AbstractPackage(importTarget)(config) + val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) + // for type-checking this package, we need type information for imported packages: + val importedTypeInfoFutures = // ast.imports.map(tuplesTypeCheck) + ast.imports.map(importNode => typeCheck(RegularImport(importNode.importPath))) + // add `BuiltInImport` since it's implicitly imported by every package + Future.sequence(typeCheck(BuiltInImport) +: importedTypeInfoFutures) + .flatMap(packageResults => { + val errsInImportedPackages = packageResults + // .collect { case (_, Left(errs)) => errs } + .collect { case Left(errs) => errs } + .flatten + val job = if (errsInImportedPackages.isEmpty) { + TypeCheckJob(sources, ast, this) + } else { + FailureJob(errsInImportedPackages) + } + typeCheckManager.addIfAbsent(abstractPackage, job, insertOnly = config.typeCheckMode == TypeCheckMode.Sequential)(executionContext) + job.getFuture + }) + } + */ /* lazy val jobMap: Map[AbstractPackage, Job] = parserContextMap.transform { case (_, value) => value match { @@ -364,9 +863,23 @@ object Info { // // def getExternalErrors: Vector[VerifierError] = contextMap.values.collect { case Left(errs) => errs }.flatten.toVector - def getContexts: Iterable[ExternalTypeInfo] = + def getContexts: Iterable[ExternalTypeInfo] = { // typeContextMap.values.map(fut => Await.result(fut, Duration.Inf)).collect { case Right(info) => info } - typeCheckManager.getAllResults.collect { case Right(info) => info } + config.typeCheckMode match { + case Lazy | Sequential => typeCheckManager.getAllResults(executionContext).collect { case Right(info) => info } + case Parallel => + implicit val executor: GobraExecutionContext = executionContext + val results = Await.result(Future.sequence(parallelTypeCheckManager.getAllResults(executionContext)), Duration.Inf) + results.collect { case Right(info) => info } + } + // typeCheckManager.getAllResults.collect { case Right(info) => info } + // typeCheckManager.getAllResults(executionContext).collect { case Right(info) => info } + /* + implicit val executor: GobraExecutionContext = executionContext + val results = Await.result(Future.sequence(typeCheckManager.getAllResults), Duration.Inf) + results.collect { case Right(info) => info } + */ + } /* def getTypeInfoNonBlocking(importTarget: AbstractImport)(config: Config): Option[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] = { val packageTarget = AbstractPackage(importTarget)(config) @@ -388,7 +901,7 @@ object Info { } */ - def getTypeInfo(importTarget: AbstractImport)(config: Config): Either[Vector[VerifierError], ExternalTypeInfo] = { + def getTypeInfo(importTarget: AbstractImport)(config: Config): TypeCheckResult = { val packageTarget = AbstractPackage(importTarget)(config) /* Violation.violation(typeContextMap.contains(packageTarget), s"expected that a job for ${packageTarget} but found none") @@ -407,33 +920,58 @@ object Info { case TypeCheckMode.Parallel => Await.result(job.getFuture, Duration.Inf) } */ - typeCheckManager.getResult(packageTarget) + /* + val future = typeCheckManager.getResult(packageTarget) + Violation.violation(future.isCompleted, s"job $importTarget is not yet completed") + Await.result(future, Duration.Inf) + */ + config.typeCheckMode match { + case Lazy | Sequential => typeCheckManager.getResult(packageTarget) + case Parallel => + val future = parallelTypeCheckManager.getFuture(packageTarget).flatten + Violation.violation(future.isCompleted, s"job $importTarget is not yet completed") + Await.result(future, Duration.Inf) + } + // typeCheckManager.getResult(packageTarget) + // val future = typeCheckManager.getFuture(packageTarget).flatten + // val future = typeCheckManager.getFuture(packageTarget) + // Violation.violation(future.isCompleted, s"job $importTarget is not yet completed") + // Await.result(future, Duration.Inf) } } - def check(pkg: PPackage, sources: Vector[Source], context: Context /*= new Context()*/, isMainContext: Boolean = false)(config: Config): Either[Vector[VerifierError], TypeInfo with ExternalTypeInfo] = { + def check(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseSuccessResult])(executionContext: GobraExecutionContext): TypeCheckResult = { + // check for cycles + val cyclicErrors = new CycleChecker(config, parseResults).check(abstractPackage) + if (cyclicErrors.isEmpty) { + val typeCheckingStartMs = System.currentTimeMillis() + // add type-checking jobs to context: + val context = new Context(config, parseResults)(executionContext) + val res = context.typeCheck(abstractPackage) + val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" + println(s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})") + // we do not report any messages in this case, because `checkSources` will do so (for each package) + res + } else { + val (sources, pkg) = parseResults(abstractPackage) + val sourceNames = sources.map(_.name) + val errors = pkg.positions.translate(cyclicErrors, TypeError).distinct + config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errors) + Left(errors) + } + /* + val pkg = context.parseManager.getResult(pkgInfo) val tree = new GoTree(pkg) // println(program.declarations.head) // println("-------------------") // println(tree) val info = new TypeInfoImpl(tree, context, isMainContext)(config: Config) - def createImportError(importNode: PImport, errs: Vector[VerifierError]): Messages = { - val importTarget = RegularImport(importNode.importPath) - // create an error message located at the import statement to indicate errors in the imported package - // we distinguish between parse and type errors, cyclic imports, and packages whose source files could not be found - val notFoundErr = errs.collectFirst { case e: NotFoundError => e } - // alternativeErr is a function to compute the message only when needed - val alternativeErr = () => context.getParserImportCycle(importTarget) match { - case Some(cycle) => - val positionalInfo = cycle.importNodeStart.map(pos => s" at ${pos.format}").getOrElse("") - message(importNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}${positionalInfo}: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") - case _ => message(importNode, s"Package '$importTarget' contains errors: $errs") - } - notFoundErr.map(e => message(importNode, e.message)) - .getOrElse(alternativeErr()) - } + + + val mainPackage = AbstractPackage(RegularImport(""))(config) + context.parseManager.addIfAbsent(mainPackage, context.SuccessParseJob(sources, pkg))(context.executionContext) //val parserMessages = noMessages val parserMessages = if (isMainContext) { @@ -474,7 +1012,7 @@ object Info { } val durationS = f"${(System.currentTimeMillis() - parsingStartMs) / 1000f}%.1f" println(s"parsing done, took ${durationS}s, ${messages.length} errors found") - /* + *//* val imports = Vector(BuiltInImport) ++ pkg.imports.map(i => RegularImport(i.importPath)) val parseResult = imports.map(importTarget => { @@ -487,7 +1025,7 @@ object Info { return Left(transitiveParseErrors) } println(s"parsing was fine") - */ + *//* messages } else { @@ -498,6 +1036,12 @@ object Info { if (isMainContext && parserMessages.isEmpty) { // context.startTypeChecking() context.typeCheck() + // val fut = context.typeCheck() + // val importTargets = BuiltInImport +: pkg.imports.map(importNode => RegularImport(importNode.importPath)) + // val typeCheckFutures = importTargets.map(importTarget => context.typeCheck(importTarget)) + // implicit val executor: GobraExecutionContext = context.executionContext + // Await.ready(Future.sequence(typeCheckFutures), Duration.Inf) + // Await.ready(fut, Duration.Inf) } // val errors = info.errors @@ -509,6 +1053,61 @@ object Info { println(s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})") } + val sourceNames = sources.map(_.name) + // use `sources` instead of `context.inputs` for reporting such that the message is correctly attributed in case of imports + config.reporter report TypeCheckDebugMessage(sourceNames, () => pkg, () => getDebugInfo(pkg, info)) + if (errors.isEmpty) { + config.reporter report TypeCheckSuccessMessage(sourceNames, config.taskName, () => info, () => pkg, () => getErasedGhostCode(pkg, info), () => getGoifiedGhostCode(pkg, info)) + Right(info) + } else { + // remove duplicates as errors related to imported packages might occur multiple times + // consider this: each error in an imported package is converted to an error at the import node with + // message 'Package contains errors'. If the imported package contains 2 errors then only a single error + // should be reported at the import node instead of two. + // however, the duplicate removal should happen after translation so that the error position is correctly + // taken into account for the equality check. + val typeErrors = pkg.positions.translate(errors, TypeError).distinct + config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, typeErrors) + Left(typeErrors) + } + */ + } + + type TypeInfoCacheKey = String + private val typeInfoCache: ConcurrentMap[TypeInfoCacheKey, TypeInfoImpl] = new ConcurrentHashMap() + + private def getCacheKey(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoCacheKey = { + // type-checking depends on `typeBounds` and `enableLazyImport` + val key = pkg.hashCode().toString ++ + dependentTypeInfo.hashCode().toString ++ + (if (isMainContext) "1" else "0") ++ + config.typeBounds.hashCode().toString ++ + (if (config.enableLazyImports) "1" else "0") + + val bytes = MessageDigest.getInstance("MD5").digest(key.getBytes) + // convert `bytes` to a hex string representation such that we get equality on the key while performing cache lookups + bytes.map { "%02x".format(_) }.mkString + } + + def flushCache(): Unit = { + typeInfoCache.clear() + } + + def checkSources(sources: Vector[Source], pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean = false)(config: Config): TypeCheckResult = { + def getTypeInfo(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoImpl = { + val tree = new GoTree(pkg) + new TypeInfoImpl(tree, dependentTypeInfo, isMainContext)(config: Config) + } + + def getTypeInfoCached(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoImpl = { + typeInfoCache.computeIfAbsent(getCacheKey(pkg, dependentTypeInfo, isMainContext, config), _ => getTypeInfo(pkg, dependentTypeInfo, isMainContext, config)) + } + + val checkFn = if (config.cacheParser) { getTypeInfoCached _ } else { getTypeInfo _ } + val info = checkFn(pkg, dependentTypeInfo, isMainContext, config) + + val errors = info.errors + val sourceNames = sources.map(_.name) // use `sources` instead of `context.inputs` for reporting such that the message is correctly attributed in case of imports config.reporter report TypeCheckDebugMessage(sourceNames, () => pkg, () => getDebugInfo(pkg, info)) diff --git a/src/main/scala/viper/gobra/frontend/info/TypeInfo.scala b/src/main/scala/viper/gobra/frontend/info/TypeInfo.scala index 41dd8c249..2482363c2 100644 --- a/src/main/scala/viper/gobra/frontend/info/TypeInfo.scala +++ b/src/main/scala/viper/gobra/frontend/info/TypeInfo.scala @@ -8,14 +8,16 @@ package viper.gobra.frontend.info import org.bitbucket.inkytonik.kiama.relation.Tree import viper.gobra.ast.frontend._ +import viper.gobra.frontend.PackageResolver.AbstractImport import viper.gobra.frontend.info.base.SymbolTable.{MethodImpl, MethodSpec, Regular, TypeMember} import viper.gobra.frontend.info.base.Type.{InterfaceT, Type} import viper.gobra.frontend.info.implementation.resolution.{AdvancedMemberSet, MemberPath} +import viper.gobra.reporting.VerifierError import viper.gobra.theory.Addressability trait TypeInfo extends ExternalTypeInfo { - def context: Info.Context + def dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]] def typOfExprOrType(expr: PExpressionOrType): Type def addressability(expr: PExpression): Addressability diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/TypeInfoImpl.scala b/src/main/scala/viper/gobra/frontend/info/implementation/TypeInfoImpl.scala index cc1a2863f..5c34ad774 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/TypeInfoImpl.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/TypeInfoImpl.scala @@ -9,6 +9,7 @@ package viper.gobra.frontend.info.implementation import com.typesafe.scalalogging.StrictLogging import org.bitbucket.inkytonik.kiama.attribution.Attribution import viper.gobra.ast.frontend._ +import viper.gobra.frontend.PackageResolver.AbstractImport import viper.gobra.frontend.{Config, PackageInfo} import viper.gobra.frontend.info.base.SymbolTable.{Regular, TypeMember, UnknownEntity, lookup} import viper.gobra.frontend.info.base.{SymbolTable, Type} @@ -18,8 +19,9 @@ import viper.gobra.frontend.info.implementation.typing._ import viper.gobra.frontend.info.implementation.typing.ghost._ import viper.gobra.frontend.info.implementation.typing.ghost.separation.GhostSeparation import viper.gobra.frontend.info.{ExternalTypeInfo, Info, TypeInfo} +import viper.gobra.reporting.VerifierError -class TypeInfoImpl(final val tree: Info.GoTree, final val context: Info.Context, val isMainContext: Boolean = false)(val config: Config) extends Attribution with TypeInfo with ExternalTypeInfo +class TypeInfoImpl(final val tree: Info.GoTree, final val dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], val isMainContext: Boolean = false)(val config: Config) extends Attribution with TypeInfo with ExternalTypeInfo with NameResolution with LabelResolution @@ -150,4 +152,12 @@ class TypeInfoImpl(final val tree: Info.GoTree, final val context: Info.Context, override def getTypeInfo: TypeInfo = this override def isPureExpression(expr: PExpression): Boolean = isPureExpr(expr).isEmpty + + def getTransitiveTypeInfos: Set[ExternalTypeInfo] = { + val directTypeInfos = dependentTypeInfo + .map { case (_, resultFn) => resultFn() } + .collect { case Right(info) => info } + .toSet + directTypeInfos.flatMap(directTypeInfo => directTypeInfo.getTransitiveTypeInfos) + this + } } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala index 4dc0f9bc9..24587317e 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala @@ -13,8 +13,7 @@ import viper.gobra.ast.frontend._ import viper.gobra.frontend.PackageResolver.{AbstractImport, BuiltInImport, RegularImport} import viper.gobra.frontend.info.base.BuiltInMemberTag import viper.gobra.frontend.info.base.BuiltInMemberTag.{BuiltInMPredicateTag, BuiltInMethodTag} -import viper.gobra.frontend.{PackageResolver, Parser, Source} -import viper.gobra.frontend.info.{ExternalTypeInfo, Info} +import viper.gobra.frontend.info.ExternalTypeInfo import viper.gobra.frontend.info.base.SymbolTable._ import viper.gobra.frontend.info.base.Type._ import viper.gobra.frontend.info.implementation.TypeInfoImpl @@ -427,11 +426,13 @@ trait MemberResolution { this: TypeInfoImpl => res } */ + /* def createImportError(errs: Vector[VerifierError]): Messages = { // create an error message located at the import statement to indicate errors in the imported package // we distinguish between parse and type errors, cyclic imports, and packages whose source files could not be found val notFoundErr = errs.collectFirst { case e: NotFoundError => e } // alternativeErr is a function to compute the message only when needed + val alternativeErr = () => context.getParserImportCycle(importTarget) match { case Some(cycle) => message(errNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") @@ -440,6 +441,17 @@ trait MemberResolution { this: TypeInfoImpl => notFoundErr.map(e => message(errNode, e.message)) .getOrElse(alternativeErr()) } + */ + def createImportError(errs: Vector[VerifierError]): Messages = { + // create an error message located at the import statement to indicate errors in the imported package + // we distinguish between regular errors and packages whose source files could not be found (not that cyclic + // errors are handled before type-checking) + val notFoundErr = errs.collectFirst { case e: NotFoundError => e } + // alternativeErr is a function to compute the message only when needed + val alternativeErr = () => message(errNode, s"Package '$importTarget' contains errors: $errs") + notFoundErr.map(e => message(errNode, e.message)) + .getOrElse(alternativeErr()) + } // check if package was already parsed, otherwise do parsing and type checking: /* @@ -451,6 +463,8 @@ trait MemberResolution { this: TypeInfoImpl => cachedInfo.get.left.map(createImportError) // cachedInfo.getOrElse(parseAndTypeCheck(importTarget)).left.map(createImportError) */ - context.getTypeInfo(importTarget)(config).left.map(createImportError) + // context.getTypeInfo(importTarget)(config).left.map(createImportError) + Violation.violation(dependentTypeInfo.contains(importTarget), s"Expected that package ${tree.root.info.id} has access to the type information of package $importTarget") + dependentTypeInfo(importTarget)().left.map(createImportError) } } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMemberTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMemberTyping.scala index 588b0810a..f0feca5fc 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMemberTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMemberTyping.scala @@ -129,16 +129,23 @@ trait GhostMemberTyping extends BaseTyping { this: TypeInfoImpl => def wellImplementationProofs: Either[Messages, Vector[(Type, InterfaceT, MethodImpl, MethodSpec)]] = { // the main context reports missing implementation proof for all packages (i.e. all packages that have been parsed & typechecked so far) if (isMainContext) { + // we not only collect the type information for directly imported packages but for all transitively imported ones: + // val typeInfos = getTransitiveTypeInfos(dependentTypeInfo) + this + val typeInfos = getTransitiveTypeInfos + // val typeInfos = dependentTypeInfo.map { case (_, resultFn) => resultFn() }.collect { case Right(info) => info }.toVector :+ this val allRequiredImplements = { - val foundRequired = localRequiredImplements ++ context.getContexts.flatMap(_.localRequiredImplements) - val foundGuaranteed = localGuaranteedImplements ++ context.getContexts.flatMap(_.localGuaranteedImplements) + // val foundRequired = localRequiredImplements ++ context.getContexts.flatMap(_.localRequiredImplements) + val foundRequired = localRequiredImplements ++ typeInfos.flatMap(_.localRequiredImplements) + // val foundGuaranteed = localGuaranteedImplements ++ context.getContexts.flatMap(_.localGuaranteedImplements) + val foundGuaranteed = localGuaranteedImplements ++ typeInfos.flatMap(_.localGuaranteedImplements) foundRequired diff foundGuaranteed } if (allRequiredImplements.nonEmpty) { // For every required implementation, check that there is at most one proof // and if not all predicates are defined, then check that there is a proof. - val providedImplProofs = localImplementationProofs ++ context.getContexts.flatMap(_.localImplementationProofs) + // val providedImplProofs = localImplementationProofs ++ context.getContexts.flatMap(_.localImplementationProofs) + val providedImplProofs = localImplementationProofs ++ typeInfos.flatMap(_.localImplementationProofs) val groupedProofs = allRequiredImplements.toVector.map{ case (impl, itf) => (impl, itf, providedImplProofs.collect{ case (`impl`, `itf`, alias, proofs) => (alias, proofs) }) } diff --git a/src/main/scala/viper/gobra/reporting/StatsCollector.scala b/src/main/scala/viper/gobra/reporting/StatsCollector.scala index c35fa4493..1ded42ceb 100644 --- a/src/main/scala/viper/gobra/reporting/StatsCollector.scala +++ b/src/main/scala/viper/gobra/reporting/StatsCollector.scala @@ -265,9 +265,18 @@ case class StatsCollector(reporter: GobraReporter) extends GobraReporter { typeInfo } else { // Try to find the correct typeInfo for the member + /* val typeInfoOption = typeInfo.context.getContexts .map(externalTypeInfo => externalTypeInfo.getTypeInfo) .find(typeInfo => treeContains(typeInfo.tree, p)) + */ + /* + val typeInfos = typeInfo.dependentTypeInfo.values + .map(typeInfoFn => typeInfoFn()) + .collect { case Right(info) => info.getTypeInfo} + */ + val typeInfos = typeInfo.getTransitiveTypeInfos.map(_.getTypeInfo) + val typeInfoOption = typeInfos.find(typeInfo => treeContains(typeInfo.tree, p)) typeInfoOption match { case Some(typeInfo) => typeInfo case None => Violation.violation("Couldn't find typeInfo for node " + p.formattedShort) From 5a4f353ac51d9195e1df393b4a709a386acbafd6 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 9 Mar 2023 15:07:44 +0100 Subject: [PATCH 04/54] fixes unit tests --- src/main/scala/viper/gobra/Gobra.scala | 44 +- .../scala/viper/gobra/frontend/Desugar.scala | 64 +- .../scala/viper/gobra/frontend/Parser.scala | 114 +-- .../frontend/info/ExternalTypeInfo.scala | 4 +- .../viper/gobra/frontend/info/Info.scala | 845 +----------------- .../info/implementation/TypeInfoImpl.scala | 8 +- .../typing/ghost/GhostMemberTyping.scala | 13 +- .../gobra/reporting/StatsCollector.scala | 13 +- .../viper/gobra/DetailedBenchmarkTests.scala | 20 +- .../gobra/erasing/GhostErasureUnitTests.scala | 3 +- .../gobra/typing/ExprTypingUnitTests.scala | 3 +- .../gobra/typing/StmtTypingUnitTests.scala | 3 +- .../gobra/typing/TypeTypingUnitTests.scala | 3 +- 13 files changed, 164 insertions(+), 973 deletions(-) diff --git a/src/main/scala/viper/gobra/Gobra.scala b/src/main/scala/viper/gobra/Gobra.scala index f83c0deaf..719e65857 100644 --- a/src/main/scala/viper/gobra/Gobra.scala +++ b/src/main/scala/viper/gobra/Gobra.scala @@ -247,25 +247,11 @@ class Gobra extends GoVerifier with GoIdeVerifier { if (config.shouldParse) { val startMs = System.currentTimeMillis() val res = Parser.parse(config, pkgInfo)(executor) - val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - println(s"parser phase done, took ${durationS}s") - res - /* - val sourcesToParse = config.packageInfoInputMap(pkgInfo) - val res = Parser.parse(sourcesToParse, pkgInfo)(config) - */ - /* - val parseManager = Parser.parse(pkgInfo)(config, executionContext) - config.typeCheckMode match { - case TypeCheckMode.Lazy => // don't do anything - case TypeCheckMode.Sequential | TypeCheckMode.Parallel => - parseManager.awaitResults() - val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - println(s"parser phase done, took ${durationS}s") - println(s"parsed packages: ${parseManager.getResults.map{ case (pkg, _) => pkg }.mkString(", ")}") + logger.debug { + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + s"parser phase done, took ${durationS}s" } - Right(parseManager) - */ + res } else { Left(Vector()) } @@ -279,12 +265,14 @@ class Gobra extends GoVerifier with GoIdeVerifier { } } - private def performDesugaring(config: Config, typeInfo: TypeInfo)(@unused executor: GobraExecutionContext): Either[Vector[VerifierError], Program] = { + private def performDesugaring(config: Config, typeInfo: TypeInfo)(executor: GobraExecutionContext): Either[Vector[VerifierError], Program] = { if (config.shouldDesugar) { val startMs = System.currentTimeMillis() - val res = Right(Desugar.desugar(typeInfo.tree.root, typeInfo)(config)) - val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - println(s"desugaring done, took ${durationS}s") + val res = Right(Desugar.desugar(config, typeInfo)(executor)) + logger.debug { + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + s"desugaring done, took ${durationS}s" + } res } else { Left(Vector()) @@ -305,9 +293,11 @@ class Gobra extends GoVerifier with GoIdeVerifier { transformations :+= OverflowChecksTransform } val result = transformations.foldLeft(program)((prog, transf) => transf.transform(prog)) + logger.debug { + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + s"internal transformations done, took ${durationS}s" + } config.reporter.report(AppliedInternalTransformsMessage(config.packageInfoInputMap(pkgInfo).map(_.name), () => result)) - val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - println(s"internal transformations done, took ${durationS}s") Right(result) } @@ -315,8 +305,10 @@ class Gobra extends GoVerifier with GoIdeVerifier { if (config.shouldViperEncode) { val startMs = System.currentTimeMillis() val res = Right(Translator.translate(program, pkgInfo)(config)) - val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - println(s"Viper encoding done, took ${durationS}s") + logger.debug { + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + s"Viper encoding done, took ${durationS}s" + } res } else { Left(Vector()) diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index 3bdc63c0d..d19d044d8 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -6,6 +6,7 @@ package viper.gobra.frontend +import com.typesafe.scalalogging.LazyLogging import viper.gobra.ast.frontend.{PExpression, AstPattern => ap, _} import viper.gobra.ast.{internal => in} import viper.gobra.frontend.PackageResolver.RegularImport @@ -20,41 +21,60 @@ import viper.gobra.reporting.{DesugaredMessage, Source} import viper.gobra.theory.Addressability import viper.gobra.translator.Names import viper.gobra.util.Violation.violation -import viper.gobra.util.{Constants, DesugarWriter, Violation} +import viper.gobra.util.{Constants, DesugarWriter, GobraExecutionContext, Violation} +import java.util.concurrent.atomic.AtomicLong import scala.annotation.{tailrec, unused} import scala.collection.{Iterable, SortedSet} +import scala.concurrent.duration.Duration +import scala.concurrent.{Await, Future} import scala.reflect.ClassTag -object Desugar { +object Desugar extends LazyLogging { - def desugar(pkg: PPackage, info: viper.gobra.frontend.info.TypeInfo)(config: Config): in.Program = { + def desugar(config: Config, info: viper.gobra.frontend.info.TypeInfo)(implicit executionContext: GobraExecutionContext): in.Program = { + val pkg = info.tree.root val importsCollector = new PackageInitSpecCollector - // independently desugar each imported package. - val importedDesugaringStartMs = System.currentTimeMillis() - // val importedPrograms = info.context.getContexts map { tI => { - // val importedPrograms = info.dependentTypeInfo.map { case (abstractPackage, tIFn) => { - val importedPrograms = info.getTransitiveTypeInfos.map { tI => { + + val importeDesugaringDurationMs = new AtomicLong(0) + val importedProgramsFuts = info.getTransitiveTypeInfos(includeThis = false).toSeq.map { tI => Future { + val importedDesugaringStartMs = System.currentTimeMillis() val typeInfo = tI.getTypeInfo - // val typeInfo: TypeInfo = tIFn().map(_.getTypeInfo).getOrElse(Violation.violation(s"cannot desugar package $abstractPackage for which type-checking failed")) // tI.getTypeInfo val importedPackage = typeInfo.tree.originalRoot val d = new Desugarer(importedPackage.positions, typeInfo) // registers a package to generate proof obligations for its init code d.registerPackage(importedPackage, importsCollector)(config) - (d, d.packageD(importedPackage)) + val res = (d, d.packageD(importedPackage)) + importeDesugaringDurationMs.addAndGet(System.currentTimeMillis() - importedDesugaringStartMs) + res }} - val importedDurationS = f"${(System.currentTimeMillis() - importedDesugaringStartMs) / 1000f}%.1f" - println(s"desugaring imported packages done, took ${importedDurationS}s") - - val desugaringStartMs = System.currentTimeMillis() - // desugar the main package, i.e. the package on which verification is performed: - val mainDesugarer = new Desugarer(pkg.positions, info) - // registers main package to generate proof obligations for its init code - mainDesugarer.registerMainPackage(pkg, importsCollector)(config) + + val mainPackageFut = Future { + val mainDesugaringStartMs = System.currentTimeMillis() + // desugar the main package, i.e. the package on which verification is performed: + val mainDesugarer = new Desugarer(pkg.positions, info) + // registers main package to generate proof obligations for its init code + mainDesugarer.registerMainPackage(pkg, importsCollector)(config) + val res = (mainDesugarer, mainDesugarer.packageD(pkg)) + logger.debug { + val durationS = f"${(System.currentTimeMillis() - mainDesugaringStartMs) / 1000f}%.1f" + s"desugaring package ${info.pkgInfo.id} done, took ${durationS}s" + } + res + } + + // we place `mainPackageFut` at index 0 + val allPackagesFut = Future.sequence(mainPackageFut +: importedProgramsFuts) + val futResults = Await.result(allPackagesFut, Duration.Inf) + val (mainDesugarer, mainProgram) = futResults.head + val importedPrograms = futResults.tail + logger.debug { + val importedDurationS = f"${importeDesugaringDurationMs.get() / 1000f}%.1f" + s"desugaring imported packages done, took ${importedDurationS}s" + } + // combine all desugared results into one Viper program: - val internalProgram = combine(mainDesugarer, mainDesugarer.packageD(pkg), importedPrograms) - val durationS = f"${(System.currentTimeMillis() - desugaringStartMs) / 1000f}%.1f" - println(s"desugaring main package done, took ${durationS}s") + val internalProgram = combine(mainDesugarer, mainProgram, importedPrograms) config.reporter report DesugaredMessage(config.packageInfoInputMap(pkg.info).map(_.name), () => internalProgram) internalProgram } @@ -3466,9 +3486,7 @@ object Desugar { pkg.imports.foreach{ imp => { val importedPackage = RegularImport(imp.importPath) Violation.violation(info.dependentTypeInfo.contains(importedPackage), s"Desugarer expects to have acess to the type information of all imported packages but could not find $importedPackage") - // info.context.getTypeInfo(RegularImport(imp.importPath))(config) match { info.dependentTypeInfo(importedPackage)() match { - // case Some(Right(tI)) => case Right(tI) => val desugaredPre = imp.importPres.map(specificationD(FunctionContext.empty(), info)) Violation.violation(!config.enableLazyImports || desugaredPre.isEmpty, s"Import precondition found despite running with ${Config.enableLazyImportOptionPrettyPrinted}") diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index ba88bac41..1e2a87f69 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -6,6 +6,7 @@ package viper.gobra.frontend +import com.typesafe.scalalogging.LazyLogging import org.bitbucket.inkytonik.kiama.rewriting.Cloner.{rewrite, topdown} import org.bitbucket.inkytonik.kiama.rewriting.PositionedRewriter.strategyWithName import org.bitbucket.inkytonik.kiama.rewriting.{Cloner, PositionedRewriter, Strategy} @@ -30,7 +31,7 @@ object Parser { type ParseSuccessResult = (Vector[Source], PPackage) type ParseResult = Either[Vector[VerifierError], ParseSuccessResult] - class ParseManager(config: Config, executionContext: GobraExecutionContext) { + class ParseManager(config: Config, executionContext: GobraExecutionContext) extends LazyLogging { private val manager = new TaskManager[AbstractPackage, ParseResult](TaskManagerMode.Parallel) def parse(pkgInfo: PackageInfo): Unit = { @@ -44,76 +45,74 @@ object Parser { trait ParseJob extends Job[ParseResult] { def pkgInfo: PackageInfo def pkgSources: Vector[Source] + def specOnly: Boolean override def compute(): ParseResult = { require(pkgSources.nonEmpty) + val preprocessedSources = preprocess(pkgSources)(config) + val startPreambleParsingMs = System.currentTimeMillis() - var endPreambleParsingMs: Option[Long] = None // before parsing, get imports and add these parse jobs - fastParse(pkgSources) - .map(directImportTarget => { - if (endPreambleParsingMs.isEmpty) { - endPreambleParsingMs = Some(System.currentTimeMillis()) - } + val imports = fastParse(preprocessedSources) + val preambleParsingDurationMs = System.currentTimeMillis() - startPreambleParsingMs + imports.foreach(directImportTarget => { val directImportPackage = AbstractPackage(directImportTarget)(config) - val pkgSources = PackageResolver.resolveSources(directImportTarget)(config) + val importedSources = PackageResolver.resolveSources(directImportTarget)(config) .getOrElse(Vector()) .map(_.source) - if (pkgSources.isEmpty) { + if (importedSources.isEmpty) { manager.addIfAbsent(directImportPackage, ParseFailureJob(Vector(NotFoundError(s"No source files for package '$directImportTarget found"))))(executionContext) } else { - manager.addIfAbsent(directImportPackage, ParseSourcesJob(pkgSources, directImportPackage))(executionContext) + manager.addIfAbsent(directImportPackage, ParseSourcesJob(importedSources, directImportPackage))(executionContext) } }) val startMs = System.currentTimeMillis() val res = for { - parsedProgram <- Parser.parse(pkgSources, pkgInfo, specOnly = true)(config) + parsedProgram <- Parser.process(preprocessedSources, pkgInfo, specOnly = specOnly)(config) } yield (pkgSources, parsedProgram) - val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - val preambleParsingRatio = f"${100f * (endPreambleParsingMs.get - startPreambleParsingMs) / (System.currentTimeMillis() - startMs)}%.1f" - println(s"parsing ${pkgInfo.id} done (took ${durationS}s; parsing preamble takes ${preambleParsingRatio}%)") + + logger.trace { + val parsingDurationMs = System.currentTimeMillis() - startMs + val parsingDurationS = f"${parsingDurationMs / 1000f}%.1f" + val preambleParsingRatio = f"${100f * preambleParsingDurationMs / parsingDurationMs}%.1f" + s"parsing ${pkgInfo.id} done (took ${parsingDurationS}s; parsing preamble overhead is ${preambleParsingRatio}%)" + } + res } - private def fastParse(sources: Vector[Source]): Set[AbstractImport] = { - def getImportPaths(source: Source): Set[AbstractImport] = { - parsePreamble(source)(config) + private def fastParse(preprocessedInput: Vector[Source]): Set[AbstractImport] = { + def getImportPaths(preprocessedSource: Source): Set[AbstractImport] = { + processPreamble(preprocessedSource)(config) .map(_.imports.toSet.map[AbstractImport](importNode => RegularImport(importNode.importPath))) // we do not handle parser errors here but defer this to the time point when we actually // parse this source .getOrElse(Set.empty) } - sources.flatMap(getImportPaths).toSet + BuiltInImport + preprocessedInput.flatMap(getImportPaths).toSet + BuiltInImport } } + /** this job is used to parse the package that should be verified */ case class ParseInfoJob(override val pkgInfo: PackageInfo) extends ParseJob { lazy val pkgSources: Vector[Source] = config.packageInfoInputMap(pkgInfo) + lazy val specOnly: Boolean = false } + /** this job is used to parse all packages that are imported */ case class ParseSourcesJob(override val pkgSources: Vector[Source], pkg: AbstractPackage) extends ParseJob { require(pkgSources.nonEmpty) lazy val pkgInfo: PackageInfo = Source.getPackageInfo(pkgSources.head, config.projectRoot) + lazy val specOnly: Boolean = true } case class ParseFailureJob(errs: Vector[NotFoundError]) extends Job[ParseResult] { override def compute(): ParseResult = Left(errs) } - /* - def awaitResults(): Iterable[ParseResult] = manager.getAllResults(executionContext) - def getResult(pkgInfo: PackageInfo): ParseResult = - getResult(RegularPackage(pkgInfo.id)) - - def getResult(abstractPackage: AbstractPackage): ParseResult = - manager.getResult(abstractPackage) - - def getResults: Iterable[(AbstractPackage, ParseResult)] = - manager.getAllResultsWithKeys - */ def getParseResults(executionContext: GobraExecutionContext): Either[Map[AbstractPackage, Vector[VerifierError]], Map[AbstractPackage, ParseSuccessResult]] = { val (failedResults, successfulResults) = manager.getAllResultsWithKeys(executionContext) .partitionMap { case (key, eitherResult) => eitherResult.fold[Either[(AbstractPackage, Vector[VerifierError]), (AbstractPackage, ParseSuccessResult)]](errs => Left((key, errs)), result => Right((key, result))) } @@ -146,13 +145,45 @@ object Parser { } def parse(input: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean = false)(config: Config): Either[Vector[VerifierError], PPackage] = { + val preprocessedInputs = preprocess(input)(config) + process(preprocessedInputs, pkgInfo, specOnly = specOnly)(config) + } + + private def preprocess(input: Vector[Source])(config: Config): Vector[Source] = { val sources = input.map(Gobrafier.gobrafy) sources.foreach { s => config.reporter report PreprocessedInputMessage(s.name, () => s.content) } + sources + } + + /** + * Parses a source's preamble containing all (file-level) imports; This function expects that the input has already + * been preprocessed + */ + private def processPreamble(preprocessedSource: Source)(config: Config): Either[Vector[ParserError], PPreamble] = { + val positions = new Positions + val pom = new PositionManager(positions) + + def parseSource(preprocessedSource: Source): Either[Vector[ParserError], PPreamble] = { + val parser = new SyntaxAnalyzer[PreambleContext, PPreamble](preprocessedSource, ListBuffer.empty[ParserError], pom, specOnly = true) + parser.parse(parser.preamble) + } + + def parseSourceCached(preprocessedSource: Source): Either[Vector[ParserError], PPreamble] = { + def parseAndStore(): Either[Vector[ParserError], PPreamble] = + parseSource(preprocessedSource) + + preambleCache.computeIfAbsent(getCacheKey(preprocessedSource, specOnly = true), _ => parseAndStore()) + } + + if (config.cacheParser) parseSourceCached(preprocessedSource) else parseSource(preprocessedSource) + } + + private def process(preprocessedInputs: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { for { - parseAst <- parseSources(sources, pkgInfo, specOnly)(config) + parseAst <- parseSources(preprocessedInputs, pkgInfo, specOnly = specOnly)(config) postprocessors = Seq( new ImportPostprocessor(parseAst.positions.positions), - new TerminationMeasurePostprocessor(parseAst.positions.positions, specOnly), + new TerminationMeasurePostprocessor(parseAst.positions.positions, specOnly = specOnly), ) postprocessedAst <- postprocessors.foldLeft[Either[Vector[VerifierError], PPackage]](Right(parseAst)) { case (Right(ast), postprocessor) => postprocessor.postprocess(ast)(config) @@ -286,27 +317,6 @@ object Parser { parser.parse(parser.sourceFile()) } - /** parses a source's preamble containing all (file-level) imports */ - def parsePreamble(source: Source)(config: Config): Either[Vector[ParserError], PPreamble] = { - // TODO: gobrafy only once - val positions = new Positions - val pom = new PositionManager(positions) - - def parseSource(source: Source): Either[Vector[ParserError], PPreamble] = { - val parser = new SyntaxAnalyzer[PreambleContext, PPreamble](Gobrafier.gobrafy(source), ListBuffer.empty[ParserError], pom, specOnly = true) - parser.parse(parser.preamble) - } - - def parseSourceCached(source: Source): Either[Vector[ParserError], PPreamble] = { - def parseAndStore(): Either[Vector[ParserError], PPreamble] = - parseSource(source) - - preambleCache.computeIfAbsent(getCacheKey(source, specOnly = true), _ => parseAndStore()) - } - - if (config.cacheParser) parseSourceCached(source) else parseSource(source) - } - def parseFunction(source: Source, specOnly: Boolean = false): Either[Vector[ParserError], PMember] = { val positions = new Positions val pom = new PositionManager(positions) diff --git a/src/main/scala/viper/gobra/frontend/info/ExternalTypeInfo.scala b/src/main/scala/viper/gobra/frontend/info/ExternalTypeInfo.scala index d4a19fd8f..fc72758b5 100644 --- a/src/main/scala/viper/gobra/frontend/info/ExternalTypeInfo.scala +++ b/src/main/scala/viper/gobra/frontend/info/ExternalTypeInfo.scala @@ -23,8 +23,8 @@ trait ExternalTypeInfo { def pkgInfo: PackageInfo def dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]] - /** returns this and the type information of directly and transitively dependent packages */ - def getTransitiveTypeInfos: Set[ExternalTypeInfo] + /** returns this (unless disabled via parameter) and the type information of directly and transitively dependent packages */ + def getTransitiveTypeInfos(includeThis: Boolean = true): Set[ExternalTypeInfo] /** * Gets called by the type checker to perform a symbol table lookup in an imported package diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 3f43cebf6..561456e58 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -6,6 +6,7 @@ package viper.gobra.frontend.info +import com.typesafe.scalalogging.LazyLogging import org.bitbucket.inkytonik.kiama.relation.Tree import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, message} import org.bitbucket.inkytonik.kiama.util.{Position, Source} @@ -24,7 +25,7 @@ import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} import scala.concurrent.duration.Duration import scala.concurrent.{Await, Future} -object Info { +object Info extends LazyLogging { type GoTree = Tree[PNode, PPackage] type TypeCheckResult = Either[Vector[VerifierError], TypeInfo with ExternalTypeInfo] @@ -92,273 +93,20 @@ object Info { * Therefore, package management is centralized. */ class Context(val config: Config, val parseResults: Map[AbstractPackage, ParseSuccessResult])(val executionContext: GobraExecutionContext) extends GetParseResult { - /** stores the results of all imported packages that have been parsed so far */ - // private var parserContextMap: Map[AbstractPackage, Either[Vector[VerifierError], (Vector[Source], PPackage)]] = ListMap() - /** keeps track of the package dependencies that are currently resolved. This information is used to detect cycles */ - // private var parserPendingPackages: Vector[AbstractImport] = Vector() - /** stores all cycles that have been discovered so far */ - // var parserKnownImportCycles: Set[ImportCycle] = Set() - - /* - def parseRecursively(importTarget: AbstractImport)(config: Config): Either[Vector[VerifierError], PPackage] = { - val packageTarget = AbstractPackage(importTarget)(config) - parserPendingPackages = parserPendingPackages :+ importTarget - val pkgSources = PackageResolver.resolveSources(importTarget)(config) - .getOrElse(Vector()) - .map(_.source) - val res = for { - nonEmptyPkgSources <- if (pkgSources.isEmpty) - Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) - else Right(pkgSources) - parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) - directImportTargets = parsedProgram.imports.map(i => RegularImport(i.importPath)) - errorsInTransitivePackages = directImportTargets - .map(directImportTarget => { - if (parserPendingPackages.contains(directImportTarget)) { - // package cycle detected - parserKnownImportCycles += parserPendingPackages - Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'"))) - } else { - parseRecursively(directImportTarget)(config) - } - }) - .flatMap(_.left.getOrElse(Vector.empty)) - res <- if (errorsInTransitivePackages.isEmpty) Right(parsedProgram) else Left(errorsInTransitivePackages) - } yield res - parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) - parserContextMap = parserContextMap + (packageTarget -> res) - res - } - */ - /* - def parseRecursively(importTarget: AbstractImport)(config: Config): Either[Vector[VerifierError], PPackage] = { - val packageTarget = AbstractPackage(importTarget)(config) - - // skip packages that we have already parsed: - if (parserContextMap.contains(packageTarget)) { - return parserContextMap(packageTarget) match { - case Right((_, pkg)) => Right(pkg) - case Left(errs) => Left(errs) - } - } - - println(s"parsing $importTarget") - parserPendingPackages = parserPendingPackages :+ importTarget - val pkgSources = PackageResolver.resolveSources(importTarget)(config) - .getOrElse(Vector()) - .map(_.source) - - val res = for { - nonEmptyPkgSources <- if (pkgSources.isEmpty) - Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) - // Left(message(importNode, s"No source files for package '$importTarget' found")) - else Right(pkgSources) - parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) - errorsInTransitivePackages = parsedProgram.imports - .map(importNode => { - val directImportTarget = RegularImport(importNode.importPath) - if (parserPendingPackages.contains(directImportTarget)) { - // package cycle detected - val importNodeStart = parsedProgram.positions.positions.getStart(importNode) - parserKnownImportCycles += ImportCycle(importNode, importNodeStart, parserPendingPackages) - println(s"cycle detected: ${importTarget} has import ${directImportTarget} that occurs in ${parserKnownImportCycles}") - Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'"))) - // val cycle = parserPendingPackages - // Left(message(importNode, s"Package '$importTarget' is part of this import cycle: ${cycle.mkString("[", ", ", "]")}")) - } else { - parseRecursively(directImportTarget)(config) - } - }) - .flatMap(_.left.getOrElse(Vector.empty)) - res <- if (errorsInTransitivePackages.isEmpty) Right(parsedProgram) else Left(errorsInTransitivePackages) - } yield res - /* - val res: Either[Messages, PPackage] = for { - nonEmptyPkgSources <- if (pkgSources.isEmpty) - // Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) - Left(message(importNode, s"No source files for package '$importTarget' found")) - else Right(pkgSources) - parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) - directImportTargets = parsedProgram.imports // .map(i => RegularImport(i.importPath)) - errorsInTransitivePackages: Messages = directImportTargets - .map(directImportTarget => { - if (parserPendingPackages.contains(directImportTarget)) { - // package cycle detected - parserKnownImportCycles += parserPendingPackages - // Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'"))) - val cycle = parserPendingPackages - Left(message(importNode, s"Package '$importTarget' is part of this import cycle: ${cycle.mkString("[", ", ", "]")}")) - } else { - parseRecursively(directImportTarget)(config) - } - }) - .flatMap(_.left.getOrElse(noMessages)) - res <- if (errorsInTransitivePackages.isEmpty) Right(parsedProgram) else Left(errorsInTransitivePackages) - } yield res - */ - parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) - parserContextMap = parserContextMap + (packageTarget -> res.map(pkg => (pkgSources, pkg))) - res - } - */ - /** - * returns all parser errors and cyclic errors transitively found in imported packages - */ - /* - def computeCycles(importTarget: AbstractImport): Vector[VerifierError] = { - parserPendingPackages = parserPendingPackages :+ importTarget - val abstractPackage = AbstractPackage(importTarget)(config) - val res = for { - res <- parseManager.getResult(abstractPackage) - (_, ast) = res - directImportTargets = ast.imports - errorsInTransitivePackages = directImportTargets - .flatMap(importNode => { - val directImportTarget = RegularImport(importNode.importPath) - if (parserPendingPackages.contains(directImportTarget)) { - // package cycle detected - val importNodeStart = ast.positions.positions.getStart(importNode) - parserKnownImportCycles += ImportCycle(importNode, importNodeStart, parserPendingPackages) - Vector(CyclicImportError(s"Cyclic package import detected starting with package '$directImportTarget'")) - // val cycle = parserPendingPackages - // message(importNode, s"Package '$importTarget' is part of this import cycle: ${cycle.mkString("[", ", ", "]")}") - } else { - computeCycles(directImportTarget) - } - }) - res <- if (errorsInTransitivePackages.isEmpty) Right(ast) else Left(errorsInTransitivePackages) - } yield res - parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) - res.left.getOrElse(Vector.empty) - } - */ - /* - def parseRecursively(pkg: PPackage)(config: Config): Either[Vector[VerifierError], PPackage] = { - val imports = Seq(BuiltInImport) ++ - pkg.imports.map(i => RegularImport(i.importPath)) - imports.map(importTarget => { - parserPendingPackages = parserPendingPackages :+ importTarget - val pkgSources = PackageResolver.resolveSources(importTarget)(config) - .getOrElse(Vector()) - .map(_.source) - val res = for { - nonEmptyPkgSources <- if (pkgSources.isEmpty) - Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) - else Right(pkgSources) - parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) - }) - - } - */ - - /** - * Returns all package names that lie on the cycle of imports or none if no cycle was found - */ - /* - def getParserImportCycle(importTarget: AbstractImport): Option[ImportCycle] = - parserKnownImportCycles.find(_.cyclicPackages.contains(importTarget)) - */ - - /* - case class ParseJob(importTarget: AbstractImport) extends Job[Either[Vector[VerifierError], (Vector[Source], PPackage)]] { - override def compute(): Either[Vector[VerifierError], (Vector[Source], PPackage)] = { - println(s"start parsing $importTarget") - val startMs = System.currentTimeMillis() - val pkgSources = PackageResolver.resolveSources(importTarget)(config) - .getOrElse(Vector()) - .map(_.source) - for { - nonEmptyPkgSources <- if (pkgSources.isEmpty) - Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) - // Left(message(importNode, s"No source files for package '$importTarget' found")) - else Right(pkgSources) - - // before parsing, get imports and add these parse jobs - _ = fastParse(nonEmptyPkgSources) - .map(directImportTarget => { - val directImportPackage = AbstractPackage(directImportTarget)(config) - parseManager.addIfAbsent(directImportPackage, ParseJob(directImportTarget))(executionContext) - }) - - parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) - durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - _ = println(s"parsing $importTarget done (took ${durationS}s)") - /* - // submit jobs to parse dependent packages: - _ = parsedProgram.imports.foreach(importNode => { - val directImportTarget = RegularImport(importNode.importPath) - val directImportPackage = AbstractPackage(directImportTarget)(config) - parseManager.addIfAbsent(directImportPackage, ParseJob(directImportTarget))(executionContext) - }) - */ - } yield (pkgSources, parsedProgram) - } - } - - case class SuccessParseJob(sources: Vector[Source], pkg: PPackage) extends Job[Either[Vector[VerifierError], (Vector[Source], PPackage)]] { - override def compute(): Either[Vector[VerifierError], (Vector[Source], PPackage)] = - Right((sources, pkg)) - } + private val typeCheckManager = new TaskManager[AbstractPackage, TypeCheckResult](config.typeCheckMode) + private val parallelTypeCheckManager = new TaskManager[AbstractPackage, Future[TypeCheckResult]](config.typeCheckMode) - // val parseManager = new TaskManager[AbstractPackage, Either[Vector[VerifierError], (Vector[Source], PPackage)]](config) - def parse(importTarget: AbstractImport): Unit = { - val abstractPackage = AbstractPackage(importTarget)(config) - val parseJob = ParseJob(importTarget) - parseManager.addIfAbsent(abstractPackage, parseJob)(executionContext) - } - */ trait TypeCheckJob { protected def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isMainContext: Boolean = false): TypeCheckResult = { - println(s"start type-checking ${pkg.info.id}") val startMs = System.currentTimeMillis() val res = Info.checkSources(pkgSources, pkg, dependentTypeInfo, isMainContext = isMainContext)(config) - val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - println(s"type-checking ${pkg.info.id} done (took ${durationS}s)") + logger.trace { + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + s"type-checking ${pkg.info.id} done (took ${durationS}s)" + } res } } - /* - case class SimpleTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { - override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = typeCheck(pkgSources, pkg, context) - } - */ - /* - case class DependentTypeCheckJob(importTarget: AbstractImport, context: Context) extends Job[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] with TypeCheckJob { - override def toString: String = s"DependentTypeCheckJob for $importTarget" - - override def compute(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { - val abstractPackage = AbstractPackage(importTarget)(config) - val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) - val isBuiltIn = importTarget == BuiltInImport - val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets - val dependentJobsFuts = dependencies - .map(DependentTypeCheckJob(_, context)) - // add to manager & typecheck them if not present yet - .map(dependentJob => { - val dependentAbstractPackage = AbstractPackage(dependentJob.importTarget)(config) - typeCheckManager.addIfAbsent(dependentAbstractPackage, dependentJob)(executionContext) - typeCheckManager.getFuture(dependentAbstractPackage).flatten - }) - implicit val executor: GobraExecutionContext = executionContext - val dependentJobsFut = Future.sequence(dependentJobsFuts) - dependentJobsFut.map(_ => typeCheck(sources, ast, context)) - } - } - */ - /* - case class LazyTypeCheckJob(importTarget: AbstractImport, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { - override def toString: String = s"LazyTypeCheckJob for $importTarget" - - override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { - // in lazy mode, this function is called exactly when this package needs to be type-checked - // we also do not care about any dependent packages, because they will be lazily type-checked - val abstractPackage = AbstractPackage(importTarget)(config) - val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - typeCheck(sources, ast, context) - } - } - */ case class LazyTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[TypeCheckResult] with TypeCheckJob { override def toString: String = s"LazyTypeCheckJob for $abstractPackage" @@ -377,43 +125,7 @@ object Info { typeCheck(sources, ast, dependentTypeInfo, isMainContext = isMainContext) } } - /* - case class LazyTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { - override def toString: String = s"LazyTypeCheckJob for ${pkg.info.id}" - - override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { - // in lazy mode, this function is called exactly when this package needs to be type-checked - // we also do not care about any dependent packages, because they will be lazily type-checked - // val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $abstractPackage failed")) - typeCheck(pkgSources, pkg, context) - } - } - */ - /* - case class SequentialTypeCheckJob(importTarget: AbstractImport, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { - override def toString: String = s"SequentialTypeCheckJob for $importTarget" - override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { - // in lazy mode, this function is called exactly when this package needs to be type-checked - // we also do not care about any dependent packages, because they will be lazily type-checked - val abstractPackage = AbstractPackage(importTarget)(config) - val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) - val isBuiltIn = importTarget == BuiltInImport - val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets - // first type-check dependent packages: - dependencies - .map(SequentialTypeCheckJob(_, context)) - // add to manager & typecheck them if not present yet - .foreach(dependentJob => { - val dependentAbstractPackage = AbstractPackage(dependentJob.importTarget)(config) - typeCheckManager.addIfAbsent(dependentAbstractPackage, dependentJob)(executionContext) - }) - typeCheck(sources, ast, context) - // typeCheck(abstractPackage, context) - } - } - */ case class SequentialTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[TypeCheckResult] with TypeCheckJob { override def toString: String = s"SequentialTypeCheckJob for $abstractPackage" @@ -435,33 +147,7 @@ object Info { typeCheck(sources, ast, dependentTypeInfos.toMap, isMainContext = isMainContext) } } - /* - case class ParallelTypeCheckJob(importTarget: AbstractImport, context: Context) extends Job[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] with TypeCheckJob { - override def toString: String = s"ParallelTypeCheckJob for $importTarget" - override def compute(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { - // in lazy mode, this function is called exactly when this package needs to be type-checked - // we also do not care about any dependent packages, because they will be lazily type-checked - val abstractPackage = AbstractPackage(importTarget)(config) - val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) - val isBuiltIn = importTarget == BuiltInImport - val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets - // first type-check dependent packages: - val dependentJobsFuts = dependencies - .map(ParallelTypeCheckJob(_, context)) - // add to manager & typecheck them if not present yet - .map(dependentJob => { - val dependentAbstractPackage = AbstractPackage(dependentJob.importTarget)(config) - parallelTypeCheckManager.addIfAbsent(dependentAbstractPackage, dependentJob)(executionContext) - parallelTypeCheckManager.getFuture(dependentAbstractPackage).flatten - }) - implicit val executor: GobraExecutionContext = executionContext - val dependentJobsFut = Future.sequence(dependentJobsFuts) - dependentJobsFut.map(_ => typeCheck(sources, ast, context)) - } - } - */ case class ParallelTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[Future[TypeCheckResult]] with TypeCheckJob { override def toString: String = s"ParallelTypeCheckJob for $abstractPackage" @@ -485,121 +171,11 @@ object Info { dependentJobsFut.map(dependentTypeInfo => typeCheck(sources, ast, dependentTypeInfo.toMap, isMainContext = isMainContext)) } } - /* - case class ChainingTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] with TypeCheckJob { - // case class ChainingTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends Job[Either[Vector[VerifierError], ExternalTypeInfo]] with TypeCheckJob { - // case class ChainingTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends TypeCheckJob { - override def toString: String = s"ChainingTypeCheckJob for ${pkg.info.id}" - - private def lookupPackage(importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { - val abstractPackage = AbstractPackage(importTarget)(config) - val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - val job = ChainingTypeCheckJob(sources, ast, context) - // typeCheckManager.addIfAbsent(abstractPackage, job)(executionContext) - // typeCheckManager.getFuture(abstractPackage) - // typeCheckManager.getResult(abstractPackage) - typeCheckManager.addIfAbsent(abstractPackage,() => job.compute()) - } - - // override def compute(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { - // override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { - def compute(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { - println(s"$this compute()") - implicit val executor: GobraExecutionContext = executionContext - // val abstractPackage = AbstractPackage(importTarget)(config) - // val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - // for type-checking this package, we need type information for imported packages: - val importedTypeInfoFutures = // ast.imports.map(tuplesTypeCheck) - pkg.imports.map(importNode => lookupPackage(RegularImport(importNode.importPath))) - // add `BuiltInImport` since it's implicitly imported by every package - val (_, builtInAst) = parseManager.getResult(BuiltInPackage).getOrElse(() => Violation.violation(s"parsing $BuiltInImport failed")) - val isBuiltIn = pkg == builtInAst - val dependentFutures = if (isBuiltIn) importedTypeInfoFutures else lookupPackage(BuiltInImport) +: importedTypeInfoFutures - // execute call synchronously if there are no dependencies: - // if (dependentFutures.isEmpty) { - // Future { typeCheck(pkgSources, pkg, context) } - // } else { - Future.sequence(dependentFutures) - .map(packageResults => { - val errsInImportedPackages = packageResults - .collect { case Left(errs) => errs } - .flatten - if (errsInImportedPackages.isEmpty) { - typeCheck(pkgSources, pkg, context) - } else { - Left(errsInImportedPackages) - } - }) - // Await.result(fut, Duration.Inf) - // } - } - } - */ - /* - case class ChainingTypeCheckJob(pkgSources: Vector[Source], pkg: PPackage, context: Context) extends TypeCheckJob { - private def lookupPackage(importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { - val abstractPackage = AbstractPackage(importTarget)(config) - val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - val job = ChainingTypeCheckJob(sources, ast, context) - typeCheckManager.addIfAbsent(abstractPackage, job)(executionContext) - typeCheckManager.getFuture(abstractPackage) - } - override def getFuture: Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { - implicit val executor: GobraExecutionContext = executionContext - // val abstractPackage = AbstractPackage(importTarget)(config) - // val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - // for type-checking this package, we need type information for imported packages: - val importedTypeInfoFutures = // ast.imports.map(tuplesTypeCheck) - pkg.imports.map(importNode => lookupPackage(RegularImport(importNode.importPath))) - // add `BuiltInImport` since it's implicitly imported by every package - val (builtInSources, builtInAst) = parseManager.getResult(BuiltInPackage).getOrElse(() => Violation.violation(s"parsing $BuiltInImport failed")) - val isBuiltIn = pkg == builtInAst - val dependentFutures = if (isBuiltIn) importedTypeInfoFutures else lookupPackage(BuiltInImport) +: importedTypeInfoFutures - Future.sequence(dependentFutures) - .map(packageResults => { - val errsInImportedPackages = packageResults - .collect { case Left(errs) => errs } - .flatten - if (errsInImportedPackages.isEmpty) { - typeCheck - } else { - Left(errsInImportedPackages) - } - }) - } - - override def compute(): Either[Vector[VerifierError], ExternalTypeInfo] = { - println(s"ERROR: compute called job ${pkg.info.id}") - Left(Vector.empty) - } - } - */ case class FailureJob(errs: Vector[VerifierError]) extends Job[TypeCheckResult] { override def compute(): TypeCheckResult = Left(errs) } - /* - lazy val typeContextMap: Map[AbstractPackage, Future[Either[Vector[VerifierError], ExternalTypeInfo]]] = - parserContextMap.map{ case (abstractPackage, value) => (abstractPackage, value match { - case Right((pkgSources, pkg)) => - if (parallelizeTypechecking) Future { typeCheck(pkgSources, pkg) }(executionContext) - else { - val res = typeCheck(pkgSources, pkg) - if (res.isLeft) { - println(s"type-checking ${abstractPackage} failed: ${res.left.get}") - } - Future.successful(res) - } - case Left(errs) => Future.successful(Left(errs)) - })} - */ - private val typeCheckManager = new TaskManager[AbstractPackage, TypeCheckResult](config.typeCheckMode) - private val parallelTypeCheckManager = new TaskManager[AbstractPackage, Future[TypeCheckResult]](config.typeCheckMode) - // private val typeCheckManager = new TaskManager[AbstractPackage, Future[Either[Vector[VerifierError], ExternalTypeInfo]]](config) - // private val typeCheckManager = new FutureManager[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]] - - // def typeCheck(): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { def typeCheck(pkg: AbstractPackage): TypeCheckResult = { config.typeCheckMode match { case Lazy => @@ -615,37 +191,9 @@ object Info { val fut = parallelTypeCheckManager.getResult(pkg) Await.result(fut, Duration.Inf) } - // typeCheckManager.addIfAbsent(mainPackage, DependentTypeCheckJob(RegularImport(""), this))(executionContext) - // typeCheckManager.getFuture(mainPackage).flatten - // typeCheckManager.getFuture(mainPackage) } - /* - def lazyTypeCheckRecursively(importTarget: AbstractImport): Unit = { - def allImports(importTarget: AbstractImport): Set[AbstractImport] = { - val abstractPackage = AbstractPackage(importTarget)(config) - val (_, ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $abstractPackage failed")) - ast.imports.toSet.flatMap[AbstractImport](importNode => allImports(RegularImport(importNode.importPath))) + importTarget - } - - val packages = allImports(importTarget) + BuiltInImport - packages.foreach(importTarget => typeCheckManager.addIfAbsent(AbstractPackage(importTarget)(config), LazyTypeCheckJob(importTarget, this))(executionContext)) - println(s"packages added to typeCheckManager: ${packages.mkString("\n")}") - } - */ - /* - def lazyTypeCheckRecursively(abstractPackage: AbstractPackage): Unit = { - def allImports(abstractPackage: AbstractPackage): Set[AbstractPackage] = { - val (_, ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $abstractPackage failed")) - ast.imports.toSet.flatMap[AbstractPackage](importNode => allImports(AbstractPackage(RegularImport(importNode.importPath))(config))) + abstractPackage - } - - val packages = allImports(abstractPackage) + BuiltInPackage - packages.foreach(pkg => typeCheckManager.addIfAbsent(pkg, LazyTypeCheckJob(pkg, this))(executionContext)) - println(s"packages added to typeCheckManager: ${packages.mkString("\n")}") - } - */ - def lazyTypeCheckRecursively(abstractPackage: AbstractPackage, isMainContext: Boolean = false): Unit = { + private def lazyTypeCheckRecursively(abstractPackage: AbstractPackage, isMainContext: Boolean): Unit = { /** returns all transitively imported packages. However, `abstractPackage` is not included in the returned set! */ def allImports(abstractPackage: AbstractPackage): Set[AbstractPackage] = { val (_, ast: PPackage) = getParseResult(abstractPackage) @@ -660,211 +208,9 @@ object Info { dependentPackages.foreach(pkg => typeCheckManager.addIfAbsent(pkg, LazyTypeCheckJob(pkg))(executionContext)) // create job for this package: typeCheckManager.addIfAbsent(abstractPackage, LazyTypeCheckJob(abstractPackage, isMainContext = isMainContext))(executionContext) - // println(s"packages added to typeCheckManager: ${(dependentPackages + abstractPackage).mkString("\n")}") - } -// def typeCheck(sources: Vector[Source], pkg: PPackage, importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { -// /*parserContextMap.foreach { case (abstractPackage, parseResult) => -// val typeCheckJob = parseResult match { -// case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) -// case Left(errs) => FailureJob(errs) -// } -// println(s"adding task $abstractPackage") -// typeCheckManager.addIfAbsent(abstractPackage, typeCheckJob)(executionContext) -// } -// */ -// /* -// parseManager.getAllResultsWithKeys.foreach { case (abstractPackage, parseResult) => -// val typeCheckJob = parseResult match { -// case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) -// case Left(errs) => FailureJob(errs) -// } -// println(s"adding task $abstractPackage") -// // since we're adding the packages in arbitrary order, we cannot directly run the task in SEQUENTIAL mode because -// // depending packages might not have been inserted yet -// typeCheckManager.addIfAbsent(abstractPackage, typeCheckJob, insertOnly = config.typeCheckMode == TypeCheckMode.Sequential)(executionContext) -// } -// -// */ -// /* -// val job = ChainingTypeCheckJob(sources, pkg, this) -// /** this is a bit artificial as this is the top-level package, i.e. the one we want to verify */ -// val abstractPackage = AbstractPackage(RegularImport(""))(config) -// // typeCheckManager.addIfAbsent(abstractPackage, job)(executionContext) -// // typeCheckManager.getResult(abstractPackage) -// // typeCheckManager.getFuture(abstractPackage) -// typeCheckManager.addIfAbsent(abstractPackage, () => job.compute()) -// */ -// -// /* -// pkg.imports -// .map(importNode => RegularImport(importNode.importPath)) -// .map(typeCheckInternal) -// */ -// -// // TODO perform lookup in typeCheckManager before re-checking every dependent package -// val dependentTypeCheckFuts = pkg.imports -// .map(importNode => RegularImport(importNode.importPath)) -// .map(typeCheckInternal) -// -// val job = ChainingTypeCheckJob(sources, pkg, this) -// -// implicit val executor: GobraExecutionContext = executionContext -// val fut = for { -// dependentTypeChecks <- Future.sequence(dependentTypeCheckFuts) -// dependentErrs = dependentTypeChecks.flatMap { -// case Right(_) => Vector.empty -// case Left(errs) => errs -// } -// res = if (dependentErrs.isEmpty) { -// println(s"start type-checking ${pkg.info.id}") -// val startMs = System.currentTimeMillis() -// val typeCheckRes = Info.check(pkg, sources, this)(config) -// val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" -// println(s"type-checking ${pkg.info.id} done (took ${durationS}s)") -// typeCheckRes -// } else Left(dependentErrs) -// } yield res -// typeCheckManager.addIfAbsent(AbstractPackage(importTarget)(config), () => fut) -// } -// -// private def typeCheckInternal(importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { -// // we iterate down to the package having no dependencies and register futures bottom up -// val parseRes = parseManager.getResult(AbstractPackage(importTarget)(config)) -// parseRes.fold(errs => Future.successful(Left(errs)), { case (sources, pkg) => typeCheck(sources, pkg, importTarget) }) -// /* -// for { -// (sources: Vector[Source], pkg: PPackage) <- parseManager.getResult(AbstractPackage(importTarget)(config)) -// // .left.map(errs => Future.successful(Left(errs))) -// dependentTypeCheckFuts = pkg.imports -// .map(importNode => RegularImport(importNode.importPath)) -// .map(typeCheckInternal) -// fut = for { -// dependentTypeChecks <- Future.sequence(dependentTypeCheckFuts) -// dependentErrs = dependentTypeChecks.flatMap { -// case Right(_) => Vector.empty -// case Left(errs) => errs -// } -// res = if (dependentErrs.isEmpty) { -// println(s"start type-checking ${pkg.info.id}") -// val startMs = System.currentTimeMillis() -// val typeCheckRes = Info.check(pkg, sources, this)(config) -// val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" -// println(s"type-checking ${pkg.info.id} done (took ${durationS}s)") -// typeCheckRes -// } else Left(dependentErrs) -// } yield res -// } yield fut -// */ -// } - - /* - def typeCheck(importTarget: AbstractImport): Future[Either[Vector[VerifierError], ExternalTypeInfo]] = { - implicit val executor: GobraExecutionContext = executionContext - *//* - def tuplesTypeCheck(importNode: PImport): Future[(PImport, Either[Vector[VerifierError], ExternalTypeInfo])] = { - val abstractPackage = RegularImport(importNode.importPath) - typeCheck(abstractPackage) - .map(res => (importNode, res)) - } - *//* - val abstractPackage = AbstractPackage(importTarget)(config) - val (sources: Vector[Source], ast: PPackage) = parseManager.getResult(abstractPackage).getOrElse(() => Violation.violation(s"parsing $importTarget failed")) - // for type-checking this package, we need type information for imported packages: - val importedTypeInfoFutures = // ast.imports.map(tuplesTypeCheck) - ast.imports.map(importNode => typeCheck(RegularImport(importNode.importPath))) - // add `BuiltInImport` since it's implicitly imported by every package - Future.sequence(typeCheck(BuiltInImport) +: importedTypeInfoFutures) - .flatMap(packageResults => { - val errsInImportedPackages = packageResults - // .collect { case (_, Left(errs)) => errs } - .collect { case Left(errs) => errs } - .flatten - val job = if (errsInImportedPackages.isEmpty) { - TypeCheckJob(sources, ast, this) - } else { - FailureJob(errsInImportedPackages) - } - typeCheckManager.addIfAbsent(abstractPackage, job, insertOnly = config.typeCheckMode == TypeCheckMode.Sequential)(executionContext) - job.getFuture - }) } - */ /* - lazy val jobMap: Map[AbstractPackage, Job] = - parserContextMap.transform { case (_, value) => value match { - case Right((pkgSources, pkg)) => TypeCheckJob(pkgSources, pkg, this) - case Left(errs) => FailureJob(errs) - }} - */ - - def typeCheckSequentially(): Unit = { - /* - val jobs = jobMap.toVector.sorted(Ordering.by[(AbstractPackage, Job), Int](_._1.hashCode())) - println(s"typeCheckSequentially: ${jobs.map(_._1)}") - jobs.foreach { case (abstractPackage, job) => - // println(s"typeCheckSequentially: $abstractPackage") - job.call() } - */ - // NOP - } - - def typeCheckInParallel(): Unit = { - // NOP - // jobMap.foreach { case (_, job) => Future{ job.call() }(executionContext) } - } - /* - lazy val typeContextMap: Map[AbstractPackage, Future[Either[Vector[VerifierError], ExternalTypeInfo]]] = - jobMap.transform { case (_, job) => job.getFuture } - */ -// /** stores the results of all imported packages that have been parsed and type checked so far */ -// private var contextMap: Map[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]] = ListMap[AbstractPackage, Either[Vector[VerifierError], ExternalTypeInfo]]() -// /** keeps track of the package dependencies that are currently resolved. This information is used to detect cycles */ -// private var pendingPackages: Vector[AbstractImport] = Vector() -// /** stores all cycles that have been discovered so far */ -// private var knownImportCycles: Set[Vector[AbstractImport]] = Set() -// -// def addPackage(importTarget: AbstractImport, typeInfo: ExternalTypeInfo)(config: Config): Unit = { -// val packageTarget = AbstractPackage(importTarget)(config) -// pendingPackages = pendingPackages.filterNot(_ == importTarget) -// contextMap = contextMap + (packageTarget -> Right(typeInfo)) -// } -// -// def addErrenousPackage(importTarget: AbstractImport, errors: Vector[VerifierError])(config: Config): Unit = { -// val packageTarget = AbstractPackage(importTarget)(config) -// pendingPackages = pendingPackages.filterNot(_ == importTarget) -// contextMap = contextMap + (packageTarget -> Left(errors)) -// } -// -// def getTypeInfo(importTarget: AbstractImport)(config: Config): Option[Either[Vector[VerifierError], ExternalTypeInfo]] = { -// val packageTarget = AbstractPackage(importTarget)(config) -// contextMap.get(packageTarget) match { -// case s@Some(_) => s -// case _ => { -// // there is no entry yet and package resolution might need to resolve multiple depending packages -// // keep track of these packages in pendingPackages until either type information or an error is added to contextMap -// if (pendingPackages.contains(importTarget)) { -// // package cycle detected -// knownImportCycles += pendingPackages -// Some(Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$packageTarget'")))) -// } else { -// pendingPackages = pendingPackages :+ importTarget -// None -// } -// } -// } -// } -// -// /** -// * Returns all package names that lie on the cycle of imports or none if no cycle was found -// */ -// def getImportCycle(importTarget: AbstractImport): Option[Vector[AbstractImport]] = knownImportCycles.find(_.contains(importTarget)) -// -// def getContexts: Iterable[ExternalTypeInfo] = contextMap.values.collect { case Right(info) => info } -// -// def getExternalErrors: Vector[VerifierError] = contextMap.values.collect { case Left(errs) => errs }.flatten.toVector - def getContexts: Iterable[ExternalTypeInfo] = { - // typeContextMap.values.map(fut => Await.result(fut, Duration.Inf)).collect { case Right(info) => info } config.typeCheckMode match { case Lazy | Sequential => typeCheckManager.getAllResults(executionContext).collect { case Right(info) => info } case Parallel => @@ -872,59 +218,10 @@ object Info { val results = Await.result(Future.sequence(parallelTypeCheckManager.getAllResults(executionContext)), Duration.Inf) results.collect { case Right(info) => info } } - // typeCheckManager.getAllResults.collect { case Right(info) => info } - // typeCheckManager.getAllResults(executionContext).collect { case Right(info) => info } - /* - implicit val executor: GobraExecutionContext = executionContext - val results = Await.result(Future.sequence(typeCheckManager.getAllResults), Duration.Inf) - results.collect { case Right(info) => info } - */ - } - /* - def getTypeInfoNonBlocking(importTarget: AbstractImport)(config: Config): Option[Future[Either[Vector[VerifierError], ExternalTypeInfo]]] = { - val packageTarget = AbstractPackage(importTarget)(config) - typeContextMap.get(packageTarget) - } - - def getTypeInfo(importTarget: AbstractImport)(config: Config): Option[Either[Vector[VerifierError], ExternalTypeInfo]] = - getTypeInfoNonBlocking(importTarget)(config).map(Await.result(_, Duration.Inf)) - - */ - - /* - def startTypeChecking(): Unit = { - config.typeCheckMode match { - case TypeCheckMode.Parallel => typeCheckInParallel() - case TypeCheckMode.Sequential => typeCheckSequentially() - case TypeCheckMode.Lazy => // don't do anything yet - } } - */ def getTypeInfo(importTarget: AbstractImport)(config: Config): TypeCheckResult = { val packageTarget = AbstractPackage(importTarget)(config) - /* - Violation.violation(typeContextMap.contains(packageTarget), s"expected that a job for ${packageTarget} but found none") - val fut = typeContextMap(packageTarget) - Await.result(fut, Duration.Inf) - */ - /* - Violation.violation(jobMap.contains(packageTarget), s"expected that a job for ${packageTarget} but found none") - val job = jobMap(packageTarget) - config.typeCheckMode match { - case TypeCheckMode.Lazy => job.call() - case TypeCheckMode.Sequential => - // note that we cannot await the future here as type-checking of this package might not have started yet. - // Thus, we use `.call()` that either returns a previously calculated type-checking result or will calculate it. - job.call() - case TypeCheckMode.Parallel => Await.result(job.getFuture, Duration.Inf) - } - */ - /* - val future = typeCheckManager.getResult(packageTarget) - Violation.violation(future.isCompleted, s"job $importTarget is not yet completed") - Await.result(future, Duration.Inf) - */ config.typeCheckMode match { case Lazy | Sequential => typeCheckManager.getResult(packageTarget) case Parallel => @@ -932,15 +229,10 @@ object Info { Violation.violation(future.isCompleted, s"job $importTarget is not yet completed") Await.result(future, Duration.Inf) } - // typeCheckManager.getResult(packageTarget) - // val future = typeCheckManager.getFuture(packageTarget).flatten - // val future = typeCheckManager.getFuture(packageTarget) - // Violation.violation(future.isCompleted, s"job $importTarget is not yet completed") - // Await.result(future, Duration.Inf) } + */ } - def check(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseSuccessResult])(executionContext: GobraExecutionContext): TypeCheckResult = { // check for cycles val cyclicErrors = new CycleChecker(config, parseResults).check(abstractPackage) @@ -949,8 +241,10 @@ object Info { // add type-checking jobs to context: val context = new Context(config, parseResults)(executionContext) val res = context.typeCheck(abstractPackage) - val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" - println(s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})") + logger.debug { + val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" + s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})" + } // we do not report any messages in this case, because `checkSources` will do so (for each package) res } else { @@ -960,117 +254,6 @@ object Info { config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errors) Left(errors) } - /* - val pkg = context.parseManager.getResult(pkgInfo) - val tree = new GoTree(pkg) - // println(program.declarations.head) - // println("-------------------") - // println(tree) - val info = new TypeInfoImpl(tree, context, isMainContext)(config: Config) - - - - val mainPackage = AbstractPackage(RegularImport(""))(config) - context.parseManager.addIfAbsent(mainPackage, context.SuccessParseJob(sources, pkg))(context.executionContext) - - //val parserMessages = noMessages - val parserMessages = if (isMainContext) { - val sequential = false - val parsingStartMs = System.currentTimeMillis() - val messages = if (sequential) { - // parse BuiltInImport - val builtInParseResult = context.parseRecursively(BuiltInImport)(config) - val builtInMessages = if (builtInParseResult.isRight) noMessages else message(pkg, s"Parsing package with Gobra's built-in definitions failed. This is an internal bug.") - - val importedPackagesMessages = pkg.imports.flatMap(importNode => { - val importTarget = RegularImport(importNode.importPath) - val parseResult = context.parseRecursively(importTarget)(config) - parseResult.left.map(errs => createImportError(importNode, errs)).left.getOrElse(noMessages) - }) - - builtInMessages ++ importedPackagesMessages - } else { - // parse BuiltInImport - context.parse(BuiltInImport) - - pkg.imports.foreach(importNode => { - val importTarget = RegularImport(importNode.importPath) - context.parse(importTarget) - }) - - // collect parse errors and cyclic import errors: - val builtInParseErrors = context.computeCycles(BuiltInImport) - val builtInMessages = if (builtInParseErrors.isEmpty) noMessages else message(pkg, s"Parsing package with Gobra's built-in definitions failed. This is an internal bug.") - - val importedPackagesMessages = pkg.imports.flatMap(importNode => { - val importTarget = RegularImport(importNode.importPath) - val parseErrors = context.computeCycles(importTarget) - if (parseErrors.isEmpty) noMessages else createImportError(importNode, parseErrors) - }) - - builtInMessages ++ importedPackagesMessages - } - val durationS = f"${(System.currentTimeMillis() - parsingStartMs) / 1000f}%.1f" - println(s"parsing done, took ${durationS}s, ${messages.length} errors found") - *//* - val imports = Vector(BuiltInImport) ++ - pkg.imports.map(i => RegularImport(i.importPath)) - val parseResult = imports.map(importTarget => { - context.parseRecursively(importTarget)(config) - }) - val transitiveParseErrors = parseResult.flatMap(res => res.left.getOrElse(Vector.empty)) - if (transitiveParseErrors.nonEmpty) { - println(s"parse error encountered") - println(transitiveParseErrors) - return Left(transitiveParseErrors) - } - println(s"parsing was fine") - *//* - - messages - } else { - noMessages - } - - val typeCheckingStartMs = System.currentTimeMillis() - if (isMainContext && parserMessages.isEmpty) { - // context.startTypeChecking() - context.typeCheck() - // val fut = context.typeCheck() - // val importTargets = BuiltInImport +: pkg.imports.map(importNode => RegularImport(importNode.importPath)) - // val typeCheckFutures = importTargets.map(importTarget => context.typeCheck(importTarget)) - // implicit val executor: GobraExecutionContext = context.executionContext - // Await.ready(Future.sequence(typeCheckFutures), Duration.Inf) - // Await.ready(fut, Duration.Inf) - } - - // val errors = info.errors - val errors = if (parserMessages.nonEmpty) parserMessages else { - info.errors - } - if (isMainContext && errors.isEmpty) { - val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" - println(s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})") - } - - val sourceNames = sources.map(_.name) - // use `sources` instead of `context.inputs` for reporting such that the message is correctly attributed in case of imports - config.reporter report TypeCheckDebugMessage(sourceNames, () => pkg, () => getDebugInfo(pkg, info)) - if (errors.isEmpty) { - config.reporter report TypeCheckSuccessMessage(sourceNames, config.taskName, () => info, () => pkg, () => getErasedGhostCode(pkg, info), () => getGoifiedGhostCode(pkg, info)) - Right(info) - } else { - // remove duplicates as errors related to imported packages might occur multiple times - // consider this: each error in an imported package is converted to an error at the import node with - // message 'Package contains errors'. If the imported package contains 2 errors then only a single error - // should be reported at the import node instead of two. - // however, the duplicate removal should happen after translation so that the error position is correctly - // taken into account for the equality check. - val typeErrors = pkg.positions.translate(errors, TypeError).distinct - config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, typeErrors) - Left(typeErrors) - } - */ } type TypeInfoCacheKey = String diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/TypeInfoImpl.scala b/src/main/scala/viper/gobra/frontend/info/implementation/TypeInfoImpl.scala index 5c34ad774..5ca81f4c4 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/TypeInfoImpl.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/TypeInfoImpl.scala @@ -153,11 +153,15 @@ class TypeInfoImpl(final val tree: Info.GoTree, final val dependentTypeInfo: Map override def isPureExpression(expr: PExpression): Boolean = isPureExpr(expr).isEmpty - def getTransitiveTypeInfos: Set[ExternalTypeInfo] = { + def getTransitiveTypeInfos(includeThis: Boolean = true): Set[ExternalTypeInfo] = { val directTypeInfos = dependentTypeInfo .map { case (_, resultFn) => resultFn() } .collect { case Right(info) => info } .toSet - directTypeInfos.flatMap(directTypeInfo => directTypeInfo.getTransitiveTypeInfos) + this + // note that we call `getTransitiveTypeInfos` recursively with including the parameter in the results (which + // corresponds to the parameter's default value) + val dependentTypeInfos = directTypeInfos.flatMap(directTypeInfo => directTypeInfo.getTransitiveTypeInfos()) + if (includeThis) dependentTypeInfos + this + else dependentTypeInfos } } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMemberTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMemberTyping.scala index f0feca5fc..6ff5bef67 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMemberTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMemberTyping.scala @@ -130,22 +130,17 @@ trait GhostMemberTyping extends BaseTyping { this: TypeInfoImpl => // the main context reports missing implementation proof for all packages (i.e. all packages that have been parsed & typechecked so far) if (isMainContext) { // we not only collect the type information for directly imported packages but for all transitively imported ones: - // val typeInfos = getTransitiveTypeInfos(dependentTypeInfo) + this - val typeInfos = getTransitiveTypeInfos - // val typeInfos = dependentTypeInfo.map { case (_, resultFn) => resultFn() }.collect { case Right(info) => info }.toVector :+ this + val typeInfos = getTransitiveTypeInfos() val allRequiredImplements = { - // val foundRequired = localRequiredImplements ++ context.getContexts.flatMap(_.localRequiredImplements) - val foundRequired = localRequiredImplements ++ typeInfos.flatMap(_.localRequiredImplements) - // val foundGuaranteed = localGuaranteedImplements ++ context.getContexts.flatMap(_.localGuaranteedImplements) - val foundGuaranteed = localGuaranteedImplements ++ typeInfos.flatMap(_.localGuaranteedImplements) + val foundRequired = typeInfos.flatMap(_.localRequiredImplements) + val foundGuaranteed = typeInfos.flatMap(_.localGuaranteedImplements) foundRequired diff foundGuaranteed } if (allRequiredImplements.nonEmpty) { // For every required implementation, check that there is at most one proof // and if not all predicates are defined, then check that there is a proof. - // val providedImplProofs = localImplementationProofs ++ context.getContexts.flatMap(_.localImplementationProofs) - val providedImplProofs = localImplementationProofs ++ typeInfos.flatMap(_.localImplementationProofs) + val providedImplProofs = typeInfos.flatMap(_.localImplementationProofs) val groupedProofs = allRequiredImplements.toVector.map{ case (impl, itf) => (impl, itf, providedImplProofs.collect{ case (`impl`, `itf`, alias, proofs) => (alias, proofs) }) } diff --git a/src/main/scala/viper/gobra/reporting/StatsCollector.scala b/src/main/scala/viper/gobra/reporting/StatsCollector.scala index 1ded42ceb..611689580 100644 --- a/src/main/scala/viper/gobra/reporting/StatsCollector.scala +++ b/src/main/scala/viper/gobra/reporting/StatsCollector.scala @@ -265,18 +265,9 @@ case class StatsCollector(reporter: GobraReporter) extends GobraReporter { typeInfo } else { // Try to find the correct typeInfo for the member - /* - val typeInfoOption = typeInfo.context.getContexts - .map(externalTypeInfo => externalTypeInfo.getTypeInfo) + val typeInfoOption = typeInfo.getTransitiveTypeInfos() + .map(_.getTypeInfo) .find(typeInfo => treeContains(typeInfo.tree, p)) - */ - /* - val typeInfos = typeInfo.dependentTypeInfo.values - .map(typeInfoFn => typeInfoFn()) - .collect { case Right(info) => info.getTypeInfo} - */ - val typeInfos = typeInfo.getTransitiveTypeInfos.map(_.getTypeInfo) - val typeInfoOption = typeInfos.find(typeInfo => treeContains(typeInfo.tree, p)) typeInfoOption match { case Some(typeInfo) => typeInfo case None => Violation.violation("Couldn't find typeInfo for node " + p.formattedShort) diff --git a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala index 1e2ea620f..c7e9ba31f 100644 --- a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala +++ b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala @@ -8,12 +8,12 @@ package viper.gobra import java.nio.file.Path import java.util.concurrent.TimeUnit - import org.scalatest.DoNotDiscover -import viper.gobra.ast.frontend.PPackage import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.OverflowChecksTransform import viper.gobra.backend.BackendVerifier +import viper.gobra.frontend.PackageResolver.{AbstractPackage, RegularPackage} +import viper.gobra.frontend.Parser.ParseSuccessResult import viper.gobra.frontend.info.{Info, TypeInfo} import viper.gobra.frontend.{Desugar, Parser} import viper.gobra.reporting.{AppliedInternalTransformsMessage, BackTranslator, VerifierError, VerifierResult} @@ -105,22 +105,24 @@ class DetailedBenchmarkTests extends BenchmarkTests { val c = config.get assert(c.packageInfoInputMap.size == 1) val pkgInfo = c.packageInfoInputMap.keys.head - Parser.parse(c.packageInfoInputMap(pkgInfo), pkgInfo)(c) + Parser.parse(c, pkgInfo)(executor) }) - private val typeChecking: NextStep[PPackage, (PPackage, TypeInfo), Vector[VerifierError]] = - NextStep("type-checking", parsing, (parsedPackage: PPackage) => { + private val typeChecking: NextStep[Map[AbstractPackage, ParseSuccessResult], TypeInfo, Vector[VerifierError]] = + NextStep("type-checking", parsing, (parseResults: Map[AbstractPackage, ParseSuccessResult]) => { assert(config.isDefined) val c = config.get assert(c.packageInfoInputMap.size == 1) val pkgInfo = c.packageInfoInputMap.keys.head - Info.check(parsedPackage, c.packageInfoInputMap(pkgInfo))(c).map(typeInfo => (parsedPackage, typeInfo)) + Info.check(c, RegularPackage(pkgInfo.id), parseResults)(executor) + // Info.check(parsedPackage, c.packageInfoInputMap(pkgInfo))(c).map(typeInfo => (parsedPackage, typeInfo)) }) - private val desugaring: NextStep[(PPackage, TypeInfo), Program, Vector[VerifierError]] = - NextStep("desugaring", typeChecking, { case (parsedPackage: PPackage, typeInfo: TypeInfo) => + private val desugaring: NextStep[TypeInfo, Program, Vector[VerifierError]] = + NextStep("desugaring", typeChecking, { case (typeInfo: TypeInfo) => assert(config.isDefined) - Right(Desugar.desugar(parsedPackage, typeInfo)(config.get)) + val c = config.get + Right(Desugar.desugar(c, typeInfo)(executor)) }) private val internalTransforming = NextStep("internal transforming", desugaring, (program: Program) => { diff --git a/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala b/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala index f65633b21..b8097a222 100644 --- a/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala +++ b/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala @@ -342,9 +342,8 @@ class GhostErasureUnitTests extends AnyFunSuite with Matchers with Inside { new PackageInfo("pkg", "pkg", false) ) val tree = new Info.GoTree(pkg) - val context = new Info.Context() val config = Config() - val info = new TypeInfoImpl(tree, context)(config) + val info = new TypeInfoImpl(tree, Map.empty)(config) info.errors match { case Vector(msgs) => fail(s"Type-checking failed: $msgs") case _ => diff --git a/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala index 84f1f3aff..ed9020f20 100644 --- a/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala @@ -3391,9 +3391,8 @@ class ExprTypingUnitTests extends AnyFunSuite with Matchers with Inside { new PackageInfo("pkg", "pkg", false) ) val tree = new Info.GoTree(pkg) - val context = new Info.Context() val config = Config() - new TypeInfoImpl(tree, context)(config) + new TypeInfoImpl(tree, Map.empty)(config) } def exprType(expr : PExpression)(inArgs: Vector[(PParameter, Boolean)] = Vector()) : Type.Type = diff --git a/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala index 4675ee774..dc3a3fbc7 100644 --- a/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala @@ -81,9 +81,8 @@ class StmtTypingUnitTests extends AnyFunSuite with Matchers with Inside { new PackageInfo("pkg", "pkg", false) ) val tree = new Info.GoTree(pkg) - val context = new Info.Context() val config = Config() - new TypeInfoImpl(tree, context)(config) + new TypeInfoImpl(tree, Map.empty)(config) } def wellDefStmt(stmt : PStatement)(inArgs: Vector[(PParameter, Boolean)] = Vector()) = diff --git a/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala index 27f489be5..a248c2a15 100644 --- a/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala @@ -378,9 +378,8 @@ class TypeTypingUnitTests extends AnyFunSuite with Matchers with Inside { new PackageInfo("pkg", "pkg", false) ) val tree = new Info.GoTree(pkg) - val context = new Info.Context() val config = Config() - new TypeInfoImpl(tree, context)(config) + new TypeInfoImpl(tree, Map.empty)(config) } def areComparable(t1 : PType, t2 : PType) : Boolean = { From db26519b759440c90d2abca3ff1ad406f5746970 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 9 Mar 2023 15:10:54 +0100 Subject: [PATCH 05/54] fixes license headers --- src/main/antlr4/GoParser.g4 | 49 +++++++++++-------- .../viper/gobra/frontend/TaskManager.scala | 6 +++ 2 files changed, 34 insertions(+), 21 deletions(-) diff --git a/src/main/antlr4/GoParser.g4 b/src/main/antlr4/GoParser.g4 index d357ed404..273ed8336 100644 --- a/src/main/antlr4/GoParser.g4 +++ b/src/main/antlr4/GoParser.g4 @@ -1,25 +1,32 @@ /* - [The "BSD licence"] Copyright (c) 2017 Sasa Coh, Michał Błotniak Copyright (c) 2019 Ivan Kochurkin, - kvanttt@gmail.com, Positive Technologies Copyright (c) 2019 Dmitry Rassadin, - flipparassa@gmail.com,Positive Technologies All rights reserved. Copyright (c) 2021 Martin Mirchev, - mirchevmartin2203@gmail.com - - Redistribution and use in source and binary forms, with or without modification, are permitted - provided that the following conditions are met: 1. Redistributions of source code must retain the - above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in - binary form must reproduce the above copyright notice, this list of conditions and the following - disclaimer in the documentation and/or other materials provided with the distribution. 3. The name - of the author may not be used to endorse or promote products derived from this software without - specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, - BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. + [The "BSD licence"] + Copyright (c) 2017 Sasa Coh, Michał Błotniak + Copyright (c) 2019 Ivan Kochurkin, kvanttt@gmail.com, Positive Technologies + Copyright (c) 2019 Dmitry Rassadin, flipparassa@gmail.com, Positive Technologies + Copyright (c) 2021 Martin Mirchev, mirchevmartin2203@gmail.com + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. The name of the author may not be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index 1efd6d496..4996e5155 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -1,3 +1,9 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. +// +// Copyright (c) 2011-2023 ETH Zurich. + package viper.gobra.frontend import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential, TaskManagerMode} From a45f58c62027502ead246e2245d477ce957b2e93 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 9 Mar 2023 15:12:10 +0100 Subject: [PATCH 06/54] fixes license headers --- src/main/antlr4/GoParser.g4 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/antlr4/GoParser.g4 b/src/main/antlr4/GoParser.g4 index 273ed8336..ca03f1108 100644 --- a/src/main/antlr4/GoParser.g4 +++ b/src/main/antlr4/GoParser.g4 @@ -27,7 +27,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ +*/ /* * A Go grammar for ANTLR 4 derived from the Go Language Specification https://golang.org/ref/spec From a2b9b6c1e0ccc1cb4169bac6f1691848cac144f3 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Fri, 10 Mar 2023 15:43:46 +0100 Subject: [PATCH 07/54] adds PPackage caching to parser --- .../scala/viper/gobra/frontend/Parser.scala | 107 ++++++++++-------- .../viper/gobra/frontend/TaskManager.scala | 3 + .../viper/gobra/frontend/info/Info.scala | 25 +++- 3 files changed, 84 insertions(+), 51 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index 1e2a87f69..5c0aa220b 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -20,34 +20,38 @@ import org.antlr.v4.runtime.atn.PredictionMode import org.antlr.v4.runtime.misc.ParseCancellationException import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} +import viper.gobra.frontend.info.Info.{getCacheKey, typeInfoCache} import viper.gobra.util.GobraExecutionContext import viper.silver.ast.SourcePosition import scala.collection.mutable.ListBuffer import java.security.MessageDigest import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} +import scala.concurrent.duration.Duration +import scala.concurrent.{Await, Future} object Parser { type ParseSuccessResult = (Vector[Source], PPackage) type ParseResult = Either[Vector[VerifierError], ParseSuccessResult] + class ParseManager(config: Config, executionContext: GobraExecutionContext) extends LazyLogging { - private val manager = new TaskManager[AbstractPackage, ParseResult](TaskManagerMode.Parallel) + private val manager = new TaskManager[AbstractPackage, Future[ParseResult]](TaskManagerMode.Parallel) - def parse(pkgInfo: PackageInfo): Unit = { + def parse(pkgInfo: PackageInfo): ParseResult = { val pkg = RegularPackage(pkgInfo.id) val parseJob = ParseInfoJob(pkgInfo) manager.addIfAbsent(pkg, parseJob)(executionContext) // trigger and wait for parsing of at least this package (which will ensure that parse jobs for all dependent packages are created too) - manager.getResult(pkg) + Await.result(manager.getResult(pkg), Duration.Inf) } - trait ParseJob extends Job[ParseResult] { + trait ParseJob extends Job[Future[ParseResult]] { def pkgInfo: PackageInfo def pkgSources: Vector[Source] def specOnly: Boolean - override def compute(): ParseResult = { + override def compute(): Future[ParseResult] = { require(pkgSources.nonEmpty) val preprocessedSources = preprocess(pkgSources)(config) @@ -56,15 +60,17 @@ object Parser { // before parsing, get imports and add these parse jobs val imports = fastParse(preprocessedSources) val preambleParsingDurationMs = System.currentTimeMillis() - startPreambleParsingMs - imports.foreach(directImportTarget => { + val futs = imports.map(directImportTarget => { val directImportPackage = AbstractPackage(directImportTarget)(config) val importedSources = PackageResolver.resolveSources(directImportTarget)(config) .getOrElse(Vector()) .map(_.source) if (importedSources.isEmpty) { manager.addIfAbsent(directImportPackage, ParseFailureJob(Vector(NotFoundError(s"No source files for package '$directImportTarget found"))))(executionContext) + manager.getFuture(directImportPackage) // we do not flatten here as we only need to await the job's creation } else { manager.addIfAbsent(directImportPackage, ParseSourcesJob(importedSources, directImportPackage))(executionContext) + manager.getFuture(directImportPackage) // we do not flatten here as we only need to await the job's creation } }) @@ -80,7 +86,9 @@ object Parser { s"parsing ${pkgInfo.id} done (took ${parsingDurationS}s; parsing preamble overhead is ${preambleParsingRatio}%)" } - res + implicit val executor: GobraExecutionContext = executionContext + Future.sequence(futs) + .map(_ => res) } private def fastParse(preprocessedInput: Vector[Source]): Set[AbstractImport] = { @@ -109,12 +117,16 @@ object Parser { lazy val specOnly: Boolean = true } - case class ParseFailureJob(errs: Vector[NotFoundError]) extends Job[ParseResult] { - override def compute(): ParseResult = Left(errs) + case class ParseFailureJob(errs: Vector[NotFoundError]) extends Job[Future[ParseResult]] { + override def compute(): Future[ParseResult] = Future.successful[ParseResult](Left(errs)) } def getParseResults(executionContext: GobraExecutionContext): Either[Map[AbstractPackage, Vector[VerifierError]], Map[AbstractPackage, ParseSuccessResult]] = { - val (failedResults, successfulResults) = manager.getAllResultsWithKeys(executionContext) + implicit val executor: GobraExecutionContext = executionContext + // val futs = manager.getAllResultsWithKeys(executionContext).map { case (key, fut) => fut.map(res => (key, res)) } + val futs = manager.getAllFutures.map { case (key, fut) => fut.flatten.map(res => (key, res)) } + val results = Await.result(Future.sequence(futs), Duration.Inf) + val (failedResults, successfulResults) = results .partitionMap { case (key, eitherResult) => eitherResult.fold[Either[(AbstractPackage, Vector[VerifierError]), (AbstractPackage, ParseSuccessResult)]](errs => Left((key, errs)), result => Right((key, result))) } if (failedResults.isEmpty) Right(successfulResults.toMap) else Left(failedResults.toMap) @@ -168,11 +180,18 @@ object Parser { parser.parse(parser.preamble) } + var cacheHit: Boolean = true def parseSourceCached(preprocessedSource: Source): Either[Vector[ParserError], PPreamble] = { - def parseAndStore(): Either[Vector[ParserError], PPreamble] = + def parseAndStore(): Either[Vector[ParserError], PPreamble] = { + cacheHit = false parseSource(preprocessedSource) + } - preambleCache.computeIfAbsent(getCacheKey(preprocessedSource, specOnly = true), _ => parseAndStore()) + val res = preambleCache.computeIfAbsent(getCacheKey(preprocessedSource, specOnly = true), _ => parseAndStore()) + if (!cacheHit) { + println(s"No cache hit for ${res.map(_.packageClause.id.name)}'s preamble") + } + res } if (config.cacheParser) parseSourceCached(preprocessedSource) else parseSource(preprocessedSource) @@ -193,9 +212,10 @@ object Parser { } type SourceCacheKey = String - // cache maps a key (obtained by hasing file path and file content) to the parse result - private val sourceCache: ConcurrentMap[SourceCacheKey, (Either[Vector[ParserError], PProgram], Positions)] = new ConcurrentHashMap() + // cache maps a key (obtained by hashing file path and file content) to the parse result private val preambleCache: ConcurrentMap[SourceCacheKey, Either[Vector[ParserError], PPreamble]] = new ConcurrentHashMap() + type PackageCacheKey = String + private val packageCache: ConcurrentMap[PackageCacheKey, Either[Vector[VerifierError], PPackage]] = new ConcurrentHashMap() /** computes the key for caching a particular source. This takes the name, the specOnly flag, and the file's contents into account */ private def getCacheKey(source: Source, specOnly: Boolean): SourceCacheKey = { @@ -205,12 +225,37 @@ object Parser { bytes.map { "%02x".format(_) }.mkString } + private def getPackageCacheKey(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean): PackageCacheKey = { + val key = sources.map(source => source.name ++ source.content).mkString("") ++ pkgInfo.hashCode.toString ++ (if (specOnly) "1" else "0") + val bytes = MessageDigest.getInstance("MD5").digest(key.getBytes) + // convert `bytes` to a hex string representation such that we get equality on the key while performing cache lookups + bytes.map { "%02x".format(_) }.mkString + } + def flushCache(): Unit = { - sourceCache.clear() preambleCache.clear() + packageCache.clear() } private def parseSources(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { + def parseSourcesCached(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { + var cacheHit: Boolean = true + val res = packageCache.computeIfAbsent(getPackageCacheKey(sources, pkgInfo, specOnly), _ => { + cacheHit = false + parseSourcesUncached(sources, pkgInfo, specOnly)(config) + }) + if (!cacheHit) { + println(s"No cache hit for package ${pkgInfo.id}") + } + res + } + + val parseFn = if (config.cacheParser) { parseSourcesCached _ } else { parseSourcesUncached _ } + parseFn(sources, pkgInfo, specOnly)(config) + } + + /** parses a package not taking the package cache but only the program cache into account */ + private def parseSourcesUncached(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { val positions = new Positions val pom = new PositionManager(positions) lazy val rewriter = new PRewriter(pom.positions) @@ -230,35 +275,6 @@ object Parser { } } - def parseSourceCached(source: Source): Either[Vector[ParserError], PProgram] = { - var cacheHit = true - def parseAndStore(): (Either[Vector[ParserError], PProgram], Positions) = { - cacheHit = false - val res = parseSource(source) - // sourceCache.put(getCacheKey(source, specOnly), (res, positions)) - (res, positions) - } - // val (res, pos) = sourceCache.getOrElse(getCacheKey(source, specOnly), parseAndStore()) - val (res, pos) = sourceCache.computeIfAbsent(getCacheKey(source, specOnly), _ => parseAndStore()) - if (cacheHit) { - // a cached AST has been found in the cache. The position manager does not yet have any positions for nodes in - // this AST. Therefore, the following strategy iterates over the entire AST and copies positional information - // from the cached positions to the position manager - val copyPosStrategy = strategyWithName[Any]("copyPositionInformation", { - case n: PNode => - val start = pos.getStart(n) - val finish = pos.getFinish(n) - start.foreach(positions.setStart(n, _)) - finish.foreach(positions.setFinish(n, _)) - Some(n): Option[Any] - case n => Some(n) - }) - res.map(prog => rewrite(topdown(copyPosStrategy))(prog)) - } else { - res - } - } - def isErrorFree(parserResults: Vector[Either[Vector[ParserError], PProgram]]): Either[Vector[ParserError], Vector[PProgram]] = { val (errors, programs) = parserResults.partitionMap(identity) if (errors.isEmpty) Right(programs) else Left(errors.flatten) @@ -290,8 +306,7 @@ object Parser { Right(parsedPackage) } - val parsingFn = if (config.cacheParser) { parseSourceCached _ } else { parseSource _ } - val parsedPrograms = sources.map(parsingFn) + val parsedPrograms = sources.map(parseSource) val res = for { // check that each of the parsed programs has the same package clause. If not, the algorithm collecting all files diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index 4996e5155..ec258a513 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -105,6 +105,9 @@ class TaskManager[K, R](mode: TaskManagerMode) { job.getFuture } + def getAllFutures: Iterable[(K, Future[R])] = + jobs.asScala.toVector.map { case (key, job) => (key, job.getFuture) } + def getResult(id: K): R = { val job = jobs.get(id) Violation.violation(job != null, s"Task $id not found") diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 561456e58..8dff14b00 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -260,13 +260,23 @@ object Info extends LazyLogging { private val typeInfoCache: ConcurrentMap[TypeInfoCacheKey, TypeInfoImpl] = new ConcurrentHashMap() private def getCacheKey(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoCacheKey = { - // type-checking depends on `typeBounds` and `enableLazyImport` - val key = pkg.hashCode().toString ++ - dependentTypeInfo.hashCode().toString ++ - (if (isMainContext) "1" else "0") ++ - config.typeBounds.hashCode().toString ++ + // the cache key only depends on config's `typeBounds` and `enableLazyImport` + val pkgKey = pkg.hashCode().toString + // the computed key must be deterministic! + val dependentTypeInfoKey = dependentTypeInfo + .toVector + .map { case (pkg, fn) => pkg.hashCode().toString ++ fn().hashCode().toString } + .sorted + .mkString("") + val isMainContextKey = if (isMainContext) "1" else "0" + val configKey = config.typeBounds.hashCode().toString ++ (if (config.enableLazyImports) "1" else "0") + val key = pkgKey ++ + dependentTypeInfoKey ++ + isMainContextKey ++ + configKey + val bytes = MessageDigest.getInstance("MD5").digest(key.getBytes) // convert `bytes` to a hex string representation such that we get equality on the key while performing cache lookups bytes.map { "%02x".format(_) }.mkString @@ -277,7 +287,9 @@ object Info extends LazyLogging { } def checkSources(sources: Vector[Source], pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean = false)(config: Config): TypeCheckResult = { + var cacheHit: Boolean = true def getTypeInfo(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoImpl = { + cacheHit = false val tree = new GoTree(pkg) new TypeInfoImpl(tree, dependentTypeInfo, isMainContext)(config: Config) } @@ -288,6 +300,9 @@ object Info extends LazyLogging { val checkFn = if (config.cacheParser) { getTypeInfoCached _ } else { getTypeInfo _ } val info = checkFn(pkg, dependentTypeInfo, isMainContext, config) + if (!cacheHit) { + println(s"No cache hit for type info for ${pkg.info.id}") + } val errors = info.errors From 04874c9e641438d02e399b39b3bc8401dda35ce4 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Fri, 10 Mar 2023 16:02:12 +0100 Subject: [PATCH 08/54] fixes a unit test --- .../gobra/ast/frontend/PrettyPrinter.scala | 17 ++++++++++++++--- .../scala/viper/gobra/frontend/Desugar.scala | 4 ++-- .../features/errors/error-fail2.gobra | 2 +- 3 files changed, 17 insertions(+), 6 deletions(-) diff --git a/src/main/scala/viper/gobra/ast/frontend/PrettyPrinter.scala b/src/main/scala/viper/gobra/ast/frontend/PrettyPrinter.scala index eaddcec2b..a3de74798 100644 --- a/src/main/scala/viper/gobra/ast/frontend/PrettyPrinter.scala +++ b/src/main/scala/viper/gobra/ast/frontend/PrettyPrinter.scala @@ -24,6 +24,7 @@ class DefaultPrettyPrinter extends PrettyPrinter with kiama.output.PrettyPrinter def show(node: PNode): Doc = node match { case n: PPackage => showPackage(n) case n: PProgram => showProgram(n) + case n: PPreamble => showPreamble(n) case n: PPackageClause => showPackageClause(n) case n: PImport => showImport(n) case n: PMember => showMember(n) @@ -61,12 +62,22 @@ class DefaultPrettyPrinter extends PrettyPrinter with kiama.output.PrettyPrinter def showProgram(p: PProgram): Doc = p match { case PProgram(packageClause, progPosts, imports, declarations) => - vcat(progPosts.map("initEnsures" <+> showExpr(_))) <> - showPackageClause(packageClause) <> line <> line <> - ssep(imports map showImport, line) <> line <> + showPreamble(packageClause, progPosts, imports) <> ssep(declarations map showMember, line <> line) <> line } + // preamble + + def showPreamble(p: PPreamble): Doc = p match { + case PPreamble(packageClause, progPosts, imports) => + showPreamble(packageClause, progPosts, imports) + } + + private def showPreamble(packageClause: PPackageClause, progPosts: Vector[PExpression], imports: Vector[PImport]): Doc = + vcat(progPosts.map("initEnsures" <+> showExpr(_))) <> + showPackageClause(packageClause) <> line <> line <> + ssep(imports map showImport, line) <> line + // package def showPackageClause(node: PPackageClause): Doc = "package" <+> showPackageId(node.id) diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index d19d044d8..96a56fdc4 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -56,7 +56,7 @@ object Desugar extends LazyLogging { // registers main package to generate proof obligations for its init code mainDesugarer.registerMainPackage(pkg, importsCollector)(config) val res = (mainDesugarer, mainDesugarer.packageD(pkg)) - logger.debug { + logger.trace { val durationS = f"${(System.currentTimeMillis() - mainDesugaringStartMs) / 1000f}%.1f" s"desugaring package ${info.pkgInfo.id} done, took ${durationS}s" } @@ -68,7 +68,7 @@ object Desugar extends LazyLogging { val futResults = Await.result(allPackagesFut, Duration.Inf) val (mainDesugarer, mainProgram) = futResults.head val importedPrograms = futResults.tail - logger.debug { + logger.trace { val importedDurationS = f"${importeDesugaringDurationMs.get() / 1000f}%.1f" s"desugaring imported packages done, took ${importedDurationS}s" } diff --git a/src/test/resources/regressions/features/errors/error-fail2.gobra b/src/test/resources/regressions/features/errors/error-fail2.gobra index ec9936e10..e810d3ed8 100644 --- a/src/test/resources/regressions/features/errors/error-fail2.gobra +++ b/src/test/resources/regressions/features/errors/error-fail2.gobra @@ -3,7 +3,7 @@ package pkg -// ##(-I src/test/resources/regressions/features/errors) +// ##(-I ./) import . "bar" func foo(e error) int { From 53453f046da217a20fac34399c8300f28ab89794 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Mon, 13 Mar 2023 14:21:29 +0100 Subject: [PATCH 09/54] restricts unit tests to 'regressions/features/header_only' --- src/test/scala/viper/gobra/GobraTests.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index a719e5a26..8f6d88980 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -24,7 +24,7 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { val regressionsPropertyName = "GOBRATESTS_REGRESSIONS_DIR" - val regressionsDir: String = System.getProperty(regressionsPropertyName, "regressions") + val regressionsDir: String = System.getProperty(regressionsPropertyName, "regressions/features/header_only") val testDirectories: Seq[String] = Vector(regressionsDir) override val defaultTestPattern: String = PackageResolver.inputFilePattern From 9edc26ece388cd170e727638514bd502685bacdb Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 14 Mar 2023 08:54:47 +0100 Subject: [PATCH 10/54] propagates parsing exceptions, built-in files are always considered even with enabled --- .../viper/gobra/frontend/PackageResolver.scala | 15 ++++++++++++--- .../scala/viper/gobra/frontend/TaskManager.scala | 11 +++++++++-- src/test/scala/viper/gobra/GobraTests.scala | 2 +- 3 files changed, 22 insertions(+), 6 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/PackageResolver.scala b/src/main/scala/viper/gobra/frontend/PackageResolver.scala index 58e43da5d..c766fcd41 100644 --- a/src/main/scala/viper/gobra/frontend/PackageResolver.scala +++ b/src/main/scala/viper/gobra/frontend/PackageResolver.scala @@ -249,7 +249,8 @@ object PackageResolver { lazy val shouldBeConsidered = !shouldIgnoreResource(resource) // note that the following condition has to be lazily evaluated to avoid reading the file's content and applying // a regex. The first part in particular can fail when the file does not contain text! - lazy val headerIsMissing = onlyFilesWithHeader && !isResourceWithHeader(resource) + // Note that that we do not enforce the header for builtin resources (even if onlyFilesWithHeader is set to true) + lazy val headerIsMissing = onlyFilesWithHeader && !resource.builtin && !isResourceWithHeader(resource) if (validExtension && shouldBeConsidered && !headerIsMissing) Vector(resource) else Vector() } else { Vector() @@ -268,8 +269,14 @@ object PackageResolver { * Returns right with the package name used in the package clause if they do, otherwise returns left with an error message */ private def checkPackageClauses(files: Vector[InputResource], importTarget: AbstractImport): Either[String, String] = { + def isEmpty(files: Vector[InputResource]): Either[String, Vector[InputResource]] = { + if (files.isEmpty) Left(s"No files belonging to package $importTarget found") + else Right(files) + } + // importPath is only used to create an error message that is similar to the error message of the official Go compiler def getPackageClauses(files: Vector[InputResource]): Either[String, Vector[(InputResource, String)]] = { + require(files.nonEmpty) val pkgClauses = files.map(f => { getPackageClause(f.asSource()) match { case Some(pkgClause) => Right(f -> pkgClause) @@ -282,6 +289,7 @@ object PackageResolver { } def isEqual(pkgClauses: Vector[(InputResource, String)]): Either[String, String] = { + require(pkgClauses.nonEmpty) val differingClauses = pkgClauses.filter(_._2 != pkgClauses.head._2) if (differingClauses.isEmpty) Right(pkgClauses.head._2) else { @@ -291,7 +299,8 @@ object PackageResolver { } for { - pkgClauses <- getPackageClauses(files) + nonEmptyFiles <- isEmpty(files) + pkgClauses <- getPackageClauses(nonEmptyFiles) pkgName <- isEqual(pkgClauses) } yield pkgName } @@ -349,7 +358,7 @@ object PackageResolver { override def listContent(): Vector[FileResource] = { Files.newDirectoryStream(path).asScala.toVector - .map(p => FileResource(p)) + .map(p => FileResource(p, builtin)) } override def asSource(): FromFileSource = FromFileSource(path, builtin) diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index ec258a513..b7aa0f271 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -36,8 +36,15 @@ trait Job[R] { } Violation.violation(!compututationStarted, s"Job $this is already on-going") compututationStarted = true - val res = compute() - promise.success(res) + val res = try { + val res = compute() + promise.success(res) + res + } catch { + case e: Exception => + promise.failure(e) + throw e + } res } // } diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index 8f6d88980..710c116af 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -48,7 +48,7 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { override def run(input: AnnotatedTestInput): Seq[AbstractOutput] = { - val source = FromFileSource(input.file); + val source = FromFileSource(input.file) val config = Config( logLevel = Level.INFO, reporter = NoopReporter, From 66f542d33377c3b39e308685bbae8f5d0e89c357 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 14 Mar 2023 08:56:09 +0100 Subject: [PATCH 11/54] Revert "restricts unit tests to 'regressions/features/header_only'" This reverts commit 53453f046da217a20fac34399c8300f28ab89794. --- src/test/scala/viper/gobra/GobraTests.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index 710c116af..efa898916 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -24,7 +24,7 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { val regressionsPropertyName = "GOBRATESTS_REGRESSIONS_DIR" - val regressionsDir: String = System.getProperty(regressionsPropertyName, "regressions/features/header_only") + val regressionsDir: String = System.getProperty(regressionsPropertyName, "regressions") val testDirectories: Seq[String] = Vector(regressionsDir) override val defaultTestPattern: String = PackageResolver.inputFilePattern From 3ed1598d9fcec2e4ac303e56f49d62b7b261336c Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 14 Mar 2023 17:36:43 +0100 Subject: [PATCH 12/54] fixes unit tests --- .../gobra/frontend/PackageResolver.scala | 6 +-- .../scala/viper/gobra/frontend/Parser.scala | 49 ++++++++++++------- .../viper/gobra/frontend/info/Info.scala | 2 +- .../viper/gobra/reporting/VerifierError.scala | 3 +- .../import/cyclic_import/bar/bar.gobra | 2 +- .../import/cyclic_import/foo/foo.gobra | 2 +- .../regressions/features/import/import1.gobra | 11 ++++- .../regressions/features/import/import2.gobra | 2 +- .../regressions/features/import/import4.gobra | 20 -------- .../features/stubs/stubs-fail0.gobra | 2 +- 10 files changed, 48 insertions(+), 51 deletions(-) delete mode 100644 src/test/resources/regressions/features/import/import4.gobra diff --git a/src/main/scala/viper/gobra/frontend/PackageResolver.scala b/src/main/scala/viper/gobra/frontend/PackageResolver.scala index c766fcd41..962dd3718 100644 --- a/src/main/scala/viper/gobra/frontend/PackageResolver.scala +++ b/src/main/scala/viper/gobra/frontend/PackageResolver.scala @@ -42,7 +42,7 @@ object PackageResolver { sealed trait AbstractPackage /** represents an error */ - case object NoPackage extends AbstractPackage + case class NoPackage(importTarget: RegularImport) extends AbstractPackage /** represents all built-in packages together */ case object BuiltInPackage extends AbstractPackage /** represents a regular package */ @@ -54,11 +54,11 @@ object PackageResolver { case BuiltInImport => BuiltInPackage case imp: RegularImport => getLookupPath(imp)(config) match { - case Left(_) => NoPackage + case Left(_) => NoPackage(imp) case Right(inputResource) => try { RegularPackage(Source.uniquePath(inputResource.path, config.projectRoot).toString) - } catch { case _: Throwable => NoPackage } + } catch { case _: Throwable => NoPackage(imp) } } } } diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index 5c0aa220b..97447e363 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -60,19 +60,19 @@ object Parser { // before parsing, get imports and add these parse jobs val imports = fastParse(preprocessedSources) val preambleParsingDurationMs = System.currentTimeMillis() - startPreambleParsingMs - val futs = imports.map(directImportTarget => { + val futs = imports.map{ case (directImportTarget, optSourcePos) => { val directImportPackage = AbstractPackage(directImportTarget)(config) val importedSources = PackageResolver.resolveSources(directImportTarget)(config) .getOrElse(Vector()) .map(_.source) if (importedSources.isEmpty) { - manager.addIfAbsent(directImportPackage, ParseFailureJob(Vector(NotFoundError(s"No source files for package '$directImportTarget found"))))(executionContext) + manager.addIfAbsent(directImportPackage, ParseFailureJob(Vector(NotFoundError(s"No source files for package '$directImportTarget' found", optSourcePos))))(executionContext) manager.getFuture(directImportPackage) // we do not flatten here as we only need to await the job's creation } else { manager.addIfAbsent(directImportPackage, ParseSourcesJob(importedSources, directImportPackage))(executionContext) manager.getFuture(directImportPackage) // we do not flatten here as we only need to await the job's creation } - }) + }} val startMs = System.currentTimeMillis() val res = for { @@ -91,16 +91,27 @@ object Parser { .map(_ => res) } - private def fastParse(preprocessedInput: Vector[Source]): Set[AbstractImport] = { - def getImportPaths(preprocessedSource: Source): Set[AbstractImport] = { + private def fastParse(preprocessedInput: Vector[Source]): Set[(AbstractImport, Option[SourcePosition])] = { + def getImportPaths(preprocessedSource: Source): Set[(RegularImport, Option[SourcePosition])] = { processPreamble(preprocessedSource)(config) - .map(_.imports.toSet.map[AbstractImport](importNode => RegularImport(importNode.importPath))) - // we do not handle parser errors here but defer this to the time point when we actually - // parse this source + .map(preambleManager => { + preambleManager.preamble.imports + .map(importNode => { + val nodeStart = preambleManager.pom.positions.getStart(importNode) + val nodeFinish = preambleManager.pom.positions.getFinish(importNode) + val nodePos = (nodeStart, nodeFinish) match { + case (Some(start), Some(finish)) => Some(preambleManager.pom.translate(start, finish)) + case _ => None + } + (RegularImport(importNode.importPath), nodePos) + }) + .toSet + }) .getOrElse(Set.empty) } - preprocessedInput.flatMap(getImportPaths).toSet + BuiltInImport + val builtInImportTuple = (BuiltInImport, None) + preprocessedInput.flatMap(getImportPaths).toSet + builtInImportTuple } } @@ -167,29 +178,29 @@ object Parser { sources } + case class PreambleManager(preamble: PPreamble, pom: PositionManager) /** * Parses a source's preamble containing all (file-level) imports; This function expects that the input has already * been preprocessed */ - private def processPreamble(preprocessedSource: Source)(config: Config): Either[Vector[ParserError], PPreamble] = { - val positions = new Positions - val pom = new PositionManager(positions) - - def parseSource(preprocessedSource: Source): Either[Vector[ParserError], PPreamble] = { + private def processPreamble(preprocessedSource: Source)(config: Config): Either[Vector[ParserError], PreambleManager] = { + def parseSource(preprocessedSource: Source): Either[Vector[ParserError], PreambleManager] = { + val positions = new Positions + val pom = new PositionManager(positions) val parser = new SyntaxAnalyzer[PreambleContext, PPreamble](preprocessedSource, ListBuffer.empty[ParserError], pom, specOnly = true) - parser.parse(parser.preamble) + parser.parse(parser.preamble).map(preamble => PreambleManager(preamble, pom)) } var cacheHit: Boolean = true - def parseSourceCached(preprocessedSource: Source): Either[Vector[ParserError], PPreamble] = { - def parseAndStore(): Either[Vector[ParserError], PPreamble] = { + def parseSourceCached(preprocessedSource: Source): Either[Vector[ParserError], PreambleManager] = { + def parseAndStore(): Either[Vector[ParserError], PreambleManager] = { cacheHit = false parseSource(preprocessedSource) } val res = preambleCache.computeIfAbsent(getCacheKey(preprocessedSource, specOnly = true), _ => parseAndStore()) if (!cacheHit) { - println(s"No cache hit for ${res.map(_.packageClause.id.name)}'s preamble") + println(s"No cache hit for ${res.map(_.preamble.packageClause.id.name)}'s preamble") } res } @@ -213,7 +224,7 @@ object Parser { type SourceCacheKey = String // cache maps a key (obtained by hashing file path and file content) to the parse result - private val preambleCache: ConcurrentMap[SourceCacheKey, Either[Vector[ParserError], PPreamble]] = new ConcurrentHashMap() + private val preambleCache: ConcurrentMap[SourceCacheKey, Either[Vector[ParserError], PreambleManager]] = new ConcurrentHashMap() type PackageCacheKey = String private val packageCache: ConcurrentMap[PackageCacheKey, Either[Vector[VerifierError], PPackage]] = new ConcurrentHashMap() diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 8dff14b00..5a68b034e 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -300,7 +300,7 @@ object Info extends LazyLogging { val checkFn = if (config.cacheParser) { getTypeInfoCached _ } else { getTypeInfo _ } val info = checkFn(pkg, dependentTypeInfo, isMainContext, config) - if (!cacheHit) { + if (!cacheHit && config.cacheParser) { println(s"No cache hit for type info for ${pkg.info.id}") } diff --git a/src/main/scala/viper/gobra/reporting/VerifierError.scala b/src/main/scala/viper/gobra/reporting/VerifierError.scala index 858c2f2ae..3798941c1 100644 --- a/src/main/scala/viper/gobra/reporting/VerifierError.scala +++ b/src/main/scala/viper/gobra/reporting/VerifierError.scala @@ -28,8 +28,7 @@ sealed trait VerifierError { var cached: Boolean = false } -case class NotFoundError(message: String) extends VerifierError { - val position: Option[SourcePosition] = None +case class NotFoundError(message: String, position: Option[SourcePosition]) extends VerifierError { val id = "not_found_error" } diff --git a/src/test/resources/regressions/features/import/cyclic_import/bar/bar.gobra b/src/test/resources/regressions/features/import/cyclic_import/bar/bar.gobra index 443776192..4c2bacd2d 100644 --- a/src/test/resources/regressions/features/import/cyclic_import/bar/bar.gobra +++ b/src/test/resources/regressions/features/import/cyclic_import/bar/bar.gobra @@ -3,7 +3,7 @@ package bar -// ##(-I src/test/resources/regressions/features/import/cyclic_import) +// ##(-I ../) //:: ExpectedOutput(type_error) import f "foo" // this is a cyclic import diff --git a/src/test/resources/regressions/features/import/cyclic_import/foo/foo.gobra b/src/test/resources/regressions/features/import/cyclic_import/foo/foo.gobra index 8d4600ecc..d6708a3d0 100644 --- a/src/test/resources/regressions/features/import/cyclic_import/foo/foo.gobra +++ b/src/test/resources/regressions/features/import/cyclic_import/foo/foo.gobra @@ -3,7 +3,7 @@ package foo -// ##(-I src/test/resources/regressions/features/import/cyclic_import) +// ##(-I ../) //:: ExpectedOutput(type_error) import b "bar" // this is a cyclic import diff --git a/src/test/resources/regressions/features/import/import1.gobra b/src/test/resources/regressions/features/import/import1.gobra index 31810b7ec..7e8ebbc08 100644 --- a/src/test/resources/regressions/features/import/import1.gobra +++ b/src/test/resources/regressions/features/import/import1.gobra @@ -4,20 +4,27 @@ package main import fmt "fmt" +//:: ExpectedOutput(not_found_error) import a "a"; +//:: ExpectedOutput(not_found_error) import (b "b") +//:: ExpectedOutput(not_found_error) import (c "c"); import ( + //:: ExpectedOutput(not_found_error) d "d" + //:: ExpectedOutput(not_found_error) e "e") import ( + //:: ExpectedOutput(not_found_error) f "f" + //:: ExpectedOutput(not_found_error) g "g" ) -import math "lib/math" -//:: ExpectedOutput(type_error) +//:: ExpectedOutput(not_found_error) import m "lib/mathm" // wrong package name used on purpose such that this test case does not potentially depend on the configured Go path +//:: ExpectedOutput(not_found_error) import . "lib/mathn" func test() { diff --git a/src/test/resources/regressions/features/import/import2.gobra b/src/test/resources/regressions/features/import/import2.gobra index 5e99934f1..33bad9c88 100644 --- a/src/test/resources/regressions/features/import/import2.gobra +++ b/src/test/resources/regressions/features/import/import2.gobra @@ -3,7 +3,7 @@ package main -//:: ExpectedOutput(type_error) +//:: ExpectedOutput(not_found_error) import math "lib/mathm" // wrong package name used on purpose such that this test case does not potentially depend on the configured Go path type cell struct{ diff --git a/src/test/resources/regressions/features/import/import4.gobra b/src/test/resources/regressions/features/import/import4.gobra deleted file mode 100644 index afa6dcd58..000000000 --- a/src/test/resources/regressions/features/import/import4.gobra +++ /dev/null @@ -1,20 +0,0 @@ -// Any copyright is dedicated to the Public Domain. -// http://creativecommons.org/publicdomain/zero/1.0/ - -package main - -//:: ExpectedOutput(parser_error) -import "a" -//:: ExpectedOutput(parser_error) -import ("b") -//:: ExpectedOutput(parser_error) -import ("c"); -import ( - //:: ExpectedOutput(parser_error) - "d" - e "e") -import ( - f "f" - //:: ExpectedOutput(parser_error) - "g" -) diff --git a/src/test/resources/regressions/features/stubs/stubs-fail0.gobra b/src/test/resources/regressions/features/stubs/stubs-fail0.gobra index 02ea982d1..6ee25b286 100644 --- a/src/test/resources/regressions/features/stubs/stubs-fail0.gobra +++ b/src/test/resources/regressions/features/stubs/stubs-fail0.gobra @@ -4,6 +4,6 @@ package main import ( - //:: ExpectedOutput(parser_error) + //:: ExpectedOutput(not_found_error) "nopackagewhatsoever" ) \ No newline at end of file From ba5f161b41b9c0aa8caa89bd69ab7bcd8c5367c6 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 14 Mar 2023 17:59:26 +0100 Subject: [PATCH 13/54] cleans up --- .../scala/viper/gobra/ast/frontend/Ast.scala | 3 +- .../gobra/ast/frontend/PrettyPrinter.scala | 2 +- .../gobra/frontend/ParseTreeTranslator.scala | 2 +- .../scala/viper/gobra/frontend/Parser.scala | 41 +++++++------- .../viper/gobra/frontend/TaskManager.scala | 56 ++++--------------- .../resolution/MemberResolution.scala | 50 ----------------- .../viper/gobra/DetailedBenchmarkTests.scala | 1 - 7 files changed, 36 insertions(+), 119 deletions(-) diff --git a/src/main/scala/viper/gobra/ast/frontend/Ast.scala b/src/main/scala/viper/gobra/ast/frontend/Ast.scala index e6819f68c..eb543ed16 100644 --- a/src/main/scala/viper/gobra/ast/frontend/Ast.scala +++ b/src/main/scala/viper/gobra/ast/frontend/Ast.scala @@ -67,7 +67,8 @@ case class PPreamble( // after this program is initialized initPosts: Vector[PExpression], imports: Vector[PImport], - ) extends PNode with PUnorderedScope // imports are in program scopes + positions: PositionManager, + ) extends PNode with PUnorderedScope class PositionManager(val positions: Positions) extends Messaging(positions) { diff --git a/src/main/scala/viper/gobra/ast/frontend/PrettyPrinter.scala b/src/main/scala/viper/gobra/ast/frontend/PrettyPrinter.scala index a3de74798..1a750fa88 100644 --- a/src/main/scala/viper/gobra/ast/frontend/PrettyPrinter.scala +++ b/src/main/scala/viper/gobra/ast/frontend/PrettyPrinter.scala @@ -69,7 +69,7 @@ class DefaultPrettyPrinter extends PrettyPrinter with kiama.output.PrettyPrinter // preamble def showPreamble(p: PPreamble): Doc = p match { - case PPreamble(packageClause, progPosts, imports) => + case PPreamble(packageClause, progPosts, imports, _) => showPreamble(packageClause, progPosts, imports) } diff --git a/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala b/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala index b498a1db2..c63d3911d 100644 --- a/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala +++ b/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala @@ -2192,7 +2192,7 @@ class ParseTreeTranslator(pom: PositionManager, source: Source, specOnly : Boole val packageClause: PPackageClause = visitNode(ctx.packageClause()) val initPosts: Vector[PExpression] = visitListNode[PExpression](ctx.initPost()) val importDecls = ctx.importDecl().asScala.toVector.flatMap(visitImportDecl) - PPreamble(packageClause, initPosts, importDecls).at(ctx) + PPreamble(packageClause, initPosts, importDecls, pom).at(ctx) } /** diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index 97447e363..f83a56b86 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -7,8 +7,6 @@ package viper.gobra.frontend import com.typesafe.scalalogging.LazyLogging -import org.bitbucket.inkytonik.kiama.rewriting.Cloner.{rewrite, topdown} -import org.bitbucket.inkytonik.kiama.rewriting.PositionedRewriter.strategyWithName import org.bitbucket.inkytonik.kiama.rewriting.{Cloner, PositionedRewriter, Strategy} import org.bitbucket.inkytonik.kiama.util.{Positions, Source} import org.bitbucket.inkytonik.kiama.util.Messaging.{error, message} @@ -20,7 +18,6 @@ import org.antlr.v4.runtime.atn.PredictionMode import org.antlr.v4.runtime.misc.ParseCancellationException import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} -import viper.gobra.frontend.info.Info.{getCacheKey, typeInfoCache} import viper.gobra.util.GobraExecutionContext import viper.silver.ast.SourcePosition @@ -94,13 +91,14 @@ object Parser { private def fastParse(preprocessedInput: Vector[Source]): Set[(AbstractImport, Option[SourcePosition])] = { def getImportPaths(preprocessedSource: Source): Set[(RegularImport, Option[SourcePosition])] = { processPreamble(preprocessedSource)(config) - .map(preambleManager => { - preambleManager.preamble.imports + .map(preamble => { + val pom = preamble.positions + preamble.imports .map(importNode => { - val nodeStart = preambleManager.pom.positions.getStart(importNode) - val nodeFinish = preambleManager.pom.positions.getFinish(importNode) + val nodeStart = pom.positions.getStart(importNode) + val nodeFinish = pom.positions.getFinish(importNode) val nodePos = (nodeStart, nodeFinish) match { - case (Some(start), Some(finish)) => Some(preambleManager.pom.translate(start, finish)) + case (Some(start), Some(finish)) => Some(pom.translate(start, finish)) case _ => None } (RegularImport(importNode.importPath), nodePos) @@ -178,29 +176,28 @@ object Parser { sources } - case class PreambleManager(preamble: PPreamble, pom: PositionManager) /** * Parses a source's preamble containing all (file-level) imports; This function expects that the input has already * been preprocessed */ - private def processPreamble(preprocessedSource: Source)(config: Config): Either[Vector[ParserError], PreambleManager] = { - def parseSource(preprocessedSource: Source): Either[Vector[ParserError], PreambleManager] = { + private def processPreamble(preprocessedSource: Source)(config: Config): Either[Vector[ParserError], PPreamble] = { + def parseSource(preprocessedSource: Source): Either[Vector[ParserError], PPreamble] = { val positions = new Positions val pom = new PositionManager(positions) val parser = new SyntaxAnalyzer[PreambleContext, PPreamble](preprocessedSource, ListBuffer.empty[ParserError], pom, specOnly = true) - parser.parse(parser.preamble).map(preamble => PreambleManager(preamble, pom)) + parser.parse(parser.preamble) } var cacheHit: Boolean = true - def parseSourceCached(preprocessedSource: Source): Either[Vector[ParserError], PreambleManager] = { - def parseAndStore(): Either[Vector[ParserError], PreambleManager] = { + def parseSourceCached(preprocessedSource: Source): Either[Vector[ParserError], PPreamble] = { + def parseAndStore(): Either[Vector[ParserError], PPreamble] = { cacheHit = false parseSource(preprocessedSource) } - val res = preambleCache.computeIfAbsent(getCacheKey(preprocessedSource, specOnly = true), _ => parseAndStore()) + val res = preambleCache.computeIfAbsent(getPreambleCacheKey(preprocessedSource), _ => parseAndStore()) if (!cacheHit) { - println(s"No cache hit for ${res.map(_.preamble.packageClause.id.name)}'s preamble") + println(s"No cache hit for ${res.map(_.packageClause.id.name)}'s preamble") } res } @@ -224,18 +221,22 @@ object Parser { type SourceCacheKey = String // cache maps a key (obtained by hashing file path and file content) to the parse result - private val preambleCache: ConcurrentMap[SourceCacheKey, Either[Vector[ParserError], PreambleManager]] = new ConcurrentHashMap() + private val preambleCache: ConcurrentMap[SourceCacheKey, Either[Vector[ParserError], PPreamble]] = new ConcurrentHashMap() type PackageCacheKey = String + // we cache entire packages and not individual files (i.e. PProgram) as this saves us from copying over positional information + // from one to the other position manager. Also, this transformation of copying positional information results in + // differen PPackage instances that is problematic for caching type-check results. private val packageCache: ConcurrentMap[PackageCacheKey, Either[Vector[VerifierError], PPackage]] = new ConcurrentHashMap() - /** computes the key for caching a particular source. This takes the name, the specOnly flag, and the file's contents into account */ - private def getCacheKey(source: Source, specOnly: Boolean): SourceCacheKey = { - val key = source.name ++ (if (specOnly) "1" else "0") ++ source.content + /** computes the key for caching the preamble of a particular source. This takes the name and the source's content into account */ + private def getPreambleCacheKey(source: Source): SourceCacheKey = { + val key = source.name ++ source.content val bytes = MessageDigest.getInstance("MD5").digest(key.getBytes) // convert `bytes` to a hex string representation such that we get equality on the key while performing cache lookups bytes.map { "%02x".format(_) }.mkString } + /** computes the key for caching a package. This takes the name and the content of each source, the package info and the `specOnly` flag into account */ private def getPackageCacheKey(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean): PackageCacheKey = { val key = sources.map(source => source.name ++ source.content).mkString("") ++ pkgInfo.hashCode.toString ++ (if (specOnly) "1" else "0") val bytes = MessageDigest.getInstance("MD5").digest(key.getBytes) diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index b7aa0f271..83513472a 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -25,62 +25,28 @@ trait Job[R] { private val promise: Promise[R] = Promise() def getFuture: Future[R] = promise.future protected def compute(): R - // private val lock: Object = new AnyRef def call(): R = { - // lock.synchronized { - getFuture.value match { - case Some(Success(res)) => return res // return already computed type-checker result - case Some(Failure(exception)) => Violation.violation(s"Job resulted in exception: $exception") - case _ => - } - Violation.violation(!compututationStarted, s"Job $this is already on-going") - compututationStarted = true - val res = try { - val res = compute() - promise.success(res) - res - } catch { - case e: Exception => - promise.failure(e) - throw e - } - res - } - // } -} - -/* -trait Job[R] extends DependentJob[Nothing, R] { - val dependencies = Set.empty - protected def compute(): R - - override protected def compute(dependentResults: Map[Nothing, R]): R = compute() -} - -trait DependentJob[K, R] { - val dependencies: Set[K] - private val promise: Promise[R] = Promise() - private var compututationStarted = false - - def getFuture: Future[R] = promise.future - - protected def compute(dependentResults: Map[K, R]): R - - def call(dependentResults: Map[K, R]): R = { getFuture.value match { case Some(Success(res)) => return res // return already computed type-checker result case Some(Failure(exception)) => Violation.violation(s"Job resulted in exception: $exception") case _ => } - Violation.violation(!compututationStarted, s"Job is already on-going") + Violation.violation(!compututationStarted, s"Job $this is already on-going") compututationStarted = true - val res = compute(dependentResults) - promise.success(res) + val res = try { + val res = compute() + promise.success(res) + res + } catch { + case e: Exception => + promise.failure(e) + // propagate this exception for the case that `call` is executed synchronously: + throw e + } res } } - */ class TaskManager[K, R](mode: TaskManagerMode) { private val jobs: ConcurrentMap[K, Job[R]] = new ConcurrentHashMap() diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala index 24587317e..614d2e055 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala @@ -402,46 +402,7 @@ trait MemberResolution { this: TypeInfoImpl => ) } - // TODO: move this method to another file def getTypeChecker(importTarget: AbstractImport, errNode: PNode): Either[Messages, ExternalTypeInfo] = { - /* - def parseAndTypeCheck(importTarget: AbstractImport): Either[Vector[VerifierError], ExternalTypeInfo] = { - val pkgSources = PackageResolver.resolveSources(importTarget)(config) - .getOrElse(Vector()) - .map(_.source) - val res = for { - nonEmptyPkgSources <- if (pkgSources.isEmpty) - Left(Vector(NotFoundError(s"No source files for package '$importTarget' found"))) - else Right(pkgSources) - parsedProgram <- Parser.parse(nonEmptyPkgSources, Source.getPackageInfo(nonEmptyPkgSources.head, config.projectRoot), specOnly = true)(config) - // TODO maybe don't check whole file but only members that are actually used/imported - // By parsing only declarations and their specification, there shouldn't be much left to type check anyways - // Info.check would probably need some restructuring to type check only certain members - info <- Info.check(parsedProgram, nonEmptyPkgSources, context)(config) - } yield info - res.fold( - errs => context.addErrenousPackage(importTarget, errs)(config), - info => context.addPackage(importTarget, info)(config) - ) - res - } - */ - /* - def createImportError(errs: Vector[VerifierError]): Messages = { - // create an error message located at the import statement to indicate errors in the imported package - // we distinguish between parse and type errors, cyclic imports, and packages whose source files could not be found - val notFoundErr = errs.collectFirst { case e: NotFoundError => e } - // alternativeErr is a function to compute the message only when needed - - val alternativeErr = () => context.getParserImportCycle(importTarget) match { - case Some(cycle) => - message(errNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") - case _ => message(errNode, s"Package '$importTarget' contains errors: $errs") - } - notFoundErr.map(e => message(errNode, e.message)) - .getOrElse(alternativeErr()) - } - */ def createImportError(errs: Vector[VerifierError]): Messages = { // create an error message located at the import statement to indicate errors in the imported package // we distinguish between regular errors and packages whose source files could not be found (not that cyclic @@ -453,17 +414,6 @@ trait MemberResolution { this: TypeInfoImpl => .getOrElse(alternativeErr()) } - // check if package was already parsed, otherwise do parsing and type checking: - /* - val cachedInfo = context.getTypeInfo(importTarget)(config) - if (cachedInfo.isEmpty) { - println(s"package $importTarget is not contained in context") - } - Violation.violation(cachedInfo.nonEmpty, s"package $importTarget is not contained in context") - cachedInfo.get.left.map(createImportError) - // cachedInfo.getOrElse(parseAndTypeCheck(importTarget)).left.map(createImportError) - */ - // context.getTypeInfo(importTarget)(config).left.map(createImportError) Violation.violation(dependentTypeInfo.contains(importTarget), s"Expected that package ${tree.root.info.id} has access to the type information of package $importTarget") dependentTypeInfo(importTarget)().left.map(createImportError) } diff --git a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala index c7e9ba31f..b5a6fe844 100644 --- a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala +++ b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala @@ -115,7 +115,6 @@ class DetailedBenchmarkTests extends BenchmarkTests { assert(c.packageInfoInputMap.size == 1) val pkgInfo = c.packageInfoInputMap.keys.head Info.check(c, RegularPackage(pkgInfo.id), parseResults)(executor) - // Info.check(parsedPackage, c.packageInfoInputMap(pkgInfo))(c).map(typeInfo => (parsedPackage, typeInfo)) }) private val desugaring: NextStep[TypeInfo, Program, Vector[VerifierError]] = From 169d0914282e52de162be7f801bc2b36c8c4f8d6 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Wed, 15 Mar 2023 19:46:48 +0100 Subject: [PATCH 14/54] fixes parser error messages --- .../scala/viper/gobra/frontend/Parser.scala | 152 ++++++++++++++---- .../viper/gobra/reporting/VerifierError.scala | 3 +- .../features/import/import-fail1.gobra | 10 ++ .../features/import/import-fail2.gobra | 12 ++ .../features/import/import-fail3.gobra | 12 ++ .../invalid_package_clause1.gobra | 4 + .../invalid_package_clause2.gobra | 4 + .../import/parse_error/parse_error.gobra | 8 + .../features/stubs/stubs-fail0.gobra | 9 +- .../features/stubs/stubs-fail1.gobra | 10 -- 10 files changed, 181 insertions(+), 43 deletions(-) create mode 100644 src/test/resources/regressions/features/import/import-fail1.gobra create mode 100644 src/test/resources/regressions/features/import/import-fail2.gobra create mode 100644 src/test/resources/regressions/features/import/import-fail3.gobra create mode 100644 src/test/resources/regressions/features/import/invalid_package_clause/invalid_package_clause1.gobra create mode 100644 src/test/resources/regressions/features/import/invalid_package_clause/invalid_package_clause2.gobra create mode 100644 src/test/resources/regressions/features/import/parse_error/parse_error.gobra delete mode 100644 src/test/resources/regressions/features/stubs/stubs-fail1.gobra diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index f83a56b86..e42c37afc 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -30,7 +30,7 @@ import scala.concurrent.{Await, Future} object Parser { type ParseSuccessResult = (Vector[Source], PPackage) - type ParseResult = Either[Vector[VerifierError], ParseSuccessResult] + type ParseResult = Either[Vector[ParserError], ParseSuccessResult] class ParseManager(config: Config, executionContext: GobraExecutionContext) extends LazyLogging { private val manager = new TaskManager[AbstractPackage, Future[ParseResult]](TaskManagerMode.Parallel) @@ -57,19 +57,50 @@ object Parser { // before parsing, get imports and add these parse jobs val imports = fastParse(preprocessedSources) val preambleParsingDurationMs = System.currentTimeMillis() - startPreambleParsingMs - val futs = imports.map{ case (directImportTarget, optSourcePos) => { + // val importResults: Set[Either[Vector[VerifierError], Future[ParseResult]]] = imports.map{ case (directImportTarget, importErrorFactory) => { + val importResults: Set[Future[ParseResult]] = imports.map { case (directImportTarget, importErrorFactory) => val directImportPackage = AbstractPackage(directImportTarget)(config) + val nonEmptyImportedSources = for { + resolveSourceResults <- PackageResolver.resolveSources(directImportTarget)(config) + importedSources = resolveSourceResults.map(_.source) + nonEmptyImportedSources <- if (importedSources.isEmpty) Left(s"No source files for package '$directImportTarget' found") else Right(importedSources) + } yield nonEmptyImportedSources + + nonEmptyImportedSources.fold( + errMsg => { + val errs = importErrorFactory(errMsg) + manager.addIfAbsent(directImportPackage, ParseFailureJob(errs))(executionContext) + Future.successful(Left(errs)) + }, + nonEmptySources => { + manager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage))(executionContext) + manager.getFuture(directImportPackage).flatten + .map { + case Left(_) => Left(importErrorFactory(s"Imported package contains errors")) + case success => success + }(executionContext) + }) + /* val importedSources = PackageResolver.resolveSources(directImportTarget)(config) .getOrElse(Vector()) .map(_.source) if (importedSources.isEmpty) { - manager.addIfAbsent(directImportPackage, ParseFailureJob(Vector(NotFoundError(s"No source files for package '$directImportTarget' found", optSourcePos))))(executionContext) - manager.getFuture(directImportPackage) // we do not flatten here as we only need to await the job's creation + val errMsg = s"No source files for package '$directImportTarget' found" + manager.addIfAbsent(directImportPackage, ParseFailureJob(Vector(NotFoundError(errMsg))))(executionContext) + Future.successful(Left(importErrorFactory(errMsg))) } else { manager.addIfAbsent(directImportPackage, ParseSourcesJob(importedSources, directImportPackage))(executionContext) - manager.getFuture(directImportPackage) // we do not flatten here as we only need to await the job's creation + manager.getFuture(directImportPackage).flatten + .map { + case Left(errs) => Left(importErrorFactory(s"Imported package contains errors")) + case success => success + }(executionContext) } - }} + */ + } + + // val (importFailures, futs) = importResults.partitionMap(identity) + // val flatImportFailures = importFailures.toVector.flatten val startMs = System.currentTimeMillis() val res = for { @@ -84,32 +115,66 @@ object Parser { } implicit val executor: GobraExecutionContext = executionContext + + Future.sequence(importResults) + .map(dependencyResults => { + val (importErrors, _) = dependencyResults.partitionMap(identity) + val flatImportFailures = importErrors.toVector.flatten + if (flatImportFailures.isEmpty) { + // we only post-process if dependent packages where successful + Parser.postprocess(res, specOnly = specOnly)(config) + } else { + config.reporter report ParserErrorMessage(flatImportFailures.head.position.get.file, flatImportFailures) + Left(flatImportFailures) + } + /* + if (dependencyResults.forall(_.isRight)) { + // we only post-process if dependent packages where successful + Parser.postprocess(res, specOnly = specOnly)(config) + } else { + // we return an empty list of errors not to duplicate errors + Left(Vector.empty) + } + */ + }) + /* Future.sequence(futs) .map(_ => res) + */ } - private def fastParse(preprocessedInput: Vector[Source]): Set[(AbstractImport, Option[SourcePosition])] = { - def getImportPaths(preprocessedSource: Source): Set[(RegularImport, Option[SourcePosition])] = { + type ImportErrorFactory = String => Vector[ParserError] + private def fastParse(preprocessedInput: Vector[Source]): Set[(AbstractImport, ImportErrorFactory)] = { + def getImportPaths(preprocessedSource: Source): Set[(RegularImport, ImportErrorFactory)] = { processPreamble(preprocessedSource)(config) .map(preamble => { val pom = preamble.positions preamble.imports .map(importNode => { - val nodeStart = pom.positions.getStart(importNode) - val nodeFinish = pom.positions.getFinish(importNode) - val nodePos = (nodeStart, nodeFinish) match { - case (Some(start), Some(finish)) => Some(pom.translate(start, finish)) - case _ => None + val importErrorFactory: ImportErrorFactory = (errMsg: String) => { + val err = pom.translate(message(importNode, errMsg), ParserError) + // config.reporter report ParserErrorMessage(err.head.position.get.file, err) + err } - (RegularImport(importNode.importPath), nodePos) + (RegularImport(importNode.importPath), importErrorFactory) }) .toSet }) .getOrElse(Set.empty) } - val builtInImportTuple = (BuiltInImport, None) - preprocessedInput.flatMap(getImportPaths).toSet + builtInImportTuple + val explicitImports: Set[(AbstractImport, ImportErrorFactory)] = preprocessedInput.flatMap(getImportPaths).toSet + if (pkgInfo.isBuiltIn) { + explicitImports + } else { + val builtInImportErrorFactory: ImportErrorFactory = (errMsg: String) => { + val err = Vector(ParserError(errMsg, None)) + config.reporter report ParserErrorMessage(err.head.position.get.file, err) + err + } + val builtInImportTuple = (BuiltInImport, builtInImportErrorFactory) + explicitImports + builtInImportTuple + } } } @@ -126,7 +191,7 @@ object Parser { lazy val specOnly: Boolean = true } - case class ParseFailureJob(errs: Vector[NotFoundError]) extends Job[Future[ParseResult]] { + case class ParseFailureJob(errs: Vector[ParserError]) extends Job[Future[ParseResult]] { override def compute(): Future[ParseResult] = Future.successful[ParseResult](Left(errs)) } @@ -140,6 +205,15 @@ object Parser { if (failedResults.isEmpty) Right(successfulResults.toMap) else Left(failedResults.toMap) } + + def getSuccessResults(executionContext: GobraExecutionContext): Map[AbstractPackage, ParseSuccessResult] = { + implicit val executor: GobraExecutionContext = executionContext + val futs = manager.getAllFutures.map { case (key, fut) => fut.flatten.map(res => (key, res)) } + val results = Await.result(Future.sequence(futs), Duration.Inf) + results + .collect { case (key, Right(res)) => (key, res) } + .toMap + } } /** @@ -160,9 +234,13 @@ object Parser { def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseSuccessResult]] = { val parseManager = new ParseManager(config, executionContext) + /* parseManager.parse(pkgInfo) val res = parseManager.getParseResults(executionContext).left.map(errMap => errMap.values.flatten.toVector) res + */ + val res = parseManager.parse(pkgInfo) + res.map(_ => parseManager.getSuccessResults(executionContext)) } def parse(input: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean = false)(config: Config): Either[Vector[VerifierError], PPackage] = { @@ -205,7 +283,8 @@ object Parser { if (config.cacheParser) parseSourceCached(preprocessedSource) else parseSource(preprocessedSource) } - private def process(preprocessedInputs: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { + private def process(preprocessedInputs: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[ParserError], PPackage] = { + /* for { parseAst <- parseSources(preprocessedInputs, pkgInfo, specOnly = specOnly)(config) postprocessors = Seq( @@ -217,6 +296,23 @@ object Parser { case (e, _) => e } } yield postprocessedAst + */ + parseSources(preprocessedInputs, pkgInfo, specOnly = specOnly)(config) + } + + private def postprocess(processResult: Either[Vector[ParserError], (Vector[Source], PPackage)], specOnly: Boolean)(config: Config): Either[Vector[ParserError], (Vector[Source], PPackage)] = { + for { + successfulProcessResult <- processResult + (preprocessedInputs, parseAst) = successfulProcessResult + postprocessors = Seq( + new ImportPostprocessor(parseAst.positions.positions), + new TerminationMeasurePostprocessor(parseAst.positions.positions, specOnly = specOnly), + ) + postprocessedAst <- postprocessors.foldLeft[Either[Vector[ParserError], PPackage]](Right(parseAst)) { + case (Right(ast), postprocessor) => postprocessor.postprocess(ast)(config) + case (e, _) => e + } + } yield (preprocessedInputs, postprocessedAst) } type SourceCacheKey = String @@ -226,7 +322,7 @@ object Parser { // we cache entire packages and not individual files (i.e. PProgram) as this saves us from copying over positional information // from one to the other position manager. Also, this transformation of copying positional information results in // differen PPackage instances that is problematic for caching type-check results. - private val packageCache: ConcurrentMap[PackageCacheKey, Either[Vector[VerifierError], PPackage]] = new ConcurrentHashMap() + private val packageCache: ConcurrentMap[PackageCacheKey, Either[Vector[ParserError], PPackage]] = new ConcurrentHashMap() /** computes the key for caching the preamble of a particular source. This takes the name and the source's content into account */ private def getPreambleCacheKey(source: Source): SourceCacheKey = { @@ -249,8 +345,8 @@ object Parser { packageCache.clear() } - private def parseSources(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { - def parseSourcesCached(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { + private def parseSources(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[ParserError], PPackage] = { + def parseSourcesCached(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[ParserError], PPackage] = { var cacheHit: Boolean = true val res = packageCache.computeIfAbsent(getPackageCacheKey(sources, pkgInfo, specOnly), _ => { cacheHit = false @@ -267,7 +363,7 @@ object Parser { } /** parses a package not taking the package cache but only the program cache into account */ - private def parseSourcesUncached(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[VerifierError], PPackage] = { + private def parseSourcesUncached(sources: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[ParserError], PPackage] = { val positions = new Positions val pom = new PositionManager(positions) lazy val rewriter = new PRewriter(pom.positions) @@ -388,15 +484,15 @@ object Parser { } } - def postprocess(pkg: PPackage)(config: Config): Either[Vector[VerifierError], PPackage] + def postprocess(pkg: PPackage)(config: Config): Either[Vector[ParserError], PPackage] } private class ImportPostprocessor(override val positions: Positions) extends Postprocessor { /** * Replaces all PQualifiedWoQualifierImport by PQualifiedImport nodes */ - def postprocess(pkg: PPackage)(config: Config): Either[Vector[VerifierError], PPackage] = { - def createError(n: PImplicitQualifiedImport, errorMsg: String): Vector[VerifierError] = { + def postprocess(pkg: PPackage)(config: Config): Either[Vector[ParserError], PPackage] = { + def createError(n: PImplicitQualifiedImport, errorMsg: String): Vector[ParserError] = { val err = pkg.positions.translate(message(n, s"Explicit qualifier could not be derived (reason: '$errorMsg')"), ParserError) config.reporter report ParserErrorMessage(err.head.position.get.file, err) @@ -405,7 +501,7 @@ object Parser { // unfortunately Kiama does not seem to offer a way to report errors while applying the strategy // hence, we keep ourselves track of errors - var failedNodes: Vector[VerifierError] = Vector() + var failedNodes: Vector[ParserError] = Vector() def replace(n: PImplicitQualifiedImport): Option[PExplicitQualifiedImport] = { val qualifier = for { @@ -454,11 +550,11 @@ object Parser { * Note that we do not transform the body of pure functions and pure methods (e.g. by turning the body into a * postcondition) because this would result in a matching loop for recursive functions. */ - def postprocess(pkg: PPackage)(config: Config): Either[Vector[VerifierError], PPackage] = { + def postprocess(pkg: PPackage)(config: Config): Either[Vector[ParserError], PPackage] = { if (specOnly) replaceTerminationMeasures(pkg) else Right(pkg) } - private def replaceTerminationMeasures(pkg: PPackage): Either[Vector[VerifierError], PPackage] = { + private def replaceTerminationMeasures(pkg: PPackage): Either[Vector[ParserError], PPackage] = { def replace(spec: PFunctionSpec): PFunctionSpec = { val replacedMeasures = spec.terminationMeasures.map { case n@PTupleTerminationMeasure(_, cond) => PWildcardMeasure(cond).at(n) diff --git a/src/main/scala/viper/gobra/reporting/VerifierError.scala b/src/main/scala/viper/gobra/reporting/VerifierError.scala index 3798941c1..858c2f2ae 100644 --- a/src/main/scala/viper/gobra/reporting/VerifierError.scala +++ b/src/main/scala/viper/gobra/reporting/VerifierError.scala @@ -28,7 +28,8 @@ sealed trait VerifierError { var cached: Boolean = false } -case class NotFoundError(message: String, position: Option[SourcePosition]) extends VerifierError { +case class NotFoundError(message: String) extends VerifierError { + val position: Option[SourcePosition] = None val id = "not_found_error" } diff --git a/src/test/resources/regressions/features/import/import-fail1.gobra b/src/test/resources/regressions/features/import/import-fail1.gobra new file mode 100644 index 000000000..769bcd13c --- /dev/null +++ b/src/test/resources/regressions/features/import/import-fail1.gobra @@ -0,0 +1,10 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package main + +import ( + // the following package does not exist + //:: ExpectedOutput(parser_error) + "nopackagewhatsoever" +) \ No newline at end of file diff --git a/src/test/resources/regressions/features/import/import-fail2.gobra b/src/test/resources/regressions/features/import/import-fail2.gobra new file mode 100644 index 000000000..d39496255 --- /dev/null +++ b/src/test/resources/regressions/features/import/import-fail2.gobra @@ -0,0 +1,12 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package main + +// ##(-I ./) + +import ( + // note that package `parse_error` contains a parser error so the qualifier cannot be resolved + //:: ExpectedOutput(parser_error) + "parse_error" +) diff --git a/src/test/resources/regressions/features/import/import-fail3.gobra b/src/test/resources/regressions/features/import/import-fail3.gobra new file mode 100644 index 000000000..436d52cd7 --- /dev/null +++ b/src/test/resources/regressions/features/import/import-fail3.gobra @@ -0,0 +1,12 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package main + +// ##(-I ./) + +import ( + // note that `foo` contains a parser error so the qualifier cannot be resolved + //:: ExpectedOutput(parser_error) + "invalid_package_clause" +) diff --git a/src/test/resources/regressions/features/import/invalid_package_clause/invalid_package_clause1.gobra b/src/test/resources/regressions/features/import/invalid_package_clause/invalid_package_clause1.gobra new file mode 100644 index 000000000..5c8815c06 --- /dev/null +++ b/src/test/resources/regressions/features/import/invalid_package_clause/invalid_package_clause1.gobra @@ -0,0 +1,4 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package clause1 diff --git a/src/test/resources/regressions/features/import/invalid_package_clause/invalid_package_clause2.gobra b/src/test/resources/regressions/features/import/invalid_package_clause/invalid_package_clause2.gobra new file mode 100644 index 000000000..716f1038c --- /dev/null +++ b/src/test/resources/regressions/features/import/invalid_package_clause/invalid_package_clause2.gobra @@ -0,0 +1,4 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package clause2 diff --git a/src/test/resources/regressions/features/import/parse_error/parse_error.gobra b/src/test/resources/regressions/features/import/parse_error/parse_error.gobra new file mode 100644 index 000000000..142c3e3a6 --- /dev/null +++ b/src/test/resources/regressions/features/import/parse_error/parse_error.gobra @@ -0,0 +1,8 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package parseError + +// package foo has a source file but an invalid preamble, i.e., fails to parse +//:: ExpectedOutput(parser_error) +imp bla "bla" diff --git a/src/test/resources/regressions/features/stubs/stubs-fail0.gobra b/src/test/resources/regressions/features/stubs/stubs-fail0.gobra index 6ee25b286..f4a5bd7ef 100644 --- a/src/test/resources/regressions/features/stubs/stubs-fail0.gobra +++ b/src/test/resources/regressions/features/stubs/stubs-fail0.gobra @@ -3,7 +3,8 @@ package main -import ( - //:: ExpectedOutput(not_found_error) - "nopackagewhatsoever" -) \ No newline at end of file +import "net" + +// Should fail, package net does not contain member DoesNotExist +//:: ExpectedOutput(type_error) +func closePacketConn(conn net.DoesNotExist) error \ No newline at end of file diff --git a/src/test/resources/regressions/features/stubs/stubs-fail1.gobra b/src/test/resources/regressions/features/stubs/stubs-fail1.gobra deleted file mode 100644 index f4a5bd7ef..000000000 --- a/src/test/resources/regressions/features/stubs/stubs-fail1.gobra +++ /dev/null @@ -1,10 +0,0 @@ -// Any copyright is dedicated to the Public Domain. -// http://creativecommons.org/publicdomain/zero/1.0/ - -package main - -import "net" - -// Should fail, package net does not contain member DoesNotExist -//:: ExpectedOutput(type_error) -func closePacketConn(conn net.DoesNotExist) error \ No newline at end of file From cfed2ce6aa4d7f4b18b7b8e9e63cf52c4f3140b5 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 30 Mar 2023 09:50:34 +0200 Subject: [PATCH 15/54] fixes reporting of errors in imported packages and reports them as part of type-checking --- src/main/scala/viper/gobra/Gobra.scala | 6 +- .../scala/viper/gobra/frontend/Parser.scala | 48 +++++-- .../viper/gobra/frontend/info/Info.scala | 118 ++++++++++++++++-- .../features/import/import-fail2.gobra | 2 +- .../regressions/features/import/import1.gobra | 18 +-- .../regressions/features/import/import2.gobra | 2 +- .../viper/gobra/DetailedBenchmarkTests.scala | 6 +- 7 files changed, 160 insertions(+), 40 deletions(-) diff --git a/src/main/scala/viper/gobra/Gobra.scala b/src/main/scala/viper/gobra/Gobra.scala index 719e65857..b215f88d6 100644 --- a/src/main/scala/viper/gobra/Gobra.scala +++ b/src/main/scala/viper/gobra/Gobra.scala @@ -16,7 +16,7 @@ import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.{CGEdgesTerminationTransform, ConstantPropagation, InternalTransform, OverflowChecksTransform} import viper.gobra.backend.BackendVerifier import viper.gobra.frontend.PackageResolver.{AbstractPackage, RegularPackage} -import viper.gobra.frontend.Parser.ParseSuccessResult +import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} import viper.gobra.frontend.info.{Info, TypeInfo} import viper.gobra.frontend.{Config, Desugar, PackageInfo, Parser, ScallopGobraConfig} import viper.gobra.reporting._ @@ -243,7 +243,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { .setLevel(config.logLevel) } - private def performParsing(config: Config, pkgInfo: PackageInfo)(executor: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseSuccessResult]] = { + private def performParsing(config: Config, pkgInfo: PackageInfo)(executor: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseResult]] = { if (config.shouldParse) { val startMs = System.currentTimeMillis() val res = Parser.parse(config, pkgInfo)(executor) @@ -257,7 +257,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { } } - private def performTypeChecking(config: Config, pkgInfo: PackageInfo, parseResults: Map[AbstractPackage, ParseSuccessResult])(executor: GobraExecutionContext): Either[Vector[VerifierError], TypeInfo] = { + private def performTypeChecking(config: Config, pkgInfo: PackageInfo, parseResults: Map[AbstractPackage, ParseResult])(executor: GobraExecutionContext): Either[Vector[VerifierError], TypeInfo] = { if (config.shouldTypeCheck) { Info.check(config, RegularPackage(pkgInfo.id), parseResults)(executor) } else { diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index e42c37afc..c43610564 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -18,6 +18,7 @@ import org.antlr.v4.runtime.atn.PredictionMode import org.antlr.v4.runtime.misc.ParseCancellationException import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} +import viper.gobra.frontend.Parser.ParseSuccessResult import viper.gobra.util.GobraExecutionContext import viper.silver.ast.SourcePosition @@ -57,28 +58,30 @@ object Parser { // before parsing, get imports and add these parse jobs val imports = fastParse(preprocessedSources) val preambleParsingDurationMs = System.currentTimeMillis() - startPreambleParsingMs - // val importResults: Set[Either[Vector[VerifierError], Future[ParseResult]]] = imports.map{ case (directImportTarget, importErrorFactory) => { - val importResults: Set[Future[ParseResult]] = imports.map { case (directImportTarget, importErrorFactory) => + val importResults: Set[Either[Vector[ParserError], Future[_]]] = imports.map { case (directImportTarget, importErrorFactory) => + // val importResults: Set[Future[ParseResult]] = imports.map { case (directImportTarget, importErrorFactory) => val directImportPackage = AbstractPackage(directImportTarget)(config) val nonEmptyImportedSources = for { resolveSourceResults <- PackageResolver.resolveSources(directImportTarget)(config) importedSources = resolveSourceResults.map(_.source) nonEmptyImportedSources <- if (importedSources.isEmpty) Left(s"No source files for package '$directImportTarget' found") else Right(importedSources) } yield nonEmptyImportedSources - nonEmptyImportedSources.fold( errMsg => { val errs = importErrorFactory(errMsg) manager.addIfAbsent(directImportPackage, ParseFailureJob(errs))(executionContext) - Future.successful(Left(errs)) + Left(errs) }, nonEmptySources => { manager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage))(executionContext) + Right(manager.getFuture(directImportPackage)) + /* manager.getFuture(directImportPackage).flatten .map { case Left(_) => Left(importErrorFactory(s"Imported package contains errors")) case success => success }(executionContext) + */ }) /* val importedSources = PackageResolver.resolveSources(directImportTarget)(config) @@ -99,9 +102,23 @@ object Parser { */ } - // val (importFailures, futs) = importResults.partitionMap(identity) - // val flatImportFailures = importFailures.toVector.flatten + val (importFailures, futs) = importResults.partitionMap(identity) + val flatImportFailures = importFailures.toVector.flatten + + val res: ParseResult = for { + _ <- if (flatImportFailures.isEmpty) Right(()) else Left(flatImportFailures) + startMs = System.currentTimeMillis() + parsedProgram <- Parser.process(preprocessedSources, pkgInfo, specOnly = specOnly)(config) + postprocessedProgram <- Parser.postprocess(Right((preprocessedSources, parsedProgram)), specOnly = specOnly)(config) + _ = logger.trace { + val parsingDurationMs = System.currentTimeMillis() - startMs + val parsingDurationS = f"${parsingDurationMs / 1000f}%.1f" + val preambleParsingRatio = f"${100f * preambleParsingDurationMs / parsingDurationMs}%.1f" + s"parsing ${pkgInfo.id} done (took ${parsingDurationS}s; parsing preamble overhead is ${preambleParsingRatio}%)" + } + } yield (pkgSources, postprocessedProgram._2) // we use `pkgSources` as the preprocessing of sources should be transparent from the outside + /* val startMs = System.currentTimeMillis() val res = for { parsedProgram <- Parser.process(preprocessedSources, pkgInfo, specOnly = specOnly)(config) @@ -112,10 +129,10 @@ object Parser { val parsingDurationS = f"${parsingDurationMs / 1000f}%.1f" val preambleParsingRatio = f"${100f * preambleParsingDurationMs / parsingDurationMs}%.1f" s"parsing ${pkgInfo.id} done (took ${parsingDurationS}s; parsing preamble overhead is ${preambleParsingRatio}%)" - } + }*/ implicit val executor: GobraExecutionContext = executionContext - + /* Future.sequence(importResults) .map(dependencyResults => { val (importErrors, _) = dependencyResults.partitionMap(identity) @@ -137,10 +154,9 @@ object Parser { } */ }) - /* + */ Future.sequence(futs) .map(_ => res) - */ } type ImportErrorFactory = String => Vector[ParserError] @@ -214,6 +230,14 @@ object Parser { .collect { case (key, Right(res)) => (key, res) } .toMap } + + def getResults(executionContext: GobraExecutionContext): Map[AbstractPackage, ParseResult] = { + implicit val executor: GobraExecutionContext = executionContext + val futs = manager.getAllFutures.map { case (key, fut) => fut.flatten.map(res => (key, res)) } + val results = Await.result(Future.sequence(futs), Duration.Inf) + results + .toMap + } } /** @@ -232,7 +256,7 @@ object Parser { * */ - def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseSuccessResult]] = { + def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseResult]] = { val parseManager = new ParseManager(config, executionContext) /* parseManager.parse(pkgInfo) @@ -240,7 +264,7 @@ object Parser { res */ val res = parseManager.parse(pkgInfo) - res.map(_ => parseManager.getSuccessResults(executionContext)) + res.map(_ => parseManager.getResults(executionContext)) } def parse(input: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean = false)(config: Config): Either[Vector[VerifierError], PPackage] = { diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 5a68b034e..7512fee8b 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -13,11 +13,12 @@ import org.bitbucket.inkytonik.kiama.util.{Position, Source} import viper.gobra.ast.frontend.{PImport, PNode, PPackage} import viper.gobra.frontend.{Config, Job, TaskManager} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport} -import viper.gobra.frontend.Parser.ParseSuccessResult +import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} +import viper.gobra.frontend.info.Info.CycleChecker import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.{GhostLessPrinter, GoifyingPrinter} -import viper.gobra.reporting.{TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} +import viper.gobra.reporting.{CyclicImportError, ParserError, TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} import viper.gobra.util.{GobraExecutionContext, Violation} import java.security.MessageDigest @@ -46,24 +47,83 @@ object Info extends LazyLogging { */ case class ImportCycle(importNodeCausingCycle: PImport, importNodeStart: Option[Position], cyclicPackages: Vector[AbstractImport]) - class CycleChecker(val config: Config, val parseResults: Map[AbstractPackage, ParseSuccessResult]) extends GetParseResult { + class CycleChecker(val config: Config /*, val parseResults: Map[AbstractPackage, ParseSuccessResult]*/, val parseResults: Map[AbstractPackage, ParseResult]) { /** keeps track of the package dependencies that are currently resolved. This information is used to detect cycles */ private var parserPendingPackages: Vector[AbstractImport] = Vector() - def check(abstractPackage: AbstractPackage): Messages = { + private def getParseResult(abstractPackage: AbstractPackage): Either[Vector[ParserError], ParseSuccessResult] = { + Violation.violation(parseResults.contains(abstractPackage), s"GetParseResult: expects that $abstractPackage has been parsed") + parseResults(abstractPackage) + } + + def check(abstractPackage: AbstractPackage): Either[Vector[VerifierError], Map[AbstractPackage, ParseSuccessResult]] = { + for { + parseResult <- getParseResult(abstractPackage) + (_, ast) = parseResult + perImportResult = ast.imports.map(importNode => { + // val cycles = getCycles(RegularImport(importNode.importPath)) + /* + val cycles = getImportErrors(RegularImport(importNode.importPath)) + val msgs = createImportError(importNode, cycles) + if (msgs.isEmpty) Right(()) else Left(ast.positions.translate(msgs, TypeError).distinct) + */ + val res = getImportErrors(RegularImport(importNode.importPath)) + .left + .map(errs => { + val msgs = createImportError(importNode, errs) + ast.positions.translate(msgs, TypeError).distinct + }) + res + }) + (errs, _) = perImportResult.partitionMap(identity) + _ <- if (errs.nonEmpty) Left(errs.flatten) else Right(()) + successParseResults = parseResults.collect { + case (key, Right(res)) => (key, res) + } + } yield successParseResults + /* val (_, ast) = getParseResult(abstractPackage) - ast.imports.flatMap(importNode => { + val msgs = ast.imports.flatMap(importNode => { val cycles = getCycles(RegularImport(importNode.importPath)) createImportError(importNode, cycles) }) + if (msgs.isEmpty) { + + } else { + Left(ast.positions.translate(msgs, TypeError).distinct) + } + */ } /** * returns all parser errors and cyclic errors transitively found in imported packages */ - private def getCycles(importTarget: AbstractImport): Vector[ImportCycle] = { + private def getImportErrors(importTarget: AbstractImport): Either[Vector[VerifierError], Unit] = { parserPendingPackages = parserPendingPackages :+ importTarget val abstractPackage = AbstractPackage(importTarget)(config) + val res = for { + parseResult <- getParseResult(abstractPackage) + (_, ast) = parseResult + perImportResult = ast.imports.map(importNode => { + val directlyImportedTarget = RegularImport(importNode.importPath) + if (parserPendingPackages.contains(directlyImportedTarget)) { + // package cycle detected + val importNodeStart = ast.positions.positions.getStart(importNode) + // Vector(ImportCycle(importNode, importNodeStart, parserPendingPackages)) + val msg = s"Package '$importTarget' is part of the following import cycle that involves the import $importNode$importNodeStart: ${parserPendingPackages.mkString("[", ", ", "]")}" + Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$msg'"))) + } else { + getImportErrors(directlyImportedTarget) + } + }) + (errs, _) = perImportResult.partitionMap(identity) + res <- if (errs.nonEmpty) Left(errs.flatten) else Right(()) + } yield res + parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) + res + } + /* + private def getCycles(importTarget: AbstractImport): Vector[ImportCycle] = { val (_, ast) = getParseResult(abstractPackage) val res = ast.imports.flatMap(importNode => { val directlyImportedTarget = RegularImport(importNode.importPath) @@ -78,13 +138,28 @@ object Info extends LazyLogging { parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) res } + */ - private def createImportError(importNode: PImport, cycles: Vector[ImportCycle]): Messages = { + private def createImportError(importNode: PImport, errorsInImportedPackage: Vector[VerifierError]): Messages = { val importTarget = RegularImport(importNode.importPath) + val (cyclicErrors, nonCyclicErrors) = errorsInImportedPackage.partitionMap { + case cyclicErr: CyclicImportError => Left(cyclicErr) + case e => Right(e) + } + if (cyclicErrors.isEmpty) { + // nonCyclicErrors.flatMap(err => message(importNode, err.message)) + message(importNode, s"Package contains ${nonCyclicErrors.length} error(s): ${nonCyclicErrors.map(_.message).mkString(", ")}") + } else { + cyclicErrors.flatMap(cycle => { + // val positionalInfo = cycle.importNodeStart.map(pos => s" at ${pos.format}").getOrElse("") + // message(importNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}$positionalInfo: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") + message(importNode, cycle.message) + }) + }/* cycles.flatMap(cycle => { val positionalInfo = cycle.importNodeStart.map(pos => s" at ${pos.format}").getOrElse("") message(importNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}$positionalInfo: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") - }) + })*/ } } @@ -99,10 +174,11 @@ object Info extends LazyLogging { trait TypeCheckJob { protected def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isMainContext: Boolean = false): TypeCheckResult = { val startMs = System.currentTimeMillis() + logger.trace(s"start type-checking ${pkg.info.id}") val res = Info.checkSources(pkgSources, pkg, dependentTypeInfo, isMainContext = isMainContext)(config) logger.trace { val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - s"type-checking ${pkg.info.id} done (took ${durationS}s)" + s"type-checking ${pkg.info.id} done (took ${durationS}s with ${res.map(info => info.tree.nodes.length.toString).getOrElse("_")} nodes)" } res } @@ -233,9 +309,28 @@ object Info extends LazyLogging { */ } - def check(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseSuccessResult])(executionContext: GobraExecutionContext): TypeCheckResult = { + def check(config: Config, abstractPackage: AbstractPackage, /*parseResults: Map[AbstractPackage, ParseSuccessResult]*/ parseResults: Map[AbstractPackage, ParseResult])(executionContext: GobraExecutionContext): TypeCheckResult = { // check for cycles - val cyclicErrors = new CycleChecker(config, parseResults).check(abstractPackage) + // val cyclicErrors = new CycleChecker(config, parseResults).check(abstractPackage) + for { + successParseResult <- new CycleChecker(config, parseResults).check(abstractPackage) + .left.map(errs => { + val (sources, pkg) = parseResults(abstractPackage).right.get + val sourceNames = sources.map(_.name) + config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errs) + errs + }) + typeCheckingStartMs = System.currentTimeMillis() + context = new Context(config, successParseResult)(executionContext) + typeInfo <- context.typeCheck(abstractPackage) + _ = logger.debug { + val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" + s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})" + } + } yield typeInfo + + + /* if (cyclicErrors.isEmpty) { val typeCheckingStartMs = System.currentTimeMillis() // add type-checking jobs to context: @@ -254,6 +349,7 @@ object Info extends LazyLogging { config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errors) Left(errors) } + */ } type TypeInfoCacheKey = String diff --git a/src/test/resources/regressions/features/import/import-fail2.gobra b/src/test/resources/regressions/features/import/import-fail2.gobra index d39496255..1c91c949f 100644 --- a/src/test/resources/regressions/features/import/import-fail2.gobra +++ b/src/test/resources/regressions/features/import/import-fail2.gobra @@ -7,6 +7,6 @@ package main import ( // note that package `parse_error` contains a parser error so the qualifier cannot be resolved - //:: ExpectedOutput(parser_error) + //:: ExpectedOutput(type_error) "parse_error" ) diff --git a/src/test/resources/regressions/features/import/import1.gobra b/src/test/resources/regressions/features/import/import1.gobra index 7e8ebbc08..eb3106227 100644 --- a/src/test/resources/regressions/features/import/import1.gobra +++ b/src/test/resources/regressions/features/import/import1.gobra @@ -4,27 +4,27 @@ package main import fmt "fmt" -//:: ExpectedOutput(not_found_error) +//:: ExpectedOutput(parser_error) import a "a"; -//:: ExpectedOutput(not_found_error) +//:: ExpectedOutput(parser_error) import (b "b") -//:: ExpectedOutput(not_found_error) +//:: ExpectedOutput(parser_error) import (c "c"); import ( - //:: ExpectedOutput(not_found_error) + //:: ExpectedOutput(parser_error) d "d" - //:: ExpectedOutput(not_found_error) + //:: ExpectedOutput(parser_error) e "e") import ( - //:: ExpectedOutput(not_found_error) + //:: ExpectedOutput(parser_error) f "f" - //:: ExpectedOutput(not_found_error) + //:: ExpectedOutput(parser_error) g "g" ) -//:: ExpectedOutput(not_found_error) +//:: ExpectedOutput(parser_error) import m "lib/mathm" // wrong package name used on purpose such that this test case does not potentially depend on the configured Go path -//:: ExpectedOutput(not_found_error) +//:: ExpectedOutput(parser_error) import . "lib/mathn" func test() { diff --git a/src/test/resources/regressions/features/import/import2.gobra b/src/test/resources/regressions/features/import/import2.gobra index 33bad9c88..ae7458fc6 100644 --- a/src/test/resources/regressions/features/import/import2.gobra +++ b/src/test/resources/regressions/features/import/import2.gobra @@ -3,7 +3,7 @@ package main -//:: ExpectedOutput(not_found_error) +//:: ExpectedOutput(parser_error) import math "lib/mathm" // wrong package name used on purpose such that this test case does not potentially depend on the configured Go path type cell struct{ diff --git a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala index b5a6fe844..83c4e7747 100644 --- a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala +++ b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala @@ -13,7 +13,7 @@ import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.OverflowChecksTransform import viper.gobra.backend.BackendVerifier import viper.gobra.frontend.PackageResolver.{AbstractPackage, RegularPackage} -import viper.gobra.frontend.Parser.ParseSuccessResult +import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} import viper.gobra.frontend.info.{Info, TypeInfo} import viper.gobra.frontend.{Desugar, Parser} import viper.gobra.reporting.{AppliedInternalTransformsMessage, BackTranslator, VerifierError, VerifierResult} @@ -108,8 +108,8 @@ class DetailedBenchmarkTests extends BenchmarkTests { Parser.parse(c, pkgInfo)(executor) }) - private val typeChecking: NextStep[Map[AbstractPackage, ParseSuccessResult], TypeInfo, Vector[VerifierError]] = - NextStep("type-checking", parsing, (parseResults: Map[AbstractPackage, ParseSuccessResult]) => { + private val typeChecking: NextStep[Map[AbstractPackage, ParseResult], TypeInfo, Vector[VerifierError]] = + NextStep("type-checking", parsing, (parseResults: Map[AbstractPackage, ParseResult]) => { assert(config.isDefined) val c = config.get assert(c.packageInfoInputMap.size == 1) From c00c63691e47e182c4a983667ade94aa912d3346 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 30 Mar 2023 14:02:13 +0200 Subject: [PATCH 16/54] adds a sequential parser --- .../scala/viper/gobra/frontend/Parser.scala | 166 +++++++++++++++--- .../viper/gobra/frontend/TaskManager.scala | 86 ++++++++- .../viper/gobra/frontend/info/Info.scala | 23 ++- 3 files changed, 235 insertions(+), 40 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index c43610564..e33d07124 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -17,8 +17,9 @@ import org.antlr.v4.runtime.{CharStreams, CommonTokenStream, DefaultErrorStrateg import org.antlr.v4.runtime.atn.PredictionMode import org.antlr.v4.runtime.misc.ParseCancellationException import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} -import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} +import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport, RegularPackage} import viper.gobra.frontend.Parser.ParseSuccessResult +import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} import viper.gobra.util.GobraExecutionContext import viper.silver.ast.SourcePosition @@ -34,21 +35,120 @@ object Parser { type ParseResult = Either[Vector[ParserError], ParseSuccessResult] class ParseManager(config: Config, executionContext: GobraExecutionContext) extends LazyLogging { - private val manager = new TaskManager[AbstractPackage, Future[ParseResult]](TaskManagerMode.Parallel) + private val manager = new TaskManager[AbstractPackage, ParseResult](Sequential) // we currently do not support the lazy mode + private val parallelManager = new ParallelTaskManager[AbstractPackage, ParseResult] def parse(pkgInfo: PackageInfo): ParseResult = { val pkg = RegularPackage(pkgInfo.id) - val parseJob = ParseInfoJob(pkgInfo) + /* manager.addIfAbsent(pkg, parseJob)(executionContext) // trigger and wait for parsing of at least this package (which will ensure that parse jobs for all dependent packages are created too) Await.result(manager.getResult(pkg), Duration.Inf) + */ + config.typeCheckMode match { + case Lazy | Sequential => + val parseJob = ParseInfoJob(pkgInfo) + manager.addIfAbsent(pkg, parseJob) + manager.getResult(pkg) + case Parallel => + val parseJob = ParallelParseInfoJob(pkgInfo) + val fut = parallelManager.addIfAbsent(pkg, parseJob)(executionContext) + Await.result(fut, Duration.Inf) + } + } + + trait ImportResolver { + def pkgInfo: PackageInfo + + type ImportErrorFactory = String => Vector[ParserError] + // protected def getImports(importNodes: Vector[PImport], pom: PositionManager): Set[(AbstractImport, ImportErrorFactory)] = { + protected def getImports(importNodes: Vector[PImport], pom: PositionManager): Vector[(AbstractPackage, Either[Vector[ParserError], Vector[Source]])] = { + val explicitImports: Vector[(AbstractImport, ImportErrorFactory)] = importNodes + .map(importNode => { + val importErrorFactory: ImportErrorFactory = (errMsg: String) => { + val err = pom.translate(message(importNode, errMsg), ParserError) + // config.reporter report ParserErrorMessage(err.head.position.get.file, err) + err + } + (RegularImport(importNode.importPath), importErrorFactory) + }) + val imports = if (pkgInfo.isBuiltIn) { explicitImports } else { + val builtInImportErrorFactory: ImportErrorFactory = (errMsg: String) => { + val err = Vector(ParserError(errMsg, None)) + config.reporter report ParserErrorMessage(err.head.position.get.file, err) + err + } + val builtInImportTuple = (BuiltInImport, builtInImportErrorFactory) + explicitImports :+ builtInImportTuple + } + + val errsOrSources = imports.map { case (directImportTarget, importErrorFactory) => + val directImportPackage = AbstractPackage(directImportTarget)(config) + val nonEmptyImportedSources = for { + resolveSourceResults <- PackageResolver.resolveSources(directImportTarget)(config) + importedSources = resolveSourceResults.map(_.source) + nonEmptyImportedSources <- if (importedSources.isEmpty) Left(s"No source files for package '$directImportTarget' found") else Right(importedSources) + } yield nonEmptyImportedSources + val res = nonEmptyImportedSources.left.map(importErrorFactory) + (directImportPackage, res) + } + errsOrSources + /* + val (errors, sources) = errsOrSources.partitionMap(identity) + if (errors.nonEmpty) { + Left(errors) + } else { + Right(sources) + } + */ + } + } + + trait ParseJob extends Job[ParseResult] with ImportResolver { + def pkgInfo: PackageInfo + def pkgSources: Vector[Source] + def specOnly: Boolean + + private def getImportsForPackage(p: PPackage): Vector[(AbstractPackage, Either[Vector[ParserError], Vector[Source]])] = { + getImports(p.imports, p.positions) + } + + override def compute(): ParseResult = { + require(pkgSources.nonEmpty) + + val startMs = System.currentTimeMillis() + val preprocessedSources = preprocess(pkgSources)(config) + + for { + parsedProgram <- Parser.process(preprocessedSources, pkgInfo, specOnly = specOnly)(config) + imports = getImportsForPackage(parsedProgram) + _ = imports.map { + case (directImportPackage, Right(nonEmptySources)) => manager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage)) + case (directImportPackage, Left(errs)) => manager.addIfAbsent(directImportPackage, ParseFailureJob(errs)) + } + postprocessedProgram <- Parser.postprocess(Right((preprocessedSources, parsedProgram)), specOnly = specOnly)(config) + _ = logger.trace { + val parsingDurationMs = System.currentTimeMillis() - startMs + val parsingDurationS = f"${parsingDurationMs / 1000f}%.1f" + s"parsing ${pkgInfo.id} done (took ${parsingDurationS}s)" + } + } yield postprocessedProgram + } } - trait ParseJob extends Job[Future[ParseResult]] { + trait ParallelParseJob extends ParallelJob[ParseResult] with ImportResolver { def pkgInfo: PackageInfo def pkgSources: Vector[Source] def specOnly: Boolean + private def getImportsForPackage(preprocessedSources: Vector[Source]): Vector[(AbstractPackage, Either[Vector[ParserError], Vector[Source]])] = { + val preambles = preprocessedSources + .map(preprocessedSource => processPreamble(preprocessedSource)(config)) + // we ignore imports in files that cannot be parsed: + .collect { case Right(p) => p } + preambles.flatMap(preamble => getImports(preamble.imports, preamble.positions)) + } + override def compute(): Future[ParseResult] = { require(pkgSources.nonEmpty) @@ -56,8 +156,10 @@ object Parser { val startPreambleParsingMs = System.currentTimeMillis() // before parsing, get imports and add these parse jobs - val imports = fastParse(preprocessedSources) + // val imports = fastParse(preprocessedSources) + val imports = getImportsForPackage(preprocessedSources) val preambleParsingDurationMs = System.currentTimeMillis() - startPreambleParsingMs + /* val importResults: Set[Either[Vector[ParserError], Future[_]]] = imports.map { case (directImportTarget, importErrorFactory) => // val importResults: Set[Future[ParseResult]] = imports.map { case (directImportTarget, importErrorFactory) => val directImportPackage = AbstractPackage(directImportTarget)(config) @@ -69,21 +171,22 @@ object Parser { nonEmptyImportedSources.fold( errMsg => { val errs = importErrorFactory(errMsg) - manager.addIfAbsent(directImportPackage, ParseFailureJob(errs))(executionContext) + parallelManager.addIfAbsent(directImportPackage, ParseFailureJob(errs))(executionContext) Left(errs) }, nonEmptySources => { - manager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage))(executionContext) - Right(manager.getFuture(directImportPackage)) - /* + // manager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage))(executionContext) + // Right(manager.getFuture(directImportPackage)) + Right(parallelManager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage))(executionContext)) + *//* manager.getFuture(directImportPackage).flatten .map { case Left(_) => Left(importErrorFactory(s"Imported package contains errors")) case success => success }(executionContext) - */ + *//* }) - /* + *//* val importedSources = PackageResolver.resolveSources(directImportTarget)(config) .getOrElse(Vector()) .map(_.source) @@ -99,11 +202,18 @@ object Parser { case success => success }(executionContext) } - */ + *//* + } + */ + val importResults: Vector[Either[Vector[ParserError], Future[_]]] = imports.map { + case (directImportPackage, Right(nonEmptySources)) => Right(parallelManager.addIfAbsent(directImportPackage, ParallelParseSourcesJob(nonEmptySources, directImportPackage))(executionContext)) + case (directImportPackage, Left(errs)) => + parallelManager.addIfAbsent(directImportPackage, ParallelParseFailureJob(errs))(executionContext) + Left(errs) } val (importFailures, futs) = importResults.partitionMap(identity) - val flatImportFailures = importFailures.toVector.flatten + val flatImportFailures = importFailures.flatten val res: ParseResult = for { _ <- if (flatImportFailures.isEmpty) Right(()) else Left(flatImportFailures) @@ -158,7 +268,7 @@ object Parser { Future.sequence(futs) .map(_ => res) } - + /* type ImportErrorFactory = String => Vector[ParserError] private def fastParse(preprocessedInput: Vector[Source]): Set[(AbstractImport, ImportErrorFactory)] = { def getImportPaths(preprocessedSource: Source): Set[(RegularImport, ImportErrorFactory)] = { @@ -191,7 +301,7 @@ object Parser { val builtInImportTuple = (BuiltInImport, builtInImportErrorFactory) explicitImports + builtInImportTuple } - } + }*/ } /** this job is used to parse the package that should be verified */ @@ -199,6 +309,10 @@ object Parser { lazy val pkgSources: Vector[Source] = config.packageInfoInputMap(pkgInfo) lazy val specOnly: Boolean = false } + case class ParallelParseInfoJob(override val pkgInfo: PackageInfo) extends ParallelParseJob { + lazy val pkgSources: Vector[Source] = config.packageInfoInputMap(pkgInfo) + lazy val specOnly: Boolean = false + } /** this job is used to parse all packages that are imported */ case class ParseSourcesJob(override val pkgSources: Vector[Source], pkg: AbstractPackage) extends ParseJob { @@ -206,11 +320,20 @@ object Parser { lazy val pkgInfo: PackageInfo = Source.getPackageInfo(pkgSources.head, config.projectRoot) lazy val specOnly: Boolean = true } + case class ParallelParseSourcesJob(override val pkgSources: Vector[Source], pkg: AbstractPackage) extends ParallelParseJob { + require(pkgSources.nonEmpty) + lazy val pkgInfo: PackageInfo = Source.getPackageInfo(pkgSources.head, config.projectRoot) + lazy val specOnly: Boolean = true + } - case class ParseFailureJob(errs: Vector[ParserError]) extends Job[Future[ParseResult]] { + case class ParseFailureJob(errs: Vector[ParserError]) extends Job[ParseResult] { + override def compute(): ParseResult = Left(errs) + } + case class ParallelParseFailureJob(errs: Vector[ParserError]) extends ParallelJob[ParseResult] { override def compute(): Future[ParseResult] = Future.successful[ParseResult](Left(errs)) } + /* def getParseResults(executionContext: GobraExecutionContext): Either[Map[AbstractPackage, Vector[VerifierError]], Map[AbstractPackage, ParseSuccessResult]] = { implicit val executor: GobraExecutionContext = executionContext // val futs = manager.getAllResultsWithKeys(executionContext).map { case (key, fut) => fut.map(res => (key, res)) } @@ -230,13 +353,10 @@ object Parser { .collect { case (key, Right(res)) => (key, res) } .toMap } - - def getResults(executionContext: GobraExecutionContext): Map[AbstractPackage, ParseResult] = { - implicit val executor: GobraExecutionContext = executionContext - val futs = manager.getAllFutures.map { case (key, fut) => fut.flatten.map(res => (key, res)) } - val results = Await.result(Future.sequence(futs), Duration.Inf) - results - .toMap + */ + def getResults(executionContext: GobraExecutionContext): Map[AbstractPackage, ParseResult] = config.typeCheckMode match { + case Lazy | Sequential => manager.getAllResultsWithKeys.toMap + case Parallel => parallelManager.getAllResultsWithKeys(executionContext).toMap } } diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index 83513472a..f3f93f963 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -48,13 +48,49 @@ trait Job[R] { } } +trait ParallelJob[R] { + /* + protected def compute(): Future[R] + private var compututationStarted: Option[Future[R]] = None + def call(): Future[R] = { + compututationStarted.getOrElse { + val fut = compute() + compututationStarted = Some(fut) + fut + } + } + */ + + private var compututationStarted = false + private val promise: Promise[R] = Promise() + def getFuture: Future[R] = promise.future + protected def compute(): Future[R] + + def call(executionContext: GobraExecutionContext): Future[R] = { + getFuture.value match { + case Some(Success(res)) => return Future.successful(res) // return already computed type-checker result + case Some(Failure(exception)) => Violation.violation(s"Job resulted in exception: $exception") + case _ => + } + Violation.violation(!compututationStarted, s"Job $this is already on-going") + compututationStarted = true + compute() + .map(res => { + promise.success(res) + res + })(executionContext) + } +} + class TaskManager[K, R](mode: TaskManagerMode) { + require(mode != Parallel) + private val jobs: ConcurrentMap[K, Job[R]] = new ConcurrentHashMap() /** * returns true if job has been inserted and thus was previously absent */ - def addIfAbsent(id: K, job: Job[R], insertOnly: Boolean = false)(executionContext: GobraExecutionContext): Boolean = { + def addIfAbsent(id: K, job: Job[R], insertOnly: Boolean = false): Unit = { var isAbsent = false // first insert job, then run it (if necessary) jobs.computeIfAbsent(id, _ => { @@ -66,12 +102,10 @@ class TaskManager[K, R](mode: TaskManagerMode) { mode match { case Lazy => // don't do anything as of now case Sequential => job.call() - case Parallel => Future{ job.call() }(executionContext) } } - isAbsent } - + /* def getFuture(id: K): Future[R] = { val job = jobs.get(id) Violation.violation(job != null, s"Task $id not found") @@ -80,13 +114,13 @@ class TaskManager[K, R](mode: TaskManagerMode) { def getAllFutures: Iterable[(K, Future[R])] = jobs.asScala.toVector.map { case (key, job) => (key, job.getFuture) } - + */ def getResult(id: K): R = { val job = jobs.get(id) Violation.violation(job != null, s"Task $id not found") getResultFromJob(job) } - + /* def getAllResults(executionContext: GobraExecutionContext): Iterable[R] = mode match { case Lazy | Sequential => jobs.values().asScala.map(getResultFromJob) case Parallel => @@ -94,7 +128,10 @@ class TaskManager[K, R](mode: TaskManagerMode) { implicit val executor: GobraExecutionContext = executionContext Await.result(Future.sequence(futs), Duration.Inf) } - + */ + def getAllResults: Iterable[R] = + jobs.values().asScala.map(getResultFromJob) + /* def getAllResultsWithKeys(executionContext: GobraExecutionContext): Iterable[(K, R)] = mode match { case Lazy | Sequential => jobs.asScala.toVector.map { case (key, job) => (key, getResultFromJob(job)) } case Parallel => @@ -102,6 +139,9 @@ class TaskManager[K, R](mode: TaskManagerMode) { val futs = jobs.asScala.toVector.map { case (key, job) => job.getFuture.map(res => (key, res)) } Await.result(Future.sequence(futs), Duration.Inf) } + */ + def getAllResultsWithKeys: Iterable[(K, R)] = + jobs.asScala.toVector.map { case (key, job) => (key, getResultFromJob(job)) } private def getResultFromJob(job: Job[R]): R = mode match { case Lazy => job.call() // we perform the computation now that we need the result @@ -109,8 +149,36 @@ class TaskManager[K, R](mode: TaskManagerMode) { // note that we cannot await the future here as type-checking of this package might not have started yet. // Thus, we use `.call()` that either returns a previously calculated type-checking result or will calculate it. job.call() - case Parallel => - Await.result(job.getFuture, Duration.Inf) + // case Parallel => + // Await.result(job.getFuture, Duration.Inf) + } +} + +class ParallelTaskManager[K, R] { + private val jobs: ConcurrentMap[K, ParallelJob[R]] = new ConcurrentHashMap() + + /** + * returns true if job has been inserted and thus was previously absent + */ + def addIfAbsent(id: K, job: ParallelJob[R], insertOnly: Boolean = false)(executionContext: GobraExecutionContext): Future[R] = { + var isAbsent = false + // first insert job, then run it (if necessary) + val res = jobs.computeIfAbsent(id, _ => { + isAbsent = true + job + }) + // now run it but only if it's a new job: + if (isAbsent && !insertOnly) { + job.call(executionContext) + } + // return the future (either of the inserted job or the already existing job with the same id) + res.getFuture + } + + def getAllResultsWithKeys(executionContext: GobraExecutionContext): Iterable[(K, R)] = { + implicit val executor: GobraExecutionContext = executionContext + val futs = jobs.asScala.toVector.map { case (key, job) => job.getFuture.map(res => (key, res)) } + Await.result(Future.sequence(futs), Duration.Inf) } } diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 7512fee8b..404c05d05 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -11,7 +11,7 @@ import org.bitbucket.inkytonik.kiama.relation.Tree import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, message} import org.bitbucket.inkytonik.kiama.util.{Position, Source} import viper.gobra.ast.frontend.{PImport, PNode, PPackage} -import viper.gobra.frontend.{Config, Job, TaskManager} +import viper.gobra.frontend.{Config, Job, ParallelJob, ParallelTaskManager, TaskManager} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport} import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} @@ -168,8 +168,8 @@ object Info extends LazyLogging { * Therefore, package management is centralized. */ class Context(val config: Config, val parseResults: Map[AbstractPackage, ParseSuccessResult])(val executionContext: GobraExecutionContext) extends GetParseResult { - private val typeCheckManager = new TaskManager[AbstractPackage, TypeCheckResult](config.typeCheckMode) - private val parallelTypeCheckManager = new TaskManager[AbstractPackage, Future[TypeCheckResult]](config.typeCheckMode) + private val typeCheckManager = new TaskManager[AbstractPackage, TypeCheckResult](if (config.typeCheckMode == Parallel) Sequential else config.typeCheckMode) + private val parallelTypeCheckManager = new ParallelTaskManager[AbstractPackage, TypeCheckResult]() trait TypeCheckJob { protected def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isMainContext: Boolean = false): TypeCheckResult = { @@ -216,7 +216,7 @@ object Info extends LazyLogging { val dependentPackage = AbstractPackage(importTarget)(config) // add to manager & typecheck them if not present yet val job = SequentialTypeCheckJob(dependentPackage) - typeCheckManager.addIfAbsent(dependentPackage, job)(executionContext) + typeCheckManager.addIfAbsent(dependentPackage, job) (importTarget, () => typeCheckManager.getResult(dependentPackage)) }) @@ -224,7 +224,8 @@ object Info extends LazyLogging { } } - case class ParallelTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[Future[TypeCheckResult]] with TypeCheckJob { + // case class ParallelTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[Future[TypeCheckResult]] with TypeCheckJob { + case class ParallelTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends ParallelJob[TypeCheckResult] with TypeCheckJob { override def toString: String = s"ParallelTypeCheckJob for $abstractPackage" override def compute(): Future[TypeCheckResult] = { @@ -239,8 +240,11 @@ object Info extends LazyLogging { // add to manager & typecheck them if not present yet val job = ParallelTypeCheckJob(dependentPackage) parallelTypeCheckManager.addIfAbsent(dependentPackage, job)(executionContext) + .map(typeInfo => (importTarget, () => typeInfo))(executionContext) + /* parallelTypeCheckManager.getFuture(dependentPackage).flatten .map(typeInfo => (importTarget, () => typeInfo))(executionContext) + */ }) implicit val executor: GobraExecutionContext = executionContext val dependentJobsFut = Future.sequence(dependentJobsFuts) @@ -259,12 +263,15 @@ object Info extends LazyLogging { lazyTypeCheckRecursively(pkg, isMainContext = true) typeCheckManager.getResult(pkg) case Sequential => - typeCheckManager.addIfAbsent(pkg, SequentialTypeCheckJob(pkg, isMainContext = true))(executionContext) + typeCheckManager.addIfAbsent(pkg, SequentialTypeCheckJob(pkg, isMainContext = true)) typeCheckManager.getResult(pkg) case Parallel => + /* parallelTypeCheckManager.addIfAbsent(pkg, ParallelTypeCheckJob(pkg, isMainContext = true))(executionContext) // wait for result: val fut = parallelTypeCheckManager.getResult(pkg) + */ + val fut = parallelTypeCheckManager.addIfAbsent(pkg, ParallelTypeCheckJob(pkg, isMainContext = true))(executionContext) Await.result(fut, Duration.Inf) } } @@ -281,9 +288,9 @@ object Info extends LazyLogging { val dependentPackages = allImports(abstractPackage) + BuiltInPackage // create jobs for all dependent packages - dependentPackages.foreach(pkg => typeCheckManager.addIfAbsent(pkg, LazyTypeCheckJob(pkg))(executionContext)) + dependentPackages.foreach(pkg => typeCheckManager.addIfAbsent(pkg, LazyTypeCheckJob(pkg))) // create job for this package: - typeCheckManager.addIfAbsent(abstractPackage, LazyTypeCheckJob(abstractPackage, isMainContext = isMainContext))(executionContext) + typeCheckManager.addIfAbsent(abstractPackage, LazyTypeCheckJob(abstractPackage, isMainContext = isMainContext)) } /* def getContexts: Iterable[ExternalTypeInfo] = { From 686b53d2b58906ba038fba20bb3646e05d39f352 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 14 Mar 2023 11:23:54 +0100 Subject: [PATCH 17/54] Parses all inputs to 'GobraTests' in parallel before actually starting the unit tests --- .../scala/viper/gobra/frontend/Parser.scala | 12 +++++++ src/test/scala/viper/gobra/GobraTests.scala | 32 ++++++++++++++++--- 2 files changed, 39 insertions(+), 5 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index e33d07124..9a68e6693 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -57,6 +57,18 @@ object Parser { } } + /** this is only used for unit testing to fill the parse cache */ + def parseAll(pkgInfos: Vector[PackageInfo]): Map[PackageInfo, ParseResult] = { + val createdFuts = pkgInfos.map(pkgInfo => { + val pkg = RegularPackage(pkgInfo.id) + val parseJob = ParallelParseInfoJob(pkgInfo) + parallelManager.addIfAbsent(pkg, parseJob)(executionContext) + .map(res => (pkgInfo, res))(executionContext) + }) + implicit val executor: GobraExecutionContext = executionContext + Await.result(Future.sequence(createdFuts), Duration.Inf).toMap + } + trait ImportResolver { def pkgInfo: PackageInfo diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index efa898916..719ac1b9d 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -8,9 +8,11 @@ package viper.gobra import java.nio.file.Path import ch.qos.logback.classic.Level -import org.scalatest.BeforeAndAfterAll +import org.bitbucket.inkytonik.kiama.util.Source +import org.scalatest.{Args, BeforeAndAfterAll, Status} +import viper.gobra.frontend.Parser.ParseManager import viper.gobra.frontend.Source.FromFileSource -import viper.gobra.frontend.{Config, PackageResolver, Source} +import viper.gobra.frontend.{Config, PackageInfo, PackageResolver, Source} import viper.gobra.reporting.VerifierResult.{Failure, Success} import viper.gobra.reporting.{NoopReporter, VerifierError} import viper.silver.testing.{AbstractOutput, AnnotatedTestInput, ProjectInfo, SystemUnderTest} @@ -30,12 +32,30 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { var gobraInstance: Gobra = _ var executor: GobraExecutionContext = _ + var inputMapping: Vector[(PackageInfo, Vector[Source])] = Vector.empty + val cacheParser = true override def beforeAll(): Unit = { executor = new DefaultGobraExecutionContext() gobraInstance = new Gobra() } + override def registerTest(input: AnnotatedTestInput): Unit = { + super.registerTest(input) + val source = FromFileSource(input.file) + inputMapping = inputMapping :+ (Source.getPackageInfo(source, Path.of("")) -> Vector(source)) + } + + override def runTests(testName: Option[String], args: Args): Status = { + val inputMap = inputMapping.toMap + if (cacheParser) { + val config = Config(packageInfoInputMap = inputMap, cacheParser = true) + val parseManager = new ParseManager(config, executor) + parseManager.parseAll(inputMap.keys.toVector) + } + super.runTests(testName, args) + } + override def afterAll(): Unit = { executor.terminateAndAssertInexistanceOfTimeout() gobraInstance = null @@ -48,16 +68,18 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { override def run(input: AnnotatedTestInput): Seq[AbstractOutput] = { - val source = FromFileSource(input.file) val config = Config( logLevel = Level.INFO, reporter = NoopReporter, - packageInfoInputMap = Map(Source.getPackageInfo(source, Path.of("")) -> Vector(source)), + packageInfoInputMap = inputMapping.toMap, checkConsistency = true, + cacheParser = cacheParser, z3Exe = z3Exe ) - val (result, elapsedMilis) = time(() => Await.result(gobraInstance.verify(config.packageInfoInputMap.keys.head, config)(executor), Duration.Inf)) + val source = FromFileSource(input.file) + val pkgInfo = Source.getPackageInfo(source, Path.of("")) + val (result, elapsedMilis) = time(() => Await.result(gobraInstance.verify(pkgInfo, config)(executor), Duration.Inf)) info(s"Time required: $elapsedMilis ms") From ed3aaf4427da04fd26fd06718958102d90176124 Mon Sep 17 00:00:00 2001 From: Felix Wolf <60103963+Felalolf@users.noreply.github.com> Date: Wed, 31 May 2023 20:13:16 +0200 Subject: [PATCH 18/54] Fix #655 (#656) * Fix #655 * fixed reintroduced bug --- .../scala/viper/gobra/frontend/Desugar.scala | 2 +- .../viper/gobra/frontend/info/base/Type.scala | 14 ++++++++++++-- .../implementation/property/Assignability.scala | 4 ++-- .../resolution/NameResolution.scala | 7 +++++-- .../info/implementation/typing/ExprTyping.scala | 6 ++---- .../info/implementation/typing/IdTyping.scala | 6 ++---- .../info/implementation/typing/TypeTyping.scala | 4 ++-- .../typing/ghost/GhostIdTyping.scala | 11 +++++------ .../typing/ghost/GhostMiscTyping.scala | 10 ++++------ .../resources/regressions/issues/000655.gobra | 16 ++++++++++++++++ .../regressions/issues/000655/pkg/f.gobra | 14 ++++++++++++++ 11 files changed, 65 insertions(+), 29 deletions(-) create mode 100644 src/test/resources/regressions/issues/000655.gobra create mode 100644 src/test/resources/regressions/issues/000655/pkg/f.gobra diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index 0eff086cd..a87ad2d99 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -3736,7 +3736,7 @@ object Desugar { case t: Type.AdtClauseT => val tAdt = Type.AdtT(t.adtT, t.context) val adt: in.AdtT = in.AdtT(nm.adt(tAdt), addrMod) - val fields: Vector[in.Field] = (t.fields map { case (key: String, typ: Type) => + val fields: Vector[in.Field] = (t.fieldsWithTypes map { case (key: String, typ: Type) => in.Field(nm.adtField(key, tAdt), typeD(typ, Addressability.mathDataStructureElement)(src), true)(src) }).toVector in.AdtClauseT(idName(t.decl.id, t.context.getTypeInfo), adt, fields, addrMod) diff --git a/src/main/scala/viper/gobra/frontend/info/base/Type.scala b/src/main/scala/viper/gobra/frontend/info/base/Type.scala index 4e600a0fd..5604d4e22 100644 --- a/src/main/scala/viper/gobra/frontend/info/base/Type.scala +++ b/src/main/scala/viper/gobra/frontend/info/base/Type.scala @@ -13,7 +13,7 @@ import viper.gobra.frontend.info.ExternalTypeInfo import viper.gobra.util.TypeBounds import scala.annotation.tailrec -import scala.collection.immutable.{ListMap, SeqMap} +import scala.collection.immutable.ListMap object Type { @@ -58,7 +58,17 @@ object Type { case class AdtT(decl: PAdtType, context: ExternalTypeInfo) extends Type - case class AdtClauseT(fields: SeqMap[String, Type], decl: PAdtClause, adtT: PAdtType, context: ExternalTypeInfo) extends Type + case class AdtClauseT(fieldsToTypes: Map[String, Type], fields: Vector[String], decl: PAdtClause, adtT: PAdtType, context: ExternalTypeInfo) extends Type { + require(fields.forall(fieldsToTypes.isDefinedAt), "there must be a type for each key") + + def typeAt(idx: Int): Type = { + require(0 <= idx && idx < fields.size, s"index $idx is not within range of ADT fields (size ${fields.size})") + fieldsToTypes(fields(idx)) + } + + lazy val fieldsWithTypes: Vector[(String, Type)] = fields.map(f => (f, fieldsToTypes(f))) + lazy val fieldTypes: Vector[Type] = fieldsWithTypes.map(_._2) + } case class MapT(key: Type, elem: Type) extends PrettyType(s"map[$key]$elem") diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/property/Assignability.scala b/src/main/scala/viper/gobra/frontend/info/implementation/property/Assignability.scala index 4c0bd33fb..e79d3a9d3 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/property/Assignability.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/property/Assignability.scala @@ -184,7 +184,7 @@ trait Assignability extends BaseProperty { this: TypeInfoImpl => if (elems.isEmpty) { successProp } else if (elems.exists(_.key.nonEmpty)) { - val tmap: Map[String, Type] = a.fields + val tmap: Map[String, Type] = a.fieldsToTypes failedProp("for adt literals either all or none elements must be keyed", !elems.forall(_.key.nonEmpty)) and @@ -198,7 +198,7 @@ trait Assignability extends BaseProperty { this: TypeInfoImpl => }) } else if (elems.size == a.fields.size) { propForall( - elems.map(_.exp).zip(a.fields.values), + elems.map(_.exp).zip(a.fieldTypes), compositeValAssignableTo ) } else { diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/NameResolution.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/NameResolution.scala index b9b9da4db..7925531d6 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/NameResolution.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/NameResolution.scala @@ -94,9 +94,12 @@ trait NameResolution { case tree.parent.pair(decl: PAdtClause, adtDecl: PAdtType) => AdtClause(decl, adtDecl, this) - case tree.parent.pair(decl: PMatchBindVar, adt: PMatchAdt) => MatchVariable(decl, adt, this) case tree.parent.pair(decl: PMatchBindVar, tree.parent.pair(_: PMatchStmtCase, matchE: PMatchStatement)) => - MatchVariable(decl, matchE.exp, this) + MatchVariable(decl, matchE.exp, this) // match full expression of match statement + case tree.parent.pair(decl: PMatchBindVar, tree.parent.pair(_: PMatchExpCase, matchE: PMatchExp)) => + MatchVariable(decl, matchE.exp, this) // match full expression of match expression + case tree.parent.pair(decl: PMatchBindVar, adt: PMatchAdt) => + MatchVariable(decl, adt, this) // match part of subexpression case c => Violation.violation(s"This case should be unreachable, but got $c") } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ExprTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ExprTyping.scala index 902d34a80..40ad6d048 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ExprTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ExprTyping.scala @@ -14,8 +14,6 @@ import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.util.TypeBounds.{BoundedIntegerKind, UnboundedInteger} import viper.gobra.util.{Constants, TypeBounds, Violation} -import scala.collection.immutable.ListMap - trait ExprTyping extends BaseTyping { this: TypeInfoImpl => import viper.gobra.util.Violation._ @@ -147,8 +145,8 @@ trait ExprTyping extends BaseTyping { this: TypeInfoImpl => case Some(p: ap.DomainFunction) => FunctionT(p.symb.args map p.symb.context.typ, p.symb.context.typ(p.symb.result)) case Some(p: ap.AdtClause) => - val fields = ListMap.from(p.symb.fields.map(f => f.id.name -> p.symb.context.symbType(f.typ))) - AdtClauseT(fields, p.symb.decl, p.symb.adtDecl, this) + val fields = p.symb.fields.map(f => f.id.name -> p.symb.context.symbType(f.typ)) + AdtClauseT(fields.toMap, fields.map(_._1), p.symb.decl, p.symb.adtDecl, this) case Some(p: ap.AdtField) => p.symb match { case AdtDestructor(decl, _, context) => context.symbType(decl.typ) diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/IdTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/IdTyping.scala index 492d515f8..c62376ec4 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/IdTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/IdTyping.scala @@ -14,8 +14,6 @@ import viper.gobra.frontend.info.base.Type._ import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.property.{AssignMode, StrictAssignMode} -import scala.collection.immutable.ListMap - trait IdTyping extends BaseTyping { this: TypeInfoImpl => import viper.gobra.util.Violation._ @@ -159,8 +157,8 @@ trait IdTyping extends BaseTyping { this: TypeInfoImpl => // ADT clause is special since it is a type with a name that is not a named type case a: AdtClause => - val types = ListMap.from(a.fields.map(f => f.id.name -> a.context.symbType(f.typ))) - AdtClauseT(types, a.decl, a.adtDecl, this) + val fields = a.fields.map(f => f.id.name -> a.context.symbType(f.typ)) + AdtClauseT(fields.toMap, fields.map(_._1), a.decl, a.adtDecl, this) case BuiltInType(tag, _, _) => tag.typ case _ => violation(s"expected type, but got $id") diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/TypeTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/TypeTyping.scala index b5eeb6518..bbfa0a00f 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/TypeTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/TypeTyping.scala @@ -155,8 +155,8 @@ trait TypeTyping extends BaseTyping { this: TypeInfoImpl => // ADT clause is special since it is a type with a name that is not a named type case Some(p: ap.AdtClause) => - val types = ListMap.from(p.symb.fields.map(f => f.id.name -> p.symb.context.symbType(f.typ))) - AdtClauseT(types, p.symb.decl, p.symb.adtDecl, p.symb.context) + val fields = p.symb.fields.map(f => f.id.name -> p.symb.context.symbType(f.typ)) + AdtClauseT(fields.toMap, fields.map(_._1), p.symb.decl, p.symb.adtDecl, p.symb.context) case _ => violation(s"expected type, but got $n") } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostIdTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostIdTyping.scala index b2688de4d..a071b79af 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostIdTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostIdTyping.scala @@ -14,7 +14,6 @@ import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.util.Violation.violation import scala.annotation.unused -import scala.collection.immutable.ListMap trait GhostIdTyping { this: TypeInfoImpl => @@ -42,8 +41,10 @@ trait GhostIdTyping { this: TypeInfoImpl => case func: DomainFunction => FunctionT(func.args map func.context.typ, func.context.typ(func.result.outs.head)) case AdtClause(decl, adtDecl, context) => + val fields = decl.args.flatMap(_.fields).map(f => f.id.name -> context.symbType(f.typ)) AdtClauseT( - ListMap.from(decl.args.flatMap(_.fields).map(f => f.id.name -> context.symbType(f.typ))), + fields.toMap, + fields.map(_._1), decl, adtDecl, context @@ -51,10 +52,8 @@ trait GhostIdTyping { this: TypeInfoImpl => case MatchVariable(decl, p, context) => p match { case PMatchAdt(clause, fields) => - val argTypeWithIndex = context.symbType(clause).asInstanceOf[AdtClauseT].decl.args.flatMap(_.fields).map(_.typ).zipWithIndex - val fieldsWithIndex = fields.zipWithIndex - val fieldIndex = fieldsWithIndex.iterator.find(e => e._1 == decl).get._2 - context.symbType(argTypeWithIndex.iterator.find(e => e._2 == fieldIndex).get._1) + val clauseT = context.symbType(clause).asInstanceOf[AdtClauseT] + clauseT.typeAt(fields.indexOf(decl)) case e: PExpression => context.typ(e) case _ => violation("untypeable") diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMiscTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMiscTyping.scala index 7eff705f7..3ab5e4a53 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMiscTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMiscTyping.scala @@ -54,8 +54,8 @@ trait GhostMiscTyping extends BaseTyping { this: TypeInfoImpl => case m: PMatchPattern => m match { case PMatchAdt(clause, fields) => symbType(clause) match { case t: AdtClauseT => - val fieldTypes = fields map typ - val clauseFieldTypes = t.decl.args.flatMap(f => f.fields).map(f => symbType(f.typ)) + val fieldTypes = fields.map(typ) + val clauseFieldTypes = t.fieldTypes error(m, s"Expected ${clauseFieldTypes.size} patterns, but got ${fieldTypes.size}", clauseFieldTypes.size != fieldTypes.size) ++ fieldTypes.zip(clauseFieldTypes).flatMap(a => assignableTo.errors(a)(m)) case _ => violation("Pattern matching only works on ADT Literals") @@ -292,10 +292,8 @@ trait GhostMiscTyping extends BaseTyping { this: TypeInfoImpl => w eq _ } val adtClauseT = underlyingType(typeSymbType(c)).asInstanceOf[AdtClauseT] - val flatFields = adtClauseT.decl.args.flatMap(f => f.fields) - if (index < flatFields.size) { - val field = flatFields(index) - typeSymbType(field.typ) + if (index < adtClauseT.fields.size) { + adtClauseT.typeAt(index) } else UnknownType // Error is found when PMatchADT is checked higher up the ADT case tree.parent.pair(_: PMatchExpCase, m: PMatchExp) => exprType(m.exp) diff --git a/src/test/resources/regressions/issues/000655.gobra b/src/test/resources/regressions/issues/000655.gobra new file mode 100644 index 000000000..fcafa8991 --- /dev/null +++ b/src/test/resources/regressions/issues/000655.gobra @@ -0,0 +1,16 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package test + +// ##(-I ./000655/) +import "pkg" + +ghost +pure func foo(x pkg.List) bool { + return match x { + case pkg.Nil{}: true + case pkg.Cons{?head, pkg.Nil{}}: true + case _: false + } +} \ No newline at end of file diff --git a/src/test/resources/regressions/issues/000655/pkg/f.gobra b/src/test/resources/regressions/issues/000655/pkg/f.gobra new file mode 100644 index 000000000..2252d81b9 --- /dev/null +++ b/src/test/resources/regressions/issues/000655/pkg/f.gobra @@ -0,0 +1,14 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type List adt { + Cons { + head int + tail List + } + + Nil {} +} + From 4393ad0cc95b7403d1703aa83906595405fd501b Mon Sep 17 00:00:00 2001 From: viper-admin <59963956+viper-admin@users.noreply.github.com> Date: Wed, 31 May 2023 20:13:50 +0200 Subject: [PATCH 19/54] Updates submodules (#657) Co-authored-by: jcp19 --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index 7bc6d0da0..ae6a1c153 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit 7bc6d0da082e89f2d3defd7f0a20b33f12dd2c26 +Subproject commit ae6a1c153152bdae0005850190b24f0212113474 From 046fe54b0db5cec24c23ab232407720782017580 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 29 Jun 2023 16:43:04 +0200 Subject: [PATCH 20/54] unifies job managers for parsing and type-checking and for the 3 modes --- src/main/scala/viper/gobra/Gobra.scala | 8 +- .../scala/viper/gobra/frontend/Parser.scala | 300 +++--------------- .../viper/gobra/frontend/TaskManager.scala | 170 ++-------- .../viper/gobra/frontend/info/Info.scala | 219 ++++--------- .../viper/gobra/DetailedBenchmarkTests.scala | 6 +- src/test/scala/viper/gobra/GobraTests.scala | 6 +- .../gobra/erasing/GhostErasureUnitTests.scala | 16 +- .../gobra/typing/ExprTypingUnitTests.scala | 16 +- .../gobra/typing/StmtTypingUnitTests.scala | 16 +- .../gobra/typing/TypeTypingUnitTests.scala | 16 +- 10 files changed, 196 insertions(+), 577 deletions(-) diff --git a/src/main/scala/viper/gobra/Gobra.scala b/src/main/scala/viper/gobra/Gobra.scala index b215f88d6..e0596f2ee 100644 --- a/src/main/scala/viper/gobra/Gobra.scala +++ b/src/main/scala/viper/gobra/Gobra.scala @@ -16,7 +16,7 @@ import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.{CGEdgesTerminationTransform, ConstantPropagation, InternalTransform, OverflowChecksTransform} import viper.gobra.backend.BackendVerifier import viper.gobra.frontend.PackageResolver.{AbstractPackage, RegularPackage} -import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} +import viper.gobra.frontend.Parser.ParseResult import viper.gobra.frontend.info.{Info, TypeInfo} import viper.gobra.frontend.{Config, Desugar, PackageInfo, Parser, ScallopGobraConfig} import viper.gobra.reporting._ @@ -159,7 +159,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { for { finalConfig <- getAndMergeInFileConfig(config, pkgInfo) _ = setLogLevel(finalConfig) - parseResults <- performParsing(finalConfig, pkgInfo)(executor) + parseResults = performParsing(finalConfig, pkgInfo)(executor) typeInfo <- performTypeChecking(finalConfig, pkgInfo, parseResults)(executor) program <- performDesugaring(finalConfig, typeInfo)(executor) program <- performInternalTransformations(finalConfig, pkgInfo, program)(executor) @@ -243,7 +243,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { .setLevel(config.logLevel) } - private def performParsing(config: Config, pkgInfo: PackageInfo)(executor: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseResult]] = { + private def performParsing(config: Config, pkgInfo: PackageInfo)(executor: GobraExecutionContext): Map[AbstractPackage, ParseResult] = { if (config.shouldParse) { val startMs = System.currentTimeMillis() val res = Parser.parse(config, pkgInfo)(executor) @@ -253,7 +253,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { } res } else { - Left(Vector()) + Map.empty } } diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index 9a68e6693..f7504b8a8 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -17,56 +17,39 @@ import org.antlr.v4.runtime.{CharStreams, CommonTokenStream, DefaultErrorStrateg import org.antlr.v4.runtime.atn.PredictionMode import org.antlr.v4.runtime.misc.ParseCancellationException import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} -import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport, RegularPackage} -import viper.gobra.frontend.Parser.ParseSuccessResult -import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} +import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} import viper.gobra.util.GobraExecutionContext import viper.silver.ast.SourcePosition import scala.collection.mutable.ListBuffer import java.security.MessageDigest import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} -import scala.concurrent.duration.Duration -import scala.concurrent.{Await, Future} + object Parser { type ParseSuccessResult = (Vector[Source], PPackage) type ParseResult = Either[Vector[ParserError], ParseSuccessResult] + type PreprocessedSources = Vector[Source] + type ImportToSourceOrErrorMap = Vector[(AbstractPackage, Either[Vector[ParserError], Vector[Source]])] class ParseManager(config: Config, executionContext: GobraExecutionContext) extends LazyLogging { - private val manager = new TaskManager[AbstractPackage, ParseResult](Sequential) // we currently do not support the lazy mode - private val parallelManager = new ParallelTaskManager[AbstractPackage, ParseResult] + private val manager = new TaskManager[AbstractPackage, PreprocessedSources, ParseResult](config.typeCheckMode)(executionContext) - def parse(pkgInfo: PackageInfo): ParseResult = { + def parse(pkgInfo: PackageInfo): Unit = { val pkg = RegularPackage(pkgInfo.id) - /* - manager.addIfAbsent(pkg, parseJob)(executionContext) - // trigger and wait for parsing of at least this package (which will ensure that parse jobs for all dependent packages are created too) - Await.result(manager.getResult(pkg), Duration.Inf) - */ - config.typeCheckMode match { - case Lazy | Sequential => - val parseJob = ParseInfoJob(pkgInfo) - manager.addIfAbsent(pkg, parseJob) - manager.getResult(pkg) - case Parallel => - val parseJob = ParallelParseInfoJob(pkgInfo) - val fut = parallelManager.addIfAbsent(pkg, parseJob)(executionContext) - Await.result(fut, Duration.Inf) - } + val parseJob = ParseInfoJob(pkgInfo) + manager.addIfAbsent(pkg, parseJob) } /** this is only used for unit testing to fill the parse cache */ def parseAll(pkgInfos: Vector[PackageInfo]): Map[PackageInfo, ParseResult] = { - val createdFuts = pkgInfos.map(pkgInfo => { + pkgInfos.foreach(pkgInfo => parse(pkgInfo)) + val results = manager.getAllResultsWithKeys.toMap + pkgInfos.map(pkgInfo => { val pkg = RegularPackage(pkgInfo.id) - val parseJob = ParallelParseInfoJob(pkgInfo) - parallelManager.addIfAbsent(pkg, parseJob)(executionContext) - .map(res => (pkgInfo, res))(executionContext) - }) - implicit val executor: GobraExecutionContext = executionContext - Await.result(Future.sequence(createdFuts), Duration.Inf).toMap + (pkgInfo, results(pkg)) + }).toMap } trait ImportResolver { @@ -116,44 +99,13 @@ object Parser { } } - trait ParseJob extends Job[ParseResult] with ImportResolver { + trait ParseJob extends Job[PreprocessedSources, ParseResult] with ImportResolver { def pkgInfo: PackageInfo def pkgSources: Vector[Source] def specOnly: Boolean + var preambleParsingDurationMs: Long = 0 - private def getImportsForPackage(p: PPackage): Vector[(AbstractPackage, Either[Vector[ParserError], Vector[Source]])] = { - getImports(p.imports, p.positions) - } - - override def compute(): ParseResult = { - require(pkgSources.nonEmpty) - - val startMs = System.currentTimeMillis() - val preprocessedSources = preprocess(pkgSources)(config) - - for { - parsedProgram <- Parser.process(preprocessedSources, pkgInfo, specOnly = specOnly)(config) - imports = getImportsForPackage(parsedProgram) - _ = imports.map { - case (directImportPackage, Right(nonEmptySources)) => manager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage)) - case (directImportPackage, Left(errs)) => manager.addIfAbsent(directImportPackage, ParseFailureJob(errs)) - } - postprocessedProgram <- Parser.postprocess(Right((preprocessedSources, parsedProgram)), specOnly = specOnly)(config) - _ = logger.trace { - val parsingDurationMs = System.currentTimeMillis() - startMs - val parsingDurationS = f"${parsingDurationMs / 1000f}%.1f" - s"parsing ${pkgInfo.id} done (took ${parsingDurationS}s)" - } - } yield postprocessedProgram - } - } - - trait ParallelParseJob extends ParallelJob[ParseResult] with ImportResolver { - def pkgInfo: PackageInfo - def pkgSources: Vector[Source] - def specOnly: Boolean - - private def getImportsForPackage(preprocessedSources: Vector[Source]): Vector[(AbstractPackage, Either[Vector[ParserError], Vector[Source]])] = { + private def getImportsForPackage(preprocessedSources: Vector[Source]): ImportToSourceOrErrorMap = { val preambles = preprocessedSources .map(preprocessedSource => processPreamble(preprocessedSource)(config)) // we ignore imports in files that cannot be parsed: @@ -161,75 +113,28 @@ object Parser { preambles.flatMap(preamble => getImports(preamble.imports, preamble.positions)) } - override def compute(): Future[ParseResult] = { - require(pkgSources.nonEmpty) - + protected override def sequentialPrecompute(): PreprocessedSources = { val preprocessedSources = preprocess(pkgSources)(config) - val startPreambleParsingMs = System.currentTimeMillis() - // before parsing, get imports and add these parse jobs - // val imports = fastParse(preprocessedSources) val imports = getImportsForPackage(preprocessedSources) - val preambleParsingDurationMs = System.currentTimeMillis() - startPreambleParsingMs - /* - val importResults: Set[Either[Vector[ParserError], Future[_]]] = imports.map { case (directImportTarget, importErrorFactory) => - // val importResults: Set[Future[ParseResult]] = imports.map { case (directImportTarget, importErrorFactory) => - val directImportPackage = AbstractPackage(directImportTarget)(config) - val nonEmptyImportedSources = for { - resolveSourceResults <- PackageResolver.resolveSources(directImportTarget)(config) - importedSources = resolveSourceResults.map(_.source) - nonEmptyImportedSources <- if (importedSources.isEmpty) Left(s"No source files for package '$directImportTarget' found") else Right(importedSources) - } yield nonEmptyImportedSources - nonEmptyImportedSources.fold( - errMsg => { - val errs = importErrorFactory(errMsg) - parallelManager.addIfAbsent(directImportPackage, ParseFailureJob(errs))(executionContext) - Left(errs) - }, - nonEmptySources => { - // manager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage))(executionContext) - // Right(manager.getFuture(directImportPackage)) - Right(parallelManager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage))(executionContext)) - *//* - manager.getFuture(directImportPackage).flatten - .map { - case Left(_) => Left(importErrorFactory(s"Imported package contains errors")) - case success => success - }(executionContext) - *//* - }) - *//* - val importedSources = PackageResolver.resolveSources(directImportTarget)(config) - .getOrElse(Vector()) - .map(_.source) - if (importedSources.isEmpty) { - val errMsg = s"No source files for package '$directImportTarget' found" - manager.addIfAbsent(directImportPackage, ParseFailureJob(Vector(NotFoundError(errMsg))))(executionContext) - Future.successful(Left(importErrorFactory(errMsg))) - } else { - manager.addIfAbsent(directImportPackage, ParseSourcesJob(importedSources, directImportPackage))(executionContext) - manager.getFuture(directImportPackage).flatten - .map { - case Left(errs) => Left(importErrorFactory(s"Imported package contains errors")) - case success => success - }(executionContext) - } - *//* - } - */ - val importResults: Vector[Either[Vector[ParserError], Future[_]]] = imports.map { - case (directImportPackage, Right(nonEmptySources)) => Right(parallelManager.addIfAbsent(directImportPackage, ParallelParseSourcesJob(nonEmptySources, directImportPackage))(executionContext)) + preambleParsingDurationMs = System.currentTimeMillis() - startPreambleParsingMs + + // add imported packages to manager if not already + imports.foreach { + case (directImportPackage, Right(nonEmptySources)) => + manager.addIfAbsent(directImportPackage, ParseSourcesJob(nonEmptySources, directImportPackage)) case (directImportPackage, Left(errs)) => - parallelManager.addIfAbsent(directImportPackage, ParallelParseFailureJob(errs))(executionContext) - Left(errs) + manager.addIfAbsent(directImportPackage, ParseFailureJob(errs)) } - val (importFailures, futs) = importResults.partitionMap(identity) - val flatImportFailures = importFailures.flatten + preprocessedSources + } - val res: ParseResult = for { - _ <- if (flatImportFailures.isEmpty) Right(()) else Left(flatImportFailures) - startMs = System.currentTimeMillis() + protected def compute(preprocessedSources: PreprocessedSources): ParseResult = { + // note that we do not check here whether there have been parse errors in the imported packages as this would + // introduce additional synchronization + val startMs = System.currentTimeMillis() + for { parsedProgram <- Parser.process(preprocessedSources, pkgInfo, specOnly = specOnly)(config) postprocessedProgram <- Parser.postprocess(Right((preprocessedSources, parsedProgram)), specOnly = specOnly)(config) _ = logger.trace { @@ -239,81 +144,7 @@ object Parser { s"parsing ${pkgInfo.id} done (took ${parsingDurationS}s; parsing preamble overhead is ${preambleParsingRatio}%)" } } yield (pkgSources, postprocessedProgram._2) // we use `pkgSources` as the preprocessing of sources should be transparent from the outside - - /* - val startMs = System.currentTimeMillis() - val res = for { - parsedProgram <- Parser.process(preprocessedSources, pkgInfo, specOnly = specOnly)(config) - } yield (pkgSources, parsedProgram) - - logger.trace { - val parsingDurationMs = System.currentTimeMillis() - startMs - val parsingDurationS = f"${parsingDurationMs / 1000f}%.1f" - val preambleParsingRatio = f"${100f * preambleParsingDurationMs / parsingDurationMs}%.1f" - s"parsing ${pkgInfo.id} done (took ${parsingDurationS}s; parsing preamble overhead is ${preambleParsingRatio}%)" - }*/ - - implicit val executor: GobraExecutionContext = executionContext - /* - Future.sequence(importResults) - .map(dependencyResults => { - val (importErrors, _) = dependencyResults.partitionMap(identity) - val flatImportFailures = importErrors.toVector.flatten - if (flatImportFailures.isEmpty) { - // we only post-process if dependent packages where successful - Parser.postprocess(res, specOnly = specOnly)(config) - } else { - config.reporter report ParserErrorMessage(flatImportFailures.head.position.get.file, flatImportFailures) - Left(flatImportFailures) - } - /* - if (dependencyResults.forall(_.isRight)) { - // we only post-process if dependent packages where successful - Parser.postprocess(res, specOnly = specOnly)(config) - } else { - // we return an empty list of errors not to duplicate errors - Left(Vector.empty) - } - */ - }) - */ - Future.sequence(futs) - .map(_ => res) } - /* - type ImportErrorFactory = String => Vector[ParserError] - private def fastParse(preprocessedInput: Vector[Source]): Set[(AbstractImport, ImportErrorFactory)] = { - def getImportPaths(preprocessedSource: Source): Set[(RegularImport, ImportErrorFactory)] = { - processPreamble(preprocessedSource)(config) - .map(preamble => { - val pom = preamble.positions - preamble.imports - .map(importNode => { - val importErrorFactory: ImportErrorFactory = (errMsg: String) => { - val err = pom.translate(message(importNode, errMsg), ParserError) - // config.reporter report ParserErrorMessage(err.head.position.get.file, err) - err - } - (RegularImport(importNode.importPath), importErrorFactory) - }) - .toSet - }) - .getOrElse(Set.empty) - } - - val explicitImports: Set[(AbstractImport, ImportErrorFactory)] = preprocessedInput.flatMap(getImportPaths).toSet - if (pkgInfo.isBuiltIn) { - explicitImports - } else { - val builtInImportErrorFactory: ImportErrorFactory = (errMsg: String) => { - val err = Vector(ParserError(errMsg, None)) - config.reporter report ParserErrorMessage(err.head.position.get.file, err) - err - } - val builtInImportTuple = (BuiltInImport, builtInImportErrorFactory) - explicitImports + builtInImportTuple - } - }*/ } /** this job is used to parse the package that should be verified */ @@ -321,10 +152,6 @@ object Parser { lazy val pkgSources: Vector[Source] = config.packageInfoInputMap(pkgInfo) lazy val specOnly: Boolean = false } - case class ParallelParseInfoJob(override val pkgInfo: PackageInfo) extends ParallelParseJob { - lazy val pkgSources: Vector[Source] = config.packageInfoInputMap(pkgInfo) - lazy val specOnly: Boolean = false - } /** this job is used to parse all packages that are imported */ case class ParseSourcesJob(override val pkgSources: Vector[Source], pkg: AbstractPackage) extends ParseJob { @@ -332,44 +159,15 @@ object Parser { lazy val pkgInfo: PackageInfo = Source.getPackageInfo(pkgSources.head, config.projectRoot) lazy val specOnly: Boolean = true } - case class ParallelParseSourcesJob(override val pkgSources: Vector[Source], pkg: AbstractPackage) extends ParallelParseJob { - require(pkgSources.nonEmpty) - lazy val pkgInfo: PackageInfo = Source.getPackageInfo(pkgSources.head, config.projectRoot) - lazy val specOnly: Boolean = true - } - - case class ParseFailureJob(errs: Vector[ParserError]) extends Job[ParseResult] { - override def compute(): ParseResult = Left(errs) - } - case class ParallelParseFailureJob(errs: Vector[ParserError]) extends ParallelJob[ParseResult] { - override def compute(): Future[ParseResult] = Future.successful[ParseResult](Left(errs)) - } - /* - def getParseResults(executionContext: GobraExecutionContext): Either[Map[AbstractPackage, Vector[VerifierError]], Map[AbstractPackage, ParseSuccessResult]] = { - implicit val executor: GobraExecutionContext = executionContext - // val futs = manager.getAllResultsWithKeys(executionContext).map { case (key, fut) => fut.map(res => (key, res)) } - val futs = manager.getAllFutures.map { case (key, fut) => fut.flatten.map(res => (key, res)) } - val results = Await.result(Future.sequence(futs), Duration.Inf) - val (failedResults, successfulResults) = results - .partitionMap { case (key, eitherResult) => eitherResult.fold[Either[(AbstractPackage, Vector[VerifierError]), (AbstractPackage, ParseSuccessResult)]](errs => Left((key, errs)), result => Right((key, result))) } - if (failedResults.isEmpty) Right(successfulResults.toMap) - else Left(failedResults.toMap) + case class ParseFailureJob(errs: Vector[ParserError]) extends Job[PreprocessedSources, ParseResult] { + override protected def sequentialPrecompute(): PreprocessedSources = + Vector.empty + override protected def compute(precomputationResult: PreprocessedSources): ParseResult = + Left(errs) } - def getSuccessResults(executionContext: GobraExecutionContext): Map[AbstractPackage, ParseSuccessResult] = { - implicit val executor: GobraExecutionContext = executionContext - val futs = manager.getAllFutures.map { case (key, fut) => fut.flatten.map(res => (key, res)) } - val results = Await.result(Future.sequence(futs), Duration.Inf) - results - .collect { case (key, Right(res)) => (key, res) } - .toMap - } - */ - def getResults(executionContext: GobraExecutionContext): Map[AbstractPackage, ParseResult] = config.typeCheckMode match { - case Lazy | Sequential => manager.getAllResultsWithKeys.toMap - case Parallel => parallelManager.getAllResultsWithKeys(executionContext).toMap - } + def getResults: Map[AbstractPackage, ParseResult] = manager.getAllResultsWithKeys.toMap } /** @@ -388,15 +186,10 @@ object Parser { * */ - def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseResult]] = { + def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Map[AbstractPackage, ParseResult] = { val parseManager = new ParseManager(config, executionContext) - /* parseManager.parse(pkgInfo) - val res = parseManager.getParseResults(executionContext).left.map(errMap => errMap.values.flatten.toVector) - res - */ - val res = parseManager.parse(pkgInfo) - res.map(_ => parseManager.getResults(executionContext)) + parseManager.getResults } def parse(input: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean = false)(config: Config): Either[Vector[VerifierError], PPackage] = { @@ -431,7 +224,7 @@ object Parser { val res = preambleCache.computeIfAbsent(getPreambleCacheKey(preprocessedSource), _ => parseAndStore()) if (!cacheHit) { - println(s"No cache hit for ${res.map(_.packageClause.id.name)}'s preamble") + println(s"No cache hit for ${res.map(_.packageClause.id.name)}'s preamble (${preambleCache.size()} entries in cache)") } res } @@ -440,19 +233,6 @@ object Parser { } private def process(preprocessedInputs: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[ParserError], PPackage] = { - /* - for { - parseAst <- parseSources(preprocessedInputs, pkgInfo, specOnly = specOnly)(config) - postprocessors = Seq( - new ImportPostprocessor(parseAst.positions.positions), - new TerminationMeasurePostprocessor(parseAst.positions.positions, specOnly = specOnly), - ) - postprocessedAst <- postprocessors.foldLeft[Either[Vector[VerifierError], PPackage]](Right(parseAst)) { - case (Right(ast), postprocessor) => postprocessor.postprocess(ast)(config) - case (e, _) => e - } - } yield postprocessedAst - */ parseSources(preprocessedInputs, pkgInfo, specOnly = specOnly)(config) } diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index f3f93f963..cad745141 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -20,13 +20,20 @@ object TaskManagerMode extends Enumeration { val Lazy, Sequential, Parallel = Value } -trait Job[R] { +trait Job[I, R] { + private lazy val precomputationResult: I = sequentialPrecompute() private var compututationStarted = false private val promise: Promise[R] = Promise() def getFuture: Future[R] = promise.future - protected def compute(): R - def call(): R = { + protected def sequentialPrecompute(): I + protected def compute(precomputationResult: I): R + + def triggerPrecomputation(): I = { + precomputationResult + } + + def execute(): R = { getFuture.value match { case Some(Success(res)) => return res // return already computed type-checker result case Some(Failure(exception)) => Violation.violation(s"Job resulted in exception: $exception") @@ -34,8 +41,8 @@ trait Job[R] { } Violation.violation(!compututationStarted, s"Job $this is already on-going") compututationStarted = true - val res = try { - val res = compute() + try { + val res = compute(precomputationResult) promise.success(res) res } catch { @@ -44,160 +51,47 @@ trait Job[R] { // propagate this exception for the case that `call` is executed synchronously: throw e } - res - } -} - -trait ParallelJob[R] { - /* - protected def compute(): Future[R] - private var compututationStarted: Option[Future[R]] = None - def call(): Future[R] = { - compututationStarted.getOrElse { - val fut = compute() - compututationStarted = Some(fut) - fut - } - } - */ - - private var compututationStarted = false - private val promise: Promise[R] = Promise() - def getFuture: Future[R] = promise.future - protected def compute(): Future[R] - - def call(executionContext: GobraExecutionContext): Future[R] = { - getFuture.value match { - case Some(Success(res)) => return Future.successful(res) // return already computed type-checker result - case Some(Failure(exception)) => Violation.violation(s"Job resulted in exception: $exception") - case _ => - } - Violation.violation(!compututationStarted, s"Job $this is already on-going") - compututationStarted = true - compute() - .map(res => { - promise.success(res) - res - })(executionContext) } } -class TaskManager[K, R](mode: TaskManagerMode) { - require(mode != Parallel) - - private val jobs: ConcurrentMap[K, Job[R]] = new ConcurrentHashMap() +class TaskManager[K, I, R](mode: TaskManagerMode)(executionContext: GobraExecutionContext) { + private val jobs: ConcurrentMap[K, Job[I, R]] = new ConcurrentHashMap() - /** - * returns true if job has been inserted and thus was previously absent - */ - def addIfAbsent(id: K, job: Job[R], insertOnly: Boolean = false): Unit = { + def addIfAbsent(id: K, job: Job[I, R]): Unit = { var isAbsent = false - // first insert job, then run it (if necessary) jobs.computeIfAbsent(id, _ => { isAbsent = true job }) - // now run it but only if it's a new job: - if (isAbsent && !insertOnly) { + if (isAbsent) { + job.triggerPrecomputation() mode match { + case Sequential => job.execute() case Lazy => // don't do anything as of now - case Sequential => job.call() + case Parallel => Future{ job.execute() }(executionContext) } } } - /* - def getFuture(id: K): Future[R] = { - val job = jobs.get(id) - Violation.violation(job != null, s"Task $id not found") - job.getFuture - } - def getAllFutures: Iterable[(K, Future[R])] = - jobs.asScala.toVector.map { case (key, job) => (key, job.getFuture) } - */ def getResult(id: K): R = { val job = jobs.get(id) Violation.violation(job != null, s"Task $id not found") - getResultFromJob(job) - } - /* - def getAllResults(executionContext: GobraExecutionContext): Iterable[R] = mode match { - case Lazy | Sequential => jobs.values().asScala.map(getResultFromJob) - case Parallel => - val futs = jobs.values().asScala.map(_.getFuture) - implicit val executor: GobraExecutionContext = executionContext - Await.result(Future.sequence(futs), Duration.Inf) - } - */ - def getAllResults: Iterable[R] = - jobs.values().asScala.map(getResultFromJob) - /* - def getAllResultsWithKeys(executionContext: GobraExecutionContext): Iterable[(K, R)] = mode match { - case Lazy | Sequential => jobs.asScala.toVector.map { case (key, job) => (key, getResultFromJob(job)) } - case Parallel => - implicit val executor: GobraExecutionContext = executionContext - val futs = jobs.asScala.toVector.map { case (key, job) => job.getFuture.map(res => (key, res)) } - Await.result(Future.sequence(futs), Duration.Inf) - } - */ - def getAllResultsWithKeys: Iterable[(K, R)] = - jobs.asScala.toVector.map { case (key, job) => (key, getResultFromJob(job)) } - - private def getResultFromJob(job: Job[R]): R = mode match { - case Lazy => job.call() // we perform the computation now that we need the result - case Sequential => - // note that we cannot await the future here as type-checking of this package might not have started yet. - // Thus, we use `.call()` that either returns a previously calculated type-checking result or will calculate it. - job.call() - // case Parallel => - // Await.result(job.getFuture, Duration.Inf) - } -} - -class ParallelTaskManager[K, R] { - private val jobs: ConcurrentMap[K, ParallelJob[R]] = new ConcurrentHashMap() - - /** - * returns true if job has been inserted and thus was previously absent - */ - def addIfAbsent(id: K, job: ParallelJob[R], insertOnly: Boolean = false)(executionContext: GobraExecutionContext): Future[R] = { - var isAbsent = false - // first insert job, then run it (if necessary) - val res = jobs.computeIfAbsent(id, _ => { - isAbsent = true - job - }) - // now run it but only if it's a new job: - if (isAbsent && !insertOnly) { - job.call(executionContext) + mode match { + case Lazy => job.execute() // now we need the job's result + case _ => } - // return the future (either of the inserted job or the already existing job with the same id) - res.getFuture + Await.result(job.getFuture, Duration.Inf) } - def getAllResultsWithKeys(executionContext: GobraExecutionContext): Iterable[(K, R)] = { - implicit val executor: GobraExecutionContext = executionContext - val futs = jobs.asScala.toVector.map { case (key, job) => job.getFuture.map(res => (key, res)) } - Await.result(Future.sequence(futs), Duration.Inf) - } -} - -class FutureManager[K, R]() { - private val futures: ConcurrentMap[K, Future[R]] = new ConcurrentHashMap() - - def addIfAbsent(id: K, futFn: () => Future[R]): Future[R] = { - // first insert job, then run it (if necessary) - futures.computeIfAbsent(id, _ => futFn()) - } - - def getFuture(id: K): Future[R] = { - val fut = futures.get(id) - Violation.violation(fut != null, s"Task $id not found") - fut - } - - def getAllResults(executionContext: GobraExecutionContext): Iterable[R] = { + def getAllResultsWithKeys: Iterable[(K, R)] = { implicit val executor: GobraExecutionContext = executionContext - Await.result(Future.sequence(futures.values().asScala), Duration.Inf) + val futs = jobs.asScala.toVector.map { case (key, job) => + mode match { + case Lazy => job.execute() // now we need the job's result + case _ => + } + job.getFuture.map(res => (key, res)) + } + Await.result(Future.sequence(futs), Duration.Inf) } } diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 404c05d05..e474c1504 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -11,20 +11,18 @@ import org.bitbucket.inkytonik.kiama.relation.Tree import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, message} import org.bitbucket.inkytonik.kiama.util.{Position, Source} import viper.gobra.ast.frontend.{PImport, PNode, PPackage} -import viper.gobra.frontend.{Config, Job, ParallelJob, ParallelTaskManager, TaskManager} +import viper.gobra.frontend.{Config, Job, TaskManager} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport} import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} -import viper.gobra.frontend.info.Info.CycleChecker import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.{GhostLessPrinter, GoifyingPrinter} import viper.gobra.reporting.{CyclicImportError, ParserError, TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} import viper.gobra.util.{GobraExecutionContext, Violation} import java.security.MessageDigest +import java.util.concurrent.atomic.AtomicLong import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} -import scala.concurrent.duration.Duration -import scala.concurrent.{Await, Future} object Info extends LazyLogging { @@ -168,155 +166,68 @@ object Info extends LazyLogging { * Therefore, package management is centralized. */ class Context(val config: Config, val parseResults: Map[AbstractPackage, ParseSuccessResult])(val executionContext: GobraExecutionContext) extends GetParseResult { - private val typeCheckManager = new TaskManager[AbstractPackage, TypeCheckResult](if (config.typeCheckMode == Parallel) Sequential else config.typeCheckMode) - private val parallelTypeCheckManager = new ParallelTaskManager[AbstractPackage, TypeCheckResult]() + private val typeCheckManager = new TaskManager[AbstractPackage, (Vector[Source], PPackage, Vector[AbstractImport]), () => TypeCheckResult](config.typeCheckMode)(executionContext) - trait TypeCheckJob { - protected def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isMainContext: Boolean = false): TypeCheckResult = { - val startMs = System.currentTimeMillis() - logger.trace(s"start type-checking ${pkg.info.id}") - val res = Info.checkSources(pkgSources, pkg, dependentTypeInfo, isMainContext = isMainContext)(config) - logger.trace { - val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" - s"type-checking ${pkg.info.id} done (took ${durationS}s with ${res.map(info => info.tree.nodes.length.toString).getOrElse("_")} nodes)" - } - res - } - } + var tyeCheckDurationMs = new AtomicLong(0L) - case class LazyTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[TypeCheckResult] with TypeCheckJob { - override def toString: String = s"LazyTypeCheckJob for $abstractPackage" + case class TypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[(Vector[Source], PPackage, Vector[AbstractImport]), () => TypeCheckResult] { + override def toString: String = s"TypeCheckJob for $abstractPackage" - override def compute(): TypeCheckResult = { - // in lazy mode, this function is called exactly when this package needs to be type-checked - // we also do not care about any dependent packages, because they will be lazily type-checked + protected override def sequentialPrecompute(): (Vector[Source], PPackage, Vector[AbstractImport]) = { val (sources, ast) = getParseResult(abstractPackage) - // we assume that all packages have been registered with the typeCheckManager val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) val isBuiltIn = abstractPackage == BuiltInPackage val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets - val dependentTypeInfo: DependentTypeInfo = dependencies - .map(importTarget => (importTarget, () => typeCheckManager.getResult(AbstractPackage(importTarget)(config)))) - .toMap - typeCheck(sources, ast, dependentTypeInfo, isMainContext = isMainContext) + // schedule type-checking of dependent packages: + dependencies.foreach(importTarget => { + val dependentPackage = AbstractPackage(importTarget)(config) + val job = TypeCheckJob(dependentPackage) + typeCheckManager.addIfAbsent(dependentPackage, job) + }) + (sources, ast, dependencies) } - } - - case class SequentialTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[TypeCheckResult] with TypeCheckJob { - override def toString: String = s"SequentialTypeCheckJob for $abstractPackage" - override def compute(): TypeCheckResult = { - val (sources, ast) = getParseResult(abstractPackage) - val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) - val isBuiltIn = abstractPackage == BuiltInPackage - val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets - // first type-check dependent packages: - val dependentTypeInfos = dependencies - .map(importTarget => { - val dependentPackage = AbstractPackage(importTarget)(config) - // add to manager & typecheck them if not present yet - val job = SequentialTypeCheckJob(dependentPackage) - typeCheckManager.addIfAbsent(dependentPackage, job) - (importTarget, () => typeCheckManager.getResult(dependentPackage)) - }) - - typeCheck(sources, ast, dependentTypeInfos.toMap, isMainContext = isMainContext) + protected def compute(precomputationResult: (Vector[Source], PPackage, Vector[AbstractImport])): () => TypeCheckResult = { + val (sources, ast, dependencies) = precomputationResult + val dependentTypeInfo = dependencies.map(importTarget => { + val dependentPackage = AbstractPackage(importTarget)(config) + (importTarget, typeCheckManager.getResult(dependentPackage)) + }) + config.typeCheckMode match { + case Sequential | Parallel => + val res = typeCheck(sources, ast, dependentTypeInfo.toMap, isMainContext = isMainContext) + () => res + case Lazy => + lazy val res = typeCheck(sources, ast, dependentTypeInfo.toMap, isMainContext = isMainContext) + () => res + } } - } - // case class ParallelTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[Future[TypeCheckResult]] with TypeCheckJob { - case class ParallelTypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends ParallelJob[TypeCheckResult] with TypeCheckJob { - override def toString: String = s"ParallelTypeCheckJob for $abstractPackage" - - override def compute(): Future[TypeCheckResult] = { - val (sources, ast) = getParseResult(abstractPackage) - val importTargets = ast.imports.map(importNode => RegularImport(importNode.importPath)) - val isBuiltIn = abstractPackage == BuiltInPackage - val dependencies = if (isBuiltIn) importTargets else BuiltInImport +: importTargets - // first type-check dependent packages: - val dependentJobsFuts = dependencies - .map(importTarget => { - val dependentPackage = AbstractPackage(importTarget)(config) - // add to manager & typecheck them if not present yet - val job = ParallelTypeCheckJob(dependentPackage) - parallelTypeCheckManager.addIfAbsent(dependentPackage, job)(executionContext) - .map(typeInfo => (importTarget, () => typeInfo))(executionContext) - /* - parallelTypeCheckManager.getFuture(dependentPackage).flatten - .map(typeInfo => (importTarget, () => typeInfo))(executionContext) - */ - }) - implicit val executor: GobraExecutionContext = executionContext - val dependentJobsFut = Future.sequence(dependentJobsFuts) - dependentJobsFut.map(dependentTypeInfo => typeCheck(sources, ast, dependentTypeInfo.toMap, isMainContext = isMainContext)) + private def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isMainContext: Boolean = false, isLazy: Boolean = false): TypeCheckResult = { + val startMs = System.currentTimeMillis() + logger.trace(s"start type-checking ${pkg.info.id}") + val res = Info.checkSources(pkgSources, pkg, dependentTypeInfo, isMainContext = isMainContext)(config, executionContext) + logger.trace { + val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" + s"type-checking ${pkg.info.id} done (took ${durationS}s with ${res.map(info => info.tree.nodes.length.toString).getOrElse("_")} nodes)" + } + if (isLazy) { + tyeCheckDurationMs.getAndUpdate(prev => Math.max(prev, System.currentTimeMillis() - startMs)) + } else { + tyeCheckDurationMs.addAndGet(System.currentTimeMillis() - startMs) + } + res } } - case class FailureJob(errs: Vector[VerifierError]) extends Job[TypeCheckResult] { - override def compute(): TypeCheckResult = Left(errs) - } - def typeCheck(pkg: AbstractPackage): TypeCheckResult = { - config.typeCheckMode match { - case Lazy => - // we have to transitively add all packages to the typeCheckManager: - lazyTypeCheckRecursively(pkg, isMainContext = true) - typeCheckManager.getResult(pkg) - case Sequential => - typeCheckManager.addIfAbsent(pkg, SequentialTypeCheckJob(pkg, isMainContext = true)) - typeCheckManager.getResult(pkg) - case Parallel => - /* - parallelTypeCheckManager.addIfAbsent(pkg, ParallelTypeCheckJob(pkg, isMainContext = true))(executionContext) - // wait for result: - val fut = parallelTypeCheckManager.getResult(pkg) - */ - val fut = parallelTypeCheckManager.addIfAbsent(pkg, ParallelTypeCheckJob(pkg, isMainContext = true))(executionContext) - Await.result(fut, Duration.Inf) - } + typeCheckManager.addIfAbsent(pkg, TypeCheckJob(pkg, isMainContext = true)) + val resFn = typeCheckManager.getResult(pkg) + resFn() } - - private def lazyTypeCheckRecursively(abstractPackage: AbstractPackage, isMainContext: Boolean): Unit = { - /** returns all transitively imported packages. However, `abstractPackage` is not included in the returned set! */ - def allImports(abstractPackage: AbstractPackage): Set[AbstractPackage] = { - val (_, ast: PPackage) = getParseResult(abstractPackage) - ast.imports - .map(importNode => AbstractPackage(RegularImport(importNode.importPath))(config)) - .toSet - .flatMap[AbstractPackage](directlyImportedPackage => allImports(directlyImportedPackage) + directlyImportedPackage) - } - - val dependentPackages = allImports(abstractPackage) + BuiltInPackage - // create jobs for all dependent packages - dependentPackages.foreach(pkg => typeCheckManager.addIfAbsent(pkg, LazyTypeCheckJob(pkg))) - // create job for this package: - typeCheckManager.addIfAbsent(abstractPackage, LazyTypeCheckJob(abstractPackage, isMainContext = isMainContext)) - } - /* - def getContexts: Iterable[ExternalTypeInfo] = { - config.typeCheckMode match { - case Lazy | Sequential => typeCheckManager.getAllResults(executionContext).collect { case Right(info) => info } - case Parallel => - implicit val executor: GobraExecutionContext = executionContext - val results = Await.result(Future.sequence(parallelTypeCheckManager.getAllResults(executionContext)), Duration.Inf) - results.collect { case Right(info) => info } - } - } - - def getTypeInfo(importTarget: AbstractImport)(config: Config): TypeCheckResult = { - val packageTarget = AbstractPackage(importTarget)(config) - config.typeCheckMode match { - case Lazy | Sequential => typeCheckManager.getResult(packageTarget) - case Parallel => - val future = parallelTypeCheckManager.getFuture(packageTarget).flatten - Violation.violation(future.isCompleted, s"job $importTarget is not yet completed") - Await.result(future, Duration.Inf) - } - } - */ } - def check(config: Config, abstractPackage: AbstractPackage, /*parseResults: Map[AbstractPackage, ParseSuccessResult]*/ parseResults: Map[AbstractPackage, ParseResult])(executionContext: GobraExecutionContext): TypeCheckResult = { + def check(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseResult])(executionContext: GobraExecutionContext): TypeCheckResult = { // check for cycles // val cyclicErrors = new CycleChecker(config, parseResults).check(abstractPackage) for { @@ -334,29 +245,14 @@ object Info extends LazyLogging { val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})" } - } yield typeInfo - - - /* - if (cyclicErrors.isEmpty) { - val typeCheckingStartMs = System.currentTimeMillis() - // add type-checking jobs to context: - val context = new Context(config, parseResults)(executionContext) - val res = context.typeCheck(abstractPackage) - logger.debug { - val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" - s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})" + _ = logger.debug { + val typeCheckingEndMs = System.currentTimeMillis() + val sumDurationS = f"${context.tyeCheckDurationMs.get() / 1000f}%.1f" + val overheadMs = (typeCheckingEndMs - typeCheckingStartMs) - context.tyeCheckDurationMs.get() + val overheadS = f"${overheadMs / 1000f}%.1f" + s"type-checking individual packages took ${sumDurationS}s. Overhead for tasks is thus ${overheadS}s (${(100f * overheadMs / (typeCheckingEndMs - typeCheckingStartMs)).toInt}%)" } - // we do not report any messages in this case, because `checkSources` will do so (for each package) - res - } else { - val (sources, pkg) = parseResults(abstractPackage) - val sourceNames = sources.map(_.name) - val errors = pkg.positions.translate(cyclicErrors, TypeError).distinct - config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errors) - Left(errors) - } - */ + } yield typeInfo } type TypeInfoCacheKey = String @@ -389,12 +285,12 @@ object Info extends LazyLogging { typeInfoCache.clear() } - def checkSources(sources: Vector[Source], pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean = false)(config: Config): TypeCheckResult = { + def checkSources(sources: Vector[Source], pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean = false)(config: Config, executionContext: GobraExecutionContext): TypeCheckResult = { var cacheHit: Boolean = true def getTypeInfo(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoImpl = { cacheHit = false val tree = new GoTree(pkg) - new TypeInfoImpl(tree, dependentTypeInfo, isMainContext)(config: Config) + new TypeInfoImpl(tree, dependentTypeInfo, isMainContext)(config: Config, executionContext) } def getTypeInfoCached(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoImpl = { @@ -407,7 +303,12 @@ object Info extends LazyLogging { println(s"No cache hit for type info for ${pkg.info.id}") } + val startTimeMs = System.currentTimeMillis() val errors = info.errors + logger.trace { + val durationS = f"${(System.currentTimeMillis() - startTimeMs) / 1000f}%.1f" + s"computing errors for ${pkg.info.id} done, took ${durationS}s" + } val sourceNames = sources.map(_.name) // use `sources` instead of `context.inputs` for reporting such that the message is correctly attributed in case of imports diff --git a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala index 83c4e7747..0275acafd 100644 --- a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala +++ b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala @@ -13,7 +13,7 @@ import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.OverflowChecksTransform import viper.gobra.backend.BackendVerifier import viper.gobra.frontend.PackageResolver.{AbstractPackage, RegularPackage} -import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} +import viper.gobra.frontend.Parser.ParseResult import viper.gobra.frontend.info.{Info, TypeInfo} import viper.gobra.frontend.{Desugar, Parser} import viper.gobra.reporting.{AppliedInternalTransformsMessage, BackTranslator, VerifierError, VerifierResult} @@ -100,12 +100,12 @@ class DetailedBenchmarkTests extends BenchmarkTests { config = gobra.getAndMergeInFileConfig(c, pkgInfo).toOption } - private val parsing = InitialStep("parsing", () => { + private val parsing = InitialStep[Vector[VerifierError], Map[AbstractPackage, ParseResult]]("parsing", () => { assert(config.isDefined) val c = config.get assert(c.packageInfoInputMap.size == 1) val pkgInfo = c.packageInfoInputMap.keys.head - Parser.parse(c, pkgInfo)(executor) + Right(Parser.parse(c, pkgInfo)(executor)) }) private val typeChecking: NextStep[Map[AbstractPackage, ParseResult], TypeInfo, Vector[VerifierError]] = diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index 719ac1b9d..97632dd79 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -33,7 +33,11 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { var gobraInstance: Gobra = _ var executor: GobraExecutionContext = _ var inputMapping: Vector[(PackageInfo, Vector[Source])] = Vector.empty - val cacheParser = true + // while we could pre-fetch and cache parse and maybe even type-check results, the regression test suite is designed + // in a way that each file is its own test case. However, feeding a map of package infos to Gobra results in Gobra + // considering these files in a Go way, i.e., groups them by package clause. This in turn results in testcase failures + // as errors occur in files technically not under test but in the same directory and having the same package clause. + val cacheParser = false override def beforeAll(): Unit = { executor = new DefaultGobraExecutionContext() diff --git a/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala b/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala index b8097a222..5801caaa0 100644 --- a/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala +++ b/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala @@ -7,7 +7,7 @@ package viper.gobra.erasing import org.bitbucket.inkytonik.kiama.util.{Positions, StringSource} -import org.scalatest.{Assertion, Inside, Succeeded} +import org.scalatest.{Assertion, BeforeAndAfterAll, Inside, Succeeded} import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers import viper.gobra.ast.frontend._ @@ -15,9 +15,19 @@ import viper.gobra.frontend.{Config, PackageInfo, Parser} import viper.gobra.frontend.info.Info import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.GhostLessPrinter +import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} -class GhostErasureUnitTests extends AnyFunSuite with Matchers with Inside { +class GhostErasureUnitTests extends AnyFunSuite with Matchers with Inside with BeforeAndAfterAll { val frontend = new TestFrontend() + var executor: GobraExecutionContext = _ + + override def beforeAll(): Unit = { + executor = new DefaultGobraExecutionContext() + } + + override def afterAll(): Unit = { + executor.terminateAndAssertInexistanceOfTimeout() + } test("Ghost Erasure: variable declaration should not have a trailing equal sign") { // var value int @@ -343,7 +353,7 @@ class GhostErasureUnitTests extends AnyFunSuite with Matchers with Inside { ) val tree = new Info.GoTree(pkg) val config = Config() - val info = new TypeInfoImpl(tree, Map.empty)(config) + val info = new TypeInfoImpl(tree, Map.empty)(config, executor) info.errors match { case Vector(msgs) => fail(s"Type-checking failed: $msgs") case _ => diff --git a/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala index ed9020f20..1e0f7b4e8 100644 --- a/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala @@ -8,17 +8,27 @@ package viper.gobra.typing import org.bitbucket.inkytonik.kiama.util.Positions import org.scalatest.funsuite.AnyFunSuite -import org.scalatest.Inside +import org.scalatest.{BeforeAndAfterAll, Inside} import org.scalatest.matchers.should.Matchers import viper.gobra.ast.frontend._ import viper.gobra.frontend.{Config, PackageInfo} import viper.gobra.frontend.info.Info import viper.gobra.frontend.info.base.Type import viper.gobra.frontend.info.implementation.TypeInfoImpl +import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} import viper.gobra.util.TypeBounds.{DefaultInt, UnboundedInteger} -class ExprTypingUnitTests extends AnyFunSuite with Matchers with Inside { +class ExprTypingUnitTests extends AnyFunSuite with Matchers with Inside with BeforeAndAfterAll { val frontend = new TestFrontend() + var executor: GobraExecutionContext = _ + + override def beforeAll(): Unit = { + executor = new DefaultGobraExecutionContext() + } + + override def afterAll(): Unit = { + executor.terminateAndAssertInexistanceOfTimeout() + } test("TypeChecker: should classify an integer literal as integer") { frontend.exprType(PIntLit(42))() should matchPattern { @@ -3392,7 +3402,7 @@ class ExprTypingUnitTests extends AnyFunSuite with Matchers with Inside { ) val tree = new Info.GoTree(pkg) val config = Config() - new TypeInfoImpl(tree, Map.empty)(config) + new TypeInfoImpl(tree, Map.empty)(config, executor) } def exprType(expr : PExpression)(inArgs: Vector[(PParameter, Boolean)] = Vector()) : Type.Type = diff --git a/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala index dc3a3fbc7..f4dc6562b 100644 --- a/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala @@ -6,7 +6,7 @@ package viper.gobra.typing -import org.scalatest.Inside +import org.scalatest.{BeforeAndAfterAll, Inside} import org.scalatest.matchers.should.Matchers import org.scalatest.funsuite.AnyFunSuite import viper.gobra.ast.frontend._ @@ -15,9 +15,19 @@ import org.bitbucket.inkytonik.kiama.util.Positions import viper.gobra.frontend.PackageInfo import viper.gobra.frontend.info.Info import viper.gobra.frontend.Config +import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} -class StmtTypingUnitTests extends AnyFunSuite with Matchers with Inside { +class StmtTypingUnitTests extends AnyFunSuite with Matchers with Inside with BeforeAndAfterAll { val frontend = new TestFrontend() + var executor: GobraExecutionContext = _ + + override def beforeAll(): Unit = { + executor = new DefaultGobraExecutionContext() + } + + override def afterAll(): Unit = { + executor.terminateAndAssertInexistanceOfTimeout() + } test("TypeChecker: should detect labeled continues outside of loops") { assert(!frontend.wellDefStmt(PContinue(Some(PLabelUse("l"))))().valid) @@ -82,7 +92,7 @@ class StmtTypingUnitTests extends AnyFunSuite with Matchers with Inside { ) val tree = new Info.GoTree(pkg) val config = Config() - new TypeInfoImpl(tree, Map.empty)(config) + new TypeInfoImpl(tree, Map.empty)(config, executor) } def wellDefStmt(stmt : PStatement)(inArgs: Vector[(PParameter, Boolean)] = Vector()) = diff --git a/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala index a248c2a15..4be78c86c 100644 --- a/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala @@ -9,16 +9,26 @@ package viper.gobra.typing import org.bitbucket.inkytonik.kiama.util.Positions import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers -import org.scalatest.Inside +import org.scalatest.{BeforeAndAfterAll, Inside} import viper.gobra.ast.frontend._ import viper.gobra.frontend.{Config, PackageInfo} import viper.gobra.frontend.info.Info import viper.gobra.frontend.info.base.Type import viper.gobra.frontend.info.implementation.TypeInfoImpl +import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} import viper.gobra.util.TypeBounds.DefaultInt -class TypeTypingUnitTests extends AnyFunSuite with Matchers with Inside { +class TypeTypingUnitTests extends AnyFunSuite with Matchers with Inside with BeforeAndAfterAll { val frontend = new TestFrontend() + var executor: GobraExecutionContext = _ + + override def beforeAll(): Unit = { + executor = new DefaultGobraExecutionContext() + } + + override def afterAll(): Unit = { + executor.terminateAndAssertInexistanceOfTimeout() + } test("Typing: should correctly type an integer sequence type") { val t = PSequenceType(PIntType()) @@ -379,7 +389,7 @@ class TypeTypingUnitTests extends AnyFunSuite with Matchers with Inside { ) val tree = new Info.GoTree(pkg) val config = Config() - new TypeInfoImpl(tree, Map.empty)(config) + new TypeInfoImpl(tree, Map.empty)(config, executor) } def areComparable(t1 : PType, t2 : PType) : Boolean = { From 8d24c0149cd9ef20835ca086fe7ef459e6b7dab8 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Thu, 29 Jun 2023 17:02:23 +0200 Subject: [PATCH 21/54] fixes compilation issue and undos parser caching for unit tests --- .../scala/viper/gobra/frontend/info/Info.scala | 6 +++--- src/test/scala/viper/gobra/GobraTests.scala | 7 ++++--- .../gobra/erasing/GhostErasureUnitTests.scala | 17 +++-------------- .../gobra/typing/ExprTypingUnitTests.scala | 16 +++------------- .../gobra/typing/StmtTypingUnitTests.scala | 16 +++------------- .../gobra/typing/TypeTypingUnitTests.scala | 16 +++------------- 6 files changed, 19 insertions(+), 59 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index e474c1504..558e38a5d 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -206,7 +206,7 @@ object Info extends LazyLogging { private def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isMainContext: Boolean = false, isLazy: Boolean = false): TypeCheckResult = { val startMs = System.currentTimeMillis() logger.trace(s"start type-checking ${pkg.info.id}") - val res = Info.checkSources(pkgSources, pkg, dependentTypeInfo, isMainContext = isMainContext)(config, executionContext) + val res = Info.checkSources(pkgSources, pkg, dependentTypeInfo, isMainContext = isMainContext)(config) logger.trace { val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" s"type-checking ${pkg.info.id} done (took ${durationS}s with ${res.map(info => info.tree.nodes.length.toString).getOrElse("_")} nodes)" @@ -285,12 +285,12 @@ object Info extends LazyLogging { typeInfoCache.clear() } - def checkSources(sources: Vector[Source], pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean = false)(config: Config, executionContext: GobraExecutionContext): TypeCheckResult = { + def checkSources(sources: Vector[Source], pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean = false)(config: Config): TypeCheckResult = { var cacheHit: Boolean = true def getTypeInfo(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoImpl = { cacheHit = false val tree = new GoTree(pkg) - new TypeInfoImpl(tree, dependentTypeInfo, isMainContext)(config: Config, executionContext) + new TypeInfoImpl(tree, dependentTypeInfo, isMainContext)(config: Config) } def getTypeInfoCached(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoImpl = { diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index 97632dd79..71b0b33ff 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -51,8 +51,8 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { } override def runTests(testName: Option[String], args: Args): Status = { - val inputMap = inputMapping.toMap if (cacheParser) { + val inputMap = inputMapping.toMap val config = Config(packageInfoInputMap = inputMap, cacheParser = true) val parseManager = new ParseManager(config, executor) parseManager.parseAll(inputMap.keys.toVector) @@ -72,16 +72,17 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { override def run(input: AnnotatedTestInput): Seq[AbstractOutput] = { + val source = FromFileSource(input.file) + val packageInfoInputMap = if (cacheParser) inputMapping.toMap else Map(Source.getPackageInfo(source, Path.of("")) -> Vector(source)) val config = Config( logLevel = Level.INFO, reporter = NoopReporter, - packageInfoInputMap = inputMapping.toMap, + packageInfoInputMap = packageInfoInputMap, checkConsistency = true, cacheParser = cacheParser, z3Exe = z3Exe ) - val source = FromFileSource(input.file) val pkgInfo = Source.getPackageInfo(source, Path.of("")) val (result, elapsedMilis) = time(() => Await.result(gobraInstance.verify(pkgInfo, config)(executor), Duration.Inf)) diff --git a/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala b/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala index 5801caaa0..dd203575a 100644 --- a/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala +++ b/src/test/scala/viper/gobra/erasing/GhostErasureUnitTests.scala @@ -7,7 +7,7 @@ package viper.gobra.erasing import org.bitbucket.inkytonik.kiama.util.{Positions, StringSource} -import org.scalatest.{Assertion, BeforeAndAfterAll, Inside, Succeeded} +import org.scalatest.{Assertion, Inside, Succeeded} import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers import viper.gobra.ast.frontend._ @@ -15,20 +15,9 @@ import viper.gobra.frontend.{Config, PackageInfo, Parser} import viper.gobra.frontend.info.Info import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.GhostLessPrinter -import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} -class GhostErasureUnitTests extends AnyFunSuite with Matchers with Inside with BeforeAndAfterAll { +class GhostErasureUnitTests extends AnyFunSuite with Matchers with Inside { val frontend = new TestFrontend() - var executor: GobraExecutionContext = _ - - override def beforeAll(): Unit = { - executor = new DefaultGobraExecutionContext() - } - - override def afterAll(): Unit = { - executor.terminateAndAssertInexistanceOfTimeout() - } - test("Ghost Erasure: variable declaration should not have a trailing equal sign") { // var value int val decl = PVarDecl(Some(PIntType()), Vector(), Vector(PIdnDef("value")), Vector(false)) @@ -353,7 +342,7 @@ class GhostErasureUnitTests extends AnyFunSuite with Matchers with Inside with B ) val tree = new Info.GoTree(pkg) val config = Config() - val info = new TypeInfoImpl(tree, Map.empty)(config, executor) + val info = new TypeInfoImpl(tree, Map.empty)(config) info.errors match { case Vector(msgs) => fail(s"Type-checking failed: $msgs") case _ => diff --git a/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala index 1e0f7b4e8..ed9020f20 100644 --- a/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/ExprTypingUnitTests.scala @@ -8,27 +8,17 @@ package viper.gobra.typing import org.bitbucket.inkytonik.kiama.util.Positions import org.scalatest.funsuite.AnyFunSuite -import org.scalatest.{BeforeAndAfterAll, Inside} +import org.scalatest.Inside import org.scalatest.matchers.should.Matchers import viper.gobra.ast.frontend._ import viper.gobra.frontend.{Config, PackageInfo} import viper.gobra.frontend.info.Info import viper.gobra.frontend.info.base.Type import viper.gobra.frontend.info.implementation.TypeInfoImpl -import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} import viper.gobra.util.TypeBounds.{DefaultInt, UnboundedInteger} -class ExprTypingUnitTests extends AnyFunSuite with Matchers with Inside with BeforeAndAfterAll { +class ExprTypingUnitTests extends AnyFunSuite with Matchers with Inside { val frontend = new TestFrontend() - var executor: GobraExecutionContext = _ - - override def beforeAll(): Unit = { - executor = new DefaultGobraExecutionContext() - } - - override def afterAll(): Unit = { - executor.terminateAndAssertInexistanceOfTimeout() - } test("TypeChecker: should classify an integer literal as integer") { frontend.exprType(PIntLit(42))() should matchPattern { @@ -3402,7 +3392,7 @@ class ExprTypingUnitTests extends AnyFunSuite with Matchers with Inside with Bef ) val tree = new Info.GoTree(pkg) val config = Config() - new TypeInfoImpl(tree, Map.empty)(config, executor) + new TypeInfoImpl(tree, Map.empty)(config) } def exprType(expr : PExpression)(inArgs: Vector[(PParameter, Boolean)] = Vector()) : Type.Type = diff --git a/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala index f4dc6562b..dc3a3fbc7 100644 --- a/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/StmtTypingUnitTests.scala @@ -6,7 +6,7 @@ package viper.gobra.typing -import org.scalatest.{BeforeAndAfterAll, Inside} +import org.scalatest.Inside import org.scalatest.matchers.should.Matchers import org.scalatest.funsuite.AnyFunSuite import viper.gobra.ast.frontend._ @@ -15,19 +15,9 @@ import org.bitbucket.inkytonik.kiama.util.Positions import viper.gobra.frontend.PackageInfo import viper.gobra.frontend.info.Info import viper.gobra.frontend.Config -import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} -class StmtTypingUnitTests extends AnyFunSuite with Matchers with Inside with BeforeAndAfterAll { +class StmtTypingUnitTests extends AnyFunSuite with Matchers with Inside { val frontend = new TestFrontend() - var executor: GobraExecutionContext = _ - - override def beforeAll(): Unit = { - executor = new DefaultGobraExecutionContext() - } - - override def afterAll(): Unit = { - executor.terminateAndAssertInexistanceOfTimeout() - } test("TypeChecker: should detect labeled continues outside of loops") { assert(!frontend.wellDefStmt(PContinue(Some(PLabelUse("l"))))().valid) @@ -92,7 +82,7 @@ class StmtTypingUnitTests extends AnyFunSuite with Matchers with Inside with Bef ) val tree = new Info.GoTree(pkg) val config = Config() - new TypeInfoImpl(tree, Map.empty)(config, executor) + new TypeInfoImpl(tree, Map.empty)(config) } def wellDefStmt(stmt : PStatement)(inArgs: Vector[(PParameter, Boolean)] = Vector()) = diff --git a/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala b/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala index 4be78c86c..a248c2a15 100644 --- a/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala +++ b/src/test/scala/viper/gobra/typing/TypeTypingUnitTests.scala @@ -9,26 +9,16 @@ package viper.gobra.typing import org.bitbucket.inkytonik.kiama.util.Positions import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers -import org.scalatest.{BeforeAndAfterAll, Inside} +import org.scalatest.Inside import viper.gobra.ast.frontend._ import viper.gobra.frontend.{Config, PackageInfo} import viper.gobra.frontend.info.Info import viper.gobra.frontend.info.base.Type import viper.gobra.frontend.info.implementation.TypeInfoImpl -import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} import viper.gobra.util.TypeBounds.DefaultInt -class TypeTypingUnitTests extends AnyFunSuite with Matchers with Inside with BeforeAndAfterAll { +class TypeTypingUnitTests extends AnyFunSuite with Matchers with Inside { val frontend = new TestFrontend() - var executor: GobraExecutionContext = _ - - override def beforeAll(): Unit = { - executor = new DefaultGobraExecutionContext() - } - - override def afterAll(): Unit = { - executor.terminateAndAssertInexistanceOfTimeout() - } test("Typing: should correctly type an integer sequence type") { val t = PSequenceType(PIntType()) @@ -389,7 +379,7 @@ class TypeTypingUnitTests extends AnyFunSuite with Matchers with Inside with Bef ) val tree = new Info.GoTree(pkg) val config = Config() - new TypeInfoImpl(tree, Map.empty)(config, executor) + new TypeInfoImpl(tree, Map.empty)(config) } def areComparable(t1 : PType, t2 : PType) : Boolean = { From 6f419979ec5370401248ccb3d048740e35813090 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Fri, 30 Jun 2023 09:51:57 +0200 Subject: [PATCH 22/54] addresses several unit test errors --- src/main/scala/viper/gobra/Gobra.scala | 8 +++++--- .../scala/viper/gobra/frontend/Parser.scala | 11 ++++++++--- .../scala/viper/gobra/frontend/info/Info.scala | 11 ++++++----- .../regressions/features/import/import1.gobra | 18 +++++++++--------- .../regressions/features/import/import2.gobra | 2 +- .../viper/gobra/DetailedBenchmarkTests.scala | 2 +- 6 files changed, 30 insertions(+), 22 deletions(-) diff --git a/src/main/scala/viper/gobra/Gobra.scala b/src/main/scala/viper/gobra/Gobra.scala index e0596f2ee..051117256 100644 --- a/src/main/scala/viper/gobra/Gobra.scala +++ b/src/main/scala/viper/gobra/Gobra.scala @@ -159,7 +159,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { for { finalConfig <- getAndMergeInFileConfig(config, pkgInfo) _ = setLogLevel(finalConfig) - parseResults = performParsing(finalConfig, pkgInfo)(executor) + parseResults <- performParsing(finalConfig, pkgInfo)(executor) typeInfo <- performTypeChecking(finalConfig, pkgInfo, parseResults)(executor) program <- performDesugaring(finalConfig, typeInfo)(executor) program <- performInternalTransformations(finalConfig, pkgInfo, program)(executor) @@ -243,7 +243,9 @@ class Gobra extends GoVerifier with GoIdeVerifier { .setLevel(config.logLevel) } - private def performParsing(config: Config, pkgInfo: PackageInfo)(executor: GobraExecutionContext): Map[AbstractPackage, ParseResult] = { + // returns `Left(...)` if parsing of the package identified by `pkgInfo` failed. Note that `Right(...)` does not imply + // that all imported packages have been parsed successfully (this is only checked during type-checking) + private def performParsing(config: Config, pkgInfo: PackageInfo)(executor: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseResult]] = { if (config.shouldParse) { val startMs = System.currentTimeMillis() val res = Parser.parse(config, pkgInfo)(executor) @@ -253,7 +255,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { } res } else { - Map.empty + Left(Vector.empty) } } diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index f7504b8a8..21604626f 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -18,7 +18,7 @@ import org.antlr.v4.runtime.atn.PredictionMode import org.antlr.v4.runtime.misc.ParseCancellationException import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} -import viper.gobra.util.GobraExecutionContext +import viper.gobra.util.{GobraExecutionContext, Violation} import viper.silver.ast.SourcePosition import scala.collection.mutable.ListBuffer @@ -186,10 +186,15 @@ object Parser { * */ - def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Map[AbstractPackage, ParseResult] = { + def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Either[Vector[ParserError], Map[AbstractPackage, ParseResult]] = { val parseManager = new ParseManager(config, executionContext) parseManager.parse(pkgInfo) - parseManager.getResults + val results = parseManager.getResults + results.get(RegularPackage(pkgInfo.id)) match { + case Some(Right(_)) => Right(results) + case Some(Left(errs)) => Left(errs) + case _ => Violation.violation(s"No parse result for package '$pkgInfo' found") + } } def parse(input: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean = false)(config: Config): Either[Vector[VerifierError], PPackage] = { diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 558e38a5d..160ee730c 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -228,18 +228,19 @@ object Info extends LazyLogging { } def check(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseResult])(executionContext: GobraExecutionContext): TypeCheckResult = { - // check for cycles - // val cyclicErrors = new CycleChecker(config, parseResults).check(abstractPackage) for { - successParseResult <- new CycleChecker(config, parseResults).check(abstractPackage) + // check whether parsing of this package was successful: + parseResult <- parseResults(abstractPackage) + // check whether there are any import cycles: + cycleResult <- new CycleChecker(config, parseResults).check(abstractPackage) .left.map(errs => { - val (sources, pkg) = parseResults(abstractPackage).right.get + val (sources, pkg) = parseResult val sourceNames = sources.map(_.name) config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errs) errs }) typeCheckingStartMs = System.currentTimeMillis() - context = new Context(config, successParseResult)(executionContext) + context = new Context(config, cycleResult)(executionContext) typeInfo <- context.typeCheck(abstractPackage) _ = logger.debug { val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" diff --git a/src/test/resources/regressions/features/import/import1.gobra b/src/test/resources/regressions/features/import/import1.gobra index eb3106227..d0b9a720f 100644 --- a/src/test/resources/regressions/features/import/import1.gobra +++ b/src/test/resources/regressions/features/import/import1.gobra @@ -4,27 +4,27 @@ package main import fmt "fmt" -//:: ExpectedOutput(parser_error) +//:: ExpectedOutput(type_error) import a "a"; -//:: ExpectedOutput(parser_error) +//:: ExpectedOutput(type_error) import (b "b") -//:: ExpectedOutput(parser_error) +//:: ExpectedOutput(type_error) import (c "c"); import ( - //:: ExpectedOutput(parser_error) + //:: ExpectedOutput(type_error) d "d" - //:: ExpectedOutput(parser_error) + //:: ExpectedOutput(type_error) e "e") import ( - //:: ExpectedOutput(parser_error) + //:: ExpectedOutput(type_error) f "f" - //:: ExpectedOutput(parser_error) + //:: ExpectedOutput(type_error) g "g" ) -//:: ExpectedOutput(parser_error) +//:: ExpectedOutput(type_error) import m "lib/mathm" // wrong package name used on purpose such that this test case does not potentially depend on the configured Go path -//:: ExpectedOutput(parser_error) +//:: ExpectedOutput(type_error) import . "lib/mathn" func test() { diff --git a/src/test/resources/regressions/features/import/import2.gobra b/src/test/resources/regressions/features/import/import2.gobra index ae7458fc6..5e99934f1 100644 --- a/src/test/resources/regressions/features/import/import2.gobra +++ b/src/test/resources/regressions/features/import/import2.gobra @@ -3,7 +3,7 @@ package main -//:: ExpectedOutput(parser_error) +//:: ExpectedOutput(type_error) import math "lib/mathm" // wrong package name used on purpose such that this test case does not potentially depend on the configured Go path type cell struct{ diff --git a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala index 0275acafd..6537f6ec3 100644 --- a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala +++ b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala @@ -105,7 +105,7 @@ class DetailedBenchmarkTests extends BenchmarkTests { val c = config.get assert(c.packageInfoInputMap.size == 1) val pkgInfo = c.packageInfoInputMap.keys.head - Right(Parser.parse(c, pkgInfo)(executor)) + Parser.parse(c, pkgInfo)(executor) }) private val typeChecking: NextStep[Map[AbstractPackage, ParseResult], TypeInfo, Vector[VerifierError]] = From e97cbf55b58c710a4d44936bd1ebaacb0de59386 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Fri, 30 Jun 2023 11:22:00 +0200 Subject: [PATCH 23/54] pre-parses and pre-typeChecks Gobra tests --- .../scala/viper/gobra/frontend/Parser.scala | 40 ++++++++----- .../viper/gobra/frontend/TaskManager.scala | 16 +++-- .../viper/gobra/frontend/info/Info.scala | 43 ++++++++++++- .../scala/viper/gobra/GobraPackageTests.scala | 1 - src/test/scala/viper/gobra/GobraTests.scala | 60 ++++++++++++------- 5 files changed, 116 insertions(+), 44 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index 21604626f..8057b047a 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -24,9 +24,10 @@ import viper.silver.ast.SourcePosition import scala.collection.mutable.ListBuffer import java.security.MessageDigest import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} +import scala.concurrent.Future -object Parser { +object Parser extends LazyLogging { type ParseSuccessResult = (Vector[Source], PPackage) type ParseResult = Either[Vector[ParserError], ParseSuccessResult] @@ -36,20 +37,13 @@ object Parser { class ParseManager(config: Config, executionContext: GobraExecutionContext) extends LazyLogging { private val manager = new TaskManager[AbstractPackage, PreprocessedSources, ParseResult](config.typeCheckMode)(executionContext) - def parse(pkgInfo: PackageInfo): Unit = { + // note that the returned future might never complete if typeCheckMode is `Lazy` and there is no trigger to actually + // execute the parsing of the specified package + def parse(pkgInfo: PackageInfo): Future[ParseResult] = { val pkg = RegularPackage(pkgInfo.id) val parseJob = ParseInfoJob(pkgInfo) manager.addIfAbsent(pkg, parseJob) - } - - /** this is only used for unit testing to fill the parse cache */ - def parseAll(pkgInfos: Vector[PackageInfo]): Map[PackageInfo, ParseResult] = { - pkgInfos.foreach(pkgInfo => parse(pkgInfo)) - val results = manager.getAllResultsWithKeys.toMap - pkgInfos.map(pkgInfo => { - val pkg = RegularPackage(pkgInfo.id) - (pkgInfo, results(pkg)) - }).toMap + parseJob.getFuture } trait ImportResolver { @@ -167,7 +161,9 @@ object Parser { Left(errs) } - def getResults: Map[AbstractPackage, ParseResult] = manager.getAllResultsWithKeys.toMap + def getResults: Map[AbstractPackage, ParseResult] = manager.getAllResultsWithKeys + + def getResultsFut: Future[Map[AbstractPackage, ParseResult]] = manager.getAllResultsWithKeysFut } /** @@ -197,6 +193,20 @@ object Parser { } } + def parseFut(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Future[Either[Vector[ParserError], Map[AbstractPackage, ParseResult]]] = { + val parseManager = new ParseManager(config, executionContext) + parseManager.parse(pkgInfo) + implicit val executor: GobraExecutionContext = executionContext + for { + results <- parseManager.getResultsFut + res = results.get(RegularPackage(pkgInfo.id)) match { + case Some(Right(_)) => Right(results) + case Some(Left(errs)) => Left(errs) + case _ => Violation.violation(s"No parse result for package '$pkgInfo' found") + } + } yield res + } + def parse(input: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean = false)(config: Config): Either[Vector[VerifierError], PPackage] = { val preprocessedInputs = preprocess(input)(config) process(preprocessedInputs, pkgInfo, specOnly = specOnly)(config) @@ -229,7 +239,7 @@ object Parser { val res = preambleCache.computeIfAbsent(getPreambleCacheKey(preprocessedSource), _ => parseAndStore()) if (!cacheHit) { - println(s"No cache hit for ${res.map(_.packageClause.id.name)}'s preamble (${preambleCache.size()} entries in cache)") + logger.trace(s"No cache hit for ${res.map(_.packageClause.id.name)}'s preamble") } res } @@ -294,7 +304,7 @@ object Parser { parseSourcesUncached(sources, pkgInfo, specOnly)(config) }) if (!cacheHit) { - println(s"No cache hit for package ${pkgInfo.id}") + logger.trace(s"No cache hit for package ${pkgInfo.id}'s parse AST)") } res } diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index cad745141..85557cfd5 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -73,17 +73,21 @@ class TaskManager[K, I, R](mode: TaskManagerMode)(executionContext: GobraExecuti } } - def getResult(id: K): R = { + def getResultFut(id: K): Future[R] = { val job = jobs.get(id) Violation.violation(job != null, s"Task $id not found") mode match { case Lazy => job.execute() // now we need the job's result case _ => } - Await.result(job.getFuture, Duration.Inf) + job.getFuture + } + + def getResult(id: K): R = { + Await.result(getResultFut(id), Duration.Inf) } - def getAllResultsWithKeys: Iterable[(K, R)] = { + def getAllResultsWithKeysFut: Future[Map[K, R]] = { implicit val executor: GobraExecutionContext = executionContext val futs = jobs.asScala.toVector.map { case (key, job) => mode match { @@ -92,6 +96,10 @@ class TaskManager[K, I, R](mode: TaskManagerMode)(executionContext: GobraExecuti } job.getFuture.map(res => (key, res)) } - Await.result(Future.sequence(futs), Duration.Inf) + Future.sequence(futs).map(_.toMap) + } + + def getAllResultsWithKeys: Map[K, R] = { + Await.result(getAllResultsWithKeysFut, Duration.Inf) } } diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 160ee730c..f14877ae7 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -15,6 +15,7 @@ import viper.gobra.frontend.{Config, Job, TaskManager} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport} import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} +import viper.gobra.frontend.info.Info.Context import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.{GhostLessPrinter, GoifyingPrinter} import viper.gobra.reporting.{CyclicImportError, ParserError, TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} @@ -23,6 +24,7 @@ import viper.gobra.util.{GobraExecutionContext, Violation} import java.security.MessageDigest import java.util.concurrent.atomic.AtomicLong import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} +import scala.concurrent.Future object Info extends LazyLogging { @@ -225,6 +227,12 @@ object Info extends LazyLogging { val resFn = typeCheckManager.getResult(pkg) resFn() } + + def typeCheckFut(pkg: AbstractPackage): Future[TypeCheckResult] = { + typeCheckManager.addIfAbsent(pkg, TypeCheckJob(pkg, isMainContext = true)) + typeCheckManager.getResultFut(pkg) + .map(resFn => resFn())(executionContext) + } } def check(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseResult])(executionContext: GobraExecutionContext): TypeCheckResult = { @@ -256,6 +264,39 @@ object Info extends LazyLogging { } yield typeInfo } + def checkFut(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseResult])(executionContext: GobraExecutionContext): Future[TypeCheckResult] = { + implicit val executor: GobraExecutionContext = executionContext + val res = for { + // check whether parsing of this package was successful: + parseResult <- parseResults(abstractPackage) + // check whether there are any import cycles: + cycleResult <- new CycleChecker(config, parseResults).check(abstractPackage) + .left.map(errs => { + val (sources, pkg) = parseResult + val sourceNames = sources.map(_.name) + config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errs) + errs + }) + typeCheckingStartMs = System.currentTimeMillis() + context = new Context(config, cycleResult)(executionContext) + typeInfoFut = for { + typeInfo <- context.typeCheckFut(abstractPackage) + _ = logger.debug { + val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" + s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})" + } + _ = logger.debug { + val typeCheckingEndMs = System.currentTimeMillis() + val sumDurationS = f"${context.tyeCheckDurationMs.get() / 1000f}%.1f" + val overheadMs = (typeCheckingEndMs - typeCheckingStartMs) - context.tyeCheckDurationMs.get() + val overheadS = f"${overheadMs / 1000f}%.1f" + s"type-checking individual packages took ${sumDurationS}s. Overhead for tasks is thus ${overheadS}s (${(100f * overheadMs / (typeCheckingEndMs - typeCheckingStartMs)).toInt}%)" + } + } yield typeInfo + } yield typeInfoFut + res.fold(errs => Future.successful(Left(errs)), identity) + } + type TypeInfoCacheKey = String private val typeInfoCache: ConcurrentMap[TypeInfoCacheKey, TypeInfoImpl] = new ConcurrentHashMap() @@ -301,7 +342,7 @@ object Info extends LazyLogging { val checkFn = if (config.cacheParser) { getTypeInfoCached _ } else { getTypeInfo _ } val info = checkFn(pkg, dependentTypeInfo, isMainContext, config) if (!cacheHit && config.cacheParser) { - println(s"No cache hit for type info for ${pkg.info.id}") + logger.trace(s"No cache hit for type info for ${pkg.info.id}") } val startTimeMs = System.currentTimeMillis() diff --git a/src/test/scala/viper/gobra/GobraPackageTests.scala b/src/test/scala/viper/gobra/GobraPackageTests.scala index 8b170788d..8e01bcc49 100644 --- a/src/test/scala/viper/gobra/GobraPackageTests.scala +++ b/src/test/scala/viper/gobra/GobraPackageTests.scala @@ -58,7 +58,6 @@ class GobraPackageTests extends GobraTests { // test scallop parsing by giving package name and testing whether the same set of files is created val currentDir = input.file.getParent val parsedConfig = for { - pkgName <- getPackageClause(input.file.toFile) config <- createConfig(Array( "--logLevel", "INFO", "--directory", currentDir.toFile.getPath, diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index 71b0b33ff..e22a5ab30 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -10,16 +10,18 @@ import java.nio.file.Path import ch.qos.logback.classic.Level import org.bitbucket.inkytonik.kiama.util.Source import org.scalatest.{Args, BeforeAndAfterAll, Status} -import viper.gobra.frontend.Parser.ParseManager +import viper.gobra.frontend.PackageResolver.RegularPackage import viper.gobra.frontend.Source.FromFileSource -import viper.gobra.frontend.{Config, PackageInfo, PackageResolver, Source} +import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel} +import viper.gobra.frontend.info.Info +import viper.gobra.frontend.{Config, PackageResolver, Parser, Source} import viper.gobra.reporting.VerifierResult.{Failure, Success} import viper.gobra.reporting.{NoopReporter, VerifierError} import viper.silver.testing.{AbstractOutput, AnnotatedTestInput, ProjectInfo, SystemUnderTest} import viper.silver.utility.TimingUtils import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext} -import scala.concurrent.Await +import scala.concurrent.{Await, Future} import scala.concurrent.duration.Duration class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { @@ -32,12 +34,12 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { var gobraInstance: Gobra = _ var executor: GobraExecutionContext = _ - var inputMapping: Vector[(PackageInfo, Vector[Source])] = Vector.empty + var inputs: Vector[Source] = Vector.empty // while we could pre-fetch and cache parse and maybe even type-check results, the regression test suite is designed // in a way that each file is its own test case. However, feeding a map of package infos to Gobra results in Gobra // considering these files in a Go way, i.e., groups them by package clause. This in turn results in testcase failures // as errors occur in files technically not under test but in the same directory and having the same package clause. - val cacheParser = false + val cacheParserAndTypeChecker = true override def beforeAll(): Unit = { executor = new DefaultGobraExecutionContext() @@ -47,15 +49,36 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { override def registerTest(input: AnnotatedTestInput): Unit = { super.registerTest(input) val source = FromFileSource(input.file) - inputMapping = inputMapping :+ (Source.getPackageInfo(source, Path.of("")) -> Vector(source)) + inputs = inputs :+ source } + private def getConfig(source: Source): Config = + Config( + logLevel = Level.INFO, + reporter = NoopReporter, + packageInfoInputMap = Map(Source.getPackageInfo(source, Path.of("")) -> Vector(source)), + checkConsistency = true, + cacheParser = cacheParserAndTypeChecker, + typeCheckMode = if (cacheParserAndTypeChecker) Parallel else Lazy, + z3Exe = z3Exe + ) + override def runTests(testName: Option[String], args: Args): Status = { - if (cacheParser) { - val inputMap = inputMapping.toMap - val config = Config(packageInfoInputMap = inputMap, cacheParser = true) - val parseManager = new ParseManager(config, executor) - parseManager.parseAll(inputMap.keys.toVector) + if (cacheParserAndTypeChecker) { + implicit val execContext: GobraExecutionContext = executor + val futs = inputs.map(source => { + val config = getConfig(source) + val pkgInfo = config.packageInfoInputMap.keys.head + for { + parseResultEither <- Parser.parseFut(config, pkgInfo)(executor) + pkg = RegularPackage(pkgInfo.id) + typeCheckResultEither <- parseResultEither.fold( + parseErrs => Future.successful(Left(parseErrs)), + parseResult => Info.checkFut(config, pkg, parseResult)(executor)) + } yield typeCheckResultEither + }) + Await.result(Future.sequence(futs), Duration.Inf) + println("pre-parsing and pre-typeChecking completed") } super.runTests(testName, args) } @@ -73,18 +96,9 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { override def run(input: AnnotatedTestInput): Seq[AbstractOutput] = { val source = FromFileSource(input.file) - val packageInfoInputMap = if (cacheParser) inputMapping.toMap else Map(Source.getPackageInfo(source, Path.of("")) -> Vector(source)) - val config = Config( - logLevel = Level.INFO, - reporter = NoopReporter, - packageInfoInputMap = packageInfoInputMap, - checkConsistency = true, - cacheParser = cacheParser, - z3Exe = z3Exe - ) - - val pkgInfo = Source.getPackageInfo(source, Path.of("")) - val (result, elapsedMilis) = time(() => Await.result(gobraInstance.verify(pkgInfo, config)(executor), Duration.Inf)) + val config = getConfig(source) + val pkgInfo = config.packageInfoInputMap.keys.head + val (result, elapsedMilis) = time(() => Await.result(gobraInstance.verify(pkgInfo, getConfig(source))(executor), Duration.Inf)) info(s"Time required: $elapsedMilis ms") From 7f32830b010455ff2267c6fb2adfc0a7c6539951 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Fri, 30 Jun 2023 14:43:24 +0200 Subject: [PATCH 24/54] cleanup --- build.sbt | 1 + src/main/scala/viper/gobra/Gobra.scala | 73 +++++----- .../scala/viper/gobra/frontend/Config.scala | 31 +++-- .../scala/viper/gobra/frontend/Parser.scala | 54 ++------ .../viper/gobra/frontend/TaskManager.scala | 17 +-- .../viper/gobra/frontend/info/Info.scala | 130 ++++-------------- .../scala/viper/gobra/BenchmarkTests.scala | 2 +- src/test/scala/viper/gobra/GobraTests.scala | 19 +-- 8 files changed, 103 insertions(+), 224 deletions(-) diff --git a/build.sbt b/build.sbt index dca34e1c5..ce407ccc9 100644 --- a/build.sbt +++ b/build.sbt @@ -35,6 +35,7 @@ lazy val gobra = (project in file(".")) libraryDependencies += "org.apache.commons" % "commons-text" % "1.9", // for escaping strings in parser preprocessor libraryDependencies += "commons-codec" % "commons-codec" % "1.15", // for obtaining the hex encoding of a string libraryDependencies += "org.antlr" % "antlr4-runtime" % "4.12.0", + libraryDependencies += "org.scalaz" %% "scalaz-core" % "7.3.7", // used for EitherT scalacOptions ++= Seq( "-encoding", "UTF-8", // Enforce UTF-8, instead of relying on properly set locales diff --git a/src/main/scala/viper/gobra/Gobra.scala b/src/main/scala/viper/gobra/Gobra.scala index 051117256..38d7b7684 100644 --- a/src/main/scala/viper/gobra/Gobra.scala +++ b/src/main/scala/viper/gobra/Gobra.scala @@ -7,11 +7,13 @@ package viper.gobra import ch.qos.logback.classic.Logger +import scalaz.EitherT import java.nio.file.Paths import java.util.concurrent.ExecutionException import com.typesafe.scalalogging.StrictLogging import org.slf4j.LoggerFactory +import scalaz.Scalaz.futureInstance import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.{CGEdgesTerminationTransform, ConstantPropagation, InternalTransform, OverflowChecksTransform} import viper.gobra.backend.BackendVerifier @@ -28,7 +30,6 @@ import viper.silver.{ast => vpr} import java.time.format.DateTimeFormatter import java.time.LocalTime -import scala.annotation.unused import scala.concurrent.{Await, Future, TimeoutException} object GoVerifier { @@ -142,7 +143,7 @@ trait GoVerifier extends StrictLogging { if (allErrors.isEmpty) VerifierResult.Success else VerifierResult.Failure(allErrors) } - protected[this] def verify(pkgInfo: PackageInfo, config: Config)(executor: GobraExecutionContext): Future[VerifierResult] + protected[this] def verify(pkgInfo: PackageInfo, config: Config)(implicit executor: GobraExecutionContext): Future[VerifierResult] } trait GoIdeVerifier { @@ -151,27 +152,23 @@ trait GoIdeVerifier { class Gobra extends GoVerifier with GoIdeVerifier { - override def verify(pkgInfo: PackageInfo, config: Config)(executor: GobraExecutionContext): Future[VerifierResult] = { - // directly declaring the parameter implicit somehow does not work as the compiler is unable to spot the inheritance - implicit val _executor: GobraExecutionContext = executor - - val task = Future { - for { - finalConfig <- getAndMergeInFileConfig(config, pkgInfo) - _ = setLogLevel(finalConfig) - parseResults <- performParsing(finalConfig, pkgInfo)(executor) - typeInfo <- performTypeChecking(finalConfig, pkgInfo, parseResults)(executor) - program <- performDesugaring(finalConfig, typeInfo)(executor) - program <- performInternalTransformations(finalConfig, pkgInfo, program)(executor) - viperTask <- performViperEncoding(finalConfig, pkgInfo, program)(executor) - } yield (viperTask, finalConfig) - } - - task.flatMap{ - case Left(Vector()) => Future(VerifierResult.Success) - case Left(errors) => Future(VerifierResult.Failure(errors)) - case Right((job, finalConfig)) => performVerification(finalConfig, pkgInfo, job.program, job.backtrack)(executor) - } + override def verify(pkgInfo: PackageInfo, config: Config)(implicit executor: GobraExecutionContext): Future[VerifierResult] = { + val task = for { + finalConfig <- EitherT.fromEither(Future.successful(getAndMergeInFileConfig(config, pkgInfo))) + _ = setLogLevel(finalConfig) + parseResults <- performParsing(finalConfig, pkgInfo) + typeInfo <- performTypeChecking(finalConfig, pkgInfo, parseResults) + program <- performDesugaring(finalConfig, typeInfo) + program <- performInternalTransformations(finalConfig, pkgInfo, program) + viperTask <- performViperEncoding(finalConfig, pkgInfo, program) + } yield (viperTask, finalConfig) + + task.foldM({ + case Vector() => Future(VerifierResult.Success) + case errors => Future(VerifierResult.Failure(errors)) + }, { + case (job, finalConfig) => performVerification(finalConfig, pkgInfo, job.program, job.backtrack) + }) } override def verifyAst(config: Config, pkgInfo: PackageInfo, ast: vpr.Program, backtrack: BackTranslator.BackTrackInfo)(executor: GobraExecutionContext): Future[VerifierResult] = { @@ -245,39 +242,39 @@ class Gobra extends GoVerifier with GoIdeVerifier { // returns `Left(...)` if parsing of the package identified by `pkgInfo` failed. Note that `Right(...)` does not imply // that all imported packages have been parsed successfully (this is only checked during type-checking) - private def performParsing(config: Config, pkgInfo: PackageInfo)(executor: GobraExecutionContext): Either[Vector[VerifierError], Map[AbstractPackage, ParseResult]] = { + private def performParsing(config: Config, pkgInfo: PackageInfo)(implicit executor: GobraExecutionContext): EitherT[Vector[VerifierError], Future, Map[AbstractPackage, ParseResult]] = { if (config.shouldParse) { val startMs = System.currentTimeMillis() - val res = Parser.parse(config, pkgInfo)(executor) + val res = Parser.parse(config, pkgInfo) logger.debug { val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" s"parser phase done, took ${durationS}s" } res } else { - Left(Vector.empty) + EitherT.left(Vector.empty) } } - private def performTypeChecking(config: Config, pkgInfo: PackageInfo, parseResults: Map[AbstractPackage, ParseResult])(executor: GobraExecutionContext): Either[Vector[VerifierError], TypeInfo] = { + private def performTypeChecking(config: Config, pkgInfo: PackageInfo, parseResults: Map[AbstractPackage, ParseResult])(implicit executor: GobraExecutionContext): EitherT[Vector[VerifierError], Future, TypeInfo] = { if (config.shouldTypeCheck) { - Info.check(config, RegularPackage(pkgInfo.id), parseResults)(executor) + Info.check(config, RegularPackage(pkgInfo.id), parseResults) } else { - Left(Vector()) + EitherT.left(Vector.empty) } } - private def performDesugaring(config: Config, typeInfo: TypeInfo)(executor: GobraExecutionContext): Either[Vector[VerifierError], Program] = { + private def performDesugaring(config: Config, typeInfo: TypeInfo)(implicit executor: GobraExecutionContext): EitherT[Vector[VerifierError], Future, Program] = { if (config.shouldDesugar) { val startMs = System.currentTimeMillis() - val res = Right(Desugar.desugar(config, typeInfo)(executor)) + val res = EitherT.right[Vector[VerifierError], Future, Program](Desugar.desugar(config, typeInfo)(executor)) logger.debug { val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" s"desugaring done, took ${durationS}s" } res } else { - Left(Vector()) + EitherT.left(Vector.empty) } } @@ -285,7 +282,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { * Applies transformations to programs in the internal language. Currently, only adds overflow checks but it can * be easily extended to perform more transformations */ - private def performInternalTransformations(config: Config, pkgInfo: PackageInfo, program: Program)(@unused executor: GobraExecutionContext): Either[Vector[VerifierError], Program] = { + private def performInternalTransformations(config: Config, pkgInfo: PackageInfo, program: Program)(implicit executor: GobraExecutionContext): EitherT[Vector[VerifierError], Future, Program] = { // constant propagation does not cause duplication of verification errors caused // by overflow checks (if enabled) because all overflows in constant declarations // can be found by the well-formedness checks. @@ -300,24 +297,24 @@ class Gobra extends GoVerifier with GoIdeVerifier { s"internal transformations done, took ${durationS}s" } config.reporter.report(AppliedInternalTransformsMessage(config.packageInfoInputMap(pkgInfo).map(_.name), () => result)) - Right(result) + EitherT.right(result) } - private def performViperEncoding(config: Config, pkgInfo: PackageInfo, program: Program)(@unused executor: GobraExecutionContext): Either[Vector[VerifierError], BackendVerifier.Task] = { + private def performViperEncoding(config: Config, pkgInfo: PackageInfo, program: Program)(implicit executor: GobraExecutionContext): EitherT[Vector[VerifierError], Future, BackendVerifier.Task] = { if (config.shouldViperEncode) { val startMs = System.currentTimeMillis() - val res = Right(Translator.translate(program, pkgInfo)(config)) + val res = EitherT.right[Vector[VerifierError], Future, BackendVerifier.Task](Translator.translate(program, pkgInfo)(config)) logger.debug { val durationS = f"${(System.currentTimeMillis() - startMs) / 1000f}%.1f" s"Viper encoding done, took ${durationS}s" } res } else { - Left(Vector()) + EitherT.left(Vector.empty) } } - private def performVerification(config: Config, pkgInfo: PackageInfo, ast: vpr.Program, backtrack: BackTranslator.BackTrackInfo)(executor: GobraExecutionContext): Future[VerifierResult] = { + private def performVerification(config: Config, pkgInfo: PackageInfo, ast: vpr.Program, backtrack: BackTranslator.BackTrackInfo)(implicit executor: GobraExecutionContext): Future[VerifierResult] = { if (config.noVerify) { Future(VerifierResult.Success)(executor) } else { diff --git a/src/main/scala/viper/gobra/frontend/Config.scala b/src/main/scala/viper/gobra/frontend/Config.scala index cd2c80df7..e39e461fd 100644 --- a/src/main/scala/viper/gobra/frontend/Config.scala +++ b/src/main/scala/viper/gobra/frontend/Config.scala @@ -54,7 +54,7 @@ object ConfigDefaults { lazy val DefaultInt32bit: Boolean = false // the following option is currently not controllable via CLI as it is meaningless without a constantly // running JVM. It is targeted in particular to Gobra Server and Gobra IDE - lazy val DefaultCacheParser: Boolean = false + lazy val DefaultCacheParserAndTypeChecker: Boolean = false // this option introduces a mode where Gobra only considers files with a specific annotation ("// +gobra"). // this is useful when verifying large packages where some files might use some unsupported feature of Gobra, // or when the goal is to gradually verify part of a package without having to provide an explicit list of the files @@ -69,7 +69,7 @@ object ConfigDefaults { lazy val DefaultEnableLazyImports: Boolean = false lazy val DefaultNoVerify: Boolean = false lazy val DefaultNoStreamErrors: Boolean = false - lazy val DefaultTypeCheckMode: TaskManagerMode = TaskManagerMode.Parallel + lazy val DefaultParseAndTypeCheckMode: TaskManagerMode = TaskManagerMode.Parallel } case class Config( @@ -105,7 +105,7 @@ case class Config( int32bit: Boolean = ConfigDefaults.DefaultInt32bit, // the following option is currently not controllable via CLI as it is meaningless without a constantly // running JVM. It is targeted in particular to Gobra Server and Gobra IDE - cacheParser: Boolean = ConfigDefaults.DefaultCacheParser, + cacheParserAndTypeChecker: Boolean = ConfigDefaults.DefaultCacheParserAndTypeChecker, // this option introduces a mode where Gobra only considers files with a specific annotation ("// +gobra"). // this is useful when verifying large packages where some files might use some unsupported feature of Gobra, // or when the goal is to gradually verify part of a package without having to provide an explicit list of the files @@ -121,7 +121,7 @@ case class Config( enableLazyImports: Boolean = ConfigDefaults.DefaultEnableLazyImports, noVerify: Boolean = ConfigDefaults.DefaultNoVerify, noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors, - typeCheckMode: TaskManagerMode = ConfigDefaults.DefaultTypeCheckMode, + parseAndTypeCheckMode: TaskManagerMode = ConfigDefaults.DefaultParseAndTypeCheckMode, ) { def merge(other: Config): Config = { @@ -159,6 +159,7 @@ case class Config( shouldVerify = shouldVerify, int32bit = int32bit || other.int32bit, checkConsistency = checkConsistency || other.checkConsistency, + cacheParserAndTypeChecker = cacheParserAndTypeChecker || other.cacheParserAndTypeChecker, onlyFilesWithHeader = onlyFilesWithHeader || other.onlyFilesWithHeader, assumeInjectivityOnInhale = assumeInjectivityOnInhale || other.assumeInjectivityOnInhale, parallelizeBranches = parallelizeBranches, @@ -167,7 +168,7 @@ case class Config( enableLazyImports = enableLazyImports || other.enableLazyImports, noVerify = noVerify || other.noVerify, noStreamErrors = noStreamErrors || other.noStreamErrors, - typeCheckMode = typeCheckMode + parseAndTypeCheckMode = parseAndTypeCheckMode ) } @@ -209,7 +210,7 @@ case class BaseConfig(gobraDirectory: Path = ConfigDefaults.DefaultGobraDirector checkOverflows: Boolean = ConfigDefaults.DefaultCheckOverflows, checkConsistency: Boolean = ConfigDefaults.DefaultCheckConsistency, int32bit: Boolean = ConfigDefaults.DefaultInt32bit, - cacheParser: Boolean = ConfigDefaults.DefaultCacheParser, + cacheParserAndTypeChecker: Boolean = ConfigDefaults.DefaultCacheParserAndTypeChecker, onlyFilesWithHeader: Boolean = ConfigDefaults.DefaultOnlyFilesWithHeader, assumeInjectivityOnInhale: Boolean = ConfigDefaults.DefaultAssumeInjectivityOnInhale, parallelizeBranches: Boolean = ConfigDefaults.DefaultParallelizeBranches, @@ -218,7 +219,7 @@ case class BaseConfig(gobraDirectory: Path = ConfigDefaults.DefaultGobraDirector enableLazyImports: Boolean = ConfigDefaults.DefaultEnableLazyImports, noVerify: Boolean = ConfigDefaults.DefaultNoVerify, noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors, - typeCheckMode: TaskManagerMode = ConfigDefaults.DefaultTypeCheckMode, + parseAndTypeCheckMode: TaskManagerMode = ConfigDefaults.DefaultParseAndTypeCheckMode, ) { def shouldParse: Boolean = true def shouldTypeCheck: Boolean = !shouldParseOnly @@ -264,7 +265,7 @@ trait RawConfig { shouldVerify = baseConfig.shouldVerify, shouldChop = baseConfig.shouldChop, int32bit = baseConfig.int32bit, - cacheParser = baseConfig.cacheParser, + cacheParserAndTypeChecker = baseConfig.cacheParserAndTypeChecker, onlyFilesWithHeader = baseConfig.onlyFilesWithHeader, assumeInjectivityOnInhale = baseConfig.assumeInjectivityOnInhale, parallelizeBranches = baseConfig.parallelizeBranches, @@ -273,7 +274,7 @@ trait RawConfig { enableLazyImports = baseConfig.enableLazyImports, noVerify = baseConfig.noVerify, noStreamErrors = baseConfig.noStreamErrors, - typeCheckMode = baseConfig.typeCheckMode, + parseAndTypeCheckMode = baseConfig.parseAndTypeCheckMode, ) } @@ -645,17 +646,17 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals noshort = true, ) - val typeCheckMode: ScallopOption[TaskManagerMode] = choice( - name = "typeCheckMode", + val parseAndTypeCheckMode: ScallopOption[TaskManagerMode] = choice( + name = "parseAndTypeCheckMode", choices = Seq("LAZY", "SEQUENTIAL", "PARALLEL"), - descr = "Specifies the mode in which type-checking is performed.", + descr = "Specifies the mode in which parsing and type-checking is performed.", default = Some("PARALLEL"), noshort = true ).map { case "LAZY" => Lazy case "SEQUENTIAL" => Sequential case "PARALLEL" => Parallel - case _ => ConfigDefaults.DefaultTypeCheckMode + case _ => ConfigDefaults.DefaultParseAndTypeCheckMode } /** @@ -795,7 +796,7 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals checkOverflows = checkOverflows(), checkConsistency = checkConsistency(), int32bit = int32Bit(), - cacheParser = false, // caching does not make sense when using the CLI. Thus, we simply set it to `false` + cacheParserAndTypeChecker = false, // caching does not make sense when using the CLI. Thus, we simply set it to `false` onlyFilesWithHeader = onlyFilesWithHeader(), assumeInjectivityOnInhale = assumeInjectivityOnInhale(), parallelizeBranches = parallelizeBranches(), @@ -804,6 +805,6 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals enableLazyImports = enableLazyImports(), noVerify = noVerify(), noStreamErrors = noStreamErrors(), - typeCheckMode = typeCheckMode(), + parseAndTypeCheckMode = parseAndTypeCheckMode(), ) } diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index 8057b047a..9ef811c57 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -16,6 +16,8 @@ import viper.gobra.reporting.{Source => _, _} import org.antlr.v4.runtime.{CharStreams, CommonTokenStream, DefaultErrorStrategy, ParserRuleContext} import org.antlr.v4.runtime.atn.PredictionMode import org.antlr.v4.runtime.misc.ParseCancellationException +import scalaz.EitherT +import scalaz.Scalaz.futureInstance import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} import viper.gobra.util.{GobraExecutionContext, Violation} @@ -31,11 +33,11 @@ object Parser extends LazyLogging { type ParseSuccessResult = (Vector[Source], PPackage) type ParseResult = Either[Vector[ParserError], ParseSuccessResult] - type PreprocessedSources = Vector[Source] type ImportToSourceOrErrorMap = Vector[(AbstractPackage, Either[Vector[ParserError], Vector[Source]])] + type PreprocessedSources = Vector[Source] - class ParseManager(config: Config, executionContext: GobraExecutionContext) extends LazyLogging { - private val manager = new TaskManager[AbstractPackage, PreprocessedSources, ParseResult](config.typeCheckMode)(executionContext) + class ParseManager(config: Config)(implicit executor: GobraExecutionContext) extends LazyLogging { + private val manager = new TaskManager[AbstractPackage, PreprocessedSources, ParseResult](config.parseAndTypeCheckMode) // note that the returned future might never complete if typeCheckMode is `Lazy` and there is no trigger to actually // execute the parsing of the specified package @@ -50,13 +52,11 @@ object Parser extends LazyLogging { def pkgInfo: PackageInfo type ImportErrorFactory = String => Vector[ParserError] - // protected def getImports(importNodes: Vector[PImport], pom: PositionManager): Set[(AbstractImport, ImportErrorFactory)] = { - protected def getImports(importNodes: Vector[PImport], pom: PositionManager): Vector[(AbstractPackage, Either[Vector[ParserError], Vector[Source]])] = { + protected def getImports(importNodes: Vector[PImport], pom: PositionManager): ImportToSourceOrErrorMap = { val explicitImports: Vector[(AbstractImport, ImportErrorFactory)] = importNodes .map(importNode => { val importErrorFactory: ImportErrorFactory = (errMsg: String) => { val err = pom.translate(message(importNode, errMsg), ParserError) - // config.reporter report ParserErrorMessage(err.head.position.get.file, err) err } (RegularImport(importNode.importPath), importErrorFactory) @@ -82,14 +82,6 @@ object Parser extends LazyLogging { (directImportPackage, res) } errsOrSources - /* - val (errors, sources) = errsOrSources.partitionMap(identity) - if (errors.nonEmpty) { - Left(errors) - } else { - Right(sources) - } - */ } } @@ -161,9 +153,7 @@ object Parser extends LazyLogging { Left(errs) } - def getResults: Map[AbstractPackage, ParseResult] = manager.getAllResultsWithKeys - - def getResultsFut: Future[Map[AbstractPackage, ParseResult]] = manager.getAllResultsWithKeysFut + def getResults: Future[Map[AbstractPackage, ParseResult]] = manager.getAllResultsWithKeys } /** @@ -182,34 +172,18 @@ object Parser extends LazyLogging { * */ - def parse(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Either[Vector[ParserError], Map[AbstractPackage, ParseResult]] = { - val parseManager = new ParseManager(config, executionContext) + def parse(config: Config, pkgInfo: PackageInfo)(implicit executor: GobraExecutionContext): EitherT[Vector[VerifierError], Future, Map[AbstractPackage, ParseResult]] = { + val parseManager = new ParseManager(config) parseManager.parse(pkgInfo) - val results = parseManager.getResults - results.get(RegularPackage(pkgInfo.id)) match { - case Some(Right(_)) => Right(results) - case Some(Left(errs)) => Left(errs) - case _ => Violation.violation(s"No parse result for package '$pkgInfo' found") - } - } - - def parseFut(config: Config, pkgInfo: PackageInfo)(executionContext: GobraExecutionContext): Future[Either[Vector[ParserError], Map[AbstractPackage, ParseResult]]] = { - val parseManager = new ParseManager(config, executionContext) - parseManager.parse(pkgInfo) - implicit val executor: GobraExecutionContext = executionContext - for { - results <- parseManager.getResultsFut + val res: Future[Either[Vector[VerifierError], Map[AbstractPackage, ParseResult]]] = for { + results <- parseManager.getResults res = results.get(RegularPackage(pkgInfo.id)) match { case Some(Right(_)) => Right(results) case Some(Left(errs)) => Left(errs) case _ => Violation.violation(s"No parse result for package '$pkgInfo' found") } } yield res - } - - def parse(input: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean = false)(config: Config): Either[Vector[VerifierError], PPackage] = { - val preprocessedInputs = preprocess(input)(config) - process(preprocessedInputs, pkgInfo, specOnly = specOnly)(config) + EitherT.fromEither(res) } private def preprocess(input: Vector[Source])(config: Config): Vector[Source] = { @@ -244,7 +218,7 @@ object Parser extends LazyLogging { res } - if (config.cacheParser) parseSourceCached(preprocessedSource) else parseSource(preprocessedSource) + if (config.cacheParserAndTypeChecker) parseSourceCached(preprocessedSource) else parseSource(preprocessedSource) } private def process(preprocessedInputs: Vector[Source], pkgInfo: PackageInfo, specOnly: Boolean)(config: Config): Either[Vector[ParserError], PPackage] = { @@ -309,7 +283,7 @@ object Parser extends LazyLogging { res } - val parseFn = if (config.cacheParser) { parseSourcesCached _ } else { parseSourcesUncached _ } + val parseFn = if (config.cacheParserAndTypeChecker) { parseSourcesCached _ } else { parseSourcesUncached _ } parseFn(sources, pkgInfo, specOnly)(config) } diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/frontend/TaskManager.scala index 85557cfd5..991949ce4 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/frontend/TaskManager.scala @@ -54,7 +54,7 @@ trait Job[I, R] { } } -class TaskManager[K, I, R](mode: TaskManagerMode)(executionContext: GobraExecutionContext) { +class TaskManager[K, I, R](mode: TaskManagerMode)(implicit executor: GobraExecutionContext) { private val jobs: ConcurrentMap[K, Job[I, R]] = new ConcurrentHashMap() def addIfAbsent(id: K, job: Job[I, R]): Unit = { @@ -68,12 +68,12 @@ class TaskManager[K, I, R](mode: TaskManagerMode)(executionContext: GobraExecuti mode match { case Sequential => job.execute() case Lazy => // don't do anything as of now - case Parallel => Future{ job.execute() }(executionContext) + case Parallel => Future{ job.execute() } } } } - def getResultFut(id: K): Future[R] = { + def getResult(id: K): Future[R] = { val job = jobs.get(id) Violation.violation(job != null, s"Task $id not found") mode match { @@ -83,12 +83,11 @@ class TaskManager[K, I, R](mode: TaskManagerMode)(executionContext: GobraExecuti job.getFuture } - def getResult(id: K): R = { - Await.result(getResultFut(id), Duration.Inf) + def getResultBlocking(id: K): R = { + Await.result(getResult(id), Duration.Inf) } - def getAllResultsWithKeysFut: Future[Map[K, R]] = { - implicit val executor: GobraExecutionContext = executionContext + def getAllResultsWithKeys: Future[Map[K, R]] = { val futs = jobs.asScala.toVector.map { case (key, job) => mode match { case Lazy => job.execute() // now we need the job's result @@ -98,8 +97,4 @@ class TaskManager[K, I, R](mode: TaskManagerMode)(executionContext: GobraExecuti } Future.sequence(futs).map(_.toMap) } - - def getAllResultsWithKeys: Map[K, R] = { - Await.result(getAllResultsWithKeysFut, Duration.Inf) - } } diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index f14877ae7..687730513 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -10,12 +10,13 @@ import com.typesafe.scalalogging.LazyLogging import org.bitbucket.inkytonik.kiama.relation.Tree import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, message} import org.bitbucket.inkytonik.kiama.util.{Position, Source} +import scalaz.EitherT +import scalaz.Scalaz.futureInstance import viper.gobra.ast.frontend.{PImport, PNode, PPackage} import viper.gobra.frontend.{Config, Job, TaskManager} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport} import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} -import viper.gobra.frontend.info.Info.Context import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.{GhostLessPrinter, GoifyingPrinter} import viper.gobra.reporting.{CyclicImportError, ParserError, TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} @@ -61,12 +62,6 @@ object Info extends LazyLogging { parseResult <- getParseResult(abstractPackage) (_, ast) = parseResult perImportResult = ast.imports.map(importNode => { - // val cycles = getCycles(RegularImport(importNode.importPath)) - /* - val cycles = getImportErrors(RegularImport(importNode.importPath)) - val msgs = createImportError(importNode, cycles) - if (msgs.isEmpty) Right(()) else Left(ast.positions.translate(msgs, TypeError).distinct) - */ val res = getImportErrors(RegularImport(importNode.importPath)) .left .map(errs => { @@ -81,18 +76,6 @@ object Info extends LazyLogging { case (key, Right(res)) => (key, res) } } yield successParseResults - /* - val (_, ast) = getParseResult(abstractPackage) - val msgs = ast.imports.flatMap(importNode => { - val cycles = getCycles(RegularImport(importNode.importPath)) - createImportError(importNode, cycles) - }) - if (msgs.isEmpty) { - - } else { - Left(ast.positions.translate(msgs, TypeError).distinct) - } - */ } /** @@ -109,7 +92,6 @@ object Info extends LazyLogging { if (parserPendingPackages.contains(directlyImportedTarget)) { // package cycle detected val importNodeStart = ast.positions.positions.getStart(importNode) - // Vector(ImportCycle(importNode, importNodeStart, parserPendingPackages)) val msg = s"Package '$importTarget' is part of the following import cycle that involves the import $importNode$importNodeStart: ${parserPendingPackages.mkString("[", ", ", "]")}" Left(Vector(CyclicImportError(s"Cyclic package import detected starting with package '$msg'"))) } else { @@ -122,44 +104,17 @@ object Info extends LazyLogging { parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) res } - /* - private def getCycles(importTarget: AbstractImport): Vector[ImportCycle] = { - val (_, ast) = getParseResult(abstractPackage) - val res = ast.imports.flatMap(importNode => { - val directlyImportedTarget = RegularImport(importNode.importPath) - if (parserPendingPackages.contains(directlyImportedTarget)) { - // package cycle detected - val importNodeStart = ast.positions.positions.getStart(importNode) - Vector(ImportCycle(importNode, importNodeStart, parserPendingPackages)) - } else { - getCycles(directlyImportedTarget) - } - }) - parserPendingPackages = parserPendingPackages.filterNot(_ == importTarget) - res - } - */ private def createImportError(importNode: PImport, errorsInImportedPackage: Vector[VerifierError]): Messages = { - val importTarget = RegularImport(importNode.importPath) val (cyclicErrors, nonCyclicErrors) = errorsInImportedPackage.partitionMap { case cyclicErr: CyclicImportError => Left(cyclicErr) case e => Right(e) } if (cyclicErrors.isEmpty) { - // nonCyclicErrors.flatMap(err => message(importNode, err.message)) message(importNode, s"Package contains ${nonCyclicErrors.length} error(s): ${nonCyclicErrors.map(_.message).mkString(", ")}") } else { - cyclicErrors.flatMap(cycle => { - // val positionalInfo = cycle.importNodeStart.map(pos => s" at ${pos.format}").getOrElse("") - // message(importNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}$positionalInfo: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") - message(importNode, cycle.message) - }) - }/* - cycles.flatMap(cycle => { - val positionalInfo = cycle.importNodeStart.map(pos => s" at ${pos.format}").getOrElse("") - message(importNode, s"Package '$importTarget' is part of the following import cycle that involves the import ${cycle.importNodeCausingCycle}$positionalInfo: ${cycle.cyclicPackages.mkString("[", ", ", "]")}") - })*/ + cyclicErrors.flatMap(cycle => message(importNode, cycle.message)) + } } } @@ -167,8 +122,8 @@ object Info extends LazyLogging { * All TypeInfo instances share a single context instance. * Therefore, package management is centralized. */ - class Context(val config: Config, val parseResults: Map[AbstractPackage, ParseSuccessResult])(val executionContext: GobraExecutionContext) extends GetParseResult { - private val typeCheckManager = new TaskManager[AbstractPackage, (Vector[Source], PPackage, Vector[AbstractImport]), () => TypeCheckResult](config.typeCheckMode)(executionContext) + class Context(val config: Config, val parseResults: Map[AbstractPackage, ParseSuccessResult])(implicit executor: GobraExecutionContext) extends GetParseResult { + private val typeCheckManager = new TaskManager[AbstractPackage, (Vector[Source], PPackage, Vector[AbstractImport]), () => TypeCheckResult](config.parseAndTypeCheckMode) var tyeCheckDurationMs = new AtomicLong(0L) @@ -193,19 +148,19 @@ object Info extends LazyLogging { val (sources, ast, dependencies) = precomputationResult val dependentTypeInfo = dependencies.map(importTarget => { val dependentPackage = AbstractPackage(importTarget)(config) - (importTarget, typeCheckManager.getResult(dependentPackage)) + (importTarget, typeCheckManager.getResultBlocking(dependentPackage)) }) - config.typeCheckMode match { + config.parseAndTypeCheckMode match { case Sequential | Parallel => - val res = typeCheck(sources, ast, dependentTypeInfo.toMap, isMainContext = isMainContext) + val res = typeCheck(sources, ast, dependentTypeInfo.toMap) () => res case Lazy => - lazy val res = typeCheck(sources, ast, dependentTypeInfo.toMap, isMainContext = isMainContext) + lazy val res = typeCheck(sources, ast, dependentTypeInfo.toMap) () => res } } - private def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isMainContext: Boolean = false, isLazy: Boolean = false): TypeCheckResult = { + private def typeCheck(pkgSources: Vector[Source], pkg: PPackage, dependentTypeInfo: DependentTypeInfo, isLazy: Boolean = false): TypeCheckResult = { val startMs = System.currentTimeMillis() logger.trace(s"start type-checking ${pkg.info.id}") val res = Info.checkSources(pkgSources, pkg, dependentTypeInfo, isMainContext = isMainContext)(config) @@ -222,37 +177,31 @@ object Info extends LazyLogging { } } - def typeCheck(pkg: AbstractPackage): TypeCheckResult = { + def typeCheck(pkg: AbstractPackage): Future[TypeCheckResult] = { typeCheckManager.addIfAbsent(pkg, TypeCheckJob(pkg, isMainContext = true)) - val resFn = typeCheckManager.getResult(pkg) - resFn() - } - - def typeCheckFut(pkg: AbstractPackage): Future[TypeCheckResult] = { - typeCheckManager.addIfAbsent(pkg, TypeCheckJob(pkg, isMainContext = true)) - typeCheckManager.getResultFut(pkg) - .map(resFn => resFn())(executionContext) + typeCheckManager.getResult(pkg) + .map(resFn => resFn()) } } - def check(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseResult])(executionContext: GobraExecutionContext): TypeCheckResult = { + def check(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseResult])(implicit executor: GobraExecutionContext): EitherT[Vector[VerifierError], Future, TypeInfo] = { for { // check whether parsing of this package was successful: - parseResult <- parseResults(abstractPackage) + parseResult <- EitherT.fromEither(Future.successful[Either[Vector[VerifierError], ParseSuccessResult]](parseResults(abstractPackage))) // check whether there are any import cycles: - cycleResult <- new CycleChecker(config, parseResults).check(abstractPackage) - .left.map(errs => { + cycleResult <- EitherT.fromEither(Future.successful(new CycleChecker(config, parseResults).check(abstractPackage))) + .leftMap(errs => { val (sources, pkg) = parseResult val sourceNames = sources.map(_.name) config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errs) errs }) typeCheckingStartMs = System.currentTimeMillis() - context = new Context(config, cycleResult)(executionContext) - typeInfo <- context.typeCheck(abstractPackage) + context = new Context(config, cycleResult) + typeInfo <- EitherT.fromEither(context.typeCheck(abstractPackage)) _ = logger.debug { val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" - s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})" + s"type-checking done, took ${durationS}s (in mode ${config.parseAndTypeCheckMode})" } _ = logger.debug { val typeCheckingEndMs = System.currentTimeMillis() @@ -264,39 +213,6 @@ object Info extends LazyLogging { } yield typeInfo } - def checkFut(config: Config, abstractPackage: AbstractPackage, parseResults: Map[AbstractPackage, ParseResult])(executionContext: GobraExecutionContext): Future[TypeCheckResult] = { - implicit val executor: GobraExecutionContext = executionContext - val res = for { - // check whether parsing of this package was successful: - parseResult <- parseResults(abstractPackage) - // check whether there are any import cycles: - cycleResult <- new CycleChecker(config, parseResults).check(abstractPackage) - .left.map(errs => { - val (sources, pkg) = parseResult - val sourceNames = sources.map(_.name) - config.reporter report TypeCheckFailureMessage(sourceNames, pkg.packageClause.id.name, () => pkg, errs) - errs - }) - typeCheckingStartMs = System.currentTimeMillis() - context = new Context(config, cycleResult)(executionContext) - typeInfoFut = for { - typeInfo <- context.typeCheckFut(abstractPackage) - _ = logger.debug { - val durationS = f"${(System.currentTimeMillis() - typeCheckingStartMs) / 1000f}%.1f" - s"type-checking done, took ${durationS}s (in mode ${config.typeCheckMode})" - } - _ = logger.debug { - val typeCheckingEndMs = System.currentTimeMillis() - val sumDurationS = f"${context.tyeCheckDurationMs.get() / 1000f}%.1f" - val overheadMs = (typeCheckingEndMs - typeCheckingStartMs) - context.tyeCheckDurationMs.get() - val overheadS = f"${overheadMs / 1000f}%.1f" - s"type-checking individual packages took ${sumDurationS}s. Overhead for tasks is thus ${overheadS}s (${(100f * overheadMs / (typeCheckingEndMs - typeCheckingStartMs)).toInt}%)" - } - } yield typeInfo - } yield typeInfoFut - res.fold(errs => Future.successful(Left(errs)), identity) - } - type TypeInfoCacheKey = String private val typeInfoCache: ConcurrentMap[TypeInfoCacheKey, TypeInfoImpl] = new ConcurrentHashMap() @@ -339,9 +255,9 @@ object Info extends LazyLogging { typeInfoCache.computeIfAbsent(getCacheKey(pkg, dependentTypeInfo, isMainContext, config), _ => getTypeInfo(pkg, dependentTypeInfo, isMainContext, config)) } - val checkFn = if (config.cacheParser) { getTypeInfoCached _ } else { getTypeInfo _ } + val checkFn = if (config.cacheParserAndTypeChecker) { getTypeInfoCached _ } else { getTypeInfo _ } val info = checkFn(pkg, dependentTypeInfo, isMainContext, config) - if (!cacheHit && config.cacheParser) { + if (!cacheHit && config.cacheParserAndTypeChecker) { logger.trace(s"No cache hit for type info for ${pkg.info.id}") } diff --git a/src/test/scala/viper/gobra/BenchmarkTests.scala b/src/test/scala/viper/gobra/BenchmarkTests.scala index afbe52588..089d522a2 100644 --- a/src/test/scala/viper/gobra/BenchmarkTests.scala +++ b/src/test/scala/viper/gobra/BenchmarkTests.scala @@ -56,7 +56,7 @@ trait GobraFrontendForTesting extends Frontend { val z3PropertyName = "GOBRATESTS_Z3_EXE" val z3Exe: Option[String] = Option(System.getProperty(z3PropertyName)) - protected val executor: GobraExecutionContext = new DefaultGobraExecutionContext() + protected implicit val executor: GobraExecutionContext = new DefaultGobraExecutionContext() protected var config: Option[Config] = None /** Initialize this translator with a given verifier. Only meant to be called once. */ diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index e22a5ab30..713679558 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -10,6 +10,7 @@ import java.nio.file.Path import ch.qos.logback.classic.Level import org.bitbucket.inkytonik.kiama.util.Source import org.scalatest.{Args, BeforeAndAfterAll, Status} +import scalaz.Scalaz.futureInstance import viper.gobra.frontend.PackageResolver.RegularPackage import viper.gobra.frontend.Source.FromFileSource import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel} @@ -35,10 +36,6 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { var gobraInstance: Gobra = _ var executor: GobraExecutionContext = _ var inputs: Vector[Source] = Vector.empty - // while we could pre-fetch and cache parse and maybe even type-check results, the regression test suite is designed - // in a way that each file is its own test case. However, feeding a map of package infos to Gobra results in Gobra - // considering these files in a Go way, i.e., groups them by package clause. This in turn results in testcase failures - // as errors occur in files technically not under test but in the same directory and having the same package clause. val cacheParserAndTypeChecker = true override def beforeAll(): Unit = { @@ -58,8 +55,7 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { reporter = NoopReporter, packageInfoInputMap = Map(Source.getPackageInfo(source, Path.of("")) -> Vector(source)), checkConsistency = true, - cacheParser = cacheParserAndTypeChecker, - typeCheckMode = if (cacheParserAndTypeChecker) Parallel else Lazy, + cacheParserAndTypeChecker = cacheParserAndTypeChecker, z3Exe = z3Exe ) @@ -69,13 +65,12 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { val futs = inputs.map(source => { val config = getConfig(source) val pkgInfo = config.packageInfoInputMap.keys.head - for { - parseResultEither <- Parser.parseFut(config, pkgInfo)(executor) + val fut = for { + parseResult <- Parser.parseFut(config, pkgInfo) pkg = RegularPackage(pkgInfo.id) - typeCheckResultEither <- parseResultEither.fold( - parseErrs => Future.successful(Left(parseErrs)), - parseResult => Info.checkFut(config, pkg, parseResult)(executor)) - } yield typeCheckResultEither + typeCheckResult <- Info.checkFut(config, pkg, parseResult) + } yield typeCheckResult + fut.toEither }) Await.result(Future.sequence(futs), Duration.Inf) println("pre-parsing and pre-typeChecking completed") From 52317a45e4efcf0ddb006cc7e5ed928c7fa8f64f Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Fri, 30 Jun 2023 15:48:17 +0200 Subject: [PATCH 25/54] fixes compilation errors --- .../scala/viper/gobra/BenchmarkTests.scala | 177 ++++++++++-------- .../viper/gobra/DetailedBenchmarkTests.scala | 21 +-- src/test/scala/viper/gobra/GobraTests.scala | 5 +- 3 files changed, 116 insertions(+), 87 deletions(-) diff --git a/src/test/scala/viper/gobra/BenchmarkTests.scala b/src/test/scala/viper/gobra/BenchmarkTests.scala index 089d522a2..c10ecec0a 100644 --- a/src/test/scala/viper/gobra/BenchmarkTests.scala +++ b/src/test/scala/viper/gobra/BenchmarkTests.scala @@ -10,6 +10,8 @@ import org.rogach.scallop.throwError import java.nio.file.Path import org.scalatest.{ConfigMap, DoNotDiscover} +import scalaz.EitherT +import scalaz.Scalaz.futureInstance import viper.gobra.frontend.{Config, PackageResolver, ScallopGobraConfig} import viper.gobra.reporting.{NoopReporter, VerifierError, VerifierResult} import viper.gobra.util.{DefaultGobraExecutionContext, GobraExecutionContext, Violation} @@ -19,6 +21,10 @@ import viper.silver.testing.StatisticalTestSuite import viper.silver.verifier.{NoVerifier, Verifier} import viper.silver.{verifier => vpr} +import java.util.concurrent.TimeUnit +import scala.concurrent.duration.Duration +import scala.concurrent.{Await, Future} + @DoNotDiscover trait BenchmarkTests extends StatisticalTestSuite { @@ -50,94 +56,119 @@ trait BenchmarkTests extends StatisticalTestSuite { super.afterAll(configMap) gobraFrontend.terminate() } -} -trait GobraFrontendForTesting extends Frontend { - val z3PropertyName = "GOBRATESTS_Z3_EXE" - val z3Exe: Option[String] = Option(System.getProperty(z3PropertyName)) + trait GobraFrontendForTesting extends Frontend { + val z3PropertyName = "GOBRATESTS_Z3_EXE" + val z3Exe: Option[String] = Option(System.getProperty(z3PropertyName)) - protected implicit val executor: GobraExecutionContext = new DefaultGobraExecutionContext() - protected var config: Option[Config] = None + protected implicit val executor: GobraExecutionContext = new DefaultGobraExecutionContext() + protected var config: Option[Config] = None - /** Initialize this translator with a given verifier. Only meant to be called once. */ - override def init(verifier: Verifier): Unit = () // ignore verifier argument as we reuse the Gobra / Parser / TypeChecker / etc. instances for all tests + /** Initialize this translator with a given verifier. Only meant to be called once. */ + override def init(verifier: Verifier): Unit = () // ignore verifier argument as we reuse the Gobra / Parser / TypeChecker / etc. instances for all tests - override def reset(files: Seq[Path]): Unit = - createConfig(Array("-i", files.toVector.mkString(" "))) + override def reset(files: Seq[Path]): Unit = + createConfig(Array("-i", files.toVector.mkString(" "))) - private def createConfig(args: Array[String]): Config = { - // set throwError to true: Scallop will throw an exception instead of terminating the program in case an - // exception occurs (e.g. a validation failure) - throwError.value = true - // Simulate pick of package, Gobra normally does - val config = new ScallopGobraConfig(args.toSeq).config - Violation.violation(config.isRight, "creating the config has failed") - config.toOption.get.copy(reporter = NoopReporter, z3Exe = z3Exe) - } + private def createConfig(args: Array[String]): Config = { + // set throwError to true: Scallop will throw an exception instead of terminating the program in case an + // exception occurs (e.g. a validation failure) + throwError.value = true + // Simulate pick of package, Gobra normally does + val config = new ScallopGobraConfig(args.toSeq).config + Violation.violation(config.isRight, "creating the config has failed") + config.toOption.get.copy(reporter = NoopReporter, z3Exe = z3Exe) + } - def gobraResult: VerifierResult - - /** - * The result of the verification attempt (only available after parse, typecheck, translate and - * verify have been called). - */ - override def result: vpr.VerificationResult = { - // transform Gobra errors back to vpr.AbstractError such that the benchmarking framework automatically handles them - gobraResult match { - case VerifierResult.Success => vpr.Success - case VerifierResult.Failure(errors) => vpr.Failure(errors.map(GobraTestError)) + def gobraResult: VerifierResult + + /** + * The result of the verification attempt (only available after parse, typecheck, translate and + * verify have been called). + */ + override def result: vpr.VerificationResult = { + // transform Gobra errors back to vpr.AbstractError such that the benchmarking framework automatically handles them + gobraResult match { + case VerifierResult.Success => vpr.Success + case VerifierResult.Failure(errors) => vpr.Failure(errors.map(GobraTestError)) + } } - } - def terminate(): Unit = { - executor.terminateAndAssertInexistanceOfTimeout() - } + def terminate(): Unit = { + executor.terminateAndAssertInexistanceOfTimeout() + } - /** - * Represents a phase in Gobra producing a result of type Either[E, O]. - * As Phase is a case class defined in Frontend, this trait has to be defined here (instead of external to the Gobra frontent) - */ - trait Step[O, E] { - def res: Option[Either[E, O]] - def phase: Phase - def phases: Seq[Phase] - def reset(): Unit - } + /** + * Represents a phase in Gobra producing a result of type Either[E, O]. + * As Phase is a case class defined in Frontend, this trait has to be defined here (instead of external to the Gobra frontend) + */ + trait Step[O, E] { + def res: Option[Either[E, O]] + def phase: Phase + def phases: Seq[Phase] + def reset(): Unit + } - case class InitialStep[E, O](name: String, fn: () => Either[E, O]) extends Step[O, E] { - var res: Option[Either[E, O]] = None - override val phase: Phase = Phase(name, () => { - res = Some(fn()) - }) - override def phases: Seq[Phase] = Seq(phase) - override def reset(): Unit = + case class InitialStep[E, O](name: String, fn: () => Either[E, O]) extends Step[O, E] { + var res: Option[Either[E, O]] = None + override val phase: Phase = Phase(name, () => { + res = Some(fn()) + }) + override def phases: Seq[Phase] = Seq(phase) + override def reset(): Unit = + res = None + } + + case class InitialStepEitherT[E, O](name: String, fn: () => EitherT[E, Future, O]) extends Step[O, E] { + var res: Option[Either[E, O]] = None + override val phase: Phase = Phase(name, () => { + res = Some(Await.result(fn().toEither, Duration(timeoutSec, TimeUnit.SECONDS))) + }) + override def phases: Seq[Phase] = Seq(phase) + override def reset(): Unit = + res = None + } + + case class NextStep[I, E, O](name: String, prevStep: Step[I, E], fn: I => Either[E, O]) extends Step[O, E] { + var res: Option[Either[E, O]] = None + override val phase: Phase = Phase(name, () => { + assert(prevStep.res.isDefined) + res = prevStep.res match { + case Some(Right(output)) => Some(fn(output)) + case Some(Left(errs)) => Some(Left(errs)) // propagate errors + } + }) + override def phases: Seq[Phase] = prevStep.phases :+ phase + override def reset(): Unit = + prevStep.reset() res = None - } + } - case class NextStep[I, O, E](name: String, prevStep: Step[I, E], fn: I => Either[E, O]) extends Step[O, E] { - var res: Option[Either[E, O]] = None - override val phase: Phase = Phase(name, () => { - assert(prevStep.res.isDefined) - res = prevStep.res match { - case Some(Right(output)) => Some(fn(output)) - case Some(Left(errs)) => Some(Left(errs)) // propagate errors - } - }) - override def phases: Seq[Phase] = prevStep.phases :+ phase - override def reset(): Unit = - prevStep.reset() - res = None - } + case class NextStepEitherT[I, E, O](name: String, prevStep: Step[I, E], fn: I => EitherT[E, Future, O]) extends Step[O, E] { + var res: Option[Either[E, O]] = None + override val phase: Phase = Phase(name, () => { + assert(prevStep.res.isDefined) + res = prevStep.res match { + case Some(Right(output)) => Some(Await.result(fn(output).toEither, Duration(timeoutSec, TimeUnit.SECONDS))) + case Some(Left(errs)) => Some(Left(errs)) // propagate errors + } + }) + override def phases: Seq[Phase] = prevStep.phases :+ phase + override def reset(): Unit = + prevStep.reset() + res = None + } - case class GobraTestError(error: VerifierError) extends vpr.AbstractError { - /** The position where the error occured. */ - override def pos: Position = error.position.getOrElse(NoPosition) + case class GobraTestError(error: VerifierError) extends vpr.AbstractError { + /** The position where the error occured. */ + override def pos: Position = error.position.getOrElse(NoPosition) - /** A short and unique identifier for this error. */ - override def fullId: String = error.id + /** A short and unique identifier for this error. */ + override def fullId: String = error.id - /** A readable message describing the error. */ - override def readableMessage: String = error.formattedMessage + /** A readable message describing the error. */ + override def readableMessage: String = error.formattedMessage + } } } diff --git a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala index 6537f6ec3..f6303683b 100644 --- a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala +++ b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala @@ -7,8 +7,9 @@ package viper.gobra import java.nio.file.Path -import java.util.concurrent.TimeUnit import org.scalatest.DoNotDiscover +import scalaz.EitherT +import scalaz.Scalaz.futureInstance import viper.gobra.ast.internal.Program import viper.gobra.ast.internal.transform.OverflowChecksTransform import viper.gobra.backend.BackendVerifier @@ -19,8 +20,7 @@ import viper.gobra.frontend.{Desugar, Parser} import viper.gobra.reporting.{AppliedInternalTransformsMessage, BackTranslator, VerifierError, VerifierResult} import viper.gobra.translator.Translator -import scala.concurrent.Await -import scala.concurrent.duration.Duration +import scala.concurrent.Future /** * Tool for benchmarking Gobra's performance split into its individual steps (wrapped as a ScalaTest). @@ -100,7 +100,7 @@ class DetailedBenchmarkTests extends BenchmarkTests { config = gobra.getAndMergeInFileConfig(c, pkgInfo).toOption } - private val parsing = InitialStep[Vector[VerifierError], Map[AbstractPackage, ParseResult]]("parsing", () => { + private val parsing = InitialStepEitherT("parsing", () => { assert(config.isDefined) val c = config.get assert(c.packageInfoInputMap.size == 1) @@ -108,8 +108,7 @@ class DetailedBenchmarkTests extends BenchmarkTests { Parser.parse(c, pkgInfo)(executor) }) - private val typeChecking: NextStep[Map[AbstractPackage, ParseResult], TypeInfo, Vector[VerifierError]] = - NextStep("type-checking", parsing, (parseResults: Map[AbstractPackage, ParseResult]) => { + private val typeChecking = NextStepEitherT("type-checking", parsing, (parseResults: Map[AbstractPackage, ParseResult]) => { assert(config.isDefined) val c = config.get assert(c.packageInfoInputMap.size == 1) @@ -117,7 +116,7 @@ class DetailedBenchmarkTests extends BenchmarkTests { Info.check(c, RegularPackage(pkgInfo.id), parseResults)(executor) }) - private val desugaring: NextStep[TypeInfo, Program, Vector[VerifierError]] = + private val desugaring: NextStep[TypeInfo, Vector[VerifierError], Program] = NextStep("desugaring", typeChecking, { case (typeInfo: TypeInfo) => assert(config.isDefined) val c = config.get @@ -146,14 +145,14 @@ class DetailedBenchmarkTests extends BenchmarkTests { Right(Translator.translate(program, pkgInfo)(c)) }) - private val verifying = NextStep("Viper verification", encoding, (viperTask: BackendVerifier.Task) => { + private val verifying = NextStepEitherT("Viper verification", encoding, (viperTask: BackendVerifier.Task) => { assert(config.isDefined) val c = config.get assert(c.packageInfoInputMap.size == 1) val pkgInfo = c.packageInfoInputMap.keys.head - val resultFuture = BackendVerifier.verify(viperTask, pkgInfo)(c)(executor) - .map(BackTranslator.backTranslate(_)(c))(executor) - Right(Await.result(resultFuture, Duration(timeoutSec, TimeUnit.SECONDS))) + val resultFuture: Future[Either[Vector[VerifierError], VerifierResult]] = BackendVerifier.verify(viperTask, pkgInfo)(c) + .map(res => Right(BackTranslator.backTranslate(res)(c))) + EitherT.fromEither(resultFuture) }) private val lastStep = verifying diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index 713679558..b3ad7b95a 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -13,7 +13,6 @@ import org.scalatest.{Args, BeforeAndAfterAll, Status} import scalaz.Scalaz.futureInstance import viper.gobra.frontend.PackageResolver.RegularPackage import viper.gobra.frontend.Source.FromFileSource -import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel} import viper.gobra.frontend.info.Info import viper.gobra.frontend.{Config, PackageResolver, Parser, Source} import viper.gobra.reporting.VerifierResult.{Failure, Success} @@ -66,9 +65,9 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { val config = getConfig(source) val pkgInfo = config.packageInfoInputMap.keys.head val fut = for { - parseResult <- Parser.parseFut(config, pkgInfo) + parseResult <- Parser.parse(config, pkgInfo) pkg = RegularPackage(pkgInfo.id) - typeCheckResult <- Info.checkFut(config, pkg, parseResult) + typeCheckResult <- Info.check(config, pkg, parseResult) } yield typeCheckResult fut.toEither }) From 50f379c1b4d8b085f42165ad8a2b9ffefab8a3a2 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Fri, 30 Jun 2023 16:47:10 +0200 Subject: [PATCH 26/54] fixes unit tests by making type-check caching specific to the config's choice of 32 or 64bit ints --- src/main/scala/viper/gobra/frontend/info/Info.scala | 3 ++- src/test/scala/viper/gobra/GobraTests.scala | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 687730513..90956baf1 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -217,7 +217,7 @@ object Info extends LazyLogging { private val typeInfoCache: ConcurrentMap[TypeInfoCacheKey, TypeInfoImpl] = new ConcurrentHashMap() private def getCacheKey(pkg: PPackage, dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]], isMainContext: Boolean, config: Config): TypeInfoCacheKey = { - // the cache key only depends on config's `typeBounds` and `enableLazyImport` + // the cache key only depends on config's `typeBounds`, `int32bit`, and `enableLazyImport` val pkgKey = pkg.hashCode().toString // the computed key must be deterministic! val dependentTypeInfoKey = dependentTypeInfo @@ -227,6 +227,7 @@ object Info extends LazyLogging { .mkString("") val isMainContextKey = if (isMainContext) "1" else "0" val configKey = config.typeBounds.hashCode().toString ++ + (if (config.int32bit) "1" else "0") ++ (if (config.enableLazyImports) "1" else "0") val key = pkgKey ++ diff --git a/src/test/scala/viper/gobra/GobraTests.scala b/src/test/scala/viper/gobra/GobraTests.scala index b3ad7b95a..057d0fdb8 100644 --- a/src/test/scala/viper/gobra/GobraTests.scala +++ b/src/test/scala/viper/gobra/GobraTests.scala @@ -55,7 +55,7 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { packageInfoInputMap = Map(Source.getPackageInfo(source, Path.of("")) -> Vector(source)), checkConsistency = true, cacheParserAndTypeChecker = cacheParserAndTypeChecker, - z3Exe = z3Exe + z3Exe = z3Exe, ) override def runTests(testName: Option[String], args: Args): Status = { @@ -92,7 +92,7 @@ class GobraTests extends AbstractGobraTests with BeforeAndAfterAll { val source = FromFileSource(input.file) val config = getConfig(source) val pkgInfo = config.packageInfoInputMap.keys.head - val (result, elapsedMilis) = time(() => Await.result(gobraInstance.verify(pkgInfo, getConfig(source))(executor), Duration.Inf)) + val (result, elapsedMilis) = time(() => Await.result(gobraInstance.verify(pkgInfo, config)(executor), Duration.Inf)) info(s"Time required: $elapsedMilis ms") From a18c45081ab98a164fa63d984d4580ff175cad8b Mon Sep 17 00:00:00 2001 From: ArquintL Date: Sat, 1 Jul 2023 06:00:52 +0000 Subject: [PATCH 27/54] Updates submodules --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index ae6a1c153..a474657fa 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit ae6a1c153152bdae0005850190b24f0212113474 +Subproject commit a474657fa402c6c88da590525be790d3e16aadd8 From bb3610b9bcc0a403ad8bd1889ab7d26c3fbcfac7 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Mon, 3 Jul 2023 09:02:29 +0200 Subject: [PATCH 28/54] fixes a typo --- src/main/scala/viper/gobra/frontend/Desugar.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index d62ab7029..ee642cc98 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -36,7 +36,7 @@ object Desugar extends LazyLogging { val pkg = info.tree.root val importsCollector = new PackageInitSpecCollector - val importeDesugaringDurationMs = new AtomicLong(0) + val importedDesugaringDurationMs = new AtomicLong(0) val importedProgramsFuts = info.getTransitiveTypeInfos(includeThis = false).toSeq.map { tI => Future { val importedDesugaringStartMs = System.currentTimeMillis() val typeInfo = tI.getTypeInfo @@ -45,7 +45,7 @@ object Desugar extends LazyLogging { // registers a package to generate proof obligations for its init code d.registerPackage(importedPackage, importsCollector)(config) val res = (d, d.packageD(importedPackage)) - importeDesugaringDurationMs.addAndGet(System.currentTimeMillis() - importedDesugaringStartMs) + importedDesugaringDurationMs.addAndGet(System.currentTimeMillis() - importedDesugaringStartMs) res }} @@ -69,7 +69,7 @@ object Desugar extends LazyLogging { val (mainDesugarer, mainProgram) = futResults.head val importedPrograms = futResults.tail logger.trace { - val importedDurationS = f"${importeDesugaringDurationMs.get() / 1000f}%.1f" + val importedDurationS = f"${importedDesugaringDurationMs.get() / 1000f}%.1f" s"desugaring imported packages done, took ${importedDurationS}s" } From 08bfba3cbd3bc4e37aaca49fe2ef8f63d156962b Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Mon, 3 Jul 2023 09:48:45 +0200 Subject: [PATCH 29/54] adapts 'builtin' and 'stubs' packages to latest changes in Viper --- src/main/resources/stubs/strconv/atoi.gobra | 1 + src/main/resources/stubs/strings/strings.gobra | 1 + 2 files changed, 2 insertions(+) diff --git a/src/main/resources/stubs/strconv/atoi.gobra b/src/main/resources/stubs/strconv/atoi.gobra index 3b94ea29d..454e456e0 100644 --- a/src/main/resources/stubs/strconv/atoi.gobra +++ b/src/main/resources/stubs/strconv/atoi.gobra @@ -44,6 +44,7 @@ pure func (e *NumError) Unwrap() error { return e.Err } ghost requires exp >= 0 ensures res == (exp == 0 ? 1 : (base * Exp(base, exp - 1))) +decreases exp pure func Exp(base int, exp int) (res int) { return exp == 0 ? 1 : (base * Exp(base, exp - 1)) } diff --git a/src/main/resources/stubs/strings/strings.gobra b/src/main/resources/stubs/strings/strings.gobra index 22dbf3819..0307bf577 100644 --- a/src/main/resources/stubs/strings/strings.gobra +++ b/src/main/resources/stubs/strings/strings.gobra @@ -202,6 +202,7 @@ func Map(mapping func(rune) rune, s string) string // the result of (len(s) * count) overflows. requires count >= 0 ensures res == (count == 0? "" : s + Repeat(s, count - 1)) +decreases count pure func Repeat(s string, count int) (res string) /*{ if count == 0 { return "" From 9772277565341634a700d78da22ad67aedd6557d Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Mon, 3 Jul 2023 12:03:33 +0200 Subject: [PATCH 30/54] improves reporting of consistency errors and errors resulting from applying Viper transformers --- src/main/scala/viper/gobra/Gobra.scala | 2 +- .../scala/viper/gobra/reporting/Message.scala | 8 +++++ .../viper/gobra/reporting/Reporter.scala | 1 + .../viper/gobra/reporting/VerifierError.scala | 6 +++- .../viper/gobra/translator/Translator.scala | 35 ++++++++++++++----- 5 files changed, 42 insertions(+), 10 deletions(-) diff --git a/src/main/scala/viper/gobra/Gobra.scala b/src/main/scala/viper/gobra/Gobra.scala index cb9e18620..3012d1d16 100644 --- a/src/main/scala/viper/gobra/Gobra.scala +++ b/src/main/scala/viper/gobra/Gobra.scala @@ -293,7 +293,7 @@ class Gobra extends GoVerifier with GoIdeVerifier { private def performViperEncoding(program: Program, config: Config, pkgInfo: PackageInfo): Either[Vector[VerifierError], BackendVerifier.Task] = { if (config.shouldViperEncode) { - Right(Translator.translate(program, pkgInfo)(config)) + Translator.translate(program, pkgInfo)(config) } else { Left(Vector()) } diff --git a/src/main/scala/viper/gobra/reporting/Message.scala b/src/main/scala/viper/gobra/reporting/Message.scala index 61530d91b..418e8e4db 100644 --- a/src/main/scala/viper/gobra/reporting/Message.scala +++ b/src/main/scala/viper/gobra/reporting/Message.scala @@ -173,6 +173,14 @@ case class GeneratedViperMessage(taskName: String, inputs: Vector[String], vprAs lazy val vprAstFormatted: String = silver.ast.pretty.FastPrettyPrinter.pretty(vprAst()) } +case class TransformerFailureMessage(inputs: Vector[String], result: Vector[VerifierError]) extends GobraMessage { + override val name: String = s"transformer_failure_message" + + override def toString: String = s"transformer_failure_message(" + + s"files=$inputs, " + + s"failures=${result.map(_.toString).mkString(",")})" +} + case class ChoppedViperMessage(inputs: Vector[String], idx: Int, vprAst: () => vpr.Program, backtrack: () => BackTranslator.BackTrackInfo) extends GobraMessage { override val name: String = s"chopped_viper_message" diff --git a/src/main/scala/viper/gobra/reporting/Reporter.scala b/src/main/scala/viper/gobra/reporting/Reporter.scala index f4cffc761..0c6d7cb66 100644 --- a/src/main/scala/viper/gobra/reporting/Reporter.scala +++ b/src/main/scala/viper/gobra/reporting/Reporter.scala @@ -66,6 +66,7 @@ case class FileWriterReporter(name: String = "filewriter_reporter", } case m:ParserErrorMessage if streamErrs => m.result.foreach(err => logger.error(s"Error at: ${err.formattedMessage}")) case m:TypeCheckFailureMessage if streamErrs => m.result.foreach(err => logger.error(s"Error at: ${err.formattedMessage}")) + case m:TransformerFailureMessage if streamErrs => m.result.foreach(err => logger.error(s"Error at: ${err.formattedMessage}")) case _ => // ignore } diff --git a/src/main/scala/viper/gobra/reporting/VerifierError.scala b/src/main/scala/viper/gobra/reporting/VerifierError.scala index 858c2f2ae..a2877f4cb 100644 --- a/src/main/scala/viper/gobra/reporting/VerifierError.scala +++ b/src/main/scala/viper/gobra/reporting/VerifierError.scala @@ -56,11 +56,15 @@ case class DiamondError(message: String) extends VerifierError { val id = "diamond_error" } -case class TimeoutError(message: String) extends VerifierError { +case class TimeoutError(message: String) extends VerifierError { val position: Option[SourcePosition] = None val id = "timeout_error" } +case class ConsistencyError(message: String, position: Option[SourcePosition]) extends VerifierError { + val id = "consistency_error" +} + sealed trait VerificationError extends VerifierError { def info: Source.Verifier.Info diff --git a/src/main/scala/viper/gobra/translator/Translator.scala b/src/main/scala/viper/gobra/translator/Translator.scala index 537b7d94f..63334f790 100644 --- a/src/main/scala/viper/gobra/translator/Translator.scala +++ b/src/main/scala/viper/gobra/translator/Translator.scala @@ -10,17 +10,28 @@ package viper.gobra.translator import viper.gobra.ast.internal.Program import viper.gobra.backend.BackendVerifier import viper.gobra.frontend.{Config, PackageInfo} -import viper.gobra.reporting.GeneratedViperMessage +import viper.gobra.reporting.{ConsistencyError, GeneratedViperMessage, TransformerFailureMessage, VerifierError} import viper.gobra.translator.context.DfltTranslatorConfig import viper.gobra.translator.encodings.programs.ProgramsImpl import viper.gobra.translator.transformers.{AssumeTransformer, TerminationTransformer, ViperTransformer} import viper.gobra.util.Violation +import viper.silver.ast.{AbstractSourcePosition, SourcePosition} import viper.silver.ast.pretty.FastPrettyPrinter +import viper.silver.verifier.AbstractError import viper.silver.{ast => vpr} object Translator { - def translate(program: Program, pkgInfo: PackageInfo)(config: Config): BackendVerifier.Task = { + private def createConsistencyErrors(errs: Seq[AbstractError]): Vector[ConsistencyError] = + errs.map(err => { + val pos = err.pos match { + case sp: AbstractSourcePosition => Some(new SourcePosition(sp.file, sp.start, sp.end)) + case _ => None + } + ConsistencyError(err.readableMessage, pos) + }).toVector + + def translate(program: Program, pkgInfo: PackageInfo)(config: Config): Either[Vector[VerifierError], BackendVerifier.Task] = { val translationConfig = new DfltTranslatorConfig() val programTranslator = new ProgramsImpl() val task = programTranslator.translate(program)(translationConfig) @@ -30,17 +41,25 @@ object Translator { new TerminationTransformer ) - val transformedTask = transformers.foldLeft(task) { - case (t, transformer) => transformer.transform(t) - .fold(errs => Violation.violation(s"Applying transformer ${transformer.getClass.getSimpleName} resulted in errors: ${errs.toString}"), identity) + val transformedTask = transformers.foldLeft[Either[Vector[VerifierError], BackendVerifier.Task]](Right(task)) { + case (Right(t), transformer) => transformer.transform(t).left.map(createConsistencyErrors) + case (errs, _) => errs } if (config.checkConsistency) { - val errors = transformedTask.program.checkTransitively - if (errors.nonEmpty) Violation.violation(errors.toString) + transformedTask + .flatMap(task => { + val consistencyErrs = task.program.checkTransitively + if (consistencyErrs.isEmpty) Right(()) + else Left(createConsistencyErrors(consistencyErrs)) + }) + .left.map(errs => Violation.violation(errs.toString)) } - config.reporter report GeneratedViperMessage(config.taskName, config.packageInfoInputMap(pkgInfo).map(_.name), () => sortAst(transformedTask.program), () => transformedTask.backtrack) + val inputs = config.packageInfoInputMap(pkgInfo).map(_.name) + transformedTask.fold( + errs => config.reporter report TransformerFailureMessage(inputs, errs), + task => config.reporter report GeneratedViperMessage(config.taskName, inputs, () => sortAst(task.program), () => task.backtrack)) transformedTask } From d64f56a474df6f446502eb54d2fa291a9f63c1fd Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Mon, 3 Jul 2023 12:05:30 +0200 Subject: [PATCH 31/54] adapts regression tests to latest Viper changes --- .../regressions/features/closures/closures-calldesc2.gobra | 1 + .../regressions/features/closures/closures-calldesc4-map.gobra | 1 + 2 files changed, 2 insertions(+) diff --git a/src/test/resources/regressions/features/closures/closures-calldesc2.gobra b/src/test/resources/regressions/features/closures/closures-calldesc2.gobra index 6f39c6b9f..bc8ffc64c 100644 --- a/src/test/resources/regressions/features/closures/closures-calldesc2.gobra +++ b/src/test/resources/regressions/features/closures/closures-calldesc2.gobra @@ -33,6 +33,7 @@ func hof(ghost cs Calls, f func(ghost seq[int], int)int)(res int) { ghost ensures forall k int :: k > 0 && len(s) == k ==> res == s[k-1] + seqSum(s[:(k-1)]) +decreases len(s) pure func seqSum(s seq[int]) (res int) { return len(s) == 0 ? 0 : (s[len(s)-1] + seqSum(s[:(len(s)-1)])) } diff --git a/src/test/resources/regressions/features/closures/closures-calldesc4-map.gobra b/src/test/resources/regressions/features/closures/closures-calldesc4-map.gobra index ebfe9f7f8..53c6d6e88 100644 --- a/src/test/resources/regressions/features/closures/closures-calldesc4-map.gobra +++ b/src/test/resources/regressions/features/closures/closures-calldesc4-map.gobra @@ -112,6 +112,7 @@ func test2() { ghost ensures forall k int :: k > 0 && len(s) == k ==> res == s[k-1] + seqSum(s[:(k-1)]) +decreases len(s) pure func seqSum(s seq[int]) (res int) { return len(s) == 0 ? 0 : (s[len(s)-1] + seqSum(s[:(len(s)-1)])) } From fc634a43a0a5be2d3633624c74cd81f1aacaa256 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Mon, 3 Jul 2023 12:19:32 +0200 Subject: [PATCH 32/54] fixes a compiler error caused by recent error reporting improvements --- src/test/scala/viper/gobra/DetailedBenchmarkTests.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala index 1e2ea620f..09c9cdb6b 100644 --- a/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala +++ b/src/test/scala/viper/gobra/DetailedBenchmarkTests.scala @@ -142,7 +142,7 @@ class DetailedBenchmarkTests extends BenchmarkTests { val c = config.get assert(c.packageInfoInputMap.size == 1) val pkgInfo = c.packageInfoInputMap.keys.head - Right(Translator.translate(program, pkgInfo)(c)) + Translator.translate(program, pkgInfo)(c) }) private val verifying = NextStep("Viper verification", encoding, (viperTask: BackendVerifier.Task) => { From 0fdf73a7bf5566af591e159fb343dc183fbd88cd Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 4 Jul 2023 08:57:32 +0200 Subject: [PATCH 33/54] adds failing test case --- .../resources/regressions/issues/000659.gobra | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 src/test/resources/regressions/issues/000659.gobra diff --git a/src/test/resources/regressions/issues/000659.gobra b/src/test/resources/regressions/issues/000659.gobra new file mode 100644 index 000000000..7c6ecb2d9 --- /dev/null +++ b/src/test/resources/regressions/issues/000659.gobra @@ -0,0 +1,33 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package issue659 + +type Node struct { + ok bool +} + +pred (s *Set)mem(){ + acc(s) && + acc(s.nodes) && + forall i int:: i in domain(s.nodes) ==> acc(s.nodes[i]) +} + +type Set struct { + nodes map[int]*Node +} + +requires s.mem() +requires acc(n) +requires !(k in unfolding s.mem() in domain(s.nodes)) +func (s *Set) add2(n *Node, k int){ + unfold s.mem() + _,ok := s.nodes[0]; + if ok { + s.nodes[k] = n + fold s.mem() + //:: ExpectedOutput(assert_error:assertion_error) + assert false // should fail + return + } +} From 19296629fe75b188dbf081513da9461ef5de92c4 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 4 Jul 2023 09:30:59 +0200 Subject: [PATCH 34/54] updates ViperServer to latest commit --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index a474657fa..8ac486e32 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit a474657fa402c6c88da590525be790d3e16aadd8 +Subproject commit 8ac486e32dc2b45d82c345dfbf9602468b3b6682 From 1894cefe7a14db639b42d93b7b49eb2d7ce12962 Mon Sep 17 00:00:00 2001 From: viper-admin <59963956+viper-admin@users.noreply.github.com> Date: Wed, 12 Jul 2023 06:56:11 +0200 Subject: [PATCH 35/54] Updates submodules (#661) Co-authored-by: jcp19 --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index 8ac486e32..7b13e90a3 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit 8ac486e32dc2b45d82c345dfbf9602468b3b6682 +Subproject commit 7b13e90a37cc2e881f986fc2adbb0ff20c0f34e8 From 64389b2670a8ecff307a4f5fa878830eb091fe21 Mon Sep 17 00:00:00 2001 From: ArquintL Date: Thu, 13 Jul 2023 07:54:42 +0000 Subject: [PATCH 36/54] Updates submodules --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index 7b13e90a3..53765141c 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit 7b13e90a37cc2e881f986fc2adbb0ff20c0f34e8 +Subproject commit 53765141ceb3ea8e0657c0e1ed3065efd937ae71 From 940a4b5659aacd19a99132bdecd63b4d3fe5d6fc Mon Sep 17 00:00:00 2001 From: ArquintL Date: Mon, 17 Jul 2023 17:36:04 +0000 Subject: [PATCH 37/54] Updates submodules --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index 53765141c..e36d0d393 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit 53765141ceb3ea8e0657c0e1ed3065efd937ae71 +Subproject commit e36d0d39315f75dfdd53ab879f3e4fe755e6cd58 From 4fc3cc930923b684fb29c6aa12494049d91e4924 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 18 Jul 2023 09:06:13 +0200 Subject: [PATCH 38/54] Update src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala Co-authored-by: Felix Wolf <60103963+Felalolf@users.noreply.github.com> --- .../info/implementation/resolution/MemberResolution.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala index 614d2e055..f38148c79 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala @@ -405,7 +405,7 @@ trait MemberResolution { this: TypeInfoImpl => def getTypeChecker(importTarget: AbstractImport, errNode: PNode): Either[Messages, ExternalTypeInfo] = { def createImportError(errs: Vector[VerifierError]): Messages = { // create an error message located at the import statement to indicate errors in the imported package - // we distinguish between regular errors and packages whose source files could not be found (not that cyclic + // we distinguish between regular errors and packages whose source files could not be found (note that cyclic // errors are handled before type-checking) val notFoundErr = errs.collectFirst { case e: NotFoundError => e } // alternativeErr is a function to compute the message only when needed From 716eeeb21a2c76dcd5e9851879598f9f336ff381 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 18 Jul 2023 09:23:21 +0200 Subject: [PATCH 39/54] implements CR suggestions by Felix --- .../scala/viper/gobra/frontend/Config.scala | 4 +-- .../scala/viper/gobra/frontend/Desugar.scala | 1 + .../scala/viper/gobra/frontend/Parser.scala | 18 ++++++++---- .../viper/gobra/frontend/info/Info.scala | 28 +++++++++++-------- .../viper/gobra/frontend/info/TypeInfo.scala | 4 --- .../{frontend => util}/TaskManager.scala | 15 ++++------ .../viper/gobra/parsing/ParserUnitTests.scala | 7 +++++ 7 files changed, 45 insertions(+), 32 deletions(-) rename src/main/scala/viper/gobra/{frontend => util}/TaskManager.scala (90%) diff --git a/src/main/scala/viper/gobra/frontend/Config.scala b/src/main/scala/viper/gobra/frontend/Config.scala index 5dae8c252..2c26a944e 100644 --- a/src/main/scala/viper/gobra/frontend/Config.scala +++ b/src/main/scala/viper/gobra/frontend/Config.scala @@ -16,9 +16,9 @@ import viper.gobra.backend.{ViperBackend, ViperBackends} import viper.gobra.GoVerifier import viper.gobra.frontend.PackageResolver.FileResource import viper.gobra.frontend.Source.getPackageInfo -import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential, TaskManagerMode} +import viper.gobra.util.TaskManagerMode.{Lazy, Parallel, Sequential, TaskManagerMode} import viper.gobra.reporting.{FileWriterReporter, GobraReporter, StdIOReporter} -import viper.gobra.util.{TypeBounds, Violation} +import viper.gobra.util.{TaskManagerMode, TypeBounds, Violation} import viper.silver.ast.SourcePosition import scala.concurrent.duration.Duration diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index ee642cc98..9a0704d51 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -30,6 +30,7 @@ import scala.concurrent.duration.Duration import scala.concurrent.{Await, Future} import scala.reflect.ClassTag +// `LazyLogging` provides us with access to `logger` to emit log messages object Desugar extends LazyLogging { def desugar(config: Config, info: viper.gobra.frontend.info.TypeInfo)(implicit executionContext: GobraExecutionContext): in.Program = { diff --git a/src/main/scala/viper/gobra/frontend/Parser.scala b/src/main/scala/viper/gobra/frontend/Parser.scala index 9ef811c57..5900fa9e6 100644 --- a/src/main/scala/viper/gobra/frontend/Parser.scala +++ b/src/main/scala/viper/gobra/frontend/Parser.scala @@ -20,7 +20,7 @@ import scalaz.EitherT import scalaz.Scalaz.futureInstance import viper.gobra.frontend.GobraParser.{ExprOnlyContext, ImportDeclContext, PreambleContext, SourceFileContext, SpecMemberContext, StmtOnlyContext, TypeOnlyContext} import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, RegularImport, RegularPackage} -import viper.gobra.util.{GobraExecutionContext, Violation} +import viper.gobra.util.{GobraExecutionContext, Job, TaskManager, Violation} import viper.silver.ast.SourcePosition import scala.collection.mutable.ListBuffer @@ -29,6 +29,7 @@ import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} import scala.concurrent.Future +// `LazyLogging` provides us with access to `logger` to emit log messages object Parser extends LazyLogging { type ParseSuccessResult = (Vector[Source], PPackage) @@ -85,7 +86,14 @@ object Parser extends LazyLogging { } } - trait ParseJob extends Job[PreprocessedSources, ParseResult] with ImportResolver { + /** + * Job that preprocesses the specified sources, parses their preambles, and creates parse jobs for all imported + * packages as part of the sequential pre-computations. + * This job then fully parses and post-processes the package (identified via `pkgInfo` and `pkgSources`) in the + * `compute` step and eventually produces this package's ParseResult. Additionally, the preprocessed sources are + * provided alongside. + */ + private trait ParseJob extends Job[PreprocessedSources, ParseResult] with ImportResolver { def pkgInfo: PackageInfo def pkgSources: Vector[Source] def specOnly: Boolean @@ -134,19 +142,19 @@ object Parser extends LazyLogging { } /** this job is used to parse the package that should be verified */ - case class ParseInfoJob(override val pkgInfo: PackageInfo) extends ParseJob { + private case class ParseInfoJob(override val pkgInfo: PackageInfo) extends ParseJob { lazy val pkgSources: Vector[Source] = config.packageInfoInputMap(pkgInfo) lazy val specOnly: Boolean = false } /** this job is used to parse all packages that are imported */ - case class ParseSourcesJob(override val pkgSources: Vector[Source], pkg: AbstractPackage) extends ParseJob { + private case class ParseSourcesJob(override val pkgSources: Vector[Source], pkg: AbstractPackage) extends ParseJob { require(pkgSources.nonEmpty) lazy val pkgInfo: PackageInfo = Source.getPackageInfo(pkgSources.head, config.projectRoot) lazy val specOnly: Boolean = true } - case class ParseFailureJob(errs: Vector[ParserError]) extends Job[PreprocessedSources, ParseResult] { + private case class ParseFailureJob(errs: Vector[ParserError]) extends Job[PreprocessedSources, ParseResult] { override protected def sequentialPrecompute(): PreprocessedSources = Vector.empty override protected def compute(precomputationResult: PreprocessedSources): ParseResult = diff --git a/src/main/scala/viper/gobra/frontend/info/Info.scala b/src/main/scala/viper/gobra/frontend/info/Info.scala index 90956baf1..dcf9f341e 100644 --- a/src/main/scala/viper/gobra/frontend/info/Info.scala +++ b/src/main/scala/viper/gobra/frontend/info/Info.scala @@ -9,24 +9,25 @@ package viper.gobra.frontend.info import com.typesafe.scalalogging.LazyLogging import org.bitbucket.inkytonik.kiama.relation.Tree import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, message} -import org.bitbucket.inkytonik.kiama.util.{Position, Source} +import org.bitbucket.inkytonik.kiama.util.Source import scalaz.EitherT import scalaz.Scalaz.futureInstance import viper.gobra.ast.frontend.{PImport, PNode, PPackage} -import viper.gobra.frontend.{Config, Job, TaskManager} +import viper.gobra.frontend.Config import viper.gobra.frontend.PackageResolver.{AbstractImport, AbstractPackage, BuiltInImport, BuiltInPackage, RegularImport} import viper.gobra.frontend.Parser.{ParseResult, ParseSuccessResult} -import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential} +import viper.gobra.util.TaskManagerMode.{Lazy, Parallel, Sequential} import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.ghost.separation.{GhostLessPrinter, GoifyingPrinter} import viper.gobra.reporting.{CyclicImportError, ParserError, TypeCheckDebugMessage, TypeCheckFailureMessage, TypeCheckSuccessMessage, TypeError, VerifierError} -import viper.gobra.util.{GobraExecutionContext, Violation} +import viper.gobra.util.{GobraExecutionContext, Job, TaskManager, Violation} import java.security.MessageDigest import java.util.concurrent.atomic.AtomicLong import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} import scala.concurrent.Future +// `LazyLogging` provides us with access to `logger` to emit log messages object Info extends LazyLogging { type GoTree = Tree[PNode, PPackage] @@ -42,13 +43,8 @@ object Info extends LazyLogging { } } - /** - * ImportCycle describes a cyclic import. `importClosingCycle` is the AST node that closes the cycle and - * `cyclicPackages` stores the packages involved in the cycle. - */ - case class ImportCycle(importNodeCausingCycle: PImport, importNodeStart: Option[Position], cyclicPackages: Vector[AbstractImport]) - - class CycleChecker(val config: Config /*, val parseResults: Map[AbstractPackage, ParseSuccessResult]*/, val parseResults: Map[AbstractPackage, ParseResult]) { + /** checks whether cyclic import patterns exist in the results produced by the parser. */ + class CycleChecker(val config: Config, val parseResults: Map[AbstractPackage, ParseResult]) { /** keeps track of the package dependencies that are currently resolved. This information is used to detect cycles */ private var parserPendingPackages: Vector[AbstractImport] = Vector() @@ -127,7 +123,15 @@ object Info extends LazyLogging { var tyeCheckDurationMs = new AtomicLong(0L) - case class TypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[(Vector[Source], PPackage, Vector[AbstractImport]), () => TypeCheckResult] { + /** + * This job creates type-check jobs for all packages imported by the specified package as part of the sequential + * pre-computations. + * Then, the parse result is retrieved for the specified package and this result is type-checked. To enable lazy + * processing and type-checking, this job provides the type-check result as a closure. While the result is eagerly + * computed in `Sequential` and `Parallel` modes, the result is lazily computed on the first closure call in `Lazy` + * mode. + */ + private case class TypeCheckJob(abstractPackage: AbstractPackage, isMainContext: Boolean = false) extends Job[(Vector[Source], PPackage, Vector[AbstractImport]), () => TypeCheckResult] { override def toString: String = s"TypeCheckJob for $abstractPackage" protected override def sequentialPrecompute(): (Vector[Source], PPackage, Vector[AbstractImport]) = { diff --git a/src/main/scala/viper/gobra/frontend/info/TypeInfo.scala b/src/main/scala/viper/gobra/frontend/info/TypeInfo.scala index 2482363c2..09c479f9f 100644 --- a/src/main/scala/viper/gobra/frontend/info/TypeInfo.scala +++ b/src/main/scala/viper/gobra/frontend/info/TypeInfo.scala @@ -8,17 +8,13 @@ package viper.gobra.frontend.info import org.bitbucket.inkytonik.kiama.relation.Tree import viper.gobra.ast.frontend._ -import viper.gobra.frontend.PackageResolver.AbstractImport import viper.gobra.frontend.info.base.SymbolTable.{MethodImpl, MethodSpec, Regular, TypeMember} import viper.gobra.frontend.info.base.Type.{InterfaceT, Type} import viper.gobra.frontend.info.implementation.resolution.{AdvancedMemberSet, MemberPath} -import viper.gobra.reporting.VerifierError import viper.gobra.theory.Addressability trait TypeInfo extends ExternalTypeInfo { - def dependentTypeInfo: Map[AbstractImport, () => Either[Vector[VerifierError], ExternalTypeInfo]] - def typOfExprOrType(expr: PExpressionOrType): Type def addressability(expr: PExpression): Addressability def addressableVar(id: PIdnNode): Addressability diff --git a/src/main/scala/viper/gobra/frontend/TaskManager.scala b/src/main/scala/viper/gobra/util/TaskManager.scala similarity index 90% rename from src/main/scala/viper/gobra/frontend/TaskManager.scala rename to src/main/scala/viper/gobra/util/TaskManager.scala index 991949ce4..da641b65c 100644 --- a/src/main/scala/viper/gobra/frontend/TaskManager.scala +++ b/src/main/scala/viper/gobra/util/TaskManager.scala @@ -4,16 +4,15 @@ // // Copyright (c) 2011-2023 ETH Zurich. -package viper.gobra.frontend +package viper.gobra.util -import viper.gobra.frontend.TaskManagerMode.{Lazy, Parallel, Sequential, TaskManagerMode} -import viper.gobra.util.{GobraExecutionContext, Violation} +import viper.gobra.util.TaskManagerMode.{Lazy, Parallel, Sequential, TaskManagerMode} import java.util.concurrent.{ConcurrentHashMap, ConcurrentMap} import scala.concurrent.duration.Duration import scala.concurrent.{Await, Future, Promise} -import scala.util.{Failure, Success} import scala.jdk.CollectionConverters._ +import scala.util.{Failure, Success} object TaskManagerMode extends Enumeration { type TaskManagerMode = Value @@ -58,11 +57,9 @@ class TaskManager[K, I, R](mode: TaskManagerMode)(implicit executor: GobraExecut private val jobs: ConcurrentMap[K, Job[I, R]] = new ConcurrentHashMap() def addIfAbsent(id: K, job: Job[I, R]): Unit = { - var isAbsent = false - jobs.computeIfAbsent(id, _ => { - isAbsent = true - job - }) + // `putIfAbsent` returns null if `id` does not yet exist in the map or is associated to a null value: + val oldValue = jobs.putIfAbsent(id, job) + val isAbsent = oldValue == null if (isAbsent) { job.triggerPrecomputation() mode match { diff --git a/src/test/scala/viper/gobra/parsing/ParserUnitTests.scala b/src/test/scala/viper/gobra/parsing/ParserUnitTests.scala index 6f0ea8526..a8a132b6e 100644 --- a/src/test/scala/viper/gobra/parsing/ParserUnitTests.scala +++ b/src/test/scala/viper/gobra/parsing/ParserUnitTests.scala @@ -2689,4 +2689,11 @@ class ParserUnitTests extends AnyFunSuite with Matchers with Inside { case PFunctionDecl(_, _, _, _, Some((_, PBlock(Vector(PContinue(Some(p))))))) if p.name == "l" => } } + + test("Parser: should be able to parse an empty for clause") { + frontend.parseStmtOrFail("for { x := 42 }") should matchPattern { + case PForStmt(None, PBoolLit(true), None, PLoopSpec(Vector(), None), PBlock(Vector(PShortVarDecl(Vector(value), Vector(PIdnUnk(varname)), Vector(false))))) + if varname == "x" && value == PIntLit(42) => + } + } } From 04a7a2acdf95bd7cd5629262cdb16a618ffdef72 Mon Sep 17 00:00:00 2001 From: Linard Arquint Date: Tue, 18 Jul 2023 15:07:32 +0200 Subject: [PATCH 40/54] adapts to avoid accidental printing of ASTs --- .../scala/viper/gobra/reporting/Message.scala | 21 +++++++------------ 1 file changed, 7 insertions(+), 14 deletions(-) diff --git a/src/main/scala/viper/gobra/reporting/Message.scala b/src/main/scala/viper/gobra/reporting/Message.scala index 418e8e4db..569b96cb9 100644 --- a/src/main/scala/viper/gobra/reporting/Message.scala +++ b/src/main/scala/viper/gobra/reporting/Message.scala @@ -92,16 +92,14 @@ case class PreprocessedInputMessage(input: String, preprocessedContent: () => St override val name: String = s"preprocessed_input_message" override def toString: String = s"preprocessed_input_message(" + - s"file=$input, " + - s"content=${preprocessedContent()})" + s"file=$input)" } case class ParsedInputMessage(input: String, ast: () => PProgram) extends GobraMessage { override val name: String = s"parsed_input_message" override def toString: String = s"parsed_input_message(" + - s"file=$input, " + - s"ast=${ast().formatted})" + s"file=$input)" } case class ParserErrorMessage(input: Path, result: Vector[ParserError]) extends GobraMessage { @@ -142,24 +140,21 @@ case class TypeCheckDebugMessage(inputs: Vector[String], ast: () => PPackage, de override val name: String = s"type_check_debug_message" override def toString: String = s"type_check_debug_message(" + - s"files=$inputs, " + - s"debugInfo=${debugTypeInfo()})" + s"files=$inputs)" } case class DesugaredMessage(inputs: Vector[String], internal: () => in.Program) extends GobraMessage { override val name: String = s"desugared_message" override def toString: String = s"desugared_message(" + - s"files=$inputs, " + - s"internal=${internal().formatted})" + s"files=$inputs)" } case class AppliedInternalTransformsMessage(inputs: Vector[String], internal: () => in.Program) extends GobraMessage { override val name: String = s"transform_message" override def toString: String = s"transform_message(" + - s"files=$inputs, " + - s"internal=${internal().formatted})" + s"files=$inputs)" } case class GeneratedViperMessage(taskName: String, inputs: Vector[String], vprAst: () => vpr.Program, backtrack: () => BackTranslator.BackTrackInfo) extends GobraMessage { @@ -167,8 +162,7 @@ case class GeneratedViperMessage(taskName: String, inputs: Vector[String], vprAs override def toString: String = s"generated_viper_message(" + s"taskName=$taskName" + - s"files=$inputs, " + - s"vprFormated=$vprAstFormatted)" + s"files=$inputs)" lazy val vprAstFormatted: String = silver.ast.pretty.FastPrettyPrinter.pretty(vprAst()) } @@ -185,8 +179,7 @@ case class ChoppedViperMessage(inputs: Vector[String], idx: Int, vprAst: () => v override val name: String = s"chopped_viper_message" override def toString: String = s"chopped_viper_message(" + - s"file=$inputs, " + - s"vprFormated=$vprAstFormatted)" + s"file=$inputs)" lazy val vprAstFormatted: String = silver.ast.pretty.FastPrettyPrinter.pretty(vprAst()) } From f21fe701c0a7d4600bf2c184ffc0d06e473148f2 Mon Sep 17 00:00:00 2001 From: viper-admin <59963956+viper-admin@users.noreply.github.com> Date: Wed, 2 Aug 2023 19:46:32 +0200 Subject: [PATCH 41/54] Updates submodules (#667) Co-authored-by: ArquintL --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index e36d0d393..397b43eeb 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit e36d0d39315f75dfdd53ab879f3e4fe755e6cd58 +Subproject commit 397b43eeb24f99c05811987f54da736dd8acaa66 From caca746d0ebe79fa8e7f141c9a8747f2871a995f Mon Sep 17 00:00:00 2001 From: Felix Wolf <60103963+Felalolf@users.noreply.github.com> Date: Thu, 17 Aug 2023 13:38:33 +0200 Subject: [PATCH 42/54] Fix #668 (#669) --- src/test/scala/viper/gobra/BenchmarkTests.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/scala/viper/gobra/BenchmarkTests.scala b/src/test/scala/viper/gobra/BenchmarkTests.scala index c10ecec0a..b54ea5301 100644 --- a/src/test/scala/viper/gobra/BenchmarkTests.scala +++ b/src/test/scala/viper/gobra/BenchmarkTests.scala @@ -68,7 +68,7 @@ trait BenchmarkTests extends StatisticalTestSuite { override def init(verifier: Verifier): Unit = () // ignore verifier argument as we reuse the Gobra / Parser / TypeChecker / etc. instances for all tests override def reset(files: Seq[Path]): Unit = - createConfig(Array("-i", files.toVector.mkString(" "))) + config = Some(createConfig(Array("-i", files.toVector.mkString(" ")))) private def createConfig(args: Array[String]): Config = { From d2acefbbdb9d8f7fcdf14455319d8c79b241f570 Mon Sep 17 00:00:00 2001 From: viper-admin <59963956+viper-admin@users.noreply.github.com> Date: Wed, 6 Sep 2023 02:30:17 +0200 Subject: [PATCH 43/54] Updates submodules (#673) Co-authored-by: ArquintL --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index 397b43eeb..3e2f02096 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit 397b43eeb24f99c05811987f54da736dd8acaa66 +Subproject commit 3e2f020964fa8d837c444ee54f933e2b577ea551 From 21bd69f423832468686ea0b484445046188f2ff4 Mon Sep 17 00:00:00 2001 From: Dionysios Spiliopoulos <32896454+Dspil@users.noreply.github.com> Date: Tue, 12 Sep 2023 11:52:32 +0200 Subject: [PATCH 44/54] Add flag to use Z3 via API (#666) * added z3ApiMode flag * Api -> API * changed space to = * catch ugly exception when z3 java api not in path * Joao's feedback --- .../scala/viper/gobra/backend/Silicon.scala | 28 +++++++++++-------- .../viper/gobra/backend/ViperBackends.scala | 4 +++ .../scala/viper/gobra/frontend/Config.scala | 22 +++++++++++++++ 3 files changed, 43 insertions(+), 11 deletions(-) diff --git a/src/main/scala/viper/gobra/backend/Silicon.scala b/src/main/scala/viper/gobra/backend/Silicon.scala index a8cb1c33a..5440be1c0 100644 --- a/src/main/scala/viper/gobra/backend/Silicon.scala +++ b/src/main/scala/viper/gobra/backend/Silicon.scala @@ -11,7 +11,6 @@ import viper.silicon import viper.silver.ast.Program import viper.silver.reporter._ import viper.silver.verifier.{Failure, Success, VerificationResult} - import scala.concurrent.Future class Silicon(commandLineArguments: Seq[String]) extends ViperVerifier { @@ -23,18 +22,25 @@ class Silicon(commandLineArguments: Seq[String]) extends ViperVerifier { val backend: silicon.Silicon = silicon.Silicon.fromPartialCommandLineArguments(commandLineArguments, reporter) val startTime = System.currentTimeMillis() - backend.start() - val result = backend.verify(program) - backend.stop() + try { + backend.start() + val result = backend.verify(program) + backend.stop() - result match { - case Success => - reporter report OverallSuccessMessage(backend.name, System.currentTimeMillis() - startTime) - case f@Failure(_) => - reporter report OverallFailureMessage(backend.name, System.currentTimeMillis() - startTime, f) - } + result match { + case Success => + reporter report OverallSuccessMessage(backend.name, System.currentTimeMillis() - startTime) + case f@Failure(_) => + reporter report OverallFailureMessage(backend.name, System.currentTimeMillis() - startTime, f) + } - result + result + } catch { + case _: java.lang.UnsatisfiedLinkError => System.err.println("Couldn't find Z3 java API. No libz3java in java.library.path") + new Failure(Seq.empty) + case e: Throwable => + throw e + } } } } diff --git a/src/main/scala/viper/gobra/backend/ViperBackends.scala b/src/main/scala/viper/gobra/backend/ViperBackends.scala index ed4ca4f49..7746255ec 100644 --- a/src/main/scala/viper/gobra/backend/ViperBackends.scala +++ b/src/main/scala/viper/gobra/backend/ViperBackends.scala @@ -10,6 +10,7 @@ import viper.gobra.frontend.{Config, MCE} import viper.gobra.util.GobraExecutionContext import viper.server.ViperConfig import viper.server.core.ViperCoreServer +import viper.silicon.decider.Z3ProverAPI import viper.server.vsi.DefaultVerificationServerStart trait ViperBackend { @@ -27,6 +28,9 @@ object ViperBackends { if (config.conditionalizePermissions) { options ++= Vector("--conditionalizePermissions") } + if (config.z3APIMode) { + options = options ++ Vector(s"--prover=${Z3ProverAPI.name}") + } val mceSiliconOpt = config.mceMode match { case MCE.Disabled => "0" case MCE.Enabled => "1" diff --git a/src/main/scala/viper/gobra/frontend/Config.scala b/src/main/scala/viper/gobra/frontend/Config.scala index 2c26a944e..794f86239 100644 --- a/src/main/scala/viper/gobra/frontend/Config.scala +++ b/src/main/scala/viper/gobra/frontend/Config.scala @@ -65,6 +65,7 @@ object ConfigDefaults { lazy val DefaultAssumeInjectivityOnInhale: Boolean = true lazy val DefaultParallelizeBranches: Boolean = false lazy val DefaultConditionalizePermissions: Boolean = false + lazy val DefaultZ3APIMode: Boolean = false lazy val DefaultMCEMode: MCE.Mode = MCE.Enabled lazy val DefaultEnableLazyImports: Boolean = false lazy val DefaultNoVerify: Boolean = false @@ -127,6 +128,7 @@ case class Config( // branches will be verified in parallel parallelizeBranches: Boolean = ConfigDefaults.DefaultParallelizeBranches, conditionalizePermissions: Boolean = ConfigDefaults.DefaultConditionalizePermissions, + z3APIMode: Boolean = ConfigDefaults.DefaultZ3APIMode, mceMode: MCE.Mode = ConfigDefaults.DefaultMCEMode, enableLazyImports: Boolean = ConfigDefaults.DefaultEnableLazyImports, noVerify: Boolean = ConfigDefaults.DefaultNoVerify, @@ -174,6 +176,7 @@ case class Config( assumeInjectivityOnInhale = assumeInjectivityOnInhale || other.assumeInjectivityOnInhale, parallelizeBranches = parallelizeBranches, conditionalizePermissions = conditionalizePermissions, + z3APIMode = z3APIMode || other.z3APIMode, mceMode = mceMode, enableLazyImports = enableLazyImports || other.enableLazyImports, noVerify = noVerify || other.noVerify, @@ -225,6 +228,7 @@ case class BaseConfig(gobraDirectory: Path = ConfigDefaults.DefaultGobraDirector assumeInjectivityOnInhale: Boolean = ConfigDefaults.DefaultAssumeInjectivityOnInhale, parallelizeBranches: Boolean = ConfigDefaults.DefaultParallelizeBranches, conditionalizePermissions: Boolean = ConfigDefaults.DefaultConditionalizePermissions, + z3APIMode: Boolean = ConfigDefaults.DefaultZ3APIMode, mceMode: MCE.Mode = ConfigDefaults.DefaultMCEMode, enableLazyImports: Boolean = ConfigDefaults.DefaultEnableLazyImports, noVerify: Boolean = ConfigDefaults.DefaultNoVerify, @@ -280,6 +284,7 @@ trait RawConfig { assumeInjectivityOnInhale = baseConfig.assumeInjectivityOnInhale, parallelizeBranches = baseConfig.parallelizeBranches, conditionalizePermissions = baseConfig.conditionalizePermissions, + z3APIMode = baseConfig.z3APIMode, mceMode = baseConfig.mceMode, enableLazyImports = baseConfig.enableLazyImports, noVerify = baseConfig.noVerify, @@ -628,6 +633,13 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals short = 'c', ) + val z3APIMode: ScallopOption[Boolean] = opt[Boolean]( + name = "z3APIMode", + descr = "When the backend is either SILICON or VSWITHSILICON, silicon will use Z3 via API.", + default = Some(ConfigDefaults.DefaultZ3APIMode), + noshort = true, + ) + val mceMode: ScallopOption[MCE.Mode] = { val on = "on" val off = "off" @@ -726,6 +738,15 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals } } + addValidation { + val z3APIModeOn = z3APIMode.toOption.contains(true) + if (z3APIModeOn && !isSiliconBasedBackend) { + Left("The selected backend does not support --z3APIMode.") + } else { + Right(()) + } + } + // `mceMode` can only be provided when using a silicon-based backend addValidation { val mceModeSupplied = mceMode.isSupplied @@ -822,6 +843,7 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals assumeInjectivityOnInhale = assumeInjectivityOnInhale(), parallelizeBranches = parallelizeBranches(), conditionalizePermissions = conditionalizePermissions(), + z3APIMode = z3APIMode(), mceMode = mceMode(), enableLazyImports = enableLazyImports(), noVerify = noVerify(), From 5b178fc570f09661fba1ac1bc4e987fa39b68d23 Mon Sep 17 00:00:00 2001 From: Dionysios Spiliopoulos <32896454+Dspil@users.noreply.github.com> Date: Wed, 13 Sep 2023 21:21:16 +0200 Subject: [PATCH 45/54] Slice from array didn't have termination measure (#674) --- .../gobra/translator/encodings/slices/SliceEncoding.scala | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/scala/viper/gobra/translator/encodings/slices/SliceEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/slices/SliceEncoding.scala index 6171920e1..7dc2c151f 100644 --- a/src/main/scala/viper/gobra/translator/encodings/slices/SliceEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/slices/SliceEncoding.scala @@ -509,6 +509,7 @@ class SliceEncoding(arrayEmb : SharedArrayEmbedding) extends LeafTypeEncoding { * ensures slen(result) == j - i * ensures scap(result) == alen(a) - i * ensures sarray(result) == a + * decreases _ * { * sfullSliceFromArray(a, i, j, alen(a)) * } @@ -525,6 +526,7 @@ class SliceEncoding(arrayEmb : SharedArrayEmbedding) extends LeafTypeEncoding { val pre1 = synthesized(vpr.LeCmp(vpr.IntLit(0)(), iDecl.localVar))("The low bound of the slice might be negative") val pre2 = synthesized(vpr.LeCmp(iDecl.localVar, jDecl.localVar))("The low bound of the slice might exceed the high bound") val pre3 = synthesized(vpr.LeCmp(jDecl.localVar, ctx.array.len(aDecl.localVar)()))("The high bound of the slice might exceed the array capacity") + val pre4 = synthesized(termination.DecreasesWildcard(None))("This function is assumed to terminate") // postconditions val result = vpr.Result(ctx.slice.typ(typ))() @@ -545,7 +547,7 @@ class SliceEncoding(arrayEmb : SharedArrayEmbedding) extends LeafTypeEncoding { s"${Names.sliceFromArray}_${Names.serializeType(typ)}", Seq(aDecl, iDecl, jDecl), ctx.slice.typ(typ), - Seq(pre1, pre2, pre3), + Seq(pre1, pre2, pre3, pre4), Seq(post1, post2, post3, post4), if (generateFunctionBodies) Some(body) else None )() From 86529bc8dad584447a4fd5914e640ece4b6cddec Mon Sep 17 00:00:00 2001 From: Dionysios Spiliopoulos <32896454+Dspil@users.noreply.github.com> Date: Thu, 14 Sep 2023 20:14:43 +0200 Subject: [PATCH 46/54] Missing termination measures (#675) * sadd termination * sliceconstruct termination measure * change dummy comment in synthesized --- .../gobra/translator/encodings/slices/SliceEncoding.scala | 4 +++- .../viper/gobra/translator/library/slices/SlicesImpl.scala | 6 +++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/main/scala/viper/gobra/translator/encodings/slices/SliceEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/slices/SliceEncoding.scala index 7dc2c151f..5590c54f7 100644 --- a/src/main/scala/viper/gobra/translator/encodings/slices/SliceEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/slices/SliceEncoding.scala @@ -342,6 +342,7 @@ class SliceEncoding(arrayEmb : SharedArrayEmbedding) extends LeafTypeEncoding { * ensures soffset(result) == offset * ensures slen(result) == len * ensures scap(result) == cap + * dereases _ * }}} */ private val constructGenerator : FunctionGenerator[vpr.Type] = new FunctionGenerator[vpr.Type] { @@ -357,6 +358,7 @@ class SliceEncoding(arrayEmb : SharedArrayEmbedding) extends LeafTypeEncoding { val pre2 = synthesized(vpr.LeCmp(vpr.IntLit(0)(), lenDecl.localVar))("Slice length might be negative") val pre3 = synthesized(vpr.LeCmp(lenDecl.localVar, capDecl.localVar))("Slice length might exceed capacity") val pre4 = synthesized(vpr.LeCmp(vpr.Add(offsetDecl.localVar, capDecl.localVar)(), ctx.array.len(aDecl.localVar)()))("Slice capacity might exceed the capacity of the underlying array") + val pre5 = synthesized(termination.DecreasesWildcard(None))("This function is assumed to terminate") // postconditions val result = vpr.Result(ctx.slice.typ(typ))() @@ -369,7 +371,7 @@ class SliceEncoding(arrayEmb : SharedArrayEmbedding) extends LeafTypeEncoding { s"${Names.sliceConstruct}_${Names.serializeType(typ)}", Seq(aDecl, offsetDecl, lenDecl, capDecl), ctx.slice.typ(typ), - Seq(pre1, pre2, pre3, pre4), + Seq(pre1, pre2, pre3, pre4, pre5), Seq(post1, post2, post3, post4), None )() diff --git a/src/main/scala/viper/gobra/translator/library/slices/SlicesImpl.scala b/src/main/scala/viper/gobra/translator/library/slices/SlicesImpl.scala index f614ab63c..aa1840cb6 100644 --- a/src/main/scala/viper/gobra/translator/library/slices/SlicesImpl.scala +++ b/src/main/scala/viper/gobra/translator/library/slices/SlicesImpl.scala @@ -7,6 +7,8 @@ package viper.gobra.translator.library.slices import viper.gobra.translator.library.arrays.Arrays +import viper.silver.plugin.standard.termination +import viper.gobra.translator.util.ViperUtil.synthesized import viper.silver.{ast => vpr} class SlicesImpl(val arrays : Arrays) extends Slices { @@ -274,6 +276,7 @@ class SlicesImpl(val arrays : Arrays) extends Slices { * {{{ * function sadd(left: Int, right: Int): Int * ensures result == left + right + * decreases * { * left + right * } @@ -284,7 +287,8 @@ class SlicesImpl(val arrays : Arrays) extends Slices { val rDecl = vpr.LocalVarDecl("right", vpr.Int)() val body : vpr.Exp = vpr.Add(lDecl.localVar, rDecl.localVar)() val post : vpr.Exp = vpr.EqCmp(vpr.Result(vpr.Int)(), body)() - vpr.Function("sadd", Seq(lDecl, rDecl), vpr.Int, Seq(), Seq(post), Some(body))() + val pre : vpr.Exp = synthesized(termination.DecreasesTuple(Seq.empty, None))("Termination measure") + vpr.Function("sadd", Seq(lDecl, rDecl), vpr.Int, Seq(pre), Seq(post), Some(body))() } /** From 0c28a113f956b888582dd07c6d533f1cf7f4f958 Mon Sep 17 00:00:00 2001 From: viper-admin <59963956+viper-admin@users.noreply.github.com> Date: Thu, 21 Sep 2023 12:00:13 +0200 Subject: [PATCH 47/54] Updates submodules (#677) Co-authored-by: jcp19 --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index 3e2f02096..3359baca9 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit 3e2f020964fa8d837c444ee54f933e2b577ea551 +Subproject commit 3359baca924861f5858cda8651b342c584f20edd From 17f510bfaf53031b0d6afc48d04200ca6f830a9a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Pereira?= Date: Fri, 22 Sep 2023 16:08:47 +0200 Subject: [PATCH 48/54] Enable let expressions with weakly pure subexpressions (#678) * enable non-pure lets * fix tests * addressability of let --- .../gobra/ast/internal/PrettyPrinter.scala | 5 ++- .../viper/gobra/ast/internal/Program.scala | 4 ++- .../scala/viper/gobra/frontend/Desugar.scala | 33 ++++++++++++++----- .../property/Addressability.scala | 1 + .../typing/ghost/GhostExprTyping.scala | 2 +- .../viper/gobra/theory/Addressability.scala | 1 + .../typeless/AssertionEncoding.scala | 8 ++++- .../regressions/features/let/let_simple.gobra | 10 ++++++ 8 files changed, 51 insertions(+), 13 deletions(-) diff --git a/src/main/scala/viper/gobra/ast/internal/PrettyPrinter.scala b/src/main/scala/viper/gobra/ast/internal/PrettyPrinter.scala index 4d0cc0040..b1197c095 100644 --- a/src/main/scala/viper/gobra/ast/internal/PrettyPrinter.scala +++ b/src/main/scala/viper/gobra/ast/internal/PrettyPrinter.scala @@ -428,6 +428,8 @@ class DefaultPrettyPrinter extends PrettyPrinter with kiama.output.PrettyPrinter def showAss(a: Assertion): Doc = updatePositionStore(a) <> (a match { case SepAnd(left, right) => showAss(left) <+> "&&" <+> showAss(right) case ExprAssertion(exp) => showExpr(exp) + case Let(left, right, exp) => + "let" <+> showVar(left) <+> "==" <+> parens(showExpr(right)) <+> "in" <+> showAss(exp) case MagicWand(left, right) => showAss(left) <+> "--*" <+> showAss(right) case Implication(left, right) => showExpr(left) <+> "==>" <+> showAss(right) case Access(e, FullPerm(_)) => "acc" <> parens(showAcc(e)) @@ -462,7 +464,8 @@ class DefaultPrettyPrinter extends PrettyPrinter with kiama.output.PrettyPrinter def showExpr(e: Expr): Doc = updatePositionStore(e) <> (e match { case Unfolding(acc, exp) => "unfolding" <+> showAss(acc) <+> "in" <+> showExpr(exp) - case Let(left, right, exp) => "let" <+> showVar(left) <+> "==" <+> parens(showExpr(right)) <+> "in" <+> showExpr(exp) + case PureLet(left, right, exp) => + "let" <+> showVar(left) <+> "==" <+> parens(showExpr(right)) <+> "in" <+> showExpr(exp) case Old(op, _) => "old" <> parens(showExpr(op)) diff --git a/src/main/scala/viper/gobra/ast/internal/Program.scala b/src/main/scala/viper/gobra/ast/internal/Program.scala index a23f14046..7012d607f 100644 --- a/src/main/scala/viper/gobra/ast/internal/Program.scala +++ b/src/main/scala/viper/gobra/ast/internal/Program.scala @@ -543,10 +543,12 @@ case class Unfolding(acc: Access, in: Expr)(val info: Source.Parser.Info) extend require(typ.addressability == Addressability.unfolding(in.typ.addressability)) } -case class Let(left: LocalVar, right: Expr, in: Expr)(val info: Source.Parser.Info) extends Expr { +case class PureLet(left: LocalVar, right: Expr, in: Expr)(val info: Source.Parser.Info) extends Expr { override def typ: Type = in.typ } +case class Let(left: LocalVar, right: Expr, in: Assertion)(val info: Source.Parser.Info) extends Assertion + case class Old(operand: Expr, typ: Type)(val info: Source.Parser.Info) extends Expr case class LabeledOld(label: LabelProxy, operand: Expr)(val info: Source.Parser.Info) extends Expr { diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index 9a0704d51..a7d78f6a8 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -2446,7 +2446,6 @@ object Desugar extends LazyLogging { } } - private def indexedExprD(base : PExpression, index : PExpression)(ctx : FunctionContext, info : TypeInfo)(src : Meta) : Writer[in.IndexedExp] = { for { dbase <- exprD(ctx, info)(base) @@ -2660,14 +2659,6 @@ object Desugar extends LazyLogging { val dOp = pureExprD(ctx, info)(op) unit(in.Unfolding(dAcc, dOp)(src)) - case PLet(ass, op) => - val dOp = pureExprD(ctx, info)(op) - unit((ass.left zip ass.right).foldRight(dOp)((lr, letop) => { - val right = pureExprD(ctx, info)(lr._2) - val left = in.LocalVar(nm.variable(lr._1.name, info.scope(lr._1), info), right.typ.withAddressability(Addressability.exclusiveVariable))(src) - in.Let(left, right, letop)(src) - })) - case n : PIndexedExp => indexedExprD(n)(ctx, info) case PSliceExp(base, low, high, cap) => for { @@ -4277,6 +4268,17 @@ object Desugar extends LazyLogging { wels <- go(els) } yield in.Conditional(wcond, wthn, wels, typ)(src) + case PLet(ass, op) => + val dOp = pureExprD(ctx, info)(op) + unit((ass.left zip ass.right).foldRight(dOp)((lr, letop) => { + val right = pureExprD(ctx, info)(lr._2) + val left = in.LocalVar( + nm.variable(lr._1.name, info.scope(lr._1), info), + right.typ.withAddressability(Addressability.exclusiveVariable) + )(src) + in.PureLet(left, right, letop)(src) + })) + case PForall(vars, triggers, body) => for { (newVars, newTriggers, newBody) <- quantifierD(ctx, info)(vars, triggers, body)(ctx => exprD(ctx, info)) } yield in.PureForall(newVars, newTriggers, newBody)(src) @@ -4530,6 +4532,19 @@ object Desugar extends LazyLogging { case n: PAccess => for {e <- accessibleD(ctx, info)(n.exp); p <- permissionD(ctx, info)(n.perm)} yield in.Access(e, p)(src) case n: PPredicateAccess => predicateCallD(ctx, info)(n.pred, n.perm) + case PLet(ass, op) => + for { + dOp <- assertionD(ctx, info)(op) + lets = (ass.left zip ass.right).foldRight(dOp)((lr, letop) => { + val right = pureExprD(ctx, info)(lr._2) + val left = in.LocalVar( + nm.variable(lr._1.name, info.scope(lr._1), info), + right.typ.withAddressability(Addressability.exclusiveVariable) + )(src) + in.Let(left, right, letop)(src) + }) + } yield lets + case n: PInvoke => // a predicate invocation corresponds to a predicate access with full permissions // register the full permission AST node in the position manager such that its meta information diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/property/Addressability.scala b/src/main/scala/viper/gobra/frontend/info/implementation/property/Addressability.scala index 30ade529b..a98fe65b5 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/property/Addressability.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/property/Addressability.scala @@ -98,6 +98,7 @@ trait Addressability extends BaseProperty { this: TypeInfoImpl => case _: PPermission => AddrMod.rValue case _: PPredConstructor => AddrMod.rValue case n: PUnfolding => AddrMod.unfolding(addressability(n.op)) + case n: PLet => AddrMod.let(addressability(n.op)) case _: POld | _: PLabeledOld | _: PBefore => AddrMod.old case _: PConditional | _: PImplication | _: PForall | _: PExists => AddrMod.rValue case _: PAccess | _: PPredicateAccess | _: PMagicWand => AddrMod.rValue diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala index a49c58c22..9950853e6 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala @@ -74,7 +74,7 @@ trait GhostExprTyping extends BaseTyping { this: TypeInfoImpl => case n: PClosureImplements => isPureExpr(n.closure) ++ wellDefIfClosureMatchesSpec(n.closure, n.spec) - case n: PLet => isExpr(n.op).out ++ isPureExpr(n.op) ++ + case n: PLet => isExpr(n.op).out ++ isWeaklyPureExpr(n.op) ++ n.ass.right.foldLeft(noMessages)((a, b) => a ++ isPureExpr(b)) case n: PAccess => diff --git a/src/main/scala/viper/gobra/theory/Addressability.scala b/src/main/scala/viper/gobra/theory/Addressability.scala index 8f438518a..33ba8dc0b 100644 --- a/src/main/scala/viper/gobra/theory/Addressability.scala +++ b/src/main/scala/viper/gobra/theory/Addressability.scala @@ -119,6 +119,7 @@ object Addressability { val mathDataStructureLookup: Addressability = mathDataStructureElement def unfolding(bodyAddressability: Addressability): Addressability = bodyAddressability + def let(bodyAddressability: Addressability): Addressability = bodyAddressability val old: Addressability = rValue val make: Addressability = Exclusive val exprInAcc: Addressability = Exclusive diff --git a/src/main/scala/viper/gobra/translator/encodings/typeless/AssertionEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/typeless/AssertionEncoding.scala index 46c9b13d6..1b52308d2 100644 --- a/src/main/scala/viper/gobra/translator/encodings/typeless/AssertionEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/typeless/AssertionEncoding.scala @@ -55,7 +55,7 @@ class AssertionEncoding extends Encoding { case errors => Violation.violation(s"invalid trigger pattern (${errors.head.readableMessage})") } - case let: in.Let => + case let: in.PureLet => for { exp <- ctx.expression(let.in) l = ctx.variable(let.left) @@ -66,6 +66,12 @@ class AssertionEncoding extends Encoding { override def assertion(ctx: Context): in.Assertion ==> CodeWriter[vpr.Exp] = { case n@ in.SepAnd(l, r) => for {vl <- ctx.assertion(l); vr <- ctx.assertion(r)} yield withSrc(vpr.And(vl, vr), n) case in.ExprAssertion(e) => ctx.expression(e) + case n@ in.Let(left, right, op) => + for { + exp <- ctx.assertion(op) + r <- ctx.expression(right) + l = ctx.variable(left) + } yield withSrc(vpr.Let(l, r, exp), n) case n@ in.MagicWand(l, r) => for {vl <- ctx.assertion(l); vr <- ctx.assertion(r)} yield withSrc(vpr.MagicWand(vl, vr), n) case n@ in.Implication(l, r) => for {vl <- ctx.expression(l); vr <- ctx.assertion(r)} yield withSrc(vpr.Implies(vl, vr), n) diff --git a/src/test/resources/regressions/features/let/let_simple.gobra b/src/test/resources/regressions/features/let/let_simple.gobra index 030bb432d..f50a4e1b6 100644 --- a/src/test/resources/regressions/features/let/let_simple.gobra +++ b/src/test/resources/regressions/features/let/let_simple.gobra @@ -32,3 +32,13 @@ func (a *A) g(x int) { fold a.Mem() } +pred Q(x int) { + true +} + +requires acc(x) +requires Q(y) +func impureLets(x *int, y int) { + assert let z := y in Q(z) + assert let z := x in acc(z) +} \ No newline at end of file From 8895ec3cbacce1dac3d5a68a6488a0f87499153e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Pereira?= Date: Fri, 22 Sep 2023 19:44:45 +0200 Subject: [PATCH 49/54] Improvements in maps (#676) * start fixing triggers maps * cleanup * fix issues with 'contains' in maps and with trigger generation * backup * backup * doc * Apply suggestions from code review Co-authored-by: Felix Wolf <60103963+Felalolf@users.noreply.github.com> * feedback from Felix --------- Co-authored-by: Felix Wolf <60103963+Felalolf@users.noreply.github.com> --- .../scala/viper/gobra/frontend/Desugar.scala | 1 + .../typing/ghost/GhostExprTyping.scala | 1 + .../gobra/translator/context/Context.scala | 2 + .../context/DfltTranslatorConfig.scala | 5 +- .../combinators/FinalTypeEncoding.scala | 1 + .../encodings/combinators/TypeEncoding.scala | 7 ++ .../combinators/TypeEncodingCombiner.scala | 1 + .../defaults/DefaultTriggerExprEncoding.scala | 27 ++++++++ .../encodings/maps/MapEncoding.scala | 68 +++++++++++++++++-- .../typeless/AssertionEncoding.scala | 12 +--- .../gobra/translator/util/ViperWriter.scala | 9 ++- .../features/maps/maps-simple1.gobra | 25 +++++-- 12 files changed, 135 insertions(+), 24 deletions(-) create mode 100644 src/main/scala/viper/gobra/translator/encodings/defaults/DefaultTriggerExprEncoding.scala diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index a7d78f6a8..b0e751931 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -4306,6 +4306,7 @@ object Desugar extends LazyLogging { } yield underlyingType(dright.typ) match { case _: in.SequenceT | _: in.SetT => in.Contains(dleft, dright)(src) case _: in.MultisetT => in.LessCmp(in.IntLit(0)(src), in.Contains(dleft, dright)(src))(src) + case _: in.MapT => in.Contains(dleft, dright)(src) case t => violation(s"expected a sequence or (multi)set type, but got $t") } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala index 9950853e6..84fcf0155 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala @@ -139,6 +139,7 @@ trait GhostExprTyping extends BaseTyping { this: TypeInfoImpl => case PIn(left, right) => isExpr(left).out ++ isExpr(right).out ++ { underlyingType(exprType(right)) match { case t : GhostCollectionType => ghostComparableTypes.errors(exprType(left), t.elem)(expr) + case t : MapT => ghostComparableTypes.errors(exprType(left), t.key)(expr) case _ : AdtT => noMessages case t => error(right, s"expected a ghost collection, but got $t") } diff --git a/src/main/scala/viper/gobra/translator/context/Context.scala b/src/main/scala/viper/gobra/translator/context/Context.scala index 259598ebb..224a5c613 100644 --- a/src/main/scala/viper/gobra/translator/context/Context.scala +++ b/src/main/scala/viper/gobra/translator/context/Context.scala @@ -87,6 +87,8 @@ trait Context { def expression(x: in.Expr): CodeWriter[vpr.Exp] = typeEncoding.finalExpression(this)(x) + def triggerExpr(x: in.TriggerExpr): CodeWriter[vpr.Exp] = typeEncoding.triggerExpr(this)(x) + def assertion(x: in.Assertion): CodeWriter[vpr.Exp] = typeEncoding.finalAssertion(this)(x) def invariant(x: in.Assertion): (CodeWriter[Unit], vpr.Exp) = typeEncoding.invariant(this)(x) diff --git a/src/main/scala/viper/gobra/translator/context/DfltTranslatorConfig.scala b/src/main/scala/viper/gobra/translator/context/DfltTranslatorConfig.scala index 4361f570a..04825342f 100644 --- a/src/main/scala/viper/gobra/translator/context/DfltTranslatorConfig.scala +++ b/src/main/scala/viper/gobra/translator/context/DfltTranslatorConfig.scala @@ -16,7 +16,7 @@ import viper.gobra.translator.encodings.closures.ClosureEncoding import viper.gobra.translator.encodings.combinators.{DefaultEncoding, FinalTypeEncoding, SafeTypeEncodingCombiner, TypeEncoding} import viper.gobra.translator.encodings.interfaces.InterfaceEncoding import viper.gobra.translator.encodings.maps.{MapEncoding, MathematicalMapEncoding} -import viper.gobra.translator.encodings.defaults.{DefaultGlobalVarEncoding, DefaultMethodEncoding, DefaultPredicateEncoding, DefaultPureMethodEncoding} +import viper.gobra.translator.encodings.defaults.{DefaultGlobalVarEncoding, DefaultMethodEncoding, DefaultPredicateEncoding, DefaultPureMethodEncoding, DefaultTriggerExprEncoding} import viper.gobra.translator.encodings.options.OptionEncoding import viper.gobra.translator.encodings.preds.PredEncoding import viper.gobra.translator.encodings.sequences.SequenceEncoding @@ -61,6 +61,7 @@ class DfltTranslatorConfig( val pureMethodEncoding = new DefaultPureMethodEncoding val predicateEncoding = new DefaultPredicateEncoding val globalVarEncoding = new DefaultGlobalVarEncoding + val triggerExprEncoding = new DefaultTriggerExprEncoding val typeEncoding: TypeEncoding = new FinalTypeEncoding( new SafeTypeEncodingCombiner(Vector( @@ -73,7 +74,7 @@ class DfltTranslatorConfig( new TerminationEncoding, new BuiltInEncoding, new OutlineEncoding, new DeferEncoding, new GlobalEncoding, new Comments, ), Vector( - methodEncoding, pureMethodEncoding, predicateEncoding, globalVarEncoding + methodEncoding, pureMethodEncoding, predicateEncoding, globalVarEncoding, triggerExprEncoding )) ) diff --git a/src/main/scala/viper/gobra/translator/encodings/combinators/FinalTypeEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/combinators/FinalTypeEncoding.scala index 3b7a49e89..b6731e0f1 100644 --- a/src/main/scala/viper/gobra/translator/encodings/combinators/FinalTypeEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/combinators/FinalTypeEncoding.scala @@ -46,6 +46,7 @@ class FinalTypeEncoding(te: TypeEncoding) extends TypeEncoding { override def equal(ctx: Context): (in.Expr, in.Expr, in.Node) ==> CodeWriter[vpr.Exp] = te.equal(ctx) orElse expectedMatch("equal") override def goEqual(ctx: Context): (in.Expr, in.Expr, in.Node) ==> CodeWriter[vpr.Exp] = te.goEqual(ctx) orElse expectedMatch("equal") override def expression(ctx: Context): in.Expr ==> CodeWriter[vpr.Exp] = te.expression(ctx) orElse expectedMatch("expression") + override def triggerExpr(ctx: Context): in.TriggerExpr ==> CodeWriter[vpr.Exp] = te.triggerExpr(ctx) orElse expectedMatch("trigger expression") override def assertion(ctx: Context): in.Assertion ==> CodeWriter[vpr.Exp] = te.assertion(ctx) orElse expectedMatch("assertion") override def reference(ctx: Context): in.Location ==> CodeWriter[vpr.Exp] = te.reference(ctx) orElse expectedMatch("reference") override def addressFootprint(ctx: Context): (in.Location, in.Expr) ==> CodeWriter[vpr.Exp] = te.addressFootprint(ctx) orElse expectedMatch("addressFootprint") diff --git a/src/main/scala/viper/gobra/translator/encodings/combinators/TypeEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/combinators/TypeEncoding.scala index b130a0c2a..1421fdcc7 100644 --- a/src/main/scala/viper/gobra/translator/encodings/combinators/TypeEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/combinators/TypeEncoding.scala @@ -233,6 +233,13 @@ trait TypeEncoding extends Generator { case in.Conversion(t2, expr :: t) if typ(ctx).isDefinedAt(t) && typ(ctx).isDefinedAt(t2) => ctx.expression(expr) } + /** + * Encodes expressions when they occur as the top-level expression in a trigger. + * The default implements an encoding for predicate instances and defers the + * encoding of all expressions to the expression encoding. + */ + def triggerExpr(@unused ctx: Context): in.TriggerExpr ==> CodeWriter[vpr.Exp] = PartialFunction.empty + /** * Encodes assertions. * diff --git a/src/main/scala/viper/gobra/translator/encodings/combinators/TypeEncodingCombiner.scala b/src/main/scala/viper/gobra/translator/encodings/combinators/TypeEncodingCombiner.scala index 81b646efd..c4e80a245 100644 --- a/src/main/scala/viper/gobra/translator/encodings/combinators/TypeEncodingCombiner.scala +++ b/src/main/scala/viper/gobra/translator/encodings/combinators/TypeEncodingCombiner.scala @@ -49,6 +49,7 @@ abstract class TypeEncodingCombiner(encodings: Vector[TypeEncoding], defaults: V override def equal(ctx: Context): (in.Expr, in.Expr, in.Node) ==> CodeWriter[vpr.Exp] = combiner(_.equal(ctx)) override def goEqual(ctx: Context): (in.Expr, in.Expr, in.Node) ==> CodeWriter[vpr.Exp] = combiner(_.goEqual(ctx)) override def expression(ctx: Context): in.Expr ==> CodeWriter[vpr.Exp] = combiner(_.expression(ctx)) + override def triggerExpr(ctx: Context): in.TriggerExpr ==> CodeWriter[vpr.Exp] = combiner(_.triggerExpr(ctx)) override def assertion(ctx: Context): in.Assertion ==> CodeWriter[vpr.Exp] = combiner(_.assertion(ctx)) override def reference(ctx: Context): in.Location ==> CodeWriter[vpr.Exp] = combiner(_.reference(ctx)) override def addressFootprint(ctx: Context): (in.Location, in.Expr) ==> CodeWriter[vpr.Exp] = combiner(_.addressFootprint(ctx)) diff --git a/src/main/scala/viper/gobra/translator/encodings/defaults/DefaultTriggerExprEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/defaults/DefaultTriggerExprEncoding.scala new file mode 100644 index 000000000..ecca61171 --- /dev/null +++ b/src/main/scala/viper/gobra/translator/encodings/defaults/DefaultTriggerExprEncoding.scala @@ -0,0 +1,27 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. +// +// Copyright (c) 2011-2023 ETH Zurich. + +package viper.gobra.translator.encodings.defaults + +import org.bitbucket.inkytonik.kiama.==> +import viper.gobra.ast.{internal => in} +import viper.gobra.translator.context.Context +import viper.gobra.translator.encodings.combinators.Encoding +import viper.silver.{ast => vpr} + +class DefaultTriggerExprEncoding extends Encoding { + import viper.gobra.translator.util.ViperWriter._ + + override def triggerExpr(ctx: Context): in.TriggerExpr ==> CodeWriter[vpr.Exp] = { + // use predicate access encoding but then take just the predicate access, i.e. without the access predicate: + case in.Accessible.Predicate(op) => + for { + v <- ctx.assertion(in.Access(in.Accessible.Predicate(op), in.FullPerm(op.info))(op.info)) + pap = v.asInstanceOf[vpr.PredicateAccessPredicate] + } yield pap.loc + case e: in.Expr => ctx.expression(e) + } +} diff --git a/src/main/scala/viper/gobra/translator/encodings/maps/MapEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/maps/MapEncoding.scala index f8e9116ca..d92fa27f2 100644 --- a/src/main/scala/viper/gobra/translator/encodings/maps/MapEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/maps/MapEncoding.scala @@ -54,10 +54,11 @@ class MapEncoding extends LeafTypeEncoding { * Encodes expressions as values that do not occupy some identifiable location in memory. * R[ nil(map[K]V°) ] -> null * R[ dflt(map[K]V°) ] -> null - * R[ len(e: map[K]V) ] -> [e] == null? 0 : | getCorrespondingMap([e]) | - * R[ (e: map[K]V)[idx] ] -> [e] == null? [ dflt(V) ] : goMapLookup(e[idx]) - * R[ keySet(e: map[K]V) ] -> [e] == null? 0 : MapDomain(getCorrespondingMap(e)) - * R[ valueSet(e: map[K]V) ] -> [e] == null? 0 : MapRange(getCorrespondingMap(e)) + * R[ len(e: map[K]V) ] -> [ e ] == null? 0 : | getCorrespondingMap([ e ]) | + * R[ (e: map[K]V)[idx] ] -> [ e ] == null? [ dflt(V) ] : goMapLookup(e[idx]) + * R[ keySet(e: map[K]V) ] -> [ e ] == null? 0 : MapDomain(getCorrespondingMap([ e ])) + * R[ valueSet(e: map[K]V) ] -> [ e ] == null? 0 : MapRange(getCorrespondingMap([ e ])) + * R[ k in (e: map[K]V) ] -> [ e ] == null? false : MapContains([ k ], getCorrespondingMap([ e ])) */ override def expression(ctx: Context): in.Expr ==> CodeWriter[vpr.Exp] = { def goE(x: in.Expr): CodeWriter[vpr.Exp] = ctx.expression(x) @@ -85,6 +86,21 @@ class MapEncoding extends LeafTypeEncoding { case l@in.IndexedExp(_ :: ctx.Map(_, _), _, _) => for {(res, _) <- goMapLookup(l)(ctx)} yield res + case l@in.Contains(key, exp :: ctx.Map(keys, values)) => + for { + mapVpr <- goE(exp) + keyVpr <- goE(key) + isComp <- MapEncoding.checkKeyComparability(key)(ctx) + correspondingMap <- getCorrespondingMap(exp, keys, values)(ctx) + containsExp = + withSrc(vpr.CondExp( + withSrc(vpr.EqCmp(mapVpr, withSrc(vpr.NullLit(), l)), l), + withSrc(vpr.FalseLit(), l), + withSrc(vpr.MapContains(keyVpr, correspondingMap), l) + ), l) + checkCompAndContains <- assert(isComp, containsExp, comparabilityErrorT)(ctx) + } yield checkCompAndContains + case k@in.MapKeys(mapExp :: ctx.Map(keys, values), _) => for { vprMap <- goE(mapExp) @@ -111,6 +127,50 @@ class MapEncoding extends LeafTypeEncoding { } } + /** + * Encodes expressions when they occur as the top-level expression in a trigger. + * Notice that using the expression encoding for the following triggers, + * results in ill-formed triggers at the Viper level (e.g., because + * they have ternary operations). + * { m[i] } -> { getCorrespondingMap([ m ])[ [ i ] ] } + * { k in m } -> { [ k ] in getCorrespondingMap([ m ]) } + * { k in domain(m) } -> { [ k ] in domain(getCorrespondingMap([ m ])) } + * { k in range(m) } -> { [ k ] in range(getCorrespondingMap([ m ])) } + */ + override def triggerExpr(ctx: Context): in.TriggerExpr ==> CodeWriter[vpr.Exp] = { + default(super.triggerExpr(ctx)) { + case l@in.IndexedExp(m :: ctx.Map(keys, values), idx, _) => + for { + vIdx <- ctx.expression(idx) + correspondingMap <- getCorrespondingMap(m, keys, values)(ctx) + lookupRes = withSrc(vpr.MapLookup(correspondingMap, vIdx), l) + } yield lookupRes + + case l@in.Contains(key, m :: ctx.Map(keys, values)) => + for { + vKey <- ctx.expression(key) + correspondingMap <- getCorrespondingMap(m, keys, values)(ctx) + contains = withSrc(vpr.MapContains(vKey, correspondingMap), l) + } yield contains + + case l@in.Contains(key, in.MapKeys(m :: ctx.Map(keys, values), _)) => + for { + vKey <- ctx.expression(key) + correspondingMap <- getCorrespondingMap(m, keys, values)(ctx) + vDomainMap = withSrc(vpr.MapDomain(correspondingMap), l) + contains = withSrc(vpr.AnySetContains(vKey, vDomainMap), l) + } yield contains + + case l@in.Contains(key, in.MapValues(m :: ctx.Map(keys, values), _)) => + for { + vKey <- ctx.expression(key) + correspondingMap <- getCorrespondingMap(m, keys, values)(ctx) + vRangeMap = withSrc(vpr.MapRange(correspondingMap), l) + contains = withSrc(vpr.AnySetContains(vKey, vRangeMap), l) + } yield contains + } + } + /** * Encodes the allocation of a new map * [r := make(map[T1]T2, n)] -> diff --git a/src/main/scala/viper/gobra/translator/encodings/typeless/AssertionEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/typeless/AssertionEncoding.scala index 1b52308d2..6d30f79e2 100644 --- a/src/main/scala/viper/gobra/translator/encodings/typeless/AssertionEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/typeless/AssertionEncoding.scala @@ -112,20 +112,10 @@ class AssertionEncoding extends Encoding { def trigger(trigger: in.Trigger)(ctx: Context) : CodeWriter[vpr.Trigger] = { val (pos, info, errT) = trigger.vprMeta - for { expr <- sequence(trigger.exprs map (triggerExpr(_)(ctx))) } + for { expr <- sequence(trigger.exprs map ctx.triggerExpr)} yield vpr.Trigger(expr)(pos, info, errT) } - def triggerExpr(expr: in.TriggerExpr)(ctx: Context): CodeWriter[vpr.Exp] = expr match { - // use predicate access encoding but then take just the predicate access, i.e. remove `acc` and the permission amount: - case in.Accessible.Predicate(op) => - for { - v <- ctx.assertion(in.Access(in.Accessible.Predicate(op), in.FullPerm(op.info))(op.info)) - pap = v.asInstanceOf[vpr.PredicateAccessPredicate] - } yield pap.loc - case e: in.Expr => ctx.expression(e) - } - def quantifier(vars: Vector[in.BoundVar], triggers: Vector[in.Trigger], body: in.Expr)(ctx: Context) : CodeWriter[(Seq[vpr.LocalVarDecl], Seq[vpr.Trigger], vpr.Exp)] = { val newVars = vars map ctx.variable diff --git a/src/main/scala/viper/gobra/translator/util/ViperWriter.scala b/src/main/scala/viper/gobra/translator/util/ViperWriter.scala index de0f8bc67..3983445f9 100644 --- a/src/main/scala/viper/gobra/translator/util/ViperWriter.scala +++ b/src/main/scala/viper/gobra/translator/util/ViperWriter.scala @@ -399,8 +399,13 @@ object ViperWriter { /* Can be used in expressions. */ def assert(cond: vpr.Exp, exp: vpr.Exp, reasonT: (Source.Verifier.Info, ErrorReason) => VerificationError)(ctx: Context): Writer[vpr.Exp] = { // In the future, this might do something more sophisticated - val (res, errT) = ctx.condition.assert(cond, exp, reasonT) - errorT(errT).map(_ => res) + cond match { + case vpr.TrueLit() => + unit(exp) + case _ => + val (res, errT) = ctx.condition.assert(cond, exp, reasonT) + errorT(errT).map(_ => res) + } } /* Emits Viper statements. */ diff --git a/src/test/resources/regressions/features/maps/maps-simple1.gobra b/src/test/resources/regressions/features/maps/maps-simple1.gobra index 8a53e22cd..571d8437a 100644 --- a/src/test/resources/regressions/features/maps/maps-simple1.gobra +++ b/src/test/resources/regressions/features/maps/maps-simple1.gobra @@ -52,6 +52,9 @@ func test6() { m[3] = 10 v3, ok3 := m[3] assert ok3 && v3 == 10 + + // check if key exists in the map + assert 3 in m } type T struct { @@ -110,24 +113,24 @@ func test11() { requires acc(m, _) requires "key" in domain(m) func test12(m map[string]string) (r string){ - return m["key"] + return m["key"] } requires acc(m, _) requires "value" in range(m) func test13(m map[string]string) { - assert exists k string :: m[k] == "value" + assert exists k string :: m[k] == "value" } func test14() (res map[int]int) { x := 1 y := 2 - m := map[int]int{x: y, y: x} + m := map[int]int{x: y, y: x} return m } func test15() (res map[int]int) { - m := map[int]int{C1: C2, C2: C1} + m := map[int]int{C1: C2, C2: C1} return m } @@ -137,4 +140,16 @@ func test16() { assert x == 0 x, contained := m[2] assert x == 0 && !contained -} \ No newline at end of file +} + +requires m != nil ==> acc(m) +requires forall s string :: { s in domain(m) } s in domain(m) ==> acc(m[s]) +func test17(m map[string]*int) {} + +requires m != nil ==> acc(m) +requires forall s string :: { s in m } s in m ==> acc(m[s]) +func test18(m map[string]*int) {} + +requires m != nil ==> acc(m) +requires forall i int :: { i in range(m) } i in range(m) ==> 0 < i +func test19(m map[string]int) {} \ No newline at end of file From a82655da2070d525ad9d79068f8e0beb85e18e77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Pereira?= Date: Sun, 24 Sep 2023 12:26:55 +0200 Subject: [PATCH 50/54] Add flag to require triggers in all quantifiers (#679) * add --requireTriggers flag * change comment --- src/main/scala/viper/gobra/frontend/Config.scala | 16 +++++++++++++++- .../typing/ghost/GhostExprTyping.scala | 12 ++++++++---- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/src/main/scala/viper/gobra/frontend/Config.scala b/src/main/scala/viper/gobra/frontend/Config.scala index 794f86239..29d92a022 100644 --- a/src/main/scala/viper/gobra/frontend/Config.scala +++ b/src/main/scala/viper/gobra/frontend/Config.scala @@ -71,6 +71,7 @@ object ConfigDefaults { lazy val DefaultNoVerify: Boolean = false lazy val DefaultNoStreamErrors: Boolean = false lazy val DefaultParseAndTypeCheckMode: TaskManagerMode = TaskManagerMode.Parallel + lazy val DefaultRequireTriggers: Boolean = false } // More-complete exhale modes @@ -134,6 +135,8 @@ case class Config( noVerify: Boolean = ConfigDefaults.DefaultNoVerify, noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors, parseAndTypeCheckMode: TaskManagerMode = ConfigDefaults.DefaultParseAndTypeCheckMode, + // when enabled, all quantifiers without triggers are rejected + requireTriggers: Boolean = ConfigDefaults.DefaultRequireTriggers, ) { def merge(other: Config): Config = { @@ -181,7 +184,8 @@ case class Config( enableLazyImports = enableLazyImports || other.enableLazyImports, noVerify = noVerify || other.noVerify, noStreamErrors = noStreamErrors || other.noStreamErrors, - parseAndTypeCheckMode = parseAndTypeCheckMode + parseAndTypeCheckMode = parseAndTypeCheckMode, + requireTriggers = requireTriggers || other.requireTriggers ) } @@ -234,6 +238,7 @@ case class BaseConfig(gobraDirectory: Path = ConfigDefaults.DefaultGobraDirector noVerify: Boolean = ConfigDefaults.DefaultNoVerify, noStreamErrors: Boolean = ConfigDefaults.DefaultNoStreamErrors, parseAndTypeCheckMode: TaskManagerMode = ConfigDefaults.DefaultParseAndTypeCheckMode, + requireTriggers: Boolean = ConfigDefaults.DefaultRequireTriggers, ) { def shouldParse: Boolean = true def shouldTypeCheck: Boolean = !shouldParseOnly @@ -290,6 +295,7 @@ trait RawConfig { noVerify = baseConfig.noVerify, noStreamErrors = baseConfig.noStreamErrors, parseAndTypeCheckMode = baseConfig.parseAndTypeCheckMode, + requireTriggers = baseConfig.requireTriggers, ) } @@ -665,6 +671,13 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals noshort = true, ) + val requireTriggers: ScallopOption[Boolean] = opt[Boolean]( + name = "requireTriggers", + descr = s"Enforces that all quantifiers have a user-provided trigger.", + default = Some(ConfigDefaults.DefaultRequireTriggers), + noshort = true, + ) + val noVerify: ScallopOption[Boolean] = opt[Boolean]( name = "noVerify", descr = s"Skip the verification step performed after encoding the Gobra program into Viper.", @@ -849,5 +862,6 @@ class ScallopGobraConfig(arguments: Seq[String], isInputOptional: Boolean = fals noVerify = noVerify(), noStreamErrors = noStreamErrors(), parseAndTypeCheckMode = parseAndTypeCheckMode(), + requireTriggers = requireTriggers(), ) } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala index 84fcf0155..6713908d8 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala @@ -46,17 +46,21 @@ trait GhostExprTyping extends BaseTyping { this: TypeInfoImpl => // check that `thn` and `els` have a common type mergeableTypes.errors(exprType(thn), exprType(els))(expr) - case PForall(vars, triggers, body) => + case n@PForall(vars, triggers, body) => // check whether all triggers are valid and consistent validTriggers(vars, triggers) ++ // check that the quantifier `body` is either Boolean or an assertion - assignableToSpec(body) + assignableToSpec(body) ++ + // check that the user provided triggers when running with --requireTriggers + error(n, "found a quantifier without triggers.", config.requireTriggers && triggers.isEmpty) - case PExists(vars, triggers, body) => + case n@PExists(vars, triggers, body) => // check whether all triggers are valid and consistent validTriggers(vars, triggers) ++ // check that the quantifier `body` is Boolean - assignableToSpec(body) ++ assignableTo.errors(exprType(body), BooleanT)(expr) + assignableToSpec(body) ++ assignableTo.errors(exprType(body), BooleanT)(expr) ++ + // check that the user provided triggers when running with --requireTriggers + error(n, "found a quantifier without triggers.", config.requireTriggers && triggers.isEmpty) case n: PImplication => isExpr(n.left).out ++ isExpr(n.right).out ++ From 4389cb03fbde2276026c8df39b4c77fbf4824b5c Mon Sep 17 00:00:00 2001 From: viper-admin <59963956+viper-admin@users.noreply.github.com> Date: Sun, 24 Sep 2023 22:07:19 +0200 Subject: [PATCH 51/54] Updates submodules (#680) Co-authored-by: jcp19 --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index 3359baca9..6a70820f2 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit 3359baca924861f5858cda8651b342c584f20edd +Subproject commit 6a70820f2a7516245e5ead2e733d30e8586ed584 From 2e8205a89b2352ce63140fa63c138adc22e74689 Mon Sep 17 00:00:00 2001 From: viper-admin <59963956+viper-admin@users.noreply.github.com> Date: Thu, 28 Sep 2023 16:16:43 +0200 Subject: [PATCH 52/54] Updates submodules (#682) Co-authored-by: jcp19 --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index 6a70820f2..e68d7d2d8 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit 6a70820f2a7516245e5ead2e733d30e8586ed584 +Subproject commit e68d7d2d8cc04f4a95d9846682425dd6e3b07ff4 From 61d0bd916d5c1b183110976e517303ca8ab88289 Mon Sep 17 00:00:00 2001 From: Felix Wolf <60103963+Felalolf@users.noreply.github.com> Date: Tue, 3 Oct 2023 10:43:51 +0200 Subject: [PATCH 53/54] Several ADT improvements (#687) * fixed reordering issue, type of constructors, implicit conversion of argument, some incorrect handling of imported adts, conversion issues with ghost data types, name space conflicts with adt types. I changed the representation of adt types, which I still need to double check. * fixed some issues * adapted parser to parse adts without field names * fixed some bugs, also fixed error message with duplicate fields and clauses for adts * fixed intendation, added comment, removed todo --- build.sbt | 2 +- src/main/antlr4/GobraParser.g4 | 4 +- .../java/viper/gobra/frontend/GobraLexer.java | 634 ++- .../viper/gobra/frontend/GobraParser.java | 5042 +++++++++-------- .../frontend/GobraParserBaseVisitor.java | 9 +- .../gobra/frontend/GobraParserVisitor.java | 8 +- .../viper/gobra/ast/frontend/AstPattern.scala | 1 + .../gobra/ast/internal/PrettyPrinter.scala | 7 +- .../viper/gobra/ast/internal/Program.scala | 67 +- .../scala/viper/gobra/frontend/Desugar.scala | 242 +- .../gobra/frontend/ParseTreeTranslator.scala | 53 +- .../frontend/info/base/SymbolTable.scala | 12 +- .../viper/gobra/frontend/info/base/Type.scala | 18 +- .../property/Assignability.scala | 18 +- .../implementation/property/Implements.scala | 7 +- .../property/TypeIdentity.scala | 1 - .../implementation/property/TypeMerging.scala | 70 +- .../resolution/AdvancedMemberSet.scala | 2 + .../resolution/AmbiguityResolution.scala | 9 +- .../resolution/MemberResolution.scala | 60 +- .../resolution/NameResolution.scala | 55 +- .../implementation/typing/ExprTyping.scala | 13 +- .../info/implementation/typing/IdTyping.scala | 2 +- .../implementation/typing/TypeTyping.scala | 6 +- .../typing/ghost/GhostExprTyping.scala | 20 +- .../typing/ghost/GhostIdTyping.scala | 12 +- .../typing/ghost/GhostMiscTyping.scala | 14 +- .../typing/ghost/GhostStmtTyping.scala | 2 +- .../typing/ghost/GhostTypeTyping.scala | 27 +- .../encodings/adts/AdtEncoding.scala | 76 +- .../sequences/SequenceEncoding.scala | 18 +- .../encodings/sets/SetEncoding.scala | 24 +- .../gobra/translator/util/ViperWriter.scala | 4 +- .../resources/regressions/issues/000589.gobra | 26 + .../resources/regressions/issues/000641.gobra | 19 + .../resources/regressions/issues/000655.gobra | 23 +- .../regressions/issues/000655/pkg/f.gobra | 8 + .../resources/regressions/issues/000685.gobra | 23 + .../regressions/issues/000686-1.gobra | 23 + .../regressions/issues/000686-2.gobra | 18 + .../regressions/issues/000686-3.gobra | 19 + .../regressions/issues/000686-4.gobra | 16 + .../regressions/issues/000686-5.gobra | 16 + .../regressions/issues/000686-6.gobra | 12 + .../ast/InternalPrettyPrinterUnitTests.scala | 77 +- 45 files changed, 3622 insertions(+), 3197 deletions(-) create mode 100644 src/test/resources/regressions/issues/000589.gobra create mode 100644 src/test/resources/regressions/issues/000641.gobra create mode 100644 src/test/resources/regressions/issues/000685.gobra create mode 100644 src/test/resources/regressions/issues/000686-1.gobra create mode 100644 src/test/resources/regressions/issues/000686-2.gobra create mode 100644 src/test/resources/regressions/issues/000686-3.gobra create mode 100644 src/test/resources/regressions/issues/000686-4.gobra create mode 100644 src/test/resources/regressions/issues/000686-5.gobra create mode 100644 src/test/resources/regressions/issues/000686-6.gobra diff --git a/build.sbt b/build.sbt index ce407ccc9..1451ceaad 100644 --- a/build.sbt +++ b/build.sbt @@ -34,7 +34,7 @@ lazy val gobra = (project in file(".")) libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.9", // for SystemUtils libraryDependencies += "org.apache.commons" % "commons-text" % "1.9", // for escaping strings in parser preprocessor libraryDependencies += "commons-codec" % "commons-codec" % "1.15", // for obtaining the hex encoding of a string - libraryDependencies += "org.antlr" % "antlr4-runtime" % "4.12.0", + libraryDependencies += "org.antlr" % "antlr4-runtime" % "4.13.0", libraryDependencies += "org.scalaz" %% "scalaz-core" % "7.3.7", // used for EitherT scalacOptions ++= Seq( diff --git a/src/main/antlr4/GobraParser.g4 b/src/main/antlr4/GobraParser.g4 index c37e545ba..e6cb9b52d 100644 --- a/src/main/antlr4/GobraParser.g4 +++ b/src/main/antlr4/GobraParser.g4 @@ -150,7 +150,9 @@ domainClause: FUNC IDENTIFIER signature | AXIOM L_CURLY expression eos R_CURLY; adtType: ADT L_CURLY (adtClause eos)* R_CURLY; -adtClause: IDENTIFIER L_CURLY (fieldDecl eos)* R_CURLY; +adtClause: IDENTIFIER L_CURLY (adtFieldDecl eos)* R_CURLY; + +adtFieldDecl: identifierList? type_; ghostSliceType: GHOST L_BRACKET R_BRACKET elementType; diff --git a/src/main/java/viper/gobra/frontend/GobraLexer.java b/src/main/java/viper/gobra/frontend/GobraLexer.java index 13027367a..67e5267c7 100644 --- a/src/main/java/viper/gobra/frontend/GobraLexer.java +++ b/src/main/java/viper/gobra/frontend/GobraLexer.java @@ -1,4 +1,4 @@ -// Generated from src/main/antlr4/GobraLexer.g4 by ANTLR 4.12.0 +// Generated from src/main/antlr4/GobraLexer.g4 by ANTLR 4.13.0 package viper.gobra.frontend; import org.antlr.v4.runtime.Lexer; import org.antlr.v4.runtime.CharStream; @@ -11,7 +11,7 @@ @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) public class GobraLexer extends Lexer { - static { RuntimeMetaData.checkVersion("4.12.0", RuntimeMetaData.VERSION); } + static { RuntimeMetaData.checkVersion("4.13.0", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = @@ -437,7 +437,7 @@ private boolean DECIMAL_FLOAT_LIT_sempred(RuleContext _localctx, int predIndex) "\u0000PPpp\u0002\u0000++--\u0001\u0000``\u0002\u0000\"\"\\\\\u0002\u0000"+ "\t\t \u0002\u0000\n\n\r\r\u0003\u0000\n\n\r\r\'\'\t\u0000\"\"\'\'\\\\"+ "abffnnrrttvv\u0001\u000007\u0003\u000009AFaf\u0001\u000001\u0002\u0000"+ - "EEee>\u000009\u0660\u0669\u06f0\u06f9\u07c0\u07c9\u0966\u096f\u09e6\u09ef"+ + "EEee@\u000009\u0660\u0669\u06f0\u06f9\u07c0\u07c9\u0966\u096f\u09e6\u09ef"+ "\u0a66\u0a6f\u0ae6\u0aef\u0b66\u0b6f\u0be6\u0bef\u0c66\u0c6f\u0ce6\u0cef"+ "\u0d66\u0d6f\u0de6\u0def\u0e50\u0e59\u0ed0\u0ed9\u0f20\u0f29\u1040\u1049"+ "\u1090\u1099\u17e0\u17e9\u1810\u1819\u1946\u194f\u19d0\u19d9\u1a80\u1a89"+ @@ -450,115 +450,116 @@ private boolean DECIMAL_FLOAT_LIT_sempred(RuleContext _localctx, int predIndex) "\u8001\u1459\u8001\u14d0\u8001\u14d9\u8001\u1650\u8001\u1659\u8001\u16c0"+ "\u8001\u16c9\u8001\u1730\u8001\u1739\u8001\u18e0\u8001\u18e9\u8001\u1950"+ "\u8001\u1959\u8001\u1c50\u8001\u1c59\u8001\u1d50\u8001\u1d59\u8001\u1da0"+ - "\u8001\u1da9\u8001\u6a60\u8001\u6a69\u8001\u6ac0\u8001\u6ac9\u8001\u6b50"+ - "\u8001\u6b59\u8001\ud7ce\u8001\ud7ff\u8001\ue140\u8001\ue149\u8001\ue2f0"+ - "\u8001\ue2f9\u8001\ue950\u8001\ue959\u8001\ufbf0\u8001\ufbf9\u0288\u0000"+ - "AZaz\u00aa\u00aa\u00b5\u00b5\u00ba\u00ba\u00c0\u00d6\u00d8\u00f6\u00f8"+ - "\u02c1\u02c6\u02d1\u02e0\u02e4\u02ec\u02ec\u02ee\u02ee\u0370\u0374\u0376"+ - "\u0377\u037a\u037d\u037f\u037f\u0386\u0386\u0388\u038a\u038c\u038c\u038e"+ - "\u03a1\u03a3\u03f5\u03f7\u0481\u048a\u052f\u0531\u0556\u0559\u0559\u0560"+ - "\u0588\u05d0\u05ea\u05ef\u05f2\u0620\u064a\u066e\u066f\u0671\u06d3\u06d5"+ - "\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa\u06fc\u06ff\u06ff\u0710\u0710\u0712"+ - "\u072f\u074d\u07a5\u07b1\u07b1\u07ca\u07ea\u07f4\u07f5\u07fa\u07fa\u0800"+ - "\u0815\u081a\u081a\u0824\u0824\u0828\u0828\u0840\u0858\u0860\u086a\u0870"+ - "\u0887\u0889\u088e\u08a0\u08c9\u0904\u0939\u093d\u093d\u0950\u0950\u0958"+ - "\u0961\u0971\u0980\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2"+ - "\u09b2\u09b6\u09b9\u09bd\u09bd\u09ce\u09ce\u09dc\u09dd\u09df\u09e1\u09f0"+ - "\u09f1\u09fc\u09fc\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a\u0a30\u0a32"+ - "\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72\u0a74\u0a85"+ - "\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5\u0ab9\u0abd"+ - "\u0abd\u0ad0\u0ad0\u0ae0\u0ae1\u0af9\u0af9\u0b05\u0b0c\u0b0f\u0b10\u0b13"+ - "\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b35\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f"+ - "\u0b61\u0b71\u0b71\u0b83\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99"+ - "\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb9\u0bd0"+ - "\u0bd0\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c39\u0c3d\u0c3d\u0c58"+ - "\u0c5a\u0c5d\u0c5d\u0c60\u0c61\u0c80\u0c80\u0c85\u0c8c\u0c8e\u0c90\u0c92"+ - "\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cbd\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1"+ - "\u0cf2\u0d04\u0d0c\u0d0e\u0d10\u0d12\u0d3a\u0d3d\u0d3d\u0d4e\u0d4e\u0d54"+ - "\u0d56\u0d5f\u0d61\u0d7a\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3\u0dbb\u0dbd"+ - "\u0dbd\u0dc0\u0dc6\u0e01\u0e30\u0e32\u0e33\u0e40\u0e46\u0e81\u0e82\u0e84"+ - "\u0e84\u0e86\u0e8a\u0e8c\u0ea3\u0ea5\u0ea5\u0ea7\u0eb0\u0eb2\u0eb3\u0ebd"+ - "\u0ebd\u0ec0\u0ec4\u0ec6\u0ec6\u0edc\u0edf\u0f00\u0f00\u0f40\u0f47\u0f49"+ - "\u0f6c\u0f88\u0f8c\u1000\u102a\u103f\u103f\u1050\u1055\u105a\u105d\u1061"+ - "\u1061\u1065\u1066\u106e\u1070\u1075\u1081\u108e\u108e\u10a0\u10c5\u10c7"+ - "\u10c7\u10cd\u10cd\u10d0\u10fa\u10fc\u1248\u124a\u124d\u1250\u1256\u1258"+ - "\u1258\u125a\u125d\u1260\u1288\u128a\u128d\u1290\u12b0\u12b2\u12b5\u12b8"+ - "\u12be\u12c0\u12c0\u12c2\u12c5\u12c8\u12d6\u12d8\u1310\u1312\u1315\u1318"+ - "\u135a\u1380\u138f\u13a0\u13f5\u13f8\u13fd\u1401\u166c\u166f\u167f\u1681"+ - "\u169a\u16a0\u16ea\u16f1\u16f8\u1700\u1711\u171f\u1731\u1740\u1751\u1760"+ - "\u176c\u176e\u1770\u1780\u17b3\u17d7\u17d7\u17dc\u17dc\u1820\u1878\u1880"+ - "\u1884\u1887\u18a8\u18aa\u18aa\u18b0\u18f5\u1900\u191e\u1950\u196d\u1970"+ - "\u1974\u1980\u19ab\u19b0\u19c9\u1a00\u1a16\u1a20\u1a54\u1aa7\u1aa7\u1b05"+ - "\u1b33\u1b45\u1b4c\u1b83\u1ba0\u1bae\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d"+ - "\u1c4f\u1c5a\u1c7d\u1c80\u1c88\u1c90\u1cba\u1cbd\u1cbf\u1ce9\u1cec\u1cee"+ - "\u1cf3\u1cf5\u1cf6\u1cfa\u1cfa\u1d00\u1dbf\u1e00\u1f15\u1f18\u1f1d\u1f20"+ - "\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f"+ - "\u1f7d\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0"+ - "\u1fd3\u1fd6\u1fdb\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u2071\u2071\u207f"+ - "\u207f\u2090\u209c\u2102\u2102\u2107\u2107\u210a\u2113\u2115\u2115\u2119"+ - "\u211d\u2124\u2124\u2126\u2126\u2128\u2128\u212a\u212d\u212f\u2139\u213c"+ - "\u213f\u2145\u2149\u214e\u214e\u2183\u2184\u2c00\u2ce4\u2ceb\u2cee\u2cf2"+ - "\u2cf3\u2d00\u2d25\u2d27\u2d27\u2d2d\u2d2d\u2d30\u2d67\u2d6f\u2d6f\u2d80"+ - "\u2d96\u2da0\u2da6\u2da8\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8"+ - "\u2dce\u2dd0\u2dd6\u2dd8\u2dde\u2e2f\u2e2f\u3005\u3006\u3031\u3035\u303b"+ - "\u303c\u3041\u3096\u309d\u309f\u30a1\u30fa\u30fc\u30ff\u3105\u312f\u3131"+ - "\u318e\u31a0\u31bf\u31f0\u31ff\u3400\u4dbf\u4e00\u8000\ua48c\u8000\ua4d0"+ - "\u8000\ua4fd\u8000\ua500\u8000\ua60c\u8000\ua610\u8000\ua61f\u8000\ua62a"+ - "\u8000\ua62b\u8000\ua640\u8000\ua66e\u8000\ua67f\u8000\ua69d\u8000\ua6a0"+ - "\u8000\ua6e5\u8000\ua717\u8000\ua71f\u8000\ua722\u8000\ua788\u8000\ua78b"+ - "\u8000\ua7ca\u8000\ua7d0\u8000\ua7d1\u8000\ua7d3\u8000\ua7d3\u8000\ua7d5"+ - "\u8000\ua7d9\u8000\ua7f2\u8000\ua801\u8000\ua803\u8000\ua805\u8000\ua807"+ - "\u8000\ua80a\u8000\ua80c\u8000\ua822\u8000\ua840\u8000\ua873\u8000\ua882"+ - "\u8000\ua8b3\u8000\ua8f2\u8000\ua8f7\u8000\ua8fb\u8000\ua8fb\u8000\ua8fd"+ - "\u8000\ua8fe\u8000\ua90a\u8000\ua925\u8000\ua930\u8000\ua946\u8000\ua960"+ - "\u8000\ua97c\u8000\ua984\u8000\ua9b2\u8000\ua9cf\u8000\ua9cf\u8000\ua9e0"+ - "\u8000\ua9e4\u8000\ua9e6\u8000\ua9ef\u8000\ua9fa\u8000\ua9fe\u8000\uaa00"+ - "\u8000\uaa28\u8000\uaa40\u8000\uaa42\u8000\uaa44\u8000\uaa4b\u8000\uaa60"+ - "\u8000\uaa76\u8000\uaa7a\u8000\uaa7a\u8000\uaa7e\u8000\uaaaf\u8000\uaab1"+ - "\u8000\uaab1\u8000\uaab5\u8000\uaab6\u8000\uaab9\u8000\uaabd\u8000\uaac0"+ - "\u8000\uaac0\u8000\uaac2\u8000\uaac2\u8000\uaadb\u8000\uaadd\u8000\uaae0"+ - "\u8000\uaaea\u8000\uaaf2\u8000\uaaf4\u8000\uab01\u8000\uab06\u8000\uab09"+ - "\u8000\uab0e\u8000\uab11\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28"+ - "\u8000\uab2e\u8000\uab30\u8000\uab5a\u8000\uab5c\u8000\uab69\u8000\uab70"+ - "\u8000\uabe2\u8000\uac00\u8000\ud7a3\u8000\ud7b0\u8000\ud7c6\u8000\ud7cb"+ - "\u8000\ud7fb\u8000\uf900\u8000\ufa6d\u8000\ufa70\u8000\ufad9\u8000\ufb00"+ - "\u8000\ufb06\u8000\ufb13\u8000\ufb17\u8000\ufb1d\u8000\ufb1d\u8000\ufb1f"+ - "\u8000\ufb28\u8000\ufb2a\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e"+ - "\u8000\ufb3e\u8000\ufb40\u8000\ufb41\u8000\ufb43\u8000\ufb44\u8000\ufb46"+ - "\u8000\ufbb1\u8000\ufbd3\u8000\ufd3d\u8000\ufd50\u8000\ufd8f\u8000\ufd92"+ - "\u8000\ufdc7\u8000\ufdf0\u8000\ufdfb\u8000\ufe70\u8000\ufe74\u8000\ufe76"+ - "\u8000\ufefc\u8000\uff21\u8000\uff3a\u8000\uff41\u8000\uff5a\u8000\uff66"+ - "\u8000\uffbe\u8000\uffc2\u8000\uffc7\u8000\uffca\u8000\uffcf\u8000\uffd2"+ - "\u8000\uffd7\u8000\uffda\u8000\uffdc\u8001\u0000\u8001\u000b\u8001\r\u8001"+ - "&\u8001(\u8001:\u8001<\u8001=\u8001?\u8001M\u8001P\u8001]\u8001\u0080"+ - "\u8001\u00fa\u8001\u0280\u8001\u029c\u8001\u02a0\u8001\u02d0\u8001\u0300"+ - "\u8001\u031f\u8001\u032d\u8001\u0340\u8001\u0342\u8001\u0349\u8001\u0350"+ - "\u8001\u0375\u8001\u0380\u8001\u039d\u8001\u03a0\u8001\u03c3\u8001\u03c8"+ - "\u8001\u03cf\u8001\u0400\u8001\u049d\u8001\u04b0\u8001\u04d3\u8001\u04d8"+ - "\u8001\u04fb\u8001\u0500\u8001\u0527\u8001\u0530\u8001\u0563\u8001\u0570"+ - "\u8001\u057a\u8001\u057c\u8001\u058a\u8001\u058c\u8001\u0592\u8001\u0594"+ - "\u8001\u0595\u8001\u0597\u8001\u05a1\u8001\u05a3\u8001\u05b1\u8001\u05b3"+ - "\u8001\u05b9\u8001\u05bb\u8001\u05bc\u8001\u0600\u8001\u0736\u8001\u0740"+ - "\u8001\u0755\u8001\u0760\u8001\u0767\u8001\u0780\u8001\u0785\u8001\u0787"+ - "\u8001\u07b0\u8001\u07b2\u8001\u07ba\u8001\u0800\u8001\u0805\u8001\u0808"+ - "\u8001\u0808\u8001\u080a\u8001\u0835\u8001\u0837\u8001\u0838\u8001\u083c"+ - "\u8001\u083c\u8001\u083f\u8001\u0855\u8001\u0860\u8001\u0876\u8001\u0880"+ - "\u8001\u089e\u8001\u08e0\u8001\u08f2\u8001\u08f4\u8001\u08f5\u8001\u0900"+ - "\u8001\u0915\u8001\u0920\u8001\u0939\u8001\u0980\u8001\u09b7\u8001\u09be"+ - "\u8001\u09bf\u8001\u0a00\u8001\u0a00\u8001\u0a10\u8001\u0a13\u8001\u0a15"+ - "\u8001\u0a17\u8001\u0a19\u8001\u0a35\u8001\u0a60\u8001\u0a7c\u8001\u0a80"+ - "\u8001\u0a9c\u8001\u0ac0\u8001\u0ac7\u8001\u0ac9\u8001\u0ae4\u8001\u0b00"+ - "\u8001\u0b35\u8001\u0b40\u8001\u0b55\u8001\u0b60\u8001\u0b72\u8001\u0b80"+ - "\u8001\u0b91\u8001\u0c00\u8001\u0c48\u8001\u0c80\u8001\u0cb2\u8001\u0cc0"+ - "\u8001\u0cf2\u8001\u0d00\u8001\u0d23\u8001\u0e80\u8001\u0ea9\u8001\u0eb0"+ - "\u8001\u0eb1\u8001\u0f00\u8001\u0f1c\u8001\u0f27\u8001\u0f27\u8001\u0f30"+ - "\u8001\u0f45\u8001\u0f70\u8001\u0f81\u8001\u0fb0\u8001\u0fc4\u8001\u0fe0"+ - "\u8001\u0ff6\u8001\u1003\u8001\u1037\u8001\u1071\u8001\u1072\u8001\u1075"+ - "\u8001\u1075\u8001\u1083\u8001\u10af\u8001\u10d0\u8001\u10e8\u8001\u1103"+ - "\u8001\u1126\u8001\u1144\u8001\u1144\u8001\u1147\u8001\u1147\u8001\u1150"+ - "\u8001\u1172\u8001\u1176\u8001\u1176\u8001\u1183\u8001\u11b2\u8001\u11c1"+ - "\u8001\u11c4\u8001\u11da\u8001\u11da\u8001\u11dc\u8001\u11dc\u8001\u1200"+ - "\u8001\u1211\u8001\u1213\u8001\u122b\u8001\u1280\u8001\u1286\u8001\u1288"+ + "\u8001\u1da9\u8001\u1f50\u8001\u1f59\u8001\u6a60\u8001\u6a69\u8001\u6ac0"+ + "\u8001\u6ac9\u8001\u6b50\u8001\u6b59\u8001\ud7ce\u8001\ud7ff\u8001\ue140"+ + "\u8001\ue149\u8001\ue2f0\u8001\ue2f9\u8001\ue4f0\u8001\ue4f9\u8001\ue950"+ + "\u8001\ue959\u8001\ufbf0\u8001\ufbf9\u0293\u0000AZaz\u00aa\u00aa\u00b5"+ + "\u00b5\u00ba\u00ba\u00c0\u00d6\u00d8\u00f6\u00f8\u02c1\u02c6\u02d1\u02e0"+ + "\u02e4\u02ec\u02ec\u02ee\u02ee\u0370\u0374\u0376\u0377\u037a\u037d\u037f"+ + "\u037f\u0386\u0386\u0388\u038a\u038c\u038c\u038e\u03a1\u03a3\u03f5\u03f7"+ + "\u0481\u048a\u052f\u0531\u0556\u0559\u0559\u0560\u0588\u05d0\u05ea\u05ef"+ + "\u05f2\u0620\u064a\u066e\u066f\u0671\u06d3\u06d5\u06d5\u06e5\u06e6\u06ee"+ + "\u06ef\u06fa\u06fc\u06ff\u06ff\u0710\u0710\u0712\u072f\u074d\u07a5\u07b1"+ + "\u07b1\u07ca\u07ea\u07f4\u07f5\u07fa\u07fa\u0800\u0815\u081a\u081a\u0824"+ + "\u0824\u0828\u0828\u0840\u0858\u0860\u086a\u0870\u0887\u0889\u088e\u08a0"+ + "\u08c9\u0904\u0939\u093d\u093d\u0950\u0950\u0958\u0961\u0971\u0980\u0985"+ + "\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2\u09b2\u09b6\u09b9\u09bd"+ + "\u09bd\u09ce\u09ce\u09dc\u09dd\u09df\u09e1\u09f0\u09f1\u09fc\u09fc\u0a05"+ + "\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38"+ + "\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72\u0a74\u0a85\u0a8d\u0a8f\u0a91\u0a93"+ + "\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5\u0ab9\u0abd\u0abd\u0ad0\u0ad0\u0ae0"+ + "\u0ae1\u0af9\u0af9\u0b05\u0b0c\u0b0f\u0b10\u0b13\u0b28\u0b2a\u0b30\u0b32"+ + "\u0b33\u0b35\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f\u0b61\u0b71\u0b71\u0b83"+ + "\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99\u0b9a\u0b9c\u0b9c\u0b9e"+ + "\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb9\u0bd0\u0bd0\u0c05\u0c0c\u0c0e"+ + "\u0c10\u0c12\u0c28\u0c2a\u0c39\u0c3d\u0c3d\u0c58\u0c5a\u0c5d\u0c5d\u0c60"+ + "\u0c61\u0c80\u0c80\u0c85\u0c8c\u0c8e\u0c90\u0c92\u0ca8\u0caa\u0cb3\u0cb5"+ + "\u0cb9\u0cbd\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04\u0d0c\u0d0e"+ + "\u0d10\u0d12\u0d3a\u0d3d\u0d3d\u0d4e\u0d4e\u0d54\u0d56\u0d5f\u0d61\u0d7a"+ + "\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3\u0dbb\u0dbd\u0dbd\u0dc0\u0dc6\u0e01"+ + "\u0e30\u0e32\u0e33\u0e40\u0e46\u0e81\u0e82\u0e84\u0e84\u0e86\u0e8a\u0e8c"+ + "\u0ea3\u0ea5\u0ea5\u0ea7\u0eb0\u0eb2\u0eb3\u0ebd\u0ebd\u0ec0\u0ec4\u0ec6"+ + "\u0ec6\u0edc\u0edf\u0f00\u0f00\u0f40\u0f47\u0f49\u0f6c\u0f88\u0f8c\u1000"+ + "\u102a\u103f\u103f\u1050\u1055\u105a\u105d\u1061\u1061\u1065\u1066\u106e"+ + "\u1070\u1075\u1081\u108e\u108e\u10a0\u10c5\u10c7\u10c7\u10cd\u10cd\u10d0"+ + "\u10fa\u10fc\u1248\u124a\u124d\u1250\u1256\u1258\u1258\u125a\u125d\u1260"+ + "\u1288\u128a\u128d\u1290\u12b0\u12b2\u12b5\u12b8\u12be\u12c0\u12c0\u12c2"+ + "\u12c5\u12c8\u12d6\u12d8\u1310\u1312\u1315\u1318\u135a\u1380\u138f\u13a0"+ + "\u13f5\u13f8\u13fd\u1401\u166c\u166f\u167f\u1681\u169a\u16a0\u16ea\u16f1"+ + "\u16f8\u1700\u1711\u171f\u1731\u1740\u1751\u1760\u176c\u176e\u1770\u1780"+ + "\u17b3\u17d7\u17d7\u17dc\u17dc\u1820\u1878\u1880\u1884\u1887\u18a8\u18aa"+ + "\u18aa\u18b0\u18f5\u1900\u191e\u1950\u196d\u1970\u1974\u1980\u19ab\u19b0"+ + "\u19c9\u1a00\u1a16\u1a20\u1a54\u1aa7\u1aa7\u1b05\u1b33\u1b45\u1b4c\u1b83"+ + "\u1ba0\u1bae\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d\u1c4f\u1c5a\u1c7d\u1c80"+ + "\u1c88\u1c90\u1cba\u1cbd\u1cbf\u1ce9\u1cec\u1cee\u1cf3\u1cf5\u1cf6\u1cfa"+ + "\u1cfa\u1d00\u1dbf\u1e00\u1f15\u1f18\u1f1d\u1f20\u1f45\u1f48\u1f4d\u1f50"+ + "\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f\u1f7d\u1f80\u1fb4\u1fb6"+ + "\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0\u1fd3\u1fd6\u1fdb\u1fe0"+ + "\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u2071\u2071\u207f\u207f\u2090\u209c\u2102"+ + "\u2102\u2107\u2107\u210a\u2113\u2115\u2115\u2119\u211d\u2124\u2124\u2126"+ + "\u2126\u2128\u2128\u212a\u212d\u212f\u2139\u213c\u213f\u2145\u2149\u214e"+ + "\u214e\u2183\u2184\u2c00\u2ce4\u2ceb\u2cee\u2cf2\u2cf3\u2d00\u2d25\u2d27"+ + "\u2d27\u2d2d\u2d2d\u2d30\u2d67\u2d6f\u2d6f\u2d80\u2d96\u2da0\u2da6\u2da8"+ + "\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8\u2dce\u2dd0\u2dd6\u2dd8"+ + "\u2dde\u2e2f\u2e2f\u3005\u3006\u3031\u3035\u303b\u303c\u3041\u3096\u309d"+ + "\u309f\u30a1\u30fa\u30fc\u30ff\u3105\u312f\u3131\u318e\u31a0\u31bf\u31f0"+ + "\u31ff\u3400\u4dbf\u4e00\u8000\ua48c\u8000\ua4d0\u8000\ua4fd\u8000\ua500"+ + "\u8000\ua60c\u8000\ua610\u8000\ua61f\u8000\ua62a\u8000\ua62b\u8000\ua640"+ + "\u8000\ua66e\u8000\ua67f\u8000\ua69d\u8000\ua6a0\u8000\ua6e5\u8000\ua717"+ + "\u8000\ua71f\u8000\ua722\u8000\ua788\u8000\ua78b\u8000\ua7ca\u8000\ua7d0"+ + "\u8000\ua7d1\u8000\ua7d3\u8000\ua7d3\u8000\ua7d5\u8000\ua7d9\u8000\ua7f2"+ + "\u8000\ua801\u8000\ua803\u8000\ua805\u8000\ua807\u8000\ua80a\u8000\ua80c"+ + "\u8000\ua822\u8000\ua840\u8000\ua873\u8000\ua882\u8000\ua8b3\u8000\ua8f2"+ + "\u8000\ua8f7\u8000\ua8fb\u8000\ua8fb\u8000\ua8fd\u8000\ua8fe\u8000\ua90a"+ + "\u8000\ua925\u8000\ua930\u8000\ua946\u8000\ua960\u8000\ua97c\u8000\ua984"+ + "\u8000\ua9b2\u8000\ua9cf\u8000\ua9cf\u8000\ua9e0\u8000\ua9e4\u8000\ua9e6"+ + "\u8000\ua9ef\u8000\ua9fa\u8000\ua9fe\u8000\uaa00\u8000\uaa28\u8000\uaa40"+ + "\u8000\uaa42\u8000\uaa44\u8000\uaa4b\u8000\uaa60\u8000\uaa76\u8000\uaa7a"+ + "\u8000\uaa7a\u8000\uaa7e\u8000\uaaaf\u8000\uaab1\u8000\uaab1\u8000\uaab5"+ + "\u8000\uaab6\u8000\uaab9\u8000\uaabd\u8000\uaac0\u8000\uaac0\u8000\uaac2"+ + "\u8000\uaac2\u8000\uaadb\u8000\uaadd\u8000\uaae0\u8000\uaaea\u8000\uaaf2"+ + "\u8000\uaaf4\u8000\uab01\u8000\uab06\u8000\uab09\u8000\uab0e\u8000\uab11"+ + "\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28\u8000\uab2e\u8000\uab30"+ + "\u8000\uab5a\u8000\uab5c\u8000\uab69\u8000\uab70\u8000\uabe2\u8000\uac00"+ + "\u8000\ud7a3\u8000\ud7b0\u8000\ud7c6\u8000\ud7cb\u8000\ud7fb\u8000\uf900"+ + "\u8000\ufa6d\u8000\ufa70\u8000\ufad9\u8000\ufb00\u8000\ufb06\u8000\ufb13"+ + "\u8000\ufb17\u8000\ufb1d\u8000\ufb1d\u8000\ufb1f\u8000\ufb28\u8000\ufb2a"+ + "\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e\u8000\ufb3e\u8000\ufb40"+ + "\u8000\ufb41\u8000\ufb43\u8000\ufb44\u8000\ufb46\u8000\ufbb1\u8000\ufbd3"+ + "\u8000\ufd3d\u8000\ufd50\u8000\ufd8f\u8000\ufd92\u8000\ufdc7\u8000\ufdf0"+ + "\u8000\ufdfb\u8000\ufe70\u8000\ufe74\u8000\ufe76\u8000\ufefc\u8000\uff21"+ + "\u8000\uff3a\u8000\uff41\u8000\uff5a\u8000\uff66\u8000\uffbe\u8000\uffc2"+ + "\u8000\uffc7\u8000\uffca\u8000\uffcf\u8000\uffd2\u8000\uffd7\u8000\uffda"+ + "\u8000\uffdc\u8001\u0000\u8001\u000b\u8001\r\u8001&\u8001(\u8001:\u8001"+ + "<\u8001=\u8001?\u8001M\u8001P\u8001]\u8001\u0080\u8001\u00fa\u8001\u0280"+ + "\u8001\u029c\u8001\u02a0\u8001\u02d0\u8001\u0300\u8001\u031f\u8001\u032d"+ + "\u8001\u0340\u8001\u0342\u8001\u0349\u8001\u0350\u8001\u0375\u8001\u0380"+ + "\u8001\u039d\u8001\u03a0\u8001\u03c3\u8001\u03c8\u8001\u03cf\u8001\u0400"+ + "\u8001\u049d\u8001\u04b0\u8001\u04d3\u8001\u04d8\u8001\u04fb\u8001\u0500"+ + "\u8001\u0527\u8001\u0530\u8001\u0563\u8001\u0570\u8001\u057a\u8001\u057c"+ + "\u8001\u058a\u8001\u058c\u8001\u0592\u8001\u0594\u8001\u0595\u8001\u0597"+ + "\u8001\u05a1\u8001\u05a3\u8001\u05b1\u8001\u05b3\u8001\u05b9\u8001\u05bb"+ + "\u8001\u05bc\u8001\u0600\u8001\u0736\u8001\u0740\u8001\u0755\u8001\u0760"+ + "\u8001\u0767\u8001\u0780\u8001\u0785\u8001\u0787\u8001\u07b0\u8001\u07b2"+ + "\u8001\u07ba\u8001\u0800\u8001\u0805\u8001\u0808\u8001\u0808\u8001\u080a"+ + "\u8001\u0835\u8001\u0837\u8001\u0838\u8001\u083c\u8001\u083c\u8001\u083f"+ + "\u8001\u0855\u8001\u0860\u8001\u0876\u8001\u0880\u8001\u089e\u8001\u08e0"+ + "\u8001\u08f2\u8001\u08f4\u8001\u08f5\u8001\u0900\u8001\u0915\u8001\u0920"+ + "\u8001\u0939\u8001\u0980\u8001\u09b7\u8001\u09be\u8001\u09bf\u8001\u0a00"+ + "\u8001\u0a00\u8001\u0a10\u8001\u0a13\u8001\u0a15\u8001\u0a17\u8001\u0a19"+ + "\u8001\u0a35\u8001\u0a60\u8001\u0a7c\u8001\u0a80\u8001\u0a9c\u8001\u0ac0"+ + "\u8001\u0ac7\u8001\u0ac9\u8001\u0ae4\u8001\u0b00\u8001\u0b35\u8001\u0b40"+ + "\u8001\u0b55\u8001\u0b60\u8001\u0b72\u8001\u0b80\u8001\u0b91\u8001\u0c00"+ + "\u8001\u0c48\u8001\u0c80\u8001\u0cb2\u8001\u0cc0\u8001\u0cf2\u8001\u0d00"+ + "\u8001\u0d23\u8001\u0e80\u8001\u0ea9\u8001\u0eb0\u8001\u0eb1\u8001\u0f00"+ + "\u8001\u0f1c\u8001\u0f27\u8001\u0f27\u8001\u0f30\u8001\u0f45\u8001\u0f70"+ + "\u8001\u0f81\u8001\u0fb0\u8001\u0fc4\u8001\u0fe0\u8001\u0ff6\u8001\u1003"+ + "\u8001\u1037\u8001\u1071\u8001\u1072\u8001\u1075\u8001\u1075\u8001\u1083"+ + "\u8001\u10af\u8001\u10d0\u8001\u10e8\u8001\u1103\u8001\u1126\u8001\u1144"+ + "\u8001\u1144\u8001\u1147\u8001\u1147\u8001\u1150\u8001\u1172\u8001\u1176"+ + "\u8001\u1176\u8001\u1183\u8001\u11b2\u8001\u11c1\u8001\u11c4\u8001\u11da"+ + "\u8001\u11da\u8001\u11dc\u8001\u11dc\u8001\u1200\u8001\u1211\u8001\u1213"+ + "\u8001\u122b\u8001\u123f\u8001\u1240\u8001\u1280\u8001\u1286\u8001\u1288"+ "\u8001\u1288\u8001\u128a\u8001\u128d\u8001\u128f\u8001\u129d\u8001\u129f"+ "\u8001\u12a8\u8001\u12b0\u8001\u12de\u8001\u1305\u8001\u130c\u8001\u130f"+ "\u8001\u1310\u8001\u1313\u8001\u1328\u8001\u132a\u8001\u1330\u8001\u1332"+ @@ -579,16 +580,18 @@ private boolean DECIMAL_FLOAT_LIT_sempred(RuleContext _localctx, int predIndex) "\u8001\u1c8f\u8001\u1d00\u8001\u1d06\u8001\u1d08\u8001\u1d09\u8001\u1d0b"+ "\u8001\u1d30\u8001\u1d46\u8001\u1d46\u8001\u1d60\u8001\u1d65\u8001\u1d67"+ "\u8001\u1d68\u8001\u1d6a\u8001\u1d89\u8001\u1d98\u8001\u1d98\u8001\u1ee0"+ - "\u8001\u1ef2\u8001\u1fb0\u8001\u1fb0\u8001\u2000\u8001\u2399\u8001\u2480"+ - "\u8001\u2543\u8001\u2f90\u8001\u2ff0\u8001\u3000\u8001\u342e\u8001\u4400"+ - "\u8001\u4646\u8001\u6800\u8001\u6a38\u8001\u6a40\u8001\u6a5e\u8001\u6a70"+ - "\u8001\u6abe\u8001\u6ad0\u8001\u6aed\u8001\u6b00\u8001\u6b2f\u8001\u6b40"+ - "\u8001\u6b43\u8001\u6b63\u8001\u6b77\u8001\u6b7d\u8001\u6b8f\u8001\u6e40"+ - "\u8001\u6e7f\u8001\u6f00\u8001\u6f4a\u8001\u6f50\u8001\u6f50\u8001\u6f93"+ - "\u8001\u6f9f\u8001\u6fe0\u8001\u6fe1\u8001\u6fe3\u8001\u6fe3\u8001\u7000"+ - "\u8001\u87f7\u8001\u8800\u8001\u8cd5\u8001\u8d00\u8001\u8d08\u8001\uaff0"+ - "\u8001\uaff3\u8001\uaff5\u8001\uaffb\u8001\uaffd\u8001\uaffe\u8001\ub000"+ - "\u8001\ub122\u8001\ub150\u8001\ub152\u8001\ub164\u8001\ub167\u8001\ub170"+ + "\u8001\u1ef2\u8001\u1f02\u8001\u1f02\u8001\u1f04\u8001\u1f10\u8001\u1f12"+ + "\u8001\u1f33\u8001\u1fb0\u8001\u1fb0\u8001\u2000\u8001\u2399\u8001\u2480"+ + "\u8001\u2543\u8001\u2f90\u8001\u2ff0\u8001\u3000\u8001\u342f\u8001\u3441"+ + "\u8001\u3446\u8001\u4400\u8001\u4646\u8001\u6800\u8001\u6a38\u8001\u6a40"+ + "\u8001\u6a5e\u8001\u6a70\u8001\u6abe\u8001\u6ad0\u8001\u6aed\u8001\u6b00"+ + "\u8001\u6b2f\u8001\u6b40\u8001\u6b43\u8001\u6b63\u8001\u6b77\u8001\u6b7d"+ + "\u8001\u6b8f\u8001\u6e40\u8001\u6e7f\u8001\u6f00\u8001\u6f4a\u8001\u6f50"+ + "\u8001\u6f50\u8001\u6f93\u8001\u6f9f\u8001\u6fe0\u8001\u6fe1\u8001\u6fe3"+ + "\u8001\u6fe3\u8001\u7000\u8001\u87f7\u8001\u8800\u8001\u8cd5\u8001\u8d00"+ + "\u8001\u8d08\u8001\uaff0\u8001\uaff3\u8001\uaff5\u8001\uaffb\u8001\uaffd"+ + "\u8001\uaffe\u8001\ub000\u8001\ub122\u8001\ub132\u8001\ub132\u8001\ub150"+ + "\u8001\ub152\u8001\ub155\u8001\ub155\u8001\ub164\u8001\ub167\u8001\ub170"+ "\u8001\ub2fb\u8001\ubc00\u8001\ubc6a\u8001\ubc70\u8001\ubc7c\u8001\ubc80"+ "\u8001\ubc88\u8001\ubc90\u8001\ubc99\u8001\ud400\u8001\ud454\u8001\ud456"+ "\u8001\ud49c\u8001\ud49e\u8001\ud49f\u8001\ud4a2\u8001\ud4a2\u8001\ud4a5"+ @@ -600,9 +603,10 @@ private boolean DECIMAL_FLOAT_LIT_sempred(RuleContext _localctx, int predIndex) "\u8001\ud6c0\u8001\ud6c2\u8001\ud6da\u8001\ud6dc\u8001\ud6fa\u8001\ud6fc"+ "\u8001\ud714\u8001\ud716\u8001\ud734\u8001\ud736\u8001\ud74e\u8001\ud750"+ "\u8001\ud76e\u8001\ud770\u8001\ud788\u8001\ud78a\u8001\ud7a8\u8001\ud7aa"+ - "\u8001\ud7c2\u8001\ud7c4\u8001\ud7cb\u8001\udf00\u8001\udf1e\u8001\ue100"+ - "\u8001\ue12c\u8001\ue137\u8001\ue13d\u8001\ue14e\u8001\ue14e\u8001\ue290"+ - "\u8001\ue2ad\u8001\ue2c0\u8001\ue2eb\u8001\ue7e0\u8001\ue7e6\u8001\ue7e8"+ + "\u8001\ud7c2\u8001\ud7c4\u8001\ud7cb\u8001\udf00\u8001\udf1e\u8001\udf25"+ + "\u8001\udf2a\u8001\ue030\u8001\ue06d\u8001\ue100\u8001\ue12c\u8001\ue137"+ + "\u8001\ue13d\u8001\ue14e\u8001\ue14e\u8001\ue290\u8001\ue2ad\u8001\ue2c0"+ + "\u8001\ue2eb\u8001\ue4d0\u8001\ue4eb\u8001\ue7e0\u8001\ue7e6\u8001\ue7e8"+ "\u8001\ue7eb\u8001\ue7ed\u8001\ue7ee\u8001\ue7f0\u8001\ue7fe\u8001\ue800"+ "\u8001\ue8c4\u8001\ue900\u8001\ue943\u8001\ue94b\u8001\ue94b\u8001\uee00"+ "\u8001\uee03\u8001\uee05\u8001\uee1f\u8001\uee21\u8001\uee22\u8001\uee24"+ @@ -616,197 +620,197 @@ private boolean DECIMAL_FLOAT_LIT_sempred(RuleContext _localctx, int predIndex) "\u8001\uee72\u8001\uee74\u8001\uee77\u8001\uee79\u8001\uee7c\u8001\uee7e"+ "\u8001\uee7e\u8001\uee80\u8001\uee89\u8001\uee8b\u8001\uee9b\u8001\ueea1"+ "\u8001\ueea3\u8001\ueea5\u8001\ueea9\u8001\ueeab\u8001\ueebb\u8002\u0000"+ - "\u8002\ua6df\u8002\ua700\u8002\ub738\u8002\ub740\u8002\ub81d\u8002\ub820"+ + "\u8002\ua6df\u8002\ua700\u8002\ub739\u8002\ub740\u8002\ub81d\u8002\ub820"+ "\u8002\ucea1\u8002\uceb0\u8002\uebe0\u8002\uf800\u8002\ufa1d\u8003\u0000"+ - "\u8003\u134a\u0607\u0000\u0002\u0001\u0000\u0000\u0000\u0000\u0004\u0001"+ - "\u0000\u0000\u0000\u0000\u0006\u0001\u0000\u0000\u0000\u0000\b\u0001\u0000"+ - "\u0000\u0000\u0000\n\u0001\u0000\u0000\u0000\u0000\f\u0001\u0000\u0000"+ - "\u0000\u0000\u000e\u0001\u0000\u0000\u0000\u0000\u0010\u0001\u0000\u0000"+ - "\u0000\u0000\u0012\u0001\u0000\u0000\u0000\u0000\u0014\u0001\u0000\u0000"+ - "\u0000\u0000\u0016\u0001\u0000\u0000\u0000\u0000\u0018\u0001\u0000\u0000"+ - "\u0000\u0000\u001a\u0001\u0000\u0000\u0000\u0000\u001c\u0001\u0000\u0000"+ - "\u0000\u0000\u001e\u0001\u0000\u0000\u0000\u0000 \u0001\u0000\u0000\u0000"+ - "\u0000\"\u0001\u0000\u0000\u0000\u0000$\u0001\u0000\u0000\u0000\u0000"+ - "&\u0001\u0000\u0000\u0000\u0000(\u0001\u0000\u0000\u0000\u0000*\u0001"+ - "\u0000\u0000\u0000\u0000,\u0001\u0000\u0000\u0000\u0000.\u0001\u0000\u0000"+ - "\u0000\u00000\u0001\u0000\u0000\u0000\u00002\u0001\u0000\u0000\u0000\u0000"+ - "4\u0001\u0000\u0000\u0000\u00006\u0001\u0000\u0000\u0000\u00008\u0001"+ - "\u0000\u0000\u0000\u0000:\u0001\u0000\u0000\u0000\u0000<\u0001\u0000\u0000"+ - "\u0000\u0000>\u0001\u0000\u0000\u0000\u0000@\u0001\u0000\u0000\u0000\u0000"+ - "B\u0001\u0000\u0000\u0000\u0000D\u0001\u0000\u0000\u0000\u0000F\u0001"+ - "\u0000\u0000\u0000\u0000H\u0001\u0000\u0000\u0000\u0000J\u0001\u0000\u0000"+ - "\u0000\u0000L\u0001\u0000\u0000\u0000\u0000N\u0001\u0000\u0000\u0000\u0000"+ - "P\u0001\u0000\u0000\u0000\u0000R\u0001\u0000\u0000\u0000\u0000T\u0001"+ - "\u0000\u0000\u0000\u0000V\u0001\u0000\u0000\u0000\u0000X\u0001\u0000\u0000"+ - "\u0000\u0000Z\u0001\u0000\u0000\u0000\u0000\\\u0001\u0000\u0000\u0000"+ - "\u0000^\u0001\u0000\u0000\u0000\u0000`\u0001\u0000\u0000\u0000\u0000b"+ - "\u0001\u0000\u0000\u0000\u0000d\u0001\u0000\u0000\u0000\u0000f\u0001\u0000"+ - "\u0000\u0000\u0000h\u0001\u0000\u0000\u0000\u0000j\u0001\u0000\u0000\u0000"+ - "\u0000l\u0001\u0000\u0000\u0000\u0000n\u0001\u0000\u0000\u0000\u0000p"+ - "\u0001\u0000\u0000\u0000\u0000r\u0001\u0000\u0000\u0000\u0000t\u0001\u0000"+ - "\u0000\u0000\u0000v\u0001\u0000\u0000\u0000\u0000x\u0001\u0000\u0000\u0000"+ - "\u0000z\u0001\u0000\u0000\u0000\u0000|\u0001\u0000\u0000\u0000\u0000~"+ - "\u0001\u0000\u0000\u0000\u0000\u0080\u0001\u0000\u0000\u0000\u0000\u0082"+ - "\u0001\u0000\u0000\u0000\u0000\u0084\u0001\u0000\u0000\u0000\u0000\u0086"+ - "\u0001\u0000\u0000\u0000\u0000\u0088\u0001\u0000\u0000\u0000\u0000\u008a"+ - "\u0001\u0000\u0000\u0000\u0000\u008c\u0001\u0000\u0000\u0000\u0000\u008e"+ - "\u0001\u0000\u0000\u0000\u0000\u0090\u0001\u0000\u0000\u0000\u0000\u0092"+ - "\u0001\u0000\u0000\u0000\u0000\u0094\u0001\u0000\u0000\u0000\u0000\u0096"+ - "\u0001\u0000\u0000\u0000\u0000\u0098\u0001\u0000\u0000\u0000\u0000\u009a"+ - "\u0001\u0000\u0000\u0000\u0000\u009c\u0001\u0000\u0000\u0000\u0000\u009e"+ - "\u0001\u0000\u0000\u0000\u0000\u00a0\u0001\u0000\u0000\u0000\u0000\u00a2"+ - "\u0001\u0000\u0000\u0000\u0000\u00a4\u0001\u0000\u0000\u0000\u0000\u00a6"+ - "\u0001\u0000\u0000\u0000\u0000\u00a8\u0001\u0000\u0000\u0000\u0000\u00aa"+ - "\u0001\u0000\u0000\u0000\u0000\u00ac\u0001\u0000\u0000\u0000\u0000\u00ae"+ - "\u0001\u0000\u0000\u0000\u0000\u00b0\u0001\u0000\u0000\u0000\u0000\u00b2"+ - "\u0001\u0000\u0000\u0000\u0000\u00b4\u0001\u0000\u0000\u0000\u0000\u00b6"+ - "\u0001\u0000\u0000\u0000\u0000\u00b8\u0001\u0000\u0000\u0000\u0000\u00ba"+ - "\u0001\u0000\u0000\u0000\u0000\u00bc\u0001\u0000\u0000\u0000\u0000\u00be"+ - "\u0001\u0000\u0000\u0000\u0000\u00c0\u0001\u0000\u0000\u0000\u0000\u00c2"+ - "\u0001\u0000\u0000\u0000\u0000\u00c4\u0001\u0000\u0000\u0000\u0000\u00c6"+ - "\u0001\u0000\u0000\u0000\u0000\u00c8\u0001\u0000\u0000\u0000\u0000\u00ca"+ - "\u0001\u0000\u0000\u0000\u0000\u00cc\u0001\u0000\u0000\u0000\u0000\u00ce"+ - "\u0001\u0000\u0000\u0000\u0000\u00d0\u0001\u0000\u0000\u0000\u0000\u00d2"+ - "\u0001\u0000\u0000\u0000\u0000\u00d4\u0001\u0000\u0000\u0000\u0000\u00d6"+ - "\u0001\u0000\u0000\u0000\u0000\u00d8\u0001\u0000\u0000\u0000\u0000\u00da"+ - "\u0001\u0000\u0000\u0000\u0000\u00dc\u0001\u0000\u0000\u0000\u0000\u00de"+ - "\u0001\u0000\u0000\u0000\u0000\u00e0\u0001\u0000\u0000\u0000\u0000\u00e2"+ - "\u0001\u0000\u0000\u0000\u0000\u00e4\u0001\u0000\u0000\u0000\u0000\u00e6"+ - "\u0001\u0000\u0000\u0000\u0000\u00e8\u0001\u0000\u0000\u0000\u0000\u00ea"+ - "\u0001\u0000\u0000\u0000\u0000\u00ec\u0001\u0000\u0000\u0000\u0000\u00ee"+ - "\u0001\u0000\u0000\u0000\u0000\u00f0\u0001\u0000\u0000\u0000\u0000\u00f2"+ - "\u0001\u0000\u0000\u0000\u0000\u00f4\u0001\u0000\u0000\u0000\u0000\u00f6"+ - "\u0001\u0000\u0000\u0000\u0000\u00f8\u0001\u0000\u0000\u0000\u0000\u00fa"+ - "\u0001\u0000\u0000\u0000\u0000\u00fc\u0001\u0000\u0000\u0000\u0000\u00fe"+ - "\u0001\u0000\u0000\u0000\u0000\u0100\u0001\u0000\u0000\u0000\u0000\u0102"+ - "\u0001\u0000\u0000\u0000\u0000\u0104\u0001\u0000\u0000\u0000\u0000\u0106"+ - "\u0001\u0000\u0000\u0000\u0000\u0108\u0001\u0000\u0000\u0000\u0000\u010a"+ - "\u0001\u0000\u0000\u0000\u0000\u010c\u0001\u0000\u0000\u0000\u0000\u010e"+ - "\u0001\u0000\u0000\u0000\u0000\u0110\u0001\u0000\u0000\u0000\u0000\u0112"+ - "\u0001\u0000\u0000\u0000\u0000\u0114\u0001\u0000\u0000\u0000\u0000\u0116"+ - "\u0001\u0000\u0000\u0000\u0000\u0118\u0001\u0000\u0000\u0000\u0000\u011a"+ - "\u0001\u0000\u0000\u0000\u0000\u011c\u0001\u0000\u0000\u0000\u0000\u0122"+ - "\u0001\u0000\u0000\u0000\u0000\u0126\u0001\u0000\u0000\u0000\u0000\u0128"+ - "\u0001\u0000\u0000\u0000\u0000\u012a\u0001\u0000\u0000\u0000\u0000\u012c"+ - "\u0001\u0000\u0000\u0000\u0000\u012e\u0001\u0000\u0000\u0000\u0000\u0130"+ - "\u0001\u0000\u0000\u0000\u0000\u0132\u0001\u0000\u0000\u0000\u0000\u0134"+ - "\u0001\u0000\u0000\u0000\u0000\u0136\u0001\u0000\u0000\u0000\u0000\u0138"+ - "\u0001\u0000\u0000\u0000\u0000\u013a\u0001\u0000\u0000\u0000\u0000\u013c"+ - "\u0001\u0000\u0000\u0000\u0001\u0152\u0001\u0000\u0000\u0000\u0001\u0154"+ - "\u0001\u0000\u0000\u0000\u0001\u0156\u0001\u0000\u0000\u0000\u0001\u0158"+ - "\u0001\u0000\u0000\u0000\u0001\u015a\u0001\u0000\u0000\u0000\u0002\u015e"+ - "\u0001\u0000\u0000\u0000\u0004\u0174\u0001\u0000\u0000\u0000\u0006\u0176"+ - "\u0001\u0000\u0000\u0000\b\u017d\u0001\u0000\u0000\u0000\n\u0185\u0001"+ - "\u0000\u0000\u0000\f\u018c\u0001\u0000\u0000\u0000\u000e\u0193\u0001\u0000"+ - "\u0000\u0000\u0010\u019a\u0001\u0000\u0000\u0000\u0012\u01a1\u0001\u0000"+ - "\u0000\u0000\u0014\u01aa\u0001\u0000\u0000\u0000\u0016\u01b4\u0001\u0000"+ - "\u0000\u0000\u0018\u01bc\u0001\u0000\u0000\u0000\u001a\u01c6\u0001\u0000"+ - "\u0000\u0000\u001c\u01d2\u0001\u0000\u0000\u0000\u001e\u01d9\u0001\u0000"+ - "\u0000\u0000 \u01e4\u0001\u0000\u0000\u0000\"\u01e7\u0001\u0000\u0000"+ - "\u0000$\u01ed\u0001\u0000\u0000\u0000&\u01f6\u0001\u0000\u0000\u0000("+ - "\u01fb\u0001\u0000\u0000\u0000*\u0202\u0001\u0000\u0000\u0000,\u0209\u0001"+ - "\u0000\u0000\u0000.\u020f\u0001\u0000\u0000\u00000\u0214\u0001\u0000\u0000"+ - "\u00002\u021b\u0001\u0000\u0000\u00004\u0225\u0001\u0000\u0000\u00006"+ - "\u0229\u0001\u0000\u0000\u00008\u022f\u0001\u0000\u0000\u0000:\u0232\u0001"+ - "\u0000\u0000\u0000<\u0234\u0001\u0000\u0000\u0000>\u023b\u0001\u0000\u0000"+ - "\u0000@\u0241\u0001\u0000\u0000\u0000B\u024e\u0001\u0000\u0000\u0000D"+ - "\u0257\u0001\u0000\u0000\u0000F\u025b\u0001\u0000\u0000\u0000H\u025f\u0001"+ - "\u0000\u0000\u0000J\u0265\u0001\u0000\u0000\u0000L\u0267\u0001\u0000\u0000"+ - "\u0000N\u026a\u0001\u0000\u0000\u0000P\u026f\u0001\u0000\u0000\u0000R"+ - "\u0275\u0001\u0000\u0000\u0000T\u027b\u0001\u0000\u0000\u0000V\u0282\u0001"+ - "\u0000\u0000\u0000X\u0289\u0001\u0000\u0000\u0000Z\u0292\u0001\u0000\u0000"+ - "\u0000\\\u0298\u0001\u0000\u0000\u0000^\u029e\u0001\u0000\u0000\u0000"+ - "`\u02a5\u0001\u0000\u0000\u0000b\u02ab\u0001\u0000\u0000\u0000d\u02b2"+ - "\u0001\u0000\u0000\u0000f\u02b8\u0001\u0000\u0000\u0000h\u02c1\u0001\u0000"+ - "\u0000\u0000j\u02c9\u0001\u0000\u0000\u0000l\u02cf\u0001\u0000\u0000\u0000"+ - "n\u02d7\u0001\u0000\u0000\u0000p\u02de\u0001\u0000\u0000\u0000r\u02e3"+ - "\u0001\u0000\u0000\u0000t\u02ec\u0001\u0000\u0000\u0000v\u02fb\u0001\u0000"+ - "\u0000\u0000x\u0301\u0001\u0000\u0000\u0000z\u0305\u0001\u0000\u0000\u0000"+ - "|\u0308\u0001\u0000\u0000\u0000~\u030f\u0001\u0000\u0000\u0000\u0080\u0319"+ - "\u0001\u0000\u0000\u0000\u0082\u0323\u0001\u0000\u0000\u0000\u0084\u032f"+ - "\u0001\u0000\u0000\u0000\u0086\u0338\u0001\u0000\u0000\u0000\u0088\u0342"+ - "\u0001\u0000\u0000\u0000\u008a\u034a\u0001\u0000\u0000\u0000\u008c\u0356"+ - "\u0001\u0000\u0000\u0000\u008e\u0365\u0001\u0000\u0000\u0000\u0090\u036b"+ - "\u0001\u0000\u0000\u0000\u0092\u036f\u0001\u0000\u0000\u0000\u0094\u0373"+ - "\u0001\u0000\u0000\u0000\u0096\u0378\u0001\u0000\u0000\u0000\u0098\u0380"+ - "\u0001\u0000\u0000\u0000\u009a\u0388\u0001\u0000\u0000\u0000\u009c\u038d"+ - "\u0001\u0000\u0000\u0000\u009e\u0397\u0001\u0000\u0000\u0000\u00a0\u039e"+ - "\u0001\u0000\u0000\u0000\u00a2\u03a3\u0001\u0000\u0000\u0000\u00a4\u03a9"+ - "\u0001\u0000\u0000\u0000\u00a6\u03ac\u0001\u0000\u0000\u0000\u00a8\u03b0"+ - "\u0001\u0000\u0000\u0000\u00aa\u03b7\u0001\u0000\u0000\u0000\u00ac\u03bc"+ - "\u0001\u0000\u0000\u0000\u00ae\u03c1\u0001\u0000\u0000\u0000\u00b0\u03c6"+ - "\u0001\u0000\u0000\u0000\u00b2\u03ce\u0001\u0000\u0000\u0000\u00b4\u03d5"+ - "\u0001\u0000\u0000\u0000\u00b6\u03db\u0001\u0000\u0000\u0000\u00b8\u03e9"+ - "\u0001\u0000\u0000\u0000\u00ba\u03ec\u0001\u0000\u0000\u0000\u00bc\u03f2"+ - "\u0001\u0000\u0000\u0000\u00be\u03f7\u0001\u0000\u0000\u0000\u00c0\u0402"+ - "\u0001\u0000\u0000\u0000\u00c2\u0406\u0001\u0000\u0000\u0000\u00c4\u040d"+ - "\u0001\u0000\u0000\u0000\u00c6\u0416\u0001\u0000\u0000\u0000\u00c8\u041a"+ - "\u0001\u0000\u0000\u0000\u00ca\u0420\u0001\u0000\u0000\u0000\u00cc\u042a"+ - "\u0001\u0000\u0000\u0000\u00ce\u042c\u0001\u0000\u0000\u0000\u00d0\u0430"+ - "\u0001\u0000\u0000\u0000\u00d2\u0432\u0001\u0000\u0000\u0000\u00d4\u0436"+ - "\u0001\u0000\u0000\u0000\u00d6\u0438\u0001\u0000\u0000\u0000\u00d8\u043c"+ - "\u0001\u0000\u0000\u0000\u00da\u043e\u0001\u0000\u0000\u0000\u00dc\u0440"+ - "\u0001\u0000\u0000\u0000\u00de\u0442\u0001\u0000\u0000\u0000\u00e0\u0444"+ - "\u0001\u0000\u0000\u0000\u00e2\u0446\u0001\u0000\u0000\u0000\u00e4\u044b"+ - "\u0001\u0000\u0000\u0000\u00e6\u0450\u0001\u0000\u0000\u0000\u00e8\u0453"+ - "\u0001\u0000\u0000\u0000\u00ea\u0457\u0001\u0000\u0000\u0000\u00ec\u045a"+ - "\u0001\u0000\u0000\u0000\u00ee\u045d\u0001\u0000\u0000\u0000\u00f0\u0460"+ - "\u0001\u0000\u0000\u0000\u00f2\u0463\u0001\u0000\u0000\u0000\u00f4\u0465"+ - "\u0001\u0000\u0000\u0000\u00f6\u0468\u0001\u0000\u0000\u0000\u00f8\u046a"+ - "\u0001\u0000\u0000\u0000\u00fa\u046d\u0001\u0000\u0000\u0000\u00fc\u046f"+ - "\u0001\u0000\u0000\u0000\u00fe\u0471\u0001\u0000\u0000\u0000\u0100\u0473"+ - "\u0001\u0000\u0000\u0000\u0102\u0476\u0001\u0000\u0000\u0000\u0104\u0479"+ - "\u0001\u0000\u0000\u0000\u0106\u047c\u0001\u0000\u0000\u0000\u0108\u047e"+ - "\u0001\u0000\u0000\u0000\u010a\u0480\u0001\u0000\u0000\u0000\u010c\u0482"+ - "\u0001\u0000\u0000\u0000\u010e\u0484\u0001\u0000\u0000\u0000\u0110\u0486"+ - "\u0001\u0000\u0000\u0000\u0112\u0488\u0001\u0000\u0000\u0000\u0114\u0496"+ - "\u0001\u0000\u0000\u0000\u0116\u049a\u0001\u0000\u0000\u0000\u0118\u04a6"+ - "\u0001\u0000\u0000\u0000\u011a\u04b4\u0001\u0000\u0000\u0000\u011c\u04c0"+ - "\u0001\u0000\u0000\u0000\u011e\u04e4\u0001\u0000\u0000\u0000\u0120\u04e6"+ - "\u0001\u0000\u0000\u0000\u0122\u04f1\u0001\u0000\u0000\u0000\u0124\u04f7"+ - "\u0001\u0000\u0000\u0000\u0126\u04fe\u0001\u0000\u0000\u0000\u0128\u0504"+ - "\u0001\u0000\u0000\u0000\u012a\u0506\u0001\u0000\u0000\u0000\u012c\u050b"+ - "\u0001\u0000\u0000\u0000\u012e\u0510\u0001\u0000\u0000\u0000\u0130\u0517"+ - "\u0001\u0000\u0000\u0000\u0132\u0522\u0001\u0000\u0000\u0000\u0134\u052d"+ - "\u0001\u0000\u0000\u0000\u0136\u053a\u0001\u0000\u0000\u0000\u0138\u0540"+ - "\u0001\u0000\u0000\u0000\u013a\u054f\u0001\u0000\u0000\u0000\u013c\u0555"+ - "\u0001\u0000\u0000\u0000\u013e\u0564\u0001\u0000\u0000\u0000\u0140\u0566"+ - "\u0001\u0000\u0000\u0000\u0142\u0582\u0001\u0000\u0000\u0000\u0144\u058c"+ - "\u0001\u0000\u0000\u0000\u0146\u058e\u0001\u0000\u0000\u0000\u0148\u0590"+ - "\u0001\u0000\u0000\u0000\u014a\u0592\u0001\u0000\u0000\u0000\u014c\u059a"+ - "\u0001\u0000\u0000\u0000\u014e\u059c\u0001\u0000\u0000\u0000\u0150\u059e"+ - "\u0001\u0000\u0000\u0000\u0152\u05a1\u0001\u0000\u0000\u0000\u0154\u05a7"+ - "\u0001\u0000\u0000\u0000\u0156\u05b5\u0001\u0000\u0000\u0000\u0158\u05d2"+ - "\u0001\u0000\u0000\u0000\u015a\u05d6\u0001\u0000\u0000\u0000\u015c\u015f"+ - "\u0003\u0004\u0001\u0000\u015d\u015f\u0003\u011c\u008d\u0000\u015e\u015c"+ - "\u0001\u0000\u0000\u0000\u015e\u015d\u0001\u0000\u0000\u0000\u015f\u0160"+ - "\u0001\u0000\u0000\u0000\u0160\u0161\u0006\u0000\u0000\u0000\u0161\u0003"+ - "\u0001\u0000\u0000\u0000\u0162\u016c\u0003\u0142\u00a0\u0000\u0163\u0164"+ - "\u0005.\u0000\u0000\u0164\u0166\u0004\u0001\u0000\u0000\u0165\u0167\u0003"+ - "\u0142\u00a0\u0000\u0166\u0165\u0001\u0000\u0000\u0000\u0166\u0167\u0001"+ - "\u0000\u0000\u0000\u0167\u0169\u0001\u0000\u0000\u0000\u0168\u016a\u0003"+ - "\u014a\u00a4\u0000\u0169\u0168\u0001\u0000\u0000\u0000\u0169\u016a\u0001"+ - "\u0000\u0000\u0000\u016a\u016d\u0001\u0000\u0000\u0000\u016b\u016d\u0003"+ - "\u014a\u00a4\u0000\u016c\u0163\u0001\u0000\u0000\u0000\u016c\u016b\u0001"+ - "\u0000\u0000\u0000\u016d\u0175\u0001\u0000\u0000\u0000\u016e\u016f\u0005"+ - ".\u0000\u0000\u016f\u0170\u0004\u0001\u0001\u0000\u0170\u0172\u0003\u0142"+ - "\u00a0\u0000\u0171\u0173\u0003\u014a\u00a4\u0000\u0172\u0171\u0001\u0000"+ - "\u0000\u0000\u0172\u0173\u0001\u0000\u0000\u0000\u0173\u0175\u0001\u0000"+ - "\u0000\u0000\u0174\u0162\u0001\u0000\u0000\u0000\u0174\u016e\u0001\u0000"+ - "\u0000\u0000\u0175\u0005\u0001\u0000\u0000\u0000\u0176\u0177\u0005t\u0000"+ - "\u0000\u0177\u0178\u0005r\u0000\u0000\u0178\u0179\u0005u\u0000\u0000\u0179"+ - "\u017a\u0005e\u0000\u0000\u017a\u017b\u0001\u0000\u0000\u0000\u017b\u017c"+ - "\u0006\u0002\u0000\u0000\u017c\u0007\u0001\u0000\u0000\u0000\u017d\u017e"+ - "\u0005f\u0000\u0000\u017e\u017f\u0005a\u0000\u0000\u017f\u0180\u0005l"+ - "\u0000\u0000\u0180\u0181\u0005s\u0000\u0000\u0181\u0182\u0005e\u0000\u0000"+ - "\u0182\u0183\u0001\u0000\u0000\u0000\u0183\u0184\u0006\u0003\u0000\u0000"+ - "\u0184\t\u0001\u0000\u0000\u0000\u0185\u0186\u0005a\u0000\u0000\u0186"+ - "\u0187\u0005s\u0000\u0000\u0187\u0188\u0005s\u0000\u0000\u0188\u0189\u0005"+ - "e\u0000\u0000\u0189\u018a\u0005r\u0000\u0000\u018a\u018b\u0005t\u0000"+ - "\u0000\u018b\u000b\u0001\u0000\u0000\u0000\u018c\u018d\u0005a\u0000\u0000"+ - "\u018d\u018e\u0005s\u0000\u0000\u018e\u018f\u0005s\u0000\u0000\u018f\u0190"+ - "\u0005u\u0000\u0000\u0190\u0191\u0005m\u0000\u0000\u0191\u0192\u0005e"+ - "\u0000\u0000\u0192\r\u0001\u0000\u0000\u0000\u0193\u0194\u0005i\u0000"+ + "\u8003\u134a\u8003\u1350\u8003\u23af\u0607\u0000\u0002\u0001\u0000\u0000"+ + "\u0000\u0000\u0004\u0001\u0000\u0000\u0000\u0000\u0006\u0001\u0000\u0000"+ + "\u0000\u0000\b\u0001\u0000\u0000\u0000\u0000\n\u0001\u0000\u0000\u0000"+ + "\u0000\f\u0001\u0000\u0000\u0000\u0000\u000e\u0001\u0000\u0000\u0000\u0000"+ + "\u0010\u0001\u0000\u0000\u0000\u0000\u0012\u0001\u0000\u0000\u0000\u0000"+ + "\u0014\u0001\u0000\u0000\u0000\u0000\u0016\u0001\u0000\u0000\u0000\u0000"+ + "\u0018\u0001\u0000\u0000\u0000\u0000\u001a\u0001\u0000\u0000\u0000\u0000"+ + "\u001c\u0001\u0000\u0000\u0000\u0000\u001e\u0001\u0000\u0000\u0000\u0000"+ + " \u0001\u0000\u0000\u0000\u0000\"\u0001\u0000\u0000\u0000\u0000$\u0001"+ + "\u0000\u0000\u0000\u0000&\u0001\u0000\u0000\u0000\u0000(\u0001\u0000\u0000"+ + "\u0000\u0000*\u0001\u0000\u0000\u0000\u0000,\u0001\u0000\u0000\u0000\u0000"+ + ".\u0001\u0000\u0000\u0000\u00000\u0001\u0000\u0000\u0000\u00002\u0001"+ + "\u0000\u0000\u0000\u00004\u0001\u0000\u0000\u0000\u00006\u0001\u0000\u0000"+ + "\u0000\u00008\u0001\u0000\u0000\u0000\u0000:\u0001\u0000\u0000\u0000\u0000"+ + "<\u0001\u0000\u0000\u0000\u0000>\u0001\u0000\u0000\u0000\u0000@\u0001"+ + "\u0000\u0000\u0000\u0000B\u0001\u0000\u0000\u0000\u0000D\u0001\u0000\u0000"+ + "\u0000\u0000F\u0001\u0000\u0000\u0000\u0000H\u0001\u0000\u0000\u0000\u0000"+ + "J\u0001\u0000\u0000\u0000\u0000L\u0001\u0000\u0000\u0000\u0000N\u0001"+ + "\u0000\u0000\u0000\u0000P\u0001\u0000\u0000\u0000\u0000R\u0001\u0000\u0000"+ + "\u0000\u0000T\u0001\u0000\u0000\u0000\u0000V\u0001\u0000\u0000\u0000\u0000"+ + "X\u0001\u0000\u0000\u0000\u0000Z\u0001\u0000\u0000\u0000\u0000\\\u0001"+ + "\u0000\u0000\u0000\u0000^\u0001\u0000\u0000\u0000\u0000`\u0001\u0000\u0000"+ + "\u0000\u0000b\u0001\u0000\u0000\u0000\u0000d\u0001\u0000\u0000\u0000\u0000"+ + "f\u0001\u0000\u0000\u0000\u0000h\u0001\u0000\u0000\u0000\u0000j\u0001"+ + "\u0000\u0000\u0000\u0000l\u0001\u0000\u0000\u0000\u0000n\u0001\u0000\u0000"+ + "\u0000\u0000p\u0001\u0000\u0000\u0000\u0000r\u0001\u0000\u0000\u0000\u0000"+ + "t\u0001\u0000\u0000\u0000\u0000v\u0001\u0000\u0000\u0000\u0000x\u0001"+ + "\u0000\u0000\u0000\u0000z\u0001\u0000\u0000\u0000\u0000|\u0001\u0000\u0000"+ + "\u0000\u0000~\u0001\u0000\u0000\u0000\u0000\u0080\u0001\u0000\u0000\u0000"+ + "\u0000\u0082\u0001\u0000\u0000\u0000\u0000\u0084\u0001\u0000\u0000\u0000"+ + "\u0000\u0086\u0001\u0000\u0000\u0000\u0000\u0088\u0001\u0000\u0000\u0000"+ + "\u0000\u008a\u0001\u0000\u0000\u0000\u0000\u008c\u0001\u0000\u0000\u0000"+ + "\u0000\u008e\u0001\u0000\u0000\u0000\u0000\u0090\u0001\u0000\u0000\u0000"+ + "\u0000\u0092\u0001\u0000\u0000\u0000\u0000\u0094\u0001\u0000\u0000\u0000"+ + "\u0000\u0096\u0001\u0000\u0000\u0000\u0000\u0098\u0001\u0000\u0000\u0000"+ + "\u0000\u009a\u0001\u0000\u0000\u0000\u0000\u009c\u0001\u0000\u0000\u0000"+ + "\u0000\u009e\u0001\u0000\u0000\u0000\u0000\u00a0\u0001\u0000\u0000\u0000"+ + "\u0000\u00a2\u0001\u0000\u0000\u0000\u0000\u00a4\u0001\u0000\u0000\u0000"+ + "\u0000\u00a6\u0001\u0000\u0000\u0000\u0000\u00a8\u0001\u0000\u0000\u0000"+ + "\u0000\u00aa\u0001\u0000\u0000\u0000\u0000\u00ac\u0001\u0000\u0000\u0000"+ + "\u0000\u00ae\u0001\u0000\u0000\u0000\u0000\u00b0\u0001\u0000\u0000\u0000"+ + "\u0000\u00b2\u0001\u0000\u0000\u0000\u0000\u00b4\u0001\u0000\u0000\u0000"+ + "\u0000\u00b6\u0001\u0000\u0000\u0000\u0000\u00b8\u0001\u0000\u0000\u0000"+ + "\u0000\u00ba\u0001\u0000\u0000\u0000\u0000\u00bc\u0001\u0000\u0000\u0000"+ + "\u0000\u00be\u0001\u0000\u0000\u0000\u0000\u00c0\u0001\u0000\u0000\u0000"+ + "\u0000\u00c2\u0001\u0000\u0000\u0000\u0000\u00c4\u0001\u0000\u0000\u0000"+ + "\u0000\u00c6\u0001\u0000\u0000\u0000\u0000\u00c8\u0001\u0000\u0000\u0000"+ + "\u0000\u00ca\u0001\u0000\u0000\u0000\u0000\u00cc\u0001\u0000\u0000\u0000"+ + "\u0000\u00ce\u0001\u0000\u0000\u0000\u0000\u00d0\u0001\u0000\u0000\u0000"+ + "\u0000\u00d2\u0001\u0000\u0000\u0000\u0000\u00d4\u0001\u0000\u0000\u0000"+ + "\u0000\u00d6\u0001\u0000\u0000\u0000\u0000\u00d8\u0001\u0000\u0000\u0000"+ + "\u0000\u00da\u0001\u0000\u0000\u0000\u0000\u00dc\u0001\u0000\u0000\u0000"+ + "\u0000\u00de\u0001\u0000\u0000\u0000\u0000\u00e0\u0001\u0000\u0000\u0000"+ + "\u0000\u00e2\u0001\u0000\u0000\u0000\u0000\u00e4\u0001\u0000\u0000\u0000"+ + "\u0000\u00e6\u0001\u0000\u0000\u0000\u0000\u00e8\u0001\u0000\u0000\u0000"+ + "\u0000\u00ea\u0001\u0000\u0000\u0000\u0000\u00ec\u0001\u0000\u0000\u0000"+ + "\u0000\u00ee\u0001\u0000\u0000\u0000\u0000\u00f0\u0001\u0000\u0000\u0000"+ + "\u0000\u00f2\u0001\u0000\u0000\u0000\u0000\u00f4\u0001\u0000\u0000\u0000"+ + "\u0000\u00f6\u0001\u0000\u0000\u0000\u0000\u00f8\u0001\u0000\u0000\u0000"+ + "\u0000\u00fa\u0001\u0000\u0000\u0000\u0000\u00fc\u0001\u0000\u0000\u0000"+ + "\u0000\u00fe\u0001\u0000\u0000\u0000\u0000\u0100\u0001\u0000\u0000\u0000"+ + "\u0000\u0102\u0001\u0000\u0000\u0000\u0000\u0104\u0001\u0000\u0000\u0000"+ + "\u0000\u0106\u0001\u0000\u0000\u0000\u0000\u0108\u0001\u0000\u0000\u0000"+ + "\u0000\u010a\u0001\u0000\u0000\u0000\u0000\u010c\u0001\u0000\u0000\u0000"+ + "\u0000\u010e\u0001\u0000\u0000\u0000\u0000\u0110\u0001\u0000\u0000\u0000"+ + "\u0000\u0112\u0001\u0000\u0000\u0000\u0000\u0114\u0001\u0000\u0000\u0000"+ + "\u0000\u0116\u0001\u0000\u0000\u0000\u0000\u0118\u0001\u0000\u0000\u0000"+ + "\u0000\u011a\u0001\u0000\u0000\u0000\u0000\u011c\u0001\u0000\u0000\u0000"+ + "\u0000\u0122\u0001\u0000\u0000\u0000\u0000\u0126\u0001\u0000\u0000\u0000"+ + "\u0000\u0128\u0001\u0000\u0000\u0000\u0000\u012a\u0001\u0000\u0000\u0000"+ + "\u0000\u012c\u0001\u0000\u0000\u0000\u0000\u012e\u0001\u0000\u0000\u0000"+ + "\u0000\u0130\u0001\u0000\u0000\u0000\u0000\u0132\u0001\u0000\u0000\u0000"+ + "\u0000\u0134\u0001\u0000\u0000\u0000\u0000\u0136\u0001\u0000\u0000\u0000"+ + "\u0000\u0138\u0001\u0000\u0000\u0000\u0000\u013a\u0001\u0000\u0000\u0000"+ + "\u0000\u013c\u0001\u0000\u0000\u0000\u0001\u0152\u0001\u0000\u0000\u0000"+ + "\u0001\u0154\u0001\u0000\u0000\u0000\u0001\u0156\u0001\u0000\u0000\u0000"+ + "\u0001\u0158\u0001\u0000\u0000\u0000\u0001\u015a\u0001\u0000\u0000\u0000"+ + "\u0002\u015e\u0001\u0000\u0000\u0000\u0004\u0174\u0001\u0000\u0000\u0000"+ + "\u0006\u0176\u0001\u0000\u0000\u0000\b\u017d\u0001\u0000\u0000\u0000\n"+ + "\u0185\u0001\u0000\u0000\u0000\f\u018c\u0001\u0000\u0000\u0000\u000e\u0193"+ + "\u0001\u0000\u0000\u0000\u0010\u019a\u0001\u0000\u0000\u0000\u0012\u01a1"+ + "\u0001\u0000\u0000\u0000\u0014\u01aa\u0001\u0000\u0000\u0000\u0016\u01b4"+ + "\u0001\u0000\u0000\u0000\u0018\u01bc\u0001\u0000\u0000\u0000\u001a\u01c6"+ + "\u0001\u0000\u0000\u0000\u001c\u01d2\u0001\u0000\u0000\u0000\u001e\u01d9"+ + "\u0001\u0000\u0000\u0000 \u01e4\u0001\u0000\u0000\u0000\"\u01e7\u0001"+ + "\u0000\u0000\u0000$\u01ed\u0001\u0000\u0000\u0000&\u01f6\u0001\u0000\u0000"+ + "\u0000(\u01fb\u0001\u0000\u0000\u0000*\u0202\u0001\u0000\u0000\u0000,"+ + "\u0209\u0001\u0000\u0000\u0000.\u020f\u0001\u0000\u0000\u00000\u0214\u0001"+ + "\u0000\u0000\u00002\u021b\u0001\u0000\u0000\u00004\u0225\u0001\u0000\u0000"+ + "\u00006\u0229\u0001\u0000\u0000\u00008\u022f\u0001\u0000\u0000\u0000:"+ + "\u0232\u0001\u0000\u0000\u0000<\u0234\u0001\u0000\u0000\u0000>\u023b\u0001"+ + "\u0000\u0000\u0000@\u0241\u0001\u0000\u0000\u0000B\u024e\u0001\u0000\u0000"+ + "\u0000D\u0257\u0001\u0000\u0000\u0000F\u025b\u0001\u0000\u0000\u0000H"+ + "\u025f\u0001\u0000\u0000\u0000J\u0265\u0001\u0000\u0000\u0000L\u0267\u0001"+ + "\u0000\u0000\u0000N\u026a\u0001\u0000\u0000\u0000P\u026f\u0001\u0000\u0000"+ + "\u0000R\u0275\u0001\u0000\u0000\u0000T\u027b\u0001\u0000\u0000\u0000V"+ + "\u0282\u0001\u0000\u0000\u0000X\u0289\u0001\u0000\u0000\u0000Z\u0292\u0001"+ + "\u0000\u0000\u0000\\\u0298\u0001\u0000\u0000\u0000^\u029e\u0001\u0000"+ + "\u0000\u0000`\u02a5\u0001\u0000\u0000\u0000b\u02ab\u0001\u0000\u0000\u0000"+ + "d\u02b2\u0001\u0000\u0000\u0000f\u02b8\u0001\u0000\u0000\u0000h\u02c1"+ + "\u0001\u0000\u0000\u0000j\u02c9\u0001\u0000\u0000\u0000l\u02cf\u0001\u0000"+ + "\u0000\u0000n\u02d7\u0001\u0000\u0000\u0000p\u02de\u0001\u0000\u0000\u0000"+ + "r\u02e3\u0001\u0000\u0000\u0000t\u02ec\u0001\u0000\u0000\u0000v\u02fb"+ + "\u0001\u0000\u0000\u0000x\u0301\u0001\u0000\u0000\u0000z\u0305\u0001\u0000"+ + "\u0000\u0000|\u0308\u0001\u0000\u0000\u0000~\u030f\u0001\u0000\u0000\u0000"+ + "\u0080\u0319\u0001\u0000\u0000\u0000\u0082\u0323\u0001\u0000\u0000\u0000"+ + "\u0084\u032f\u0001\u0000\u0000\u0000\u0086\u0338\u0001\u0000\u0000\u0000"+ + "\u0088\u0342\u0001\u0000\u0000\u0000\u008a\u034a\u0001\u0000\u0000\u0000"+ + "\u008c\u0356\u0001\u0000\u0000\u0000\u008e\u0365\u0001\u0000\u0000\u0000"+ + "\u0090\u036b\u0001\u0000\u0000\u0000\u0092\u036f\u0001\u0000\u0000\u0000"+ + "\u0094\u0373\u0001\u0000\u0000\u0000\u0096\u0378\u0001\u0000\u0000\u0000"+ + "\u0098\u0380\u0001\u0000\u0000\u0000\u009a\u0388\u0001\u0000\u0000\u0000"+ + "\u009c\u038d\u0001\u0000\u0000\u0000\u009e\u0397\u0001\u0000\u0000\u0000"+ + "\u00a0\u039e\u0001\u0000\u0000\u0000\u00a2\u03a3\u0001\u0000\u0000\u0000"+ + "\u00a4\u03a9\u0001\u0000\u0000\u0000\u00a6\u03ac\u0001\u0000\u0000\u0000"+ + "\u00a8\u03b0\u0001\u0000\u0000\u0000\u00aa\u03b7\u0001\u0000\u0000\u0000"+ + "\u00ac\u03bc\u0001\u0000\u0000\u0000\u00ae\u03c1\u0001\u0000\u0000\u0000"+ + "\u00b0\u03c6\u0001\u0000\u0000\u0000\u00b2\u03ce\u0001\u0000\u0000\u0000"+ + "\u00b4\u03d5\u0001\u0000\u0000\u0000\u00b6\u03db\u0001\u0000\u0000\u0000"+ + "\u00b8\u03e9\u0001\u0000\u0000\u0000\u00ba\u03ec\u0001\u0000\u0000\u0000"+ + "\u00bc\u03f2\u0001\u0000\u0000\u0000\u00be\u03f7\u0001\u0000\u0000\u0000"+ + "\u00c0\u0402\u0001\u0000\u0000\u0000\u00c2\u0406\u0001\u0000\u0000\u0000"+ + "\u00c4\u040d\u0001\u0000\u0000\u0000\u00c6\u0416\u0001\u0000\u0000\u0000"+ + "\u00c8\u041a\u0001\u0000\u0000\u0000\u00ca\u0420\u0001\u0000\u0000\u0000"+ + "\u00cc\u042a\u0001\u0000\u0000\u0000\u00ce\u042c\u0001\u0000\u0000\u0000"+ + "\u00d0\u0430\u0001\u0000\u0000\u0000\u00d2\u0432\u0001\u0000\u0000\u0000"+ + "\u00d4\u0436\u0001\u0000\u0000\u0000\u00d6\u0438\u0001\u0000\u0000\u0000"+ + "\u00d8\u043c\u0001\u0000\u0000\u0000\u00da\u043e\u0001\u0000\u0000\u0000"+ + "\u00dc\u0440\u0001\u0000\u0000\u0000\u00de\u0442\u0001\u0000\u0000\u0000"+ + "\u00e0\u0444\u0001\u0000\u0000\u0000\u00e2\u0446\u0001\u0000\u0000\u0000"+ + "\u00e4\u044b\u0001\u0000\u0000\u0000\u00e6\u0450\u0001\u0000\u0000\u0000"+ + "\u00e8\u0453\u0001\u0000\u0000\u0000\u00ea\u0457\u0001\u0000\u0000\u0000"+ + "\u00ec\u045a\u0001\u0000\u0000\u0000\u00ee\u045d\u0001\u0000\u0000\u0000"+ + "\u00f0\u0460\u0001\u0000\u0000\u0000\u00f2\u0463\u0001\u0000\u0000\u0000"+ + "\u00f4\u0465\u0001\u0000\u0000\u0000\u00f6\u0468\u0001\u0000\u0000\u0000"+ + "\u00f8\u046a\u0001\u0000\u0000\u0000\u00fa\u046d\u0001\u0000\u0000\u0000"+ + "\u00fc\u046f\u0001\u0000\u0000\u0000\u00fe\u0471\u0001\u0000\u0000\u0000"+ + "\u0100\u0473\u0001\u0000\u0000\u0000\u0102\u0476\u0001\u0000\u0000\u0000"+ + "\u0104\u0479\u0001\u0000\u0000\u0000\u0106\u047c\u0001\u0000\u0000\u0000"+ + "\u0108\u047e\u0001\u0000\u0000\u0000\u010a\u0480\u0001\u0000\u0000\u0000"+ + "\u010c\u0482\u0001\u0000\u0000\u0000\u010e\u0484\u0001\u0000\u0000\u0000"+ + "\u0110\u0486\u0001\u0000\u0000\u0000\u0112\u0488\u0001\u0000\u0000\u0000"+ + "\u0114\u0496\u0001\u0000\u0000\u0000\u0116\u049a\u0001\u0000\u0000\u0000"+ + "\u0118\u04a6\u0001\u0000\u0000\u0000\u011a\u04b4\u0001\u0000\u0000\u0000"+ + "\u011c\u04c0\u0001\u0000\u0000\u0000\u011e\u04e4\u0001\u0000\u0000\u0000"+ + "\u0120\u04e6\u0001\u0000\u0000\u0000\u0122\u04f1\u0001\u0000\u0000\u0000"+ + "\u0124\u04f7\u0001\u0000\u0000\u0000\u0126\u04fe\u0001\u0000\u0000\u0000"+ + "\u0128\u0504\u0001\u0000\u0000\u0000\u012a\u0506\u0001\u0000\u0000\u0000"+ + "\u012c\u050b\u0001\u0000\u0000\u0000\u012e\u0510\u0001\u0000\u0000\u0000"+ + "\u0130\u0517\u0001\u0000\u0000\u0000\u0132\u0522\u0001\u0000\u0000\u0000"+ + "\u0134\u052d\u0001\u0000\u0000\u0000\u0136\u053a\u0001\u0000\u0000\u0000"+ + "\u0138\u0540\u0001\u0000\u0000\u0000\u013a\u054f\u0001\u0000\u0000\u0000"+ + "\u013c\u0555\u0001\u0000\u0000\u0000\u013e\u0564\u0001\u0000\u0000\u0000"+ + "\u0140\u0566\u0001\u0000\u0000\u0000\u0142\u0582\u0001\u0000\u0000\u0000"+ + "\u0144\u058c\u0001\u0000\u0000\u0000\u0146\u058e\u0001\u0000\u0000\u0000"+ + "\u0148\u0590\u0001\u0000\u0000\u0000\u014a\u0592\u0001\u0000\u0000\u0000"+ + "\u014c\u059a\u0001\u0000\u0000\u0000\u014e\u059c\u0001\u0000\u0000\u0000"+ + "\u0150\u059e\u0001\u0000\u0000\u0000\u0152\u05a1\u0001\u0000\u0000\u0000"+ + "\u0154\u05a7\u0001\u0000\u0000\u0000\u0156\u05b5\u0001\u0000\u0000\u0000"+ + "\u0158\u05d2\u0001\u0000\u0000\u0000\u015a\u05d6\u0001\u0000\u0000\u0000"+ + "\u015c\u015f\u0003\u0004\u0001\u0000\u015d\u015f\u0003\u011c\u008d\u0000"+ + "\u015e\u015c\u0001\u0000\u0000\u0000\u015e\u015d\u0001\u0000\u0000\u0000"+ + "\u015f\u0160\u0001\u0000\u0000\u0000\u0160\u0161\u0006\u0000\u0000\u0000"+ + "\u0161\u0003\u0001\u0000\u0000\u0000\u0162\u016c\u0003\u0142\u00a0\u0000"+ + "\u0163\u0164\u0005.\u0000\u0000\u0164\u0166\u0004\u0001\u0000\u0000\u0165"+ + "\u0167\u0003\u0142\u00a0\u0000\u0166\u0165\u0001\u0000\u0000\u0000\u0166"+ + "\u0167\u0001\u0000\u0000\u0000\u0167\u0169\u0001\u0000\u0000\u0000\u0168"+ + "\u016a\u0003\u014a\u00a4\u0000\u0169\u0168\u0001\u0000\u0000\u0000\u0169"+ + "\u016a\u0001\u0000\u0000\u0000\u016a\u016d\u0001\u0000\u0000\u0000\u016b"+ + "\u016d\u0003\u014a\u00a4\u0000\u016c\u0163\u0001\u0000\u0000\u0000\u016c"+ + "\u016b\u0001\u0000\u0000\u0000\u016d\u0175\u0001\u0000\u0000\u0000\u016e"+ + "\u016f\u0005.\u0000\u0000\u016f\u0170\u0004\u0001\u0001\u0000\u0170\u0172"+ + "\u0003\u0142\u00a0\u0000\u0171\u0173\u0003\u014a\u00a4\u0000\u0172\u0171"+ + "\u0001\u0000\u0000\u0000\u0172\u0173\u0001\u0000\u0000\u0000\u0173\u0175"+ + "\u0001\u0000\u0000\u0000\u0174\u0162\u0001\u0000\u0000\u0000\u0174\u016e"+ + "\u0001\u0000\u0000\u0000\u0175\u0005\u0001\u0000\u0000\u0000\u0176\u0177"+ + "\u0005t\u0000\u0000\u0177\u0178\u0005r\u0000\u0000\u0178\u0179\u0005u"+ + "\u0000\u0000\u0179\u017a\u0005e\u0000\u0000\u017a\u017b\u0001\u0000\u0000"+ + "\u0000\u017b\u017c\u0006\u0002\u0000\u0000\u017c\u0007\u0001\u0000\u0000"+ + "\u0000\u017d\u017e\u0005f\u0000\u0000\u017e\u017f\u0005a\u0000\u0000\u017f"+ + "\u0180\u0005l\u0000\u0000\u0180\u0181\u0005s\u0000\u0000\u0181\u0182\u0005"+ + "e\u0000\u0000\u0182\u0183\u0001\u0000\u0000\u0000\u0183\u0184\u0006\u0003"+ + "\u0000\u0000\u0184\t\u0001\u0000\u0000\u0000\u0185\u0186\u0005a\u0000"+ + "\u0000\u0186\u0187\u0005s\u0000\u0000\u0187\u0188\u0005s\u0000\u0000\u0188"+ + "\u0189\u0005e\u0000\u0000\u0189\u018a\u0005r\u0000\u0000\u018a\u018b\u0005"+ + "t\u0000\u0000\u018b\u000b\u0001\u0000\u0000\u0000\u018c\u018d\u0005a\u0000"+ + "\u0000\u018d\u018e\u0005s\u0000\u0000\u018e\u018f\u0005s\u0000\u0000\u018f"+ + "\u0190\u0005u\u0000\u0000\u0190\u0191\u0005m\u0000\u0000\u0191\u0192\u0005"+ + "e\u0000\u0000\u0192\r\u0001\u0000\u0000\u0000\u0193\u0194\u0005i\u0000"+ "\u0000\u0194\u0195\u0005n\u0000\u0000\u0195\u0196\u0005h\u0000\u0000\u0196"+ "\u0197\u0005a\u0000\u0000\u0197\u0198\u0005l\u0000\u0000\u0198\u0199\u0005"+ "e\u0000\u0000\u0199\u000f\u0001\u0000\u0000\u0000\u019a\u019b\u0005e\u0000"+ diff --git a/src/main/java/viper/gobra/frontend/GobraParser.java b/src/main/java/viper/gobra/frontend/GobraParser.java index 0b583ef70..62bcff25c 100644 --- a/src/main/java/viper/gobra/frontend/GobraParser.java +++ b/src/main/java/viper/gobra/frontend/GobraParser.java @@ -1,4 +1,4 @@ -// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.12.0 +// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.13.0 package viper.gobra.frontend; import org.antlr.v4.runtime.atn.*; import org.antlr.v4.runtime.dfa.DFA; @@ -11,7 +11,7 @@ @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) public class GobraParser extends GobraParserBase { - static { RuntimeMetaData.checkVersion("4.12.0", RuntimeMetaData.VERSION); } + static { RuntimeMetaData.checkVersion("4.13.0", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = @@ -56,47 +56,47 @@ public class GobraParser extends GobraParserBase { RULE_typeOf = 33, RULE_access = 34, RULE_range = 35, RULE_matchExpr = 36, RULE_matchExprClause = 37, RULE_seqUpdExp = 38, RULE_seqUpdClause = 39, RULE_ghostTypeLit = 40, RULE_domainType = 41, RULE_domainClause = 42, - RULE_adtType = 43, RULE_adtClause = 44, RULE_ghostSliceType = 45, RULE_sqType = 46, - RULE_specification = 47, RULE_specStatement = 48, RULE_terminationMeasure = 49, - RULE_assertion = 50, RULE_matchStmt = 51, RULE_matchStmtClause = 52, RULE_matchCase = 53, - RULE_matchPattern = 54, RULE_matchPatternList = 55, RULE_blockWithBodyParameterInfo = 56, - RULE_closureSpecInstance = 57, RULE_closureSpecParams = 58, RULE_closureSpecParam = 59, - RULE_closureImplProofStmt = 60, RULE_implementationProof = 61, RULE_methodImplementationProof = 62, - RULE_nonLocalReceiver = 63, RULE_selection = 64, RULE_implementationProofPredicateAlias = 65, - RULE_make = 66, RULE_new_ = 67, RULE_specMember = 68, RULE_functionDecl = 69, - RULE_methodDecl = 70, RULE_explicitGhostMember = 71, RULE_fpredicateDecl = 72, - RULE_predicateBody = 73, RULE_mpredicateDecl = 74, RULE_varSpec = 75, - RULE_shortVarDecl = 76, RULE_receiver = 77, RULE_parameterDecl = 78, RULE_actualParameterDecl = 79, - RULE_ghostParameterDecl = 80, RULE_parameterType = 81, RULE_expression = 82, - RULE_statement = 83, RULE_applyStmt = 84, RULE_packageStmt = 85, RULE_specForStmt = 86, - RULE_loopSpec = 87, RULE_deferStmt = 88, RULE_basicLit = 89, RULE_primaryExpr = 90, - RULE_functionLit = 91, RULE_closureDecl = 92, RULE_predConstructArgs = 93, - RULE_interfaceType = 94, RULE_predicateSpec = 95, RULE_methodSpec = 96, - RULE_type_ = 97, RULE_typeLit = 98, RULE_predType = 99, RULE_predTypeParams = 100, - RULE_literalType = 101, RULE_implicitArray = 102, RULE_slice_ = 103, RULE_low = 104, - RULE_high = 105, RULE_cap = 106, RULE_assign_op = 107, RULE_rangeClause = 108, - RULE_packageClause = 109, RULE_importPath = 110, RULE_declaration = 111, - RULE_constDecl = 112, RULE_constSpec = 113, RULE_identifierList = 114, - RULE_expressionList = 115, RULE_typeDecl = 116, RULE_typeSpec = 117, RULE_varDecl = 118, - RULE_block = 119, RULE_statementList = 120, RULE_simpleStmt = 121, RULE_expressionStmt = 122, - RULE_sendStmt = 123, RULE_incDecStmt = 124, RULE_assignment = 125, RULE_emptyStmt = 126, - RULE_labeledStmt = 127, RULE_returnStmt = 128, RULE_breakStmt = 129, RULE_continueStmt = 130, - RULE_gotoStmt = 131, RULE_fallthroughStmt = 132, RULE_ifStmt = 133, RULE_switchStmt = 134, - RULE_exprSwitchStmt = 135, RULE_exprCaseClause = 136, RULE_exprSwitchCase = 137, - RULE_typeSwitchStmt = 138, RULE_typeSwitchGuard = 139, RULE_typeCaseClause = 140, - RULE_typeSwitchCase = 141, RULE_typeList = 142, RULE_selectStmt = 143, - RULE_commClause = 144, RULE_commCase = 145, RULE_recvStmt = 146, RULE_forStmt = 147, - RULE_forClause = 148, RULE_goStmt = 149, RULE_typeName = 150, RULE_arrayType = 151, - RULE_arrayLength = 152, RULE_elementType = 153, RULE_pointerType = 154, - RULE_sliceType = 155, RULE_mapType = 156, RULE_channelType = 157, RULE_functionType = 158, - RULE_signature = 159, RULE_result = 160, RULE_parameters = 161, RULE_conversion = 162, - RULE_nonNamedType = 163, RULE_operand = 164, RULE_literal = 165, RULE_integer = 166, - RULE_operandName = 167, RULE_qualifiedIdent = 168, RULE_compositeLit = 169, - RULE_literalValue = 170, RULE_elementList = 171, RULE_keyedElement = 172, - RULE_key = 173, RULE_element = 174, RULE_structType = 175, RULE_fieldDecl = 176, - RULE_string_ = 177, RULE_embeddedField = 178, RULE_index = 179, RULE_typeAssertion = 180, - RULE_arguments = 181, RULE_methodExpr = 182, RULE_receiverType = 183, - RULE_eos = 184; + RULE_adtType = 43, RULE_adtClause = 44, RULE_adtFieldDecl = 45, RULE_ghostSliceType = 46, + RULE_sqType = 47, RULE_specification = 48, RULE_specStatement = 49, RULE_terminationMeasure = 50, + RULE_assertion = 51, RULE_matchStmt = 52, RULE_matchStmtClause = 53, RULE_matchCase = 54, + RULE_matchPattern = 55, RULE_matchPatternList = 56, RULE_blockWithBodyParameterInfo = 57, + RULE_closureSpecInstance = 58, RULE_closureSpecParams = 59, RULE_closureSpecParam = 60, + RULE_closureImplProofStmt = 61, RULE_implementationProof = 62, RULE_methodImplementationProof = 63, + RULE_nonLocalReceiver = 64, RULE_selection = 65, RULE_implementationProofPredicateAlias = 66, + RULE_make = 67, RULE_new_ = 68, RULE_specMember = 69, RULE_functionDecl = 70, + RULE_methodDecl = 71, RULE_explicitGhostMember = 72, RULE_fpredicateDecl = 73, + RULE_predicateBody = 74, RULE_mpredicateDecl = 75, RULE_varSpec = 76, + RULE_shortVarDecl = 77, RULE_receiver = 78, RULE_parameterDecl = 79, RULE_actualParameterDecl = 80, + RULE_ghostParameterDecl = 81, RULE_parameterType = 82, RULE_expression = 83, + RULE_statement = 84, RULE_applyStmt = 85, RULE_packageStmt = 86, RULE_specForStmt = 87, + RULE_loopSpec = 88, RULE_deferStmt = 89, RULE_basicLit = 90, RULE_primaryExpr = 91, + RULE_functionLit = 92, RULE_closureDecl = 93, RULE_predConstructArgs = 94, + RULE_interfaceType = 95, RULE_predicateSpec = 96, RULE_methodSpec = 97, + RULE_type_ = 98, RULE_typeLit = 99, RULE_predType = 100, RULE_predTypeParams = 101, + RULE_literalType = 102, RULE_implicitArray = 103, RULE_slice_ = 104, RULE_low = 105, + RULE_high = 106, RULE_cap = 107, RULE_assign_op = 108, RULE_rangeClause = 109, + RULE_packageClause = 110, RULE_importPath = 111, RULE_declaration = 112, + RULE_constDecl = 113, RULE_constSpec = 114, RULE_identifierList = 115, + RULE_expressionList = 116, RULE_typeDecl = 117, RULE_typeSpec = 118, RULE_varDecl = 119, + RULE_block = 120, RULE_statementList = 121, RULE_simpleStmt = 122, RULE_expressionStmt = 123, + RULE_sendStmt = 124, RULE_incDecStmt = 125, RULE_assignment = 126, RULE_emptyStmt = 127, + RULE_labeledStmt = 128, RULE_returnStmt = 129, RULE_breakStmt = 130, RULE_continueStmt = 131, + RULE_gotoStmt = 132, RULE_fallthroughStmt = 133, RULE_ifStmt = 134, RULE_switchStmt = 135, + RULE_exprSwitchStmt = 136, RULE_exprCaseClause = 137, RULE_exprSwitchCase = 138, + RULE_typeSwitchStmt = 139, RULE_typeSwitchGuard = 140, RULE_typeCaseClause = 141, + RULE_typeSwitchCase = 142, RULE_typeList = 143, RULE_selectStmt = 144, + RULE_commClause = 145, RULE_commCase = 146, RULE_recvStmt = 147, RULE_forStmt = 148, + RULE_forClause = 149, RULE_goStmt = 150, RULE_typeName = 151, RULE_arrayType = 152, + RULE_arrayLength = 153, RULE_elementType = 154, RULE_pointerType = 155, + RULE_sliceType = 156, RULE_mapType = 157, RULE_channelType = 158, RULE_functionType = 159, + RULE_signature = 160, RULE_result = 161, RULE_parameters = 162, RULE_conversion = 163, + RULE_nonNamedType = 164, RULE_operand = 165, RULE_literal = 166, RULE_integer = 167, + RULE_operandName = 168, RULE_qualifiedIdent = 169, RULE_compositeLit = 170, + RULE_literalValue = 171, RULE_elementList = 172, RULE_keyedElement = 173, + RULE_key = 174, RULE_element = 175, RULE_structType = 176, RULE_fieldDecl = 177, + RULE_string_ = 178, RULE_embeddedField = 179, RULE_index = 180, RULE_typeAssertion = 181, + RULE_arguments = 182, RULE_methodExpr = 183, RULE_receiverType = 184, + RULE_eos = 185; private static String[] makeRuleNames() { return new String[] { "exprOnly", "stmtOnly", "typeOnly", "maybeAddressableIdentifierList", @@ -108,9 +108,9 @@ private static String[] makeRuleNames() { "old", "oldLabelUse", "labelUse", "before", "isComparable", "typeOf", "access", "range", "matchExpr", "matchExprClause", "seqUpdExp", "seqUpdClause", "ghostTypeLit", "domainType", "domainClause", "adtType", "adtClause", - "ghostSliceType", "sqType", "specification", "specStatement", "terminationMeasure", - "assertion", "matchStmt", "matchStmtClause", "matchCase", "matchPattern", - "matchPatternList", "blockWithBodyParameterInfo", "closureSpecInstance", + "adtFieldDecl", "ghostSliceType", "sqType", "specification", "specStatement", + "terminationMeasure", "assertion", "matchStmt", "matchStmtClause", "matchCase", + "matchPattern", "matchPatternList", "blockWithBodyParameterInfo", "closureSpecInstance", "closureSpecParams", "closureSpecParam", "closureImplProofStmt", "implementationProof", "methodImplementationProof", "nonLocalReceiver", "selection", "implementationProofPredicateAlias", "make", "new_", "specMember", "functionDecl", "methodDecl", "explicitGhostMember", @@ -267,9 +267,9 @@ public final ExprOnlyContext exprOnly() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(370); + setState(372); expression(0); - setState(371); + setState(373); match(EOF); } } @@ -307,9 +307,9 @@ public final StmtOnlyContext stmtOnly() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(373); + setState(375); statement(); - setState(374); + setState(376); match(EOF); } } @@ -347,9 +347,9 @@ public final TypeOnlyContext typeOnly() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(376); + setState(378); type_(); - setState(377); + setState(379); match(EOF); } } @@ -394,21 +394,21 @@ public final MaybeAddressableIdentifierListContext maybeAddressableIdentifierLis try { enterOuterAlt(_localctx, 1); { - setState(379); + setState(381); maybeAddressableIdentifier(); - setState(384); + setState(386); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(380); + setState(382); match(COMMA); - setState(381); + setState(383); maybeAddressableIdentifier(); } } - setState(386); + setState(388); _errHandler.sync(this); _la = _input.LA(1); } @@ -447,14 +447,14 @@ public final MaybeAddressableIdentifierContext maybeAddressableIdentifier() thro try { enterOuterAlt(_localctx, 1); { - setState(387); - match(IDENTIFIER); setState(389); + match(IDENTIFIER); + setState(391); _errHandler.sync(this); _la = _input.LA(1); if (_la==ADDR_MOD) { { - setState(388); + setState(390); match(ADDR_MOD); } } @@ -532,79 +532,79 @@ public final SourceFileContext sourceFile() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(396); + setState(398); _errHandler.sync(this); _la = _input.LA(1); while (_la==INIT_POST) { { { - setState(391); + setState(393); initPost(); - setState(392); + setState(394); eos(); } } - setState(398); + setState(400); _errHandler.sync(this); _la = _input.LA(1); } - setState(399); + setState(401); packageClause(); - setState(400); + setState(402); eos(); - setState(406); + setState(408); _errHandler.sync(this); _la = _input.LA(1); while (_la==IMPORT_PRE || _la==IMPORT) { { { - setState(401); + setState(403); importDecl(); - setState(402); + setState(404); eos(); } } - setState(408); + setState(410); _errHandler.sync(this); _la = _input.LA(1); } - setState(418); + setState(420); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 9)) & ~0x3f) == 0 && ((1L << (_la - 9)) & 288393170444877879L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441151881350095299L) != 0)) { { { - setState(412); + setState(414); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { case 1: { - setState(409); + setState(411); specMember(); } break; case 2: { - setState(410); + setState(412); declaration(); } break; case 3: { - setState(411); + setState(413); ghostMember(); } break; } - setState(414); + setState(416); eos(); } } - setState(420); + setState(422); _errHandler.sync(this); _la = _input.LA(1); } - setState(421); + setState(423); match(EOF); } } @@ -660,39 +660,39 @@ public final PreambleContext preamble() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(428); + setState(430); _errHandler.sync(this); _la = _input.LA(1); while (_la==INIT_POST) { { { - setState(423); + setState(425); initPost(); - setState(424); + setState(426); eos(); } } - setState(430); + setState(432); _errHandler.sync(this); _la = _input.LA(1); } - setState(431); + setState(433); packageClause(); - setState(432); + setState(434); eos(); - setState(438); + setState(440); _errHandler.sync(this); _la = _input.LA(1); while (_la==IMPORT_PRE || _la==IMPORT) { { { - setState(433); + setState(435); importDecl(); - setState(434); + setState(436); eos(); } } - setState(440); + setState(442); _errHandler.sync(this); _la = _input.LA(1); } @@ -732,9 +732,9 @@ public final InitPostContext initPost() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(441); + setState(443); match(INIT_POST); - setState(442); + setState(444); expression(0); } } @@ -772,9 +772,9 @@ public final ImportPreContext importPre() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(444); + setState(446); match(IMPORT_PRE); - setState(445); + setState(447); expression(0); } } @@ -827,28 +827,28 @@ public final ImportSpecContext importSpec() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(452); + setState(454); _errHandler.sync(this); _la = _input.LA(1); while (_la==IMPORT_PRE) { { { - setState(447); + setState(449); importPre(); - setState(448); + setState(450); eos(); } } - setState(454); + setState(456); _errHandler.sync(this); _la = _input.LA(1); } - setState(456); + setState(458); _errHandler.sync(this); _la = _input.LA(1); if (_la==IDENTIFIER || _la==DOT) { { - setState(455); + setState(457); ((ImportSpecContext)_localctx).alias = _input.LT(1); _la = _input.LA(1); if ( !(_la==IDENTIFIER || _la==DOT) ) { @@ -862,7 +862,7 @@ public final ImportSpecContext importSpec() throws RecognitionException { } } - setState(458); + setState(460); importPath(); } } @@ -918,56 +918,56 @@ public final ImportDeclContext importDecl() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(465); + setState(467); _errHandler.sync(this); _la = _input.LA(1); while (_la==IMPORT_PRE) { { { - setState(460); + setState(462); importPre(); - setState(461); + setState(463); eos(); } } - setState(467); + setState(469); _errHandler.sync(this); _la = _input.LA(1); } - setState(481); + setState(483); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { case 1: { - setState(468); + setState(470); match(IMPORT); - setState(469); + setState(471); importSpec(); } break; case 2: { - setState(470); + setState(472); match(IMPORT); - setState(471); + setState(473); match(L_PAREN); - setState(477); + setState(479); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 4400193994753L) != 0) || _la==RAW_STRING_LIT || _la==INTERPRETED_STRING_LIT) { { { - setState(472); + setState(474); importSpec(); - setState(473); + setState(475); eos(); } } - setState(479); + setState(481); _errHandler.sync(this); _la = _input.LA(1); } - setState(480); + setState(482); match(R_PAREN); } break; @@ -1014,34 +1014,34 @@ public final GhostMemberContext ghostMember() throws RecognitionException { GhostMemberContext _localctx = new GhostMemberContext(_ctx, getState()); enterRule(_localctx, 22, RULE_ghostMember); try { - setState(487); + setState(489); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(483); + setState(485); implementationProof(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(484); + setState(486); fpredicateDecl(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(485); + setState(487); mpredicateDecl(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(486); + setState(488); explicitGhostMember(); } break; @@ -1133,16 +1133,16 @@ public final GhostStatementContext ghostStatement() throws RecognitionException enterRule(_localctx, 24, RULE_ghostStatement); int _la; try { - setState(496); + setState(498); _errHandler.sync(this); switch (_input.LA(1)) { case GHOST: _localctx = new ExplicitGhostStatementContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(489); + setState(491); match(GHOST); - setState(490); + setState(492); statement(); } break; @@ -1151,7 +1151,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _localctx = new FoldStatementContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(491); + setState(493); ((FoldStatementContext)_localctx).fold_stmt = _input.LT(1); _la = _input.LA(1); if ( !(_la==FOLD || _la==UNFOLD) ) { @@ -1162,7 +1162,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _errHandler.reportMatch(this); consume(); } - setState(492); + setState(494); predicateAccess(); } break; @@ -1173,7 +1173,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _localctx = new ProofStatementContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(493); + setState(495); ((ProofStatementContext)_localctx).kind = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 480L) != 0)) ) { @@ -1184,7 +1184,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _errHandler.reportMatch(this); consume(); } - setState(494); + setState(496); expression(0); } break; @@ -1192,7 +1192,7 @@ public final GhostStatementContext ghostStatement() throws RecognitionException _localctx = new MatchStmt_Context(_localctx); enterOuterAlt(_localctx, 4); { - setState(495); + setState(497); matchStmt(); } break; @@ -1233,7 +1233,7 @@ public final AuxiliaryStatementContext auxiliaryStatement() throws RecognitionEx try { enterOuterAlt(_localctx, 1); { - setState(498); + setState(500); statementWithSpec(); } } @@ -1274,10 +1274,10 @@ public final StatementWithSpecContext statementWithSpec() throws RecognitionExce try { enterOuterAlt(_localctx, 1); { - setState(500); + setState(502); ((StatementWithSpecContext)_localctx).specification = specification(); { - setState(501); + setState(503); outlineStatement(((StatementWithSpecContext)_localctx).specification.trusted, ((StatementWithSpecContext)_localctx).specification.pure); } } @@ -1323,21 +1323,21 @@ public final OutlineStatementContext outlineStatement(boolean trusted,boolean pu try { enterOuterAlt(_localctx, 1); { - setState(503); + setState(505); match(OUTLINE); - setState(504); - match(L_PAREN); setState(506); + match(L_PAREN); + setState(508); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { case 1: { - setState(505); + setState(507); statementList(); } break; } - setState(508); + setState(510); match(R_PAREN); } } @@ -1408,97 +1408,97 @@ public final GhostPrimaryExprContext ghostPrimaryExpr() throws RecognitionExcept GhostPrimaryExprContext _localctx = new GhostPrimaryExprContext(_ctx, getState()); enterRule(_localctx, 32, RULE_ghostPrimaryExpr); try { - setState(523); + setState(525); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(510); + setState(512); range(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(511); + setState(513); access(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(512); + setState(514); typeOf(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(513); + setState(515); typeExpr(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(514); + setState(516); isComparable(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(515); + setState(517); old(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(516); + setState(518); before(); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(517); + setState(519); sConversion(); } break; case 9: enterOuterAlt(_localctx, 9); { - setState(518); + setState(520); optionNone(); } break; case 10: enterOuterAlt(_localctx, 10); { - setState(519); + setState(521); optionSome(); } break; case 11: enterOuterAlt(_localctx, 11); { - setState(520); + setState(522); optionGet(); } break; case 12: enterOuterAlt(_localctx, 12); { - setState(521); + setState(523); permission(); } break; case 13: enterOuterAlt(_localctx, 13); { - setState(522); + setState(524); matchExpr(); } break; @@ -1537,7 +1537,7 @@ public final PermissionContext permission() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(525); + setState(527); _la = _input.LA(1); if ( !(_la==WRITEPERM || _la==NOPERM) ) { _errHandler.recoverInline(this); @@ -1585,13 +1585,13 @@ public final TypeExprContext typeExpr() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(527); + setState(529); match(TYPE); - setState(528); + setState(530); match(L_BRACKET); - setState(529); + setState(531); type_(); - setState(530); + setState(532); match(R_BRACKET); } } @@ -1637,32 +1637,32 @@ public final BoundVariablesContext boundVariables() throws RecognitionException int _alt; enterOuterAlt(_localctx, 1); { - setState(532); + setState(534); boundVariableDecl(); - setState(537); + setState(539); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,17,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(533); + setState(535); match(COMMA); - setState(534); + setState(536); boundVariableDecl(); } } } - setState(539); + setState(541); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,17,_ctx); } - setState(541); + setState(543); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(540); + setState(542); match(COMMA); } } @@ -1711,25 +1711,25 @@ public final BoundVariableDeclContext boundVariableDecl() throws RecognitionExce try { enterOuterAlt(_localctx, 1); { - setState(543); + setState(545); match(IDENTIFIER); - setState(548); + setState(550); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(544); + setState(546); match(COMMA); - setState(545); + setState(547); match(IDENTIFIER); } } - setState(550); + setState(552); _errHandler.sync(this); _la = _input.LA(1); } - setState(551); + setState(553); elementType(); } } @@ -1770,17 +1770,17 @@ public final TriggersContext triggers() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(556); + setState(558); _errHandler.sync(this); _la = _input.LA(1); while (_la==L_CURLY) { { { - setState(553); + setState(555); trigger(); } } - setState(558); + setState(560); _errHandler.sync(this); _la = _input.LA(1); } @@ -1829,27 +1829,27 @@ public final TriggerContext trigger() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(559); + setState(561); match(L_CURLY); - setState(560); + setState(562); expression(0); - setState(565); + setState(567); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(561); + setState(563); match(COMMA); - setState(562); + setState(564); expression(0); } } - setState(567); + setState(569); _errHandler.sync(this); _la = _input.LA(1); } - setState(568); + setState(570); match(R_CURLY); } } @@ -1886,7 +1886,7 @@ public final PredicateAccessContext predicateAccess() throws RecognitionExceptio try { enterOuterAlt(_localctx, 1); { - setState(570); + setState(572); primaryExpr(0); } } @@ -1926,13 +1926,13 @@ public final OptionSomeContext optionSome() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(572); + setState(574); match(SOME); - setState(573); + setState(575); match(L_PAREN); - setState(574); + setState(576); expression(0); - setState(575); + setState(577); match(R_PAREN); } } @@ -1972,13 +1972,13 @@ public final OptionNoneContext optionNone() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(577); + setState(579); match(NONE); - setState(578); + setState(580); match(L_BRACKET); - setState(579); + setState(581); type_(); - setState(580); + setState(582); match(R_BRACKET); } } @@ -2018,13 +2018,13 @@ public final OptionGetContext optionGet() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(582); + setState(584); match(GET); - setState(583); + setState(585); match(L_PAREN); - setState(584); + setState(586); expression(0); - setState(585); + setState(587); match(R_PAREN); } } @@ -2068,7 +2068,7 @@ public final SConversionContext sConversion() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(587); + setState(589); ((SConversionContext)_localctx).kind = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 7696581394432L) != 0)) ) { @@ -2079,11 +2079,11 @@ public final SConversionContext sConversion() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(588); + setState(590); match(L_PAREN); - setState(589); + setState(591); expression(0); - setState(590); + setState(592); match(R_PAREN); } } @@ -2129,27 +2129,27 @@ public final OldContext old() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(592); + setState(594); match(OLD); - setState(597); + setState(599); _errHandler.sync(this); _la = _input.LA(1); if (_la==L_BRACKET) { { - setState(593); + setState(595); match(L_BRACKET); - setState(594); + setState(596); oldLabelUse(); - setState(595); + setState(597); match(R_BRACKET); } } - setState(599); + setState(601); match(L_PAREN); - setState(600); + setState(602); expression(0); - setState(601); + setState(603); match(R_PAREN); } } @@ -2185,20 +2185,20 @@ public final OldLabelUseContext oldLabelUse() throws RecognitionException { OldLabelUseContext _localctx = new OldLabelUseContext(_ctx, getState()); enterRule(_localctx, 58, RULE_oldLabelUse); try { - setState(605); + setState(607); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: enterOuterAlt(_localctx, 1); { - setState(603); + setState(605); labelUse(); } break; case LHS: enterOuterAlt(_localctx, 2); { - setState(604); + setState(606); match(LHS); } break; @@ -2237,7 +2237,7 @@ public final LabelUseContext labelUse() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(607); + setState(609); match(IDENTIFIER); } } @@ -2277,13 +2277,13 @@ public final BeforeContext before() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(609); + setState(611); match(BEFORE); - setState(610); + setState(612); match(L_PAREN); - setState(611); + setState(613); expression(0); - setState(612); + setState(614); match(R_PAREN); } } @@ -2323,13 +2323,13 @@ public final IsComparableContext isComparable() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(614); + setState(616); match(IS_COMPARABLE); - setState(615); + setState(617); match(L_PAREN); - setState(616); + setState(618); expression(0); - setState(617); + setState(619); match(R_PAREN); } } @@ -2369,13 +2369,13 @@ public final TypeOfContext typeOf() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(619); + setState(621); match(TYPE_OF); - setState(620); + setState(622); match(L_PAREN); - setState(621); + setState(623); expression(0); - setState(622); + setState(624); match(R_PAREN); } } @@ -2420,25 +2420,25 @@ public final AccessContext access() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(624); + setState(626); match(ACCESS); - setState(625); + setState(627); match(L_PAREN); - setState(626); + setState(628); expression(0); - setState(629); + setState(631); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(627); + setState(629); match(COMMA); - setState(628); + setState(630); expression(0); } } - setState(631); + setState(633); match(R_PAREN); } } @@ -2486,7 +2486,7 @@ public final RangeContext range() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(633); + setState(635); ((RangeContext)_localctx).kind = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 7696581394432L) != 0)) ) { @@ -2497,15 +2497,15 @@ public final RangeContext range() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(634); - match(L_BRACKET); - setState(635); - expression(0); setState(636); - match(DOT_DOT); + match(L_BRACKET); setState(637); expression(0); setState(638); + match(DOT_DOT); + setState(639); + expression(0); + setState(640); match(R_BRACKET); } } @@ -2558,29 +2558,29 @@ public final MatchExprContext matchExpr() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(640); + setState(642); match(MATCH); - setState(641); + setState(643); expression(0); - setState(642); + setState(644); match(L_CURLY); - setState(648); + setState(650); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(643); + setState(645); matchExprClause(); - setState(644); + setState(646); eos(); } } - setState(650); + setState(652); _errHandler.sync(this); _la = _input.LA(1); } - setState(651); + setState(653); match(R_CURLY); } } @@ -2621,11 +2621,11 @@ public final MatchExprClauseContext matchExprClause() throws RecognitionExceptio try { enterOuterAlt(_localctx, 1); { - setState(653); + setState(655); matchCase(); - setState(654); + setState(656); match(COLON); - setState(655); + setState(657); expression(0); } } @@ -2672,29 +2672,29 @@ public final SeqUpdExpContext seqUpdExp() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(657); + setState(659); match(L_BRACKET); { - setState(658); + setState(660); seqUpdClause(); - setState(663); + setState(665); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(659); + setState(661); match(COMMA); - setState(660); + setState(662); seqUpdClause(); } } - setState(665); + setState(667); _errHandler.sync(this); _la = _input.LA(1); } } - setState(666); + setState(668); match(R_BRACKET); } } @@ -2735,11 +2735,11 @@ public final SeqUpdClauseContext seqUpdClause() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(668); + setState(670); expression(0); - setState(669); + setState(671); match(ASSIGN); - setState(670); + setState(672); expression(0); } } @@ -2783,7 +2783,7 @@ public final GhostTypeLitContext ghostTypeLit() throws RecognitionException { GhostTypeLitContext _localctx = new GhostTypeLitContext(_ctx, getState()); enterRule(_localctx, 80, RULE_ghostTypeLit); try { - setState(676); + setState(678); _errHandler.sync(this); switch (_input.LA(1)) { case SEQ: @@ -2793,28 +2793,28 @@ public final GhostTypeLitContext ghostTypeLit() throws RecognitionException { case OPT: enterOuterAlt(_localctx, 1); { - setState(672); + setState(674); sqType(); } break; case GHOST: enterOuterAlt(_localctx, 2); { - setState(673); + setState(675); ghostSliceType(); } break; case DOM: enterOuterAlt(_localctx, 3); { - setState(674); + setState(676); domainType(); } break; case ADT: enterOuterAlt(_localctx, 4); { - setState(675); + setState(677); adtType(); } break; @@ -2868,27 +2868,27 @@ public final DomainTypeContext domainType() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(678); + setState(680); match(DOM); - setState(679); + setState(681); match(L_CURLY); - setState(685); + setState(687); _errHandler.sync(this); _la = _input.LA(1); while (_la==AXIOM || _la==FUNC) { { { - setState(680); + setState(682); domainClause(); - setState(681); + setState(683); eos(); } } - setState(687); + setState(689); _errHandler.sync(this); _la = _input.LA(1); } - setState(688); + setState(690); match(R_CURLY); } } @@ -2934,32 +2934,32 @@ public final DomainClauseContext domainClause() throws RecognitionException { DomainClauseContext _localctx = new DomainClauseContext(_ctx, getState()); enterRule(_localctx, 84, RULE_domainClause); try { - setState(699); + setState(701); _errHandler.sync(this); switch (_input.LA(1)) { case FUNC: enterOuterAlt(_localctx, 1); { - setState(690); + setState(692); match(FUNC); - setState(691); + setState(693); match(IDENTIFIER); - setState(692); + setState(694); signature(); } break; case AXIOM: enterOuterAlt(_localctx, 2); { - setState(693); + setState(695); match(AXIOM); - setState(694); + setState(696); match(L_CURLY); - setState(695); + setState(697); expression(0); - setState(696); + setState(698); eos(); - setState(697); + setState(699); match(R_CURLY); } break; @@ -3013,27 +3013,27 @@ public final AdtTypeContext adtType() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(701); + setState(703); match(ADT); - setState(702); + setState(704); match(L_CURLY); - setState(708); + setState(710); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER) { { { - setState(703); + setState(705); adtClause(); - setState(704); + setState(706); eos(); } } - setState(710); + setState(712); _errHandler.sync(this); _la = _input.LA(1); } - setState(711); + setState(713); match(R_CURLY); } } @@ -3053,11 +3053,11 @@ public static class AdtClauseContext extends ParserRuleContext { public TerminalNode IDENTIFIER() { return getToken(GobraParser.IDENTIFIER, 0); } public TerminalNode L_CURLY() { return getToken(GobraParser.L_CURLY, 0); } public TerminalNode R_CURLY() { return getToken(GobraParser.R_CURLY, 0); } - public List fieldDecl() { - return getRuleContexts(FieldDeclContext.class); + public List adtFieldDecl() { + return getRuleContexts(AdtFieldDeclContext.class); } - public FieldDeclContext fieldDecl(int i) { - return getRuleContext(FieldDeclContext.class,i); + public AdtFieldDeclContext adtFieldDecl(int i) { + return getRuleContext(AdtFieldDeclContext.class,i); } public List eos() { return getRuleContexts(EosContext.class); @@ -3083,27 +3083,27 @@ public final AdtClauseContext adtClause() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(713); + setState(715); match(IDENTIFIER); - setState(714); + setState(716); match(L_CURLY); - setState(720); + setState(722); _errHandler.sync(this); _la = _input.LA(1); - while (_la==IDENTIFIER || _la==STAR) { + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 83350678101032960L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441151881345761731L) != 0)) { { { - setState(715); - fieldDecl(); - setState(716); + setState(717); + adtFieldDecl(); + setState(718); eos(); } } - setState(722); + setState(724); _errHandler.sync(this); _la = _input.LA(1); } - setState(723); + setState(725); match(R_CURLY); } } @@ -3118,6 +3118,56 @@ public final AdtClauseContext adtClause() throws RecognitionException { return _localctx; } + @SuppressWarnings("CheckReturnValue") + public static class AdtFieldDeclContext extends ParserRuleContext { + public Type_Context type_() { + return getRuleContext(Type_Context.class,0); + } + public IdentifierListContext identifierList() { + return getRuleContext(IdentifierListContext.class,0); + } + public AdtFieldDeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_adtFieldDecl; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof GobraParserVisitor ) return ((GobraParserVisitor)visitor).visitAdtFieldDecl(this); + else return visitor.visitChildren(this); + } + } + + public final AdtFieldDeclContext adtFieldDecl() throws RecognitionException { + AdtFieldDeclContext _localctx = new AdtFieldDeclContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_adtFieldDecl); + try { + enterOuterAlt(_localctx, 1); + { + setState(728); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { + case 1: + { + setState(727); + identifierList(); + } + break; + } + setState(730); + type_(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + @SuppressWarnings("CheckReturnValue") public static class GhostSliceTypeContext extends ParserRuleContext { public TerminalNode GHOST() { return getToken(GobraParser.GHOST, 0); } @@ -3139,17 +3189,17 @@ public T accept(ParseTreeVisitor visitor) { public final GhostSliceTypeContext ghostSliceType() throws RecognitionException { GhostSliceTypeContext _localctx = new GhostSliceTypeContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_ghostSliceType); + enterRule(_localctx, 92, RULE_ghostSliceType); try { enterOuterAlt(_localctx, 1); { - setState(725); + setState(732); match(GHOST); - setState(726); + setState(733); match(L_BRACKET); - setState(727); + setState(734); match(R_BRACKET); - setState(728); + setState(735); elementType(); } } @@ -3193,10 +3243,10 @@ public T accept(ParseTreeVisitor visitor) { public final SqTypeContext sqType() throws RecognitionException { SqTypeContext _localctx = new SqTypeContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_sqType); + enterRule(_localctx, 94, RULE_sqType); int _la; try { - setState(741); + setState(748); _errHandler.sync(this); switch (_input.LA(1)) { case SEQ: @@ -3206,7 +3256,7 @@ public final SqTypeContext sqType() throws RecognitionException { enterOuterAlt(_localctx, 1); { { - setState(730); + setState(737); ((SqTypeContext)_localctx).kind = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 25288767438848L) != 0)) ) { @@ -3217,11 +3267,11 @@ public final SqTypeContext sqType() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(731); + setState(738); match(L_BRACKET); - setState(732); + setState(739); type_(); - setState(733); + setState(740); match(R_BRACKET); } } @@ -3229,15 +3279,15 @@ public final SqTypeContext sqType() throws RecognitionException { case DICT: enterOuterAlt(_localctx, 2); { - setState(735); + setState(742); ((SqTypeContext)_localctx).kind = match(DICT); - setState(736); + setState(743); match(L_BRACKET); - setState(737); + setState(744); type_(); - setState(738); + setState(745); match(R_BRACKET); - setState(739); + setState(746); type_(); } break; @@ -3293,20 +3343,20 @@ public T accept(ParseTreeVisitor visitor) { public final SpecificationContext specification() throws RecognitionException { SpecificationContext _localctx = new SpecificationContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_specification); + enterRule(_localctx, 96, RULE_specification); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(753); + setState(760); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,34,_ctx); + _alt = getInterpreter().adaptivePredict(_input,35,_ctx); while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1+1 ) { { { - setState(748); + setState(755); _errHandler.sync(this); switch (_input.LA(1)) { case PRE: @@ -3314,20 +3364,20 @@ public final SpecificationContext specification() throws RecognitionException { case POST: case DEC: { - setState(743); + setState(750); specStatement(); } break; case PURE: { - setState(744); + setState(751); match(PURE); ((SpecificationContext)_localctx).pure = true; } break; case TRUSTED: { - setState(746); + setState(753); match(TRUSTED); ((SpecificationContext)_localctx).trusted = true; } @@ -3335,21 +3385,21 @@ public final SpecificationContext specification() throws RecognitionException { default: throw new NoViableAltException(this); } - setState(750); + setState(757); eos(); } } } - setState(755); + setState(762); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,34,_ctx); + _alt = getInterpreter().adaptivePredict(_input,35,_ctx); } - setState(758); + setState(765); _errHandler.sync(this); _la = _input.LA(1); if (_la==PURE) { { - setState(756); + setState(763); match(PURE); ((SpecificationContext)_localctx).pure = true; } @@ -3394,44 +3444,44 @@ public T accept(ParseTreeVisitor visitor) { public final SpecStatementContext specStatement() throws RecognitionException { SpecStatementContext _localctx = new SpecStatementContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_specStatement); + enterRule(_localctx, 98, RULE_specStatement); try { - setState(768); + setState(775); _errHandler.sync(this); switch (_input.LA(1)) { case PRE: enterOuterAlt(_localctx, 1); { - setState(760); + setState(767); ((SpecStatementContext)_localctx).kind = match(PRE); - setState(761); + setState(768); assertion(); } break; case PRESERVES: enterOuterAlt(_localctx, 2); { - setState(762); + setState(769); ((SpecStatementContext)_localctx).kind = match(PRESERVES); - setState(763); + setState(770); assertion(); } break; case POST: enterOuterAlt(_localctx, 3); { - setState(764); + setState(771); ((SpecStatementContext)_localctx).kind = match(POST); - setState(765); + setState(772); assertion(); } break; case DEC: enterOuterAlt(_localctx, 4); { - setState(766); + setState(773); ((SpecStatementContext)_localctx).kind = match(DEC); - setState(767); + setState(774); terminationMeasure(); } break; @@ -3472,28 +3522,28 @@ public T accept(ParseTreeVisitor visitor) { public final TerminationMeasureContext terminationMeasure() throws RecognitionException { TerminationMeasureContext _localctx = new TerminationMeasureContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_terminationMeasure); + enterRule(_localctx, 100, RULE_terminationMeasure); try { enterOuterAlt(_localctx, 1); { - setState(771); + setState(778); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { case 1: { - setState(770); + setState(777); expressionList(); } break; } - setState(775); + setState(782); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { case 1: { - setState(773); + setState(780); match(IF); - setState(774); + setState(781); expression(0); } break; @@ -3529,11 +3579,11 @@ public T accept(ParseTreeVisitor visitor) { public final AssertionContext assertion() throws RecognitionException { AssertionContext _localctx = new AssertionContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_assertion); + enterRule(_localctx, 102, RULE_assertion); try { - setState(779); + setState(786); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { @@ -3542,7 +3592,7 @@ public final AssertionContext assertion() throws RecognitionException { case 2: enterOuterAlt(_localctx, 2); { - setState(778); + setState(785); expression(0); } break; @@ -3586,32 +3636,32 @@ public T accept(ParseTreeVisitor visitor) { public final MatchStmtContext matchStmt() throws RecognitionException { MatchStmtContext _localctx = new MatchStmtContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_matchStmt); + enterRule(_localctx, 104, RULE_matchStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(781); + setState(788); match(MATCH); - setState(782); + setState(789); expression(0); - setState(783); + setState(790); match(L_CURLY); - setState(787); + setState(794); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(784); + setState(791); matchStmtClause(); } } - setState(789); + setState(796); _errHandler.sync(this); _la = _input.LA(1); } - setState(790); + setState(797); match(R_CURLY); } } @@ -3648,20 +3698,20 @@ public T accept(ParseTreeVisitor visitor) { public final MatchStmtClauseContext matchStmtClause() throws RecognitionException { MatchStmtClauseContext _localctx = new MatchStmtClauseContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_matchStmtClause); + enterRule(_localctx, 106, RULE_matchStmtClause); try { enterOuterAlt(_localctx, 1); { - setState(792); + setState(799); matchCase(); - setState(793); + setState(800); match(COLON); - setState(795); + setState(802); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { case 1: { - setState(794); + setState(801); statementList(); } break; @@ -3699,24 +3749,24 @@ public T accept(ParseTreeVisitor visitor) { public final MatchCaseContext matchCase() throws RecognitionException { MatchCaseContext _localctx = new MatchCaseContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_matchCase); + enterRule(_localctx, 108, RULE_matchCase); try { - setState(800); + setState(807); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { - setState(797); + setState(804); match(CASE); - setState(798); + setState(805); matchPattern(); } break; case DEFAULT: enterOuterAlt(_localctx, 2); { - setState(799); + setState(806); match(DEFAULT); } break; @@ -3791,19 +3841,19 @@ public T accept(ParseTreeVisitor visitor) { public final MatchPatternContext matchPattern() throws RecognitionException { MatchPatternContext _localctx = new MatchPatternContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_matchPattern); + enterRule(_localctx, 110, RULE_matchPattern); int _la; try { - setState(815); + setState(822); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) { case 1: _localctx = new MatchPatternBindContext(_localctx); enterOuterAlt(_localctx, 1); { - setState(802); + setState(809); match(QMARK); - setState(803); + setState(810); match(IDENTIFIER); } break; @@ -3811,23 +3861,23 @@ public final MatchPatternContext matchPattern() throws RecognitionException { _localctx = new MatchPatternCompositeContext(_localctx); enterOuterAlt(_localctx, 2); { - setState(804); + setState(811); literalType(); - setState(805); + setState(812); match(L_CURLY); - setState(810); + setState(817); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956190846021146L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(806); + setState(813); matchPatternList(); - setState(808); + setState(815); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(807); + setState(814); match(COMMA); } } @@ -3835,7 +3885,7 @@ public final MatchPatternContext matchPattern() throws RecognitionException { } } - setState(812); + setState(819); match(R_CURLY); } break; @@ -3843,7 +3893,7 @@ public final MatchPatternContext matchPattern() throws RecognitionException { _localctx = new MatchPatternValueContext(_localctx); enterOuterAlt(_localctx, 3); { - setState(814); + setState(821); expression(0); } break; @@ -3885,30 +3935,30 @@ public T accept(ParseTreeVisitor visitor) { public final MatchPatternListContext matchPatternList() throws RecognitionException { MatchPatternListContext _localctx = new MatchPatternListContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_matchPatternList); + enterRule(_localctx, 112, RULE_matchPatternList); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(817); + setState(824); matchPattern(); - setState(822); + setState(829); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,46,_ctx); + _alt = getInterpreter().adaptivePredict(_input,47,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(818); + setState(825); match(COMMA); - setState(819); + setState(826); matchPattern(); } } } - setState(824); + setState(831); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,46,_ctx); + _alt = getInterpreter().adaptivePredict(_input,47,_ctx); } } } @@ -3950,37 +4000,37 @@ public T accept(ParseTreeVisitor visitor) { public final BlockWithBodyParameterInfoContext blockWithBodyParameterInfo() throws RecognitionException { BlockWithBodyParameterInfoContext _localctx = new BlockWithBodyParameterInfoContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_blockWithBodyParameterInfo); + enterRule(_localctx, 114, RULE_blockWithBodyParameterInfo); try { enterOuterAlt(_localctx, 1); { - setState(825); + setState(832); match(L_CURLY); - setState(830); + setState(837); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { case 1: { - setState(826); + setState(833); match(SHARE); - setState(827); + setState(834); identifierList(); - setState(828); + setState(835); eos(); } break; } - setState(833); + setState(840); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { case 1: { - setState(832); + setState(839); statementList(); } break; } - setState(835); + setState(842); match(R_CURLY); } } @@ -4020,47 +4070,47 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureSpecInstanceContext closureSpecInstance() throws RecognitionException { ClosureSpecInstanceContext _localctx = new ClosureSpecInstanceContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_closureSpecInstance); + enterRule(_localctx, 116, RULE_closureSpecInstance); int _la; try { enterOuterAlt(_localctx, 1); { - setState(839); + setState(846); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { case 1: { - setState(837); + setState(844); qualifiedIdent(); } break; case 2: { - setState(838); + setState(845); match(IDENTIFIER); } break; } - setState(849); + setState(856); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) { case 1: { - setState(841); + setState(848); match(L_CURLY); - setState(846); + setState(853); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(842); + setState(849); closureSpecParams(); - setState(844); + setState(851); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(843); + setState(850); match(COMMA); } } @@ -4068,7 +4118,7 @@ public final ClosureSpecInstanceContext closureSpecInstance() throws Recognition } } - setState(848); + setState(855); match(R_CURLY); } break; @@ -4111,30 +4161,30 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureSpecParamsContext closureSpecParams() throws RecognitionException { ClosureSpecParamsContext _localctx = new ClosureSpecParamsContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_closureSpecParams); + enterRule(_localctx, 118, RULE_closureSpecParams); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(851); + setState(858); closureSpecParam(); - setState(856); + setState(863); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,53,_ctx); + _alt = getInterpreter().adaptivePredict(_input,54,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(852); + setState(859); match(COMMA); - setState(853); + setState(860); closureSpecParam(); } } } - setState(858); + setState(865); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,53,_ctx); + _alt = getInterpreter().adaptivePredict(_input,54,_ctx); } } } @@ -4169,23 +4219,23 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureSpecParamContext closureSpecParam() throws RecognitionException { ClosureSpecParamContext _localctx = new ClosureSpecParamContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_closureSpecParam); + enterRule(_localctx, 120, RULE_closureSpecParam); try { enterOuterAlt(_localctx, 1); { - setState(861); + setState(868); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { case 1: { - setState(859); + setState(866); match(IDENTIFIER); - setState(860); + setState(867); match(COLON); } break; } - setState(863); + setState(870); expression(0); } } @@ -4226,19 +4276,19 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureImplProofStmtContext closureImplProofStmt() throws RecognitionException { ClosureImplProofStmtContext _localctx = new ClosureImplProofStmtContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_closureImplProofStmt); + enterRule(_localctx, 122, RULE_closureImplProofStmt); try { enterOuterAlt(_localctx, 1); { - setState(865); + setState(872); match(PROOF); - setState(866); + setState(873); expression(0); - setState(867); + setState(874); match(IMPL); - setState(868); + setState(875); closureSpecInstance(); - setState(869); + setState(876); block(); } } @@ -4295,57 +4345,57 @@ public T accept(ParseTreeVisitor visitor) { public final ImplementationProofContext implementationProof() throws RecognitionException { ImplementationProofContext _localctx = new ImplementationProofContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_implementationProof); + enterRule(_localctx, 124, RULE_implementationProof); int _la; try { enterOuterAlt(_localctx, 1); { - setState(871); + setState(878); type_(); - setState(872); + setState(879); match(IMPL); - setState(873); + setState(880); type_(); - setState(892); + setState(899); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) { case 1: { - setState(874); + setState(881); match(L_CURLY); - setState(880); + setState(887); _errHandler.sync(this); _la = _input.LA(1); while (_la==PRED) { { { - setState(875); + setState(882); implementationProofPredicateAlias(); - setState(876); + setState(883); eos(); } } - setState(882); + setState(889); _errHandler.sync(this); _la = _input.LA(1); } - setState(888); + setState(895); _errHandler.sync(this); _la = _input.LA(1); while (_la==PURE || _la==L_PAREN) { { { - setState(883); + setState(890); methodImplementationProof(); - setState(884); + setState(891); eos(); } } - setState(890); + setState(897); _errHandler.sync(this); _la = _input.LA(1); } - setState(891); + setState(898); match(R_CURLY); } break; @@ -4389,33 +4439,33 @@ public T accept(ParseTreeVisitor visitor) { public final MethodImplementationProofContext methodImplementationProof() throws RecognitionException { MethodImplementationProofContext _localctx = new MethodImplementationProofContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_methodImplementationProof); + enterRule(_localctx, 126, RULE_methodImplementationProof); int _la; try { enterOuterAlt(_localctx, 1); { - setState(895); + setState(902); _errHandler.sync(this); _la = _input.LA(1); if (_la==PURE) { { - setState(894); + setState(901); match(PURE); } } - setState(897); + setState(904); nonLocalReceiver(); - setState(898); + setState(905); match(IDENTIFIER); - setState(899); + setState(906); signature(); - setState(901); + setState(908); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { case 1: { - setState(900); + setState(907); block(); } break; @@ -4455,36 +4505,36 @@ public T accept(ParseTreeVisitor visitor) { public final NonLocalReceiverContext nonLocalReceiver() throws RecognitionException { NonLocalReceiverContext _localctx = new NonLocalReceiverContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_nonLocalReceiver); + enterRule(_localctx, 128, RULE_nonLocalReceiver); int _la; try { enterOuterAlt(_localctx, 1); { - setState(903); + setState(910); match(L_PAREN); - setState(905); + setState(912); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) { case 1: { - setState(904); + setState(911); match(IDENTIFIER); } break; } - setState(908); + setState(915); _errHandler.sync(this); _la = _input.LA(1); if (_la==STAR) { { - setState(907); + setState(914); match(STAR); } } - setState(910); + setState(917); typeName(); - setState(911); + setState(918); match(R_PAREN); } } @@ -4522,26 +4572,26 @@ public T accept(ParseTreeVisitor visitor) { public final SelectionContext selection() throws RecognitionException { SelectionContext _localctx = new SelectionContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_selection); + enterRule(_localctx, 130, RULE_selection); try { - setState(918); + setState(925); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(913); + setState(920); primaryExpr(0); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(914); + setState(921); type_(); - setState(915); + setState(922); match(DOT); - setState(916); + setState(923); match(IDENTIFIER); } break; @@ -4582,28 +4632,28 @@ public T accept(ParseTreeVisitor visitor) { public final ImplementationProofPredicateAliasContext implementationProofPredicateAlias() throws RecognitionException { ImplementationProofPredicateAliasContext _localctx = new ImplementationProofPredicateAliasContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_implementationProofPredicateAlias); + enterRule(_localctx, 132, RULE_implementationProofPredicateAlias); try { enterOuterAlt(_localctx, 1); { - setState(920); + setState(927); match(PRED); - setState(921); + setState(928); match(IDENTIFIER); - setState(922); + setState(929); match(DECLARE_ASSIGN); - setState(925); + setState(932); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { case 1: { - setState(923); + setState(930); selection(); } break; case 2: { - setState(924); + setState(931); operandName(); } break; @@ -4646,30 +4696,30 @@ public T accept(ParseTreeVisitor visitor) { public final MakeContext make() throws RecognitionException { MakeContext _localctx = new MakeContext(_ctx, getState()); - enterRule(_localctx, 132, RULE_make); + enterRule(_localctx, 134, RULE_make); int _la; try { enterOuterAlt(_localctx, 1); { - setState(927); + setState(934); match(MAKE); - setState(928); + setState(935); match(L_PAREN); - setState(929); + setState(936); type_(); - setState(932); + setState(939); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(930); + setState(937); match(COMMA); - setState(931); + setState(938); expressionList(); } } - setState(934); + setState(941); match(R_PAREN); } } @@ -4705,17 +4755,17 @@ public T accept(ParseTreeVisitor visitor) { public final New_Context new_() throws RecognitionException { New_Context _localctx = new New_Context(_ctx, getState()); - enterRule(_localctx, 134, RULE_new_); + enterRule(_localctx, 136, RULE_new_); try { enterOuterAlt(_localctx, 1); { - setState(936); + setState(943); match(NEW); - setState(937); + setState(944); match(L_PAREN); - setState(938); + setState(945); type_(); - setState(939); + setState(946); match(R_PAREN); } } @@ -4755,24 +4805,24 @@ public T accept(ParseTreeVisitor visitor) { public final SpecMemberContext specMember() throws RecognitionException { SpecMemberContext _localctx = new SpecMemberContext(_ctx, getState()); - enterRule(_localctx, 136, RULE_specMember); + enterRule(_localctx, 138, RULE_specMember); try { enterOuterAlt(_localctx, 1); { - setState(941); + setState(948); ((SpecMemberContext)_localctx).specification = specification(); - setState(944); + setState(951); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) { case 1: { - setState(942); + setState(949); functionDecl(((SpecMemberContext)_localctx).specification.trusted, ((SpecMemberContext)_localctx).specification.pure); } break; case 2: { - setState(943); + setState(950); methodDecl(((SpecMemberContext)_localctx).specification.trusted, ((SpecMemberContext)_localctx).specification.pure); } break; @@ -4818,23 +4868,23 @@ public T accept(ParseTreeVisitor visitor) { public final FunctionDeclContext functionDecl(boolean trusted,boolean pure) throws RecognitionException { FunctionDeclContext _localctx = new FunctionDeclContext(_ctx, getState(), trusted, pure); - enterRule(_localctx, 138, RULE_functionDecl); + enterRule(_localctx, 140, RULE_functionDecl); try { enterOuterAlt(_localctx, 1); { - setState(946); + setState(953); match(FUNC); - setState(947); + setState(954); match(IDENTIFIER); { - setState(948); + setState(955); signature(); - setState(950); + setState(957); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { case 1: { - setState(949); + setState(956); blockWithBodyParameterInfo(); } break; @@ -4884,25 +4934,25 @@ public T accept(ParseTreeVisitor visitor) { public final MethodDeclContext methodDecl(boolean trusted,boolean pure) throws RecognitionException { MethodDeclContext _localctx = new MethodDeclContext(_ctx, getState(), trusted, pure); - enterRule(_localctx, 140, RULE_methodDecl); + enterRule(_localctx, 142, RULE_methodDecl); try { enterOuterAlt(_localctx, 1); { - setState(952); + setState(959); match(FUNC); - setState(953); + setState(960); receiver(); - setState(954); + setState(961); match(IDENTIFIER); { - setState(955); + setState(962); signature(); - setState(957); + setState(964); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) { case 1: { - setState(956); + setState(963); blockWithBodyParameterInfo(); } break; @@ -4943,13 +4993,13 @@ public T accept(ParseTreeVisitor visitor) { public final ExplicitGhostMemberContext explicitGhostMember() throws RecognitionException { ExplicitGhostMemberContext _localctx = new ExplicitGhostMemberContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_explicitGhostMember); + enterRule(_localctx, 144, RULE_explicitGhostMember); try { enterOuterAlt(_localctx, 1); { - setState(959); + setState(966); match(GHOST); - setState(962); + setState(969); _errHandler.sync(this); switch (_input.LA(1)) { case PRE: @@ -4960,7 +5010,7 @@ public final ExplicitGhostMemberContext explicitGhostMember() throws Recognition case TRUSTED: case FUNC: { - setState(960); + setState(967); specMember(); } break; @@ -4968,7 +5018,7 @@ public final ExplicitGhostMemberContext explicitGhostMember() throws Recognition case TYPE: case VAR: { - setState(961); + setState(968); declaration(); } break; @@ -5011,22 +5061,22 @@ public T accept(ParseTreeVisitor visitor) { public final FpredicateDeclContext fpredicateDecl() throws RecognitionException { FpredicateDeclContext _localctx = new FpredicateDeclContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_fpredicateDecl); + enterRule(_localctx, 146, RULE_fpredicateDecl); try { enterOuterAlt(_localctx, 1); { - setState(964); + setState(971); match(PRED); - setState(965); + setState(972); match(IDENTIFIER); - setState(966); + setState(973); parameters(); - setState(968); + setState(975); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { case 1: { - setState(967); + setState(974); predicateBody(); } break; @@ -5067,17 +5117,17 @@ public T accept(ParseTreeVisitor visitor) { public final PredicateBodyContext predicateBody() throws RecognitionException { PredicateBodyContext _localctx = new PredicateBodyContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_predicateBody); + enterRule(_localctx, 148, RULE_predicateBody); try { enterOuterAlt(_localctx, 1); { - setState(970); + setState(977); match(L_CURLY); - setState(971); + setState(978); expression(0); - setState(972); + setState(979); eos(); - setState(973); + setState(980); match(R_CURLY); } } @@ -5118,24 +5168,24 @@ public T accept(ParseTreeVisitor visitor) { public final MpredicateDeclContext mpredicateDecl() throws RecognitionException { MpredicateDeclContext _localctx = new MpredicateDeclContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_mpredicateDecl); + enterRule(_localctx, 150, RULE_mpredicateDecl); try { enterOuterAlt(_localctx, 1); { - setState(975); + setState(982); match(PRED); - setState(976); + setState(983); receiver(); - setState(977); + setState(984); match(IDENTIFIER); - setState(978); + setState(985); parameters(); - setState(980); + setState(987); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { case 1: { - setState(979); + setState(986); predicateBody(); } break; @@ -5178,13 +5228,13 @@ public T accept(ParseTreeVisitor visitor) { public final VarSpecContext varSpec() throws RecognitionException { VarSpecContext _localctx = new VarSpecContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_varSpec); + enterRule(_localctx, 152, RULE_varSpec); try { enterOuterAlt(_localctx, 1); { - setState(982); + setState(989); maybeAddressableIdentifierList(); - setState(990); + setState(997); _errHandler.sync(this); switch (_input.LA(1)) { case GHOST: @@ -5207,16 +5257,16 @@ public final VarSpecContext varSpec() throws RecognitionException { case STAR: case RECEIVE: { - setState(983); + setState(990); type_(); - setState(986); + setState(993); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { case 1: { - setState(984); + setState(991); match(ASSIGN); - setState(985); + setState(992); expressionList(); } break; @@ -5225,9 +5275,9 @@ public final VarSpecContext varSpec() throws RecognitionException { break; case ASSIGN: { - setState(988); + setState(995); match(ASSIGN); - setState(989); + setState(996); expressionList(); } break; @@ -5269,15 +5319,15 @@ public T accept(ParseTreeVisitor visitor) { public final ShortVarDeclContext shortVarDecl() throws RecognitionException { ShortVarDeclContext _localctx = new ShortVarDeclContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_shortVarDecl); + enterRule(_localctx, 154, RULE_shortVarDecl); try { enterOuterAlt(_localctx, 1); { - setState(992); + setState(999); maybeAddressableIdentifierList(); - setState(993); + setState(1000); match(DECLARE_ASSIGN); - setState(994); + setState(1001); expressionList(); } } @@ -5316,36 +5366,36 @@ public T accept(ParseTreeVisitor visitor) { public final ReceiverContext receiver() throws RecognitionException { ReceiverContext _localctx = new ReceiverContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_receiver); + enterRule(_localctx, 156, RULE_receiver); int _la; try { enterOuterAlt(_localctx, 1); { - setState(996); + setState(1003); match(L_PAREN); - setState(998); + setState(1005); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) { case 1: { - setState(997); + setState(1004); maybeAddressableIdentifier(); } break; } - setState(1000); + setState(1007); type_(); - setState(1002); + setState(1009); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1001); + setState(1008); match(COMMA); } } - setState(1004); + setState(1011); match(R_PAREN); } } @@ -5381,22 +5431,22 @@ public T accept(ParseTreeVisitor visitor) { public final ParameterDeclContext parameterDecl() throws RecognitionException { ParameterDeclContext _localctx = new ParameterDeclContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_parameterDecl); + enterRule(_localctx, 158, RULE_parameterDecl); try { - setState(1008); + setState(1015); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1006); + setState(1013); actualParameterDecl(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1007); + setState(1014); ghostParameterDecl(); } break; @@ -5434,21 +5484,21 @@ public T accept(ParseTreeVisitor visitor) { public final ActualParameterDeclContext actualParameterDecl() throws RecognitionException { ActualParameterDeclContext _localctx = new ActualParameterDeclContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_actualParameterDecl); + enterRule(_localctx, 160, RULE_actualParameterDecl); try { enterOuterAlt(_localctx, 1); { - setState(1011); + setState(1018); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { case 1: { - setState(1010); + setState(1017); identifierList(); } break; } - setState(1013); + setState(1020); parameterType(); } } @@ -5485,23 +5535,23 @@ public T accept(ParseTreeVisitor visitor) { public final GhostParameterDeclContext ghostParameterDecl() throws RecognitionException { GhostParameterDeclContext _localctx = new GhostParameterDeclContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_ghostParameterDecl); + enterRule(_localctx, 162, RULE_ghostParameterDecl); try { enterOuterAlt(_localctx, 1); { - setState(1015); + setState(1022); match(GHOST); - setState(1017); + setState(1024); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { case 1: { - setState(1016); + setState(1023); identifierList(); } break; } - setState(1019); + setState(1026); parameterType(); } } @@ -5535,22 +5585,22 @@ public T accept(ParseTreeVisitor visitor) { public final ParameterTypeContext parameterType() throws RecognitionException { ParameterTypeContext _localctx = new ParameterTypeContext(_ctx, getState()); - enterRule(_localctx, 162, RULE_parameterType); + enterRule(_localctx, 164, RULE_parameterType); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1022); + setState(1029); _errHandler.sync(this); _la = _input.LA(1); if (_la==ELLIPSIS) { { - setState(1021); + setState(1028); match(ELLIPSIS); } } - setState(1024); + setState(1031); type_(); } } @@ -5865,23 +5915,23 @@ private ExpressionContext expression(int _p) throws RecognitionException { int _parentState = getState(); ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); ExpressionContext _prevctx = _localctx; - int _startState = 164; - enterRecursionRule(_localctx, 164, RULE_expression, _p); + int _startState = 166; + enterRecursionRule(_localctx, 166, RULE_expression, _p); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1047); + setState(1054); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { case 1: { _localctx = new UnaryExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1027); + setState(1034); ((UnaryExprContext)_localctx).unary_op = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 127L) != 0)) ) { @@ -5892,7 +5942,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1028); + setState(1035); expression(15); } break; @@ -5901,7 +5951,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new PrimaryExpr_Context(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1029); + setState(1036); primaryExpr(0); } break; @@ -5910,13 +5960,13 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new UnfoldingContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1030); + setState(1037); match(UNFOLDING); - setState(1031); + setState(1038); predicateAccess(); - setState(1032); + setState(1039); match(IN); - setState(1033); + setState(1040); expression(3); } break; @@ -5925,13 +5975,13 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new LetContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1035); + setState(1042); match(LET); - setState(1036); + setState(1043); shortVarDecl(); - setState(1037); + setState(1044); match(IN); - setState(1038); + setState(1045); expression(2); } break; @@ -5940,7 +5990,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new QuantificationContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1040); + setState(1047); _la = _input.LA(1); if ( !(_la==FORALL || _la==EXISTS) ) { _errHandler.recoverInline(this); @@ -5950,38 +6000,38 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1041); + setState(1048); boundVariables(); - setState(1042); + setState(1049); match(COLON); - setState(1043); + setState(1050); match(COLON); - setState(1044); + setState(1051); triggers(); - setState(1045); + setState(1052); expression(1); } break; } _ctx.stop = _input.LT(-1); - setState(1084); + setState(1091); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,81,_ctx); + _alt = getInterpreter().adaptivePredict(_input,82,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { - setState(1082); + setState(1089); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { case 1: { _localctx = new MulExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1049); + setState(1056); if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); - setState(1050); + setState(1057); ((MulExprContext)_localctx).mul_op = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & 1567L) != 0)) ) { @@ -5992,7 +6042,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1051); + setState(1058); expression(14); } break; @@ -6000,9 +6050,9 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new AddExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1052); + setState(1059); if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); - setState(1053); + setState(1060); ((AddExprContext)_localctx).add_op = _input.LT(1); _la = _input.LA(1); if ( !(_la==WAND || ((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & 3674113L) != 0)) ) { @@ -6013,7 +6063,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1054); + setState(1061); expression(13); } break; @@ -6021,9 +6071,9 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new P42ExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1055); + setState(1062); if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); - setState(1056); + setState(1063); ((P42ExprContext)_localctx).p42_op = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 15032385536L) != 0)) ) { @@ -6034,7 +6084,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1057); + setState(1064); expression(12); } break; @@ -6042,9 +6092,9 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new P41ExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1058); + setState(1065); if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); - setState(1059); + setState(1066); ((P41ExprContext)_localctx).p41_op = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1879048192L) != 0)) ) { @@ -6055,7 +6105,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1060); + setState(1067); expression(11); } break; @@ -6063,9 +6113,9 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new RelExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1061); + setState(1068); if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); - setState(1062); + setState(1069); ((RelExprContext)_localctx).rel_op = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 8866461766385667L) != 0)) ) { @@ -6076,7 +6126,7 @@ private ExpressionContext expression(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1063); + setState(1070); expression(10); } break; @@ -6084,11 +6134,11 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new AndExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1064); + setState(1071); if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); - setState(1065); + setState(1072); match(LOGICAL_AND); - setState(1066); + setState(1073); expression(8); } break; @@ -6096,11 +6146,11 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new OrExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1067); + setState(1074); if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); - setState(1068); + setState(1075); match(LOGICAL_OR); - setState(1069); + setState(1076); expression(7); } break; @@ -6108,11 +6158,11 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new ImplicationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1070); + setState(1077); if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); - setState(1071); + setState(1078); match(IMPLIES); - setState(1072); + setState(1079); expression(5); } break; @@ -6120,15 +6170,15 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new TernaryExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1073); + setState(1080); if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); - setState(1074); + setState(1081); match(QMARK); - setState(1075); + setState(1082); expression(0); - setState(1076); + setState(1083); match(COLON); - setState(1077); + setState(1084); expression(4); } break; @@ -6136,20 +6186,20 @@ private ExpressionContext expression(int _p) throws RecognitionException { { _localctx = new ClosureImplSpecExprContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1079); + setState(1086); if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); - setState(1080); + setState(1087); match(IMPL); - setState(1081); + setState(1088); closureSpecInstance(); } break; } } } - setState(1086); + setState(1093); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,81,_ctx); + _alt = getInterpreter().adaptivePredict(_input,82,_ctx); } } } @@ -6239,148 +6289,148 @@ public T accept(ParseTreeVisitor visitor) { public final StatementContext statement() throws RecognitionException { StatementContext _localctx = new StatementContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_statement); + enterRule(_localctx, 168, RULE_statement); try { - setState(1107); + setState(1114); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1087); + setState(1094); ghostStatement(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1088); + setState(1095); auxiliaryStatement(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1089); + setState(1096); packageStmt(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1090); + setState(1097); applyStmt(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1091); + setState(1098); declaration(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(1092); + setState(1099); labeledStmt(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(1093); + setState(1100); simpleStmt(); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(1094); + setState(1101); goStmt(); } break; case 9: enterOuterAlt(_localctx, 9); { - setState(1095); + setState(1102); returnStmt(); } break; case 10: enterOuterAlt(_localctx, 10); { - setState(1096); + setState(1103); breakStmt(); } break; case 11: enterOuterAlt(_localctx, 11); { - setState(1097); + setState(1104); continueStmt(); } break; case 12: enterOuterAlt(_localctx, 12); { - setState(1098); + setState(1105); gotoStmt(); } break; case 13: enterOuterAlt(_localctx, 13); { - setState(1099); + setState(1106); fallthroughStmt(); } break; case 14: enterOuterAlt(_localctx, 14); { - setState(1100); + setState(1107); block(); } break; case 15: enterOuterAlt(_localctx, 15); { - setState(1101); + setState(1108); ifStmt(); } break; case 16: enterOuterAlt(_localctx, 16); { - setState(1102); + setState(1109); switchStmt(); } break; case 17: enterOuterAlt(_localctx, 17); { - setState(1103); + setState(1110); selectStmt(); } break; case 18: enterOuterAlt(_localctx, 18); { - setState(1104); + setState(1111); specForStmt(); } break; case 19: enterOuterAlt(_localctx, 19); { - setState(1105); + setState(1112); deferStmt(); } break; case 20: enterOuterAlt(_localctx, 20); { - setState(1106); + setState(1113); closureImplProofStmt(); } break; @@ -6416,13 +6466,13 @@ public T accept(ParseTreeVisitor visitor) { public final ApplyStmtContext applyStmt() throws RecognitionException { ApplyStmtContext _localctx = new ApplyStmtContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_applyStmt); + enterRule(_localctx, 170, RULE_applyStmt); try { enterOuterAlt(_localctx, 1); { - setState(1109); + setState(1116); match(APPLY); - setState(1110); + setState(1117); expression(0); } } @@ -6459,20 +6509,20 @@ public T accept(ParseTreeVisitor visitor) { public final PackageStmtContext packageStmt() throws RecognitionException { PackageStmtContext _localctx = new PackageStmtContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_packageStmt); + enterRule(_localctx, 172, RULE_packageStmt); try { enterOuterAlt(_localctx, 1); { - setState(1112); + setState(1119); match(PACKAGE); - setState(1113); + setState(1120); expression(0); - setState(1115); + setState(1122); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) { case 1: { - setState(1114); + setState(1121); block(); } break; @@ -6511,13 +6561,13 @@ public T accept(ParseTreeVisitor visitor) { public final SpecForStmtContext specForStmt() throws RecognitionException { SpecForStmtContext _localctx = new SpecForStmtContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_specForStmt); + enterRule(_localctx, 174, RULE_specForStmt); try { enterOuterAlt(_localctx, 1); { - setState(1117); + setState(1124); loopSpec(); - setState(1118); + setState(1125); forStmt(); } } @@ -6567,39 +6617,39 @@ public T accept(ParseTreeVisitor visitor) { public final LoopSpecContext loopSpec() throws RecognitionException { LoopSpecContext _localctx = new LoopSpecContext(_ctx, getState()); - enterRule(_localctx, 174, RULE_loopSpec); + enterRule(_localctx, 176, RULE_loopSpec); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1126); + setState(1133); _errHandler.sync(this); _la = _input.LA(1); while (_la==INV) { { { - setState(1120); + setState(1127); match(INV); - setState(1121); + setState(1128); expression(0); - setState(1122); + setState(1129); eos(); } } - setState(1128); + setState(1135); _errHandler.sync(this); _la = _input.LA(1); } - setState(1133); + setState(1140); _errHandler.sync(this); _la = _input.LA(1); if (_la==DEC) { { - setState(1129); + setState(1136); match(DEC); - setState(1130); + setState(1137); terminationMeasure(); - setState(1131); + setState(1138); eos(); } } @@ -6642,27 +6692,27 @@ public T accept(ParseTreeVisitor visitor) { public final DeferStmtContext deferStmt() throws RecognitionException { DeferStmtContext _localctx = new DeferStmtContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_deferStmt); + enterRule(_localctx, 178, RULE_deferStmt); int _la; try { - setState(1140); + setState(1147); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1135); + setState(1142); match(DEFER); - setState(1136); + setState(1143); expression(0); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1137); + setState(1144); match(DEFER); - setState(1138); + setState(1145); ((DeferStmtContext)_localctx).fold_stmt = _input.LT(1); _la = _input.LA(1); if ( !(_la==FOLD || _la==UNFOLD) ) { @@ -6673,7 +6723,7 @@ public final DeferStmtContext deferStmt() throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1139); + setState(1146); predicateAccess(); } break; @@ -6717,64 +6767,64 @@ public T accept(ParseTreeVisitor visitor) { public final BasicLitContext basicLit() throws RecognitionException { BasicLitContext _localctx = new BasicLitContext(_ctx, getState()); - enterRule(_localctx, 178, RULE_basicLit); + enterRule(_localctx, 180, RULE_basicLit); try { - setState(1150); + setState(1157); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1142); + setState(1149); match(TRUE); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1143); + setState(1150); match(FALSE); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1144); + setState(1151); match(NIL_LIT); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1145); + setState(1152); integer(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1146); + setState(1153); string_(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(1147); + setState(1154); match(FLOAT_LIT); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(1148); + setState(1155); match(IMAGINARY_LIT); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(1149); + setState(1156); match(RUNE_LIT); } break; @@ -7027,23 +7077,23 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { int _parentState = getState(); PrimaryExprContext _localctx = new PrimaryExprContext(_ctx, _parentState); PrimaryExprContext _prevctx = _localctx; - int _startState = 180; - enterRecursionRule(_localctx, 180, RULE_primaryExpr, _p); + int _startState = 182; + enterRecursionRule(_localctx, 182, RULE_primaryExpr, _p); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1164); + setState(1171); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { case 1: { _localctx = new OperandPrimaryExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1153); + setState(1160); operand(); } break; @@ -7052,7 +7102,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new ConversionPrimaryExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1154); + setState(1161); conversion(); } break; @@ -7061,7 +7111,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new MethodPrimaryExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1155); + setState(1162); methodExpr(); } break; @@ -7070,7 +7120,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new GhostPrimaryExpr_Context(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1156); + setState(1163); ghostPrimaryExpr(); } break; @@ -7079,7 +7129,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new NewExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1157); + setState(1164); new_(); } break; @@ -7088,7 +7138,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new MakeExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1158); + setState(1165); make(); } break; @@ -7097,7 +7147,7 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _localctx = new BuiltInCallExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(1159); + setState(1166); ((BuiltInCallExprContext)_localctx).call_op = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 45)) & ~0x3f) == 0 && ((1L << (_la - 45)) & 281474976710729L) != 0)) ) { @@ -7108,36 +7158,36 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { _errHandler.reportMatch(this); consume(); } - setState(1160); + setState(1167); match(L_PAREN); - setState(1161); + setState(1168); expression(0); - setState(1162); + setState(1169); match(R_PAREN); } break; } _ctx.stop = _input.LT(-1); - setState(1188); + setState(1195); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,90,_ctx); + _alt = getInterpreter().adaptivePredict(_input,91,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { - setState(1186); + setState(1193); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { case 1: { _localctx = new SelectorPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1166); + setState(1173); if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); - setState(1167); + setState(1174); match(DOT); - setState(1168); + setState(1175); match(IDENTIFIER); } break; @@ -7145,9 +7195,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new IndexPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1169); + setState(1176); if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); - setState(1170); + setState(1177); index(); } break; @@ -7155,9 +7205,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new SlicePrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1171); + setState(1178); if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); - setState(1172); + setState(1179); slice_(); } break; @@ -7165,9 +7215,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new SeqUpdPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1173); + setState(1180); if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); - setState(1174); + setState(1181); seqUpdExp(); } break; @@ -7175,9 +7225,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new TypeAssertionPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1175); + setState(1182); if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); - setState(1176); + setState(1183); typeAssertion(); } break; @@ -7185,9 +7235,9 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new InvokePrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1177); + setState(1184); if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); - setState(1178); + setState(1185); arguments(); } break; @@ -7195,13 +7245,13 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new InvokePrimaryExprWithSpecContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1179); + setState(1186); if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(1180); + setState(1187); arguments(); - setState(1181); + setState(1188); match(AS); - setState(1182); + setState(1189); closureSpecInstance(); } break; @@ -7209,18 +7259,18 @@ private PrimaryExprContext primaryExpr(int _p) throws RecognitionException { { _localctx = new PredConstrPrimaryExprContext(new PrimaryExprContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_primaryExpr); - setState(1184); + setState(1191); if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(1185); + setState(1192); predConstructArgs(); } break; } } } - setState(1190); + setState(1197); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,90,_ctx); + _alt = getInterpreter().adaptivePredict(_input,91,_ctx); } } } @@ -7257,13 +7307,13 @@ public T accept(ParseTreeVisitor visitor) { public final FunctionLitContext functionLit() throws RecognitionException { FunctionLitContext _localctx = new FunctionLitContext(_ctx, getState()); - enterRule(_localctx, 182, RULE_functionLit); + enterRule(_localctx, 184, RULE_functionLit); try { enterOuterAlt(_localctx, 1); { - setState(1191); + setState(1198); ((FunctionLitContext)_localctx).specification = specification(); - setState(1192); + setState(1199); closureDecl(((FunctionLitContext)_localctx).specification.trusted, ((FunctionLitContext)_localctx).specification.pure); } } @@ -7306,32 +7356,32 @@ public T accept(ParseTreeVisitor visitor) { public final ClosureDeclContext closureDecl(boolean trusted,boolean pure) throws RecognitionException { ClosureDeclContext _localctx = new ClosureDeclContext(_ctx, getState(), trusted, pure); - enterRule(_localctx, 184, RULE_closureDecl); + enterRule(_localctx, 186, RULE_closureDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1194); + setState(1201); match(FUNC); - setState(1196); + setState(1203); _errHandler.sync(this); _la = _input.LA(1); if (_la==IDENTIFIER) { { - setState(1195); + setState(1202); match(IDENTIFIER); } } { - setState(1198); + setState(1205); signature(); - setState(1200); + setState(1207); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { case 1: { - setState(1199); + setState(1206); blockWithBodyParameterInfo(); } break; @@ -7371,34 +7421,34 @@ public T accept(ParseTreeVisitor visitor) { public final PredConstructArgsContext predConstructArgs() throws RecognitionException { PredConstructArgsContext _localctx = new PredConstructArgsContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_predConstructArgs); + enterRule(_localctx, 188, RULE_predConstructArgs); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1202); + setState(1209); match(L_PRED); - setState(1204); + setState(1211); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1203); + setState(1210); expressionList(); } } - setState(1207); + setState(1214); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1206); + setState(1213); match(COMMA); } } - setState(1209); + setState(1216); match(R_PRED); } } @@ -7455,52 +7505,52 @@ public T accept(ParseTreeVisitor visitor) { public final InterfaceTypeContext interfaceType() throws RecognitionException { InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_interfaceType); + enterRule(_localctx, 190, RULE_interfaceType); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1211); + setState(1218); match(INTERFACE); - setState(1212); + setState(1219); match(L_CURLY); - setState(1222); + setState(1229); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 72057594172173824L) != 0) || _la==TRUSTED || _la==IDENTIFIER) { { { - setState(1216); + setState(1223); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) { case 1: { - setState(1213); + setState(1220); methodSpec(); } break; case 2: { - setState(1214); + setState(1221); typeName(); } break; case 3: { - setState(1215); + setState(1222); predicateSpec(); } break; } - setState(1218); + setState(1225); eos(); } } - setState(1224); + setState(1231); _errHandler.sync(this); _la = _input.LA(1); } - setState(1225); + setState(1232); match(R_CURLY); } } @@ -7535,15 +7585,15 @@ public T accept(ParseTreeVisitor visitor) { public final PredicateSpecContext predicateSpec() throws RecognitionException { PredicateSpecContext _localctx = new PredicateSpecContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_predicateSpec); + enterRule(_localctx, 192, RULE_predicateSpec); try { enterOuterAlt(_localctx, 1); { - setState(1227); + setState(1234); match(PRED); - setState(1228); + setState(1235); match(IDENTIFIER); - setState(1229); + setState(1236); parameters(); } } @@ -7584,53 +7634,53 @@ public T accept(ParseTreeVisitor visitor) { public final MethodSpecContext methodSpec() throws RecognitionException { MethodSpecContext _localctx = new MethodSpecContext(_ctx, getState()); - enterRule(_localctx, 192, RULE_methodSpec); + enterRule(_localctx, 194, RULE_methodSpec); int _la; try { - setState(1246); + setState(1253); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1232); + setState(1239); _errHandler.sync(this); _la = _input.LA(1); if (_la==GHOST) { { - setState(1231); + setState(1238); match(GHOST); } } - setState(1234); + setState(1241); specification(); - setState(1235); + setState(1242); match(IDENTIFIER); - setState(1236); + setState(1243); parameters(); - setState(1237); + setState(1244); result(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1240); + setState(1247); _errHandler.sync(this); _la = _input.LA(1); if (_la==GHOST) { { - setState(1239); + setState(1246); match(GHOST); } } - setState(1242); + setState(1249); specification(); - setState(1243); + setState(1250); match(IDENTIFIER); - setState(1244); + setState(1251); parameters(); } break; @@ -7676,15 +7726,15 @@ public T accept(ParseTreeVisitor visitor) { public final Type_Context type_() throws RecognitionException { Type_Context _localctx = new Type_Context(_ctx, getState()); - enterRule(_localctx, 194, RULE_type_); + enterRule(_localctx, 196, RULE_type_); try { - setState(1255); + setState(1262); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: enterOuterAlt(_localctx, 1); { - setState(1248); + setState(1255); typeName(); } break; @@ -7699,7 +7749,7 @@ public final Type_Context type_() throws RecognitionException { case RECEIVE: enterOuterAlt(_localctx, 2); { - setState(1249); + setState(1256); typeLit(); } break; @@ -7713,18 +7763,18 @@ public final Type_Context type_() throws RecognitionException { case ADT: enterOuterAlt(_localctx, 3); { - setState(1250); + setState(1257); ghostTypeLit(); } break; case L_PAREN: enterOuterAlt(_localctx, 4); { - setState(1251); + setState(1258); match(L_PAREN); - setState(1252); + setState(1259); type_(); - setState(1253); + setState(1260); match(R_PAREN); } break; @@ -7785,71 +7835,71 @@ public T accept(ParseTreeVisitor visitor) { public final TypeLitContext typeLit() throws RecognitionException { TypeLitContext _localctx = new TypeLitContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_typeLit); + enterRule(_localctx, 198, RULE_typeLit); try { - setState(1266); + setState(1273); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1257); + setState(1264); arrayType(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1258); + setState(1265); structType(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1259); + setState(1266); pointerType(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1260); + setState(1267); functionType(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1261); + setState(1268); interfaceType(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(1262); + setState(1269); sliceType(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(1263); + setState(1270); mapType(); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(1264); + setState(1271); channelType(); } break; case 9: enterOuterAlt(_localctx, 9); { - setState(1265); + setState(1272); predType(); } break; @@ -7885,13 +7935,13 @@ public T accept(ParseTreeVisitor visitor) { public final PredTypeContext predType() throws RecognitionException { PredTypeContext _localctx = new PredTypeContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_predType); + enterRule(_localctx, 200, RULE_predType); try { enterOuterAlt(_localctx, 1); { - setState(1268); + setState(1275); match(PRED); - setState(1269); + setState(1276); predTypeParams(); } } @@ -7933,45 +7983,45 @@ public T accept(ParseTreeVisitor visitor) { public final PredTypeParamsContext predTypeParams() throws RecognitionException { PredTypeParamsContext _localctx = new PredTypeParamsContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_predTypeParams); + enterRule(_localctx, 202, RULE_predTypeParams); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1271); + setState(1278); match(L_PAREN); - setState(1283); + setState(1290); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 83350678101032960L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441151881345761731L) != 0)) { { - setState(1272); + setState(1279); type_(); - setState(1277); + setState(1284); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,102,_ctx); + _alt = getInterpreter().adaptivePredict(_input,103,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1273); + setState(1280); match(COMMA); - setState(1274); + setState(1281); type_(); } } } - setState(1279); + setState(1286); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,102,_ctx); + _alt = getInterpreter().adaptivePredict(_input,103,_ctx); } - setState(1281); + setState(1288); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1280); + setState(1287); match(COMMA); } } @@ -7979,7 +8029,7 @@ public final PredTypeParamsContext predTypeParams() throws RecognitionException } } - setState(1285); + setState(1292); match(R_PAREN); } } @@ -8030,57 +8080,57 @@ public T accept(ParseTreeVisitor visitor) { public final LiteralTypeContext literalType() throws RecognitionException { LiteralTypeContext _localctx = new LiteralTypeContext(_ctx, getState()); - enterRule(_localctx, 202, RULE_literalType); + enterRule(_localctx, 204, RULE_literalType); try { - setState(1294); + setState(1301); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1287); + setState(1294); structType(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1288); + setState(1295); arrayType(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1289); + setState(1296); implicitArray(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1290); + setState(1297); sliceType(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1291); + setState(1298); mapType(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(1292); + setState(1299); ghostTypeLit(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(1293); + setState(1300); typeName(); } break; @@ -8118,17 +8168,17 @@ public T accept(ParseTreeVisitor visitor) { public final ImplicitArrayContext implicitArray() throws RecognitionException { ImplicitArrayContext _localctx = new ImplicitArrayContext(_ctx, getState()); - enterRule(_localctx, 204, RULE_implicitArray); + enterRule(_localctx, 206, RULE_implicitArray); try { enterOuterAlt(_localctx, 1); { - setState(1296); + setState(1303); match(L_BRACKET); - setState(1297); + setState(1304); match(ELLIPSIS); - setState(1298); + setState(1305); match(R_BRACKET); - setState(1299); + setState(1306); elementType(); } } @@ -8173,36 +8223,36 @@ public T accept(ParseTreeVisitor visitor) { public final Slice_Context slice_() throws RecognitionException { Slice_Context _localctx = new Slice_Context(_ctx, getState()); - enterRule(_localctx, 206, RULE_slice_); + enterRule(_localctx, 208, RULE_slice_); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1301); + setState(1308); match(L_BRACKET); - setState(1317); + setState(1324); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) { case 1: { - setState(1303); + setState(1310); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1302); + setState(1309); low(); } } - setState(1305); + setState(1312); match(COLON); - setState(1307); + setState(1314); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1306); + setState(1313); high(); } } @@ -8211,28 +8261,28 @@ public final Slice_Context slice_() throws RecognitionException { break; case 2: { - setState(1310); + setState(1317); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1309); + setState(1316); low(); } } - setState(1312); + setState(1319); match(COLON); - setState(1313); + setState(1320); high(); - setState(1314); + setState(1321); match(COLON); - setState(1315); + setState(1322); cap(); } break; } - setState(1319); + setState(1326); match(R_BRACKET); } } @@ -8265,11 +8315,11 @@ public T accept(ParseTreeVisitor visitor) { public final LowContext low() throws RecognitionException { LowContext _localctx = new LowContext(_ctx, getState()); - enterRule(_localctx, 208, RULE_low); + enterRule(_localctx, 210, RULE_low); try { enterOuterAlt(_localctx, 1); { - setState(1321); + setState(1328); expression(0); } } @@ -8302,11 +8352,11 @@ public T accept(ParseTreeVisitor visitor) { public final HighContext high() throws RecognitionException { HighContext _localctx = new HighContext(_ctx, getState()); - enterRule(_localctx, 210, RULE_high); + enterRule(_localctx, 212, RULE_high); try { enterOuterAlt(_localctx, 1); { - setState(1323); + setState(1330); expression(0); } } @@ -8339,11 +8389,11 @@ public T accept(ParseTreeVisitor visitor) { public final CapContext cap() throws RecognitionException { CapContext _localctx = new CapContext(_ctx, getState()); - enterRule(_localctx, 212, RULE_cap); + enterRule(_localctx, 214, RULE_cap); try { enterOuterAlt(_localctx, 1); { - setState(1325); + setState(1332); expression(0); } } @@ -8386,17 +8436,17 @@ public T accept(ParseTreeVisitor visitor) { public final Assign_opContext assign_op() throws RecognitionException { Assign_opContext _localctx = new Assign_opContext(_ctx, getState()); - enterRule(_localctx, 214, RULE_assign_op); + enterRule(_localctx, 216, RULE_assign_op); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1328); + setState(1335); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & 4031L) != 0)) { { - setState(1327); + setState(1334); ((Assign_opContext)_localctx).ass_op = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & 4031L) != 0)) ) { @@ -8410,7 +8460,7 @@ public final Assign_opContext assign_op() throws RecognitionException { } } - setState(1330); + setState(1337); match(ASSIGN); } } @@ -8454,48 +8504,48 @@ public T accept(ParseTreeVisitor visitor) { public final RangeClauseContext rangeClause() throws RecognitionException { RangeClauseContext _localctx = new RangeClauseContext(_ctx, getState()); - enterRule(_localctx, 216, RULE_rangeClause); + enterRule(_localctx, 218, RULE_rangeClause); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1338); + setState(1345); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) { case 1: { - setState(1332); + setState(1339); expressionList(); - setState(1333); + setState(1340); match(ASSIGN); } break; case 2: { - setState(1335); + setState(1342); maybeAddressableIdentifierList(); - setState(1336); + setState(1343); match(DECLARE_ASSIGN); } break; } - setState(1340); + setState(1347); match(RANGE); - setState(1341); + setState(1348); expression(0); - setState(1346); + setState(1353); _errHandler.sync(this); _la = _input.LA(1); if (_la==WITH) { { - setState(1342); + setState(1349); match(WITH); - setState(1344); + setState(1351); _errHandler.sync(this); _la = _input.LA(1); if (_la==IDENTIFIER) { { - setState(1343); + setState(1350); match(IDENTIFIER); } } @@ -8534,13 +8584,13 @@ public T accept(ParseTreeVisitor visitor) { public final PackageClauseContext packageClause() throws RecognitionException { PackageClauseContext _localctx = new PackageClauseContext(_ctx, getState()); - enterRule(_localctx, 218, RULE_packageClause); + enterRule(_localctx, 220, RULE_packageClause); try { enterOuterAlt(_localctx, 1); { - setState(1348); + setState(1355); match(PACKAGE); - setState(1349); + setState(1356); ((PackageClauseContext)_localctx).packageName = match(IDENTIFIER); } } @@ -8573,11 +8623,11 @@ public T accept(ParseTreeVisitor visitor) { public final ImportPathContext importPath() throws RecognitionException { ImportPathContext _localctx = new ImportPathContext(_ctx, getState()); - enterRule(_localctx, 220, RULE_importPath); + enterRule(_localctx, 222, RULE_importPath); try { enterOuterAlt(_localctx, 1); { - setState(1351); + setState(1358); string_(); } } @@ -8616,29 +8666,29 @@ public T accept(ParseTreeVisitor visitor) { public final DeclarationContext declaration() throws RecognitionException { DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); - enterRule(_localctx, 222, RULE_declaration); + enterRule(_localctx, 224, RULE_declaration); try { - setState(1356); + setState(1363); _errHandler.sync(this); switch (_input.LA(1)) { case CONST: enterOuterAlt(_localctx, 1); { - setState(1353); + setState(1360); constDecl(); } break; case TYPE: enterOuterAlt(_localctx, 2); { - setState(1354); + setState(1361); typeDecl(); } break; case VAR: enterOuterAlt(_localctx, 3); { - setState(1355); + setState(1362); varDecl(); } break; @@ -8687,43 +8737,43 @@ public T accept(ParseTreeVisitor visitor) { public final ConstDeclContext constDecl() throws RecognitionException { ConstDeclContext _localctx = new ConstDeclContext(_ctx, getState()); - enterRule(_localctx, 224, RULE_constDecl); + enterRule(_localctx, 226, RULE_constDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1358); + setState(1365); match(CONST); - setState(1370); + setState(1377); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: { - setState(1359); + setState(1366); constSpec(); } break; case L_PAREN: { - setState(1360); + setState(1367); match(L_PAREN); - setState(1366); + setState(1373); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER) { { { - setState(1361); + setState(1368); constSpec(); - setState(1362); + setState(1369); eos(); } } - setState(1368); + setState(1375); _errHandler.sync(this); _la = _input.LA(1); } - setState(1369); + setState(1376); match(R_PAREN); } break; @@ -8768,31 +8818,31 @@ public T accept(ParseTreeVisitor visitor) { public final ConstSpecContext constSpec() throws RecognitionException { ConstSpecContext _localctx = new ConstSpecContext(_ctx, getState()); - enterRule(_localctx, 226, RULE_constSpec); + enterRule(_localctx, 228, RULE_constSpec); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1372); + setState(1379); identifierList(); - setState(1378); + setState(1385); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) { case 1: { - setState(1374); + setState(1381); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 83350678101032960L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441151881345761731L) != 0)) { { - setState(1373); + setState(1380); type_(); } } - setState(1376); + setState(1383); match(ASSIGN); - setState(1377); + setState(1384); expressionList(); } break; @@ -8833,30 +8883,30 @@ public T accept(ParseTreeVisitor visitor) { public final IdentifierListContext identifierList() throws RecognitionException { IdentifierListContext _localctx = new IdentifierListContext(_ctx, getState()); - enterRule(_localctx, 228, RULE_identifierList); + enterRule(_localctx, 230, RULE_identifierList); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1380); + setState(1387); match(IDENTIFIER); - setState(1385); + setState(1392); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,119,_ctx); + _alt = getInterpreter().adaptivePredict(_input,120,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1381); + setState(1388); match(COMMA); - setState(1382); + setState(1389); match(IDENTIFIER); } } } - setState(1387); + setState(1394); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,119,_ctx); + _alt = getInterpreter().adaptivePredict(_input,120,_ctx); } } } @@ -8896,30 +8946,30 @@ public T accept(ParseTreeVisitor visitor) { public final ExpressionListContext expressionList() throws RecognitionException { ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); - enterRule(_localctx, 230, RULE_expressionList); + enterRule(_localctx, 232, RULE_expressionList); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1388); + setState(1395); expression(0); - setState(1393); + setState(1400); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,120,_ctx); + _alt = getInterpreter().adaptivePredict(_input,121,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1389); + setState(1396); match(COMMA); - setState(1390); + setState(1397); expression(0); } } } - setState(1395); + setState(1402); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,120,_ctx); + _alt = getInterpreter().adaptivePredict(_input,121,_ctx); } } } @@ -8964,43 +9014,43 @@ public T accept(ParseTreeVisitor visitor) { public final TypeDeclContext typeDecl() throws RecognitionException { TypeDeclContext _localctx = new TypeDeclContext(_ctx, getState()); - enterRule(_localctx, 232, RULE_typeDecl); + enterRule(_localctx, 234, RULE_typeDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1396); + setState(1403); match(TYPE); - setState(1408); + setState(1415); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: { - setState(1397); + setState(1404); typeSpec(); } break; case L_PAREN: { - setState(1398); + setState(1405); match(L_PAREN); - setState(1404); + setState(1411); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER) { { { - setState(1399); + setState(1406); typeSpec(); - setState(1400); + setState(1407); eos(); } } - setState(1406); + setState(1413); _errHandler.sync(this); _la = _input.LA(1); } - setState(1407); + setState(1414); match(R_PAREN); } break; @@ -9040,24 +9090,24 @@ public T accept(ParseTreeVisitor visitor) { public final TypeSpecContext typeSpec() throws RecognitionException { TypeSpecContext _localctx = new TypeSpecContext(_ctx, getState()); - enterRule(_localctx, 234, RULE_typeSpec); + enterRule(_localctx, 236, RULE_typeSpec); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1410); + setState(1417); match(IDENTIFIER); - setState(1412); + setState(1419); _errHandler.sync(this); _la = _input.LA(1); if (_la==ASSIGN) { { - setState(1411); + setState(1418); match(ASSIGN); } } - setState(1414); + setState(1421); type_(); } } @@ -9102,43 +9152,43 @@ public T accept(ParseTreeVisitor visitor) { public final VarDeclContext varDecl() throws RecognitionException { VarDeclContext _localctx = new VarDeclContext(_ctx, getState()); - enterRule(_localctx, 236, RULE_varDecl); + enterRule(_localctx, 238, RULE_varDecl); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1416); + setState(1423); match(VAR); - setState(1428); + setState(1435); _errHandler.sync(this); switch (_input.LA(1)) { case IDENTIFIER: { - setState(1417); + setState(1424); varSpec(); } break; case L_PAREN: { - setState(1418); + setState(1425); match(L_PAREN); - setState(1424); + setState(1431); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER) { { { - setState(1419); + setState(1426); varSpec(); - setState(1420); + setState(1427); eos(); } } - setState(1426); + setState(1433); _errHandler.sync(this); _la = _input.LA(1); } - setState(1427); + setState(1434); match(R_PAREN); } break; @@ -9178,23 +9228,23 @@ public T accept(ParseTreeVisitor visitor) { public final BlockContext block() throws RecognitionException { BlockContext _localctx = new BlockContext(_ctx, getState()); - enterRule(_localctx, 238, RULE_block); + enterRule(_localctx, 240, RULE_block); try { enterOuterAlt(_localctx, 1); { - setState(1430); + setState(1437); match(L_CURLY); - setState(1432); + setState(1439); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { case 1: { - setState(1431); + setState(1438); statementList(); } break; } - setState(1434); + setState(1441); match(R_CURLY); } } @@ -9244,13 +9294,13 @@ public T accept(ParseTreeVisitor visitor) { public final StatementListContext statementList() throws RecognitionException { StatementListContext _localctx = new StatementListContext(_ctx, getState()); - enterRule(_localctx, 240, RULE_statementList); + enterRule(_localctx, 242, RULE_statementList); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1448); + setState(1455); _errHandler.sync(this); _alt = 1; do { @@ -9258,17 +9308,17 @@ public final StatementListContext statementList() throws RecognitionException { case 1: { { - setState(1443); + setState(1450); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { case 1: { - setState(1437); + setState(1444); _errHandler.sync(this); _la = _input.LA(1); if (_la==SEMI) { { - setState(1436); + setState(1443); match(SEMI); } } @@ -9277,12 +9327,12 @@ public final StatementListContext statementList() throws RecognitionException { break; case 2: { - setState(1440); + setState(1447); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOS) { { - setState(1439); + setState(1446); match(EOS); } } @@ -9291,14 +9341,14 @@ public final StatementListContext statementList() throws RecognitionException { break; case 3: { - setState(1442); + setState(1449); if (!(this.closingBracket())) throw new FailedPredicateException(this, "this.closingBracket()"); } break; } - setState(1445); + setState(1452); statement(); - setState(1446); + setState(1453); eos(); } } @@ -9306,9 +9356,9 @@ public final StatementListContext statementList() throws RecognitionException { default: throw new NoViableAltException(this); } - setState(1450); + setState(1457); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,130,_ctx); + _alt = getInterpreter().adaptivePredict(_input,131,_ctx); } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); } } @@ -9353,43 +9403,43 @@ public T accept(ParseTreeVisitor visitor) { public final SimpleStmtContext simpleStmt() throws RecognitionException { SimpleStmtContext _localctx = new SimpleStmtContext(_ctx, getState()); - enterRule(_localctx, 242, RULE_simpleStmt); + enterRule(_localctx, 244, RULE_simpleStmt); try { - setState(1457); + setState(1464); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1452); + setState(1459); sendStmt(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1453); + setState(1460); incDecStmt(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1454); + setState(1461); assignment(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1455); + setState(1462); expressionStmt(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(1456); + setState(1463); shortVarDecl(); } break; @@ -9424,11 +9474,11 @@ public T accept(ParseTreeVisitor visitor) { public final ExpressionStmtContext expressionStmt() throws RecognitionException { ExpressionStmtContext _localctx = new ExpressionStmtContext(_ctx, getState()); - enterRule(_localctx, 244, RULE_expressionStmt); + enterRule(_localctx, 246, RULE_expressionStmt); try { enterOuterAlt(_localctx, 1); { - setState(1459); + setState(1466); expression(0); } } @@ -9466,15 +9516,15 @@ public T accept(ParseTreeVisitor visitor) { public final SendStmtContext sendStmt() throws RecognitionException { SendStmtContext _localctx = new SendStmtContext(_ctx, getState()); - enterRule(_localctx, 246, RULE_sendStmt); + enterRule(_localctx, 248, RULE_sendStmt); try { enterOuterAlt(_localctx, 1); { - setState(1461); + setState(1468); ((SendStmtContext)_localctx).channel = expression(0); - setState(1462); + setState(1469); match(RECEIVE); - setState(1463); + setState(1470); expression(0); } } @@ -9509,14 +9559,14 @@ public T accept(ParseTreeVisitor visitor) { public final IncDecStmtContext incDecStmt() throws RecognitionException { IncDecStmtContext _localctx = new IncDecStmtContext(_ctx, getState()); - enterRule(_localctx, 248, RULE_incDecStmt); + enterRule(_localctx, 250, RULE_incDecStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1465); + setState(1472); expression(0); - setState(1466); + setState(1473); _la = _input.LA(1); if ( !(_la==PLUS_PLUS || _la==MINUS_MINUS) ) { _errHandler.recoverInline(this); @@ -9563,15 +9613,15 @@ public T accept(ParseTreeVisitor visitor) { public final AssignmentContext assignment() throws RecognitionException { AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); - enterRule(_localctx, 250, RULE_assignment); + enterRule(_localctx, 252, RULE_assignment); try { enterOuterAlt(_localctx, 1); { - setState(1468); + setState(1475); expressionList(); - setState(1469); + setState(1476); assign_op(); - setState(1470); + setState(1477); expressionList(); } } @@ -9603,12 +9653,12 @@ public T accept(ParseTreeVisitor visitor) { public final EmptyStmtContext emptyStmt() throws RecognitionException { EmptyStmtContext _localctx = new EmptyStmtContext(_ctx, getState()); - enterRule(_localctx, 252, RULE_emptyStmt); + enterRule(_localctx, 254, RULE_emptyStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1472); + setState(1479); _la = _input.LA(1); if ( !(_la==SEMI || _la==EOS) ) { _errHandler.recoverInline(this); @@ -9651,20 +9701,20 @@ public T accept(ParseTreeVisitor visitor) { public final LabeledStmtContext labeledStmt() throws RecognitionException { LabeledStmtContext _localctx = new LabeledStmtContext(_ctx, getState()); - enterRule(_localctx, 254, RULE_labeledStmt); + enterRule(_localctx, 256, RULE_labeledStmt); try { enterOuterAlt(_localctx, 1); { - setState(1474); + setState(1481); match(IDENTIFIER); - setState(1475); + setState(1482); match(COLON); - setState(1477); + setState(1484); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) { case 1: { - setState(1476); + setState(1483); statement(); } break; @@ -9701,18 +9751,18 @@ public T accept(ParseTreeVisitor visitor) { public final ReturnStmtContext returnStmt() throws RecognitionException { ReturnStmtContext _localctx = new ReturnStmtContext(_ctx, getState()); - enterRule(_localctx, 256, RULE_returnStmt); + enterRule(_localctx, 258, RULE_returnStmt); try { enterOuterAlt(_localctx, 1); { - setState(1479); + setState(1486); match(RETURN); - setState(1481); + setState(1488); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) { case 1: { - setState(1480); + setState(1487); expressionList(); } break; @@ -9747,18 +9797,18 @@ public T accept(ParseTreeVisitor visitor) { public final BreakStmtContext breakStmt() throws RecognitionException { BreakStmtContext _localctx = new BreakStmtContext(_ctx, getState()); - enterRule(_localctx, 258, RULE_breakStmt); + enterRule(_localctx, 260, RULE_breakStmt); try { enterOuterAlt(_localctx, 1); { - setState(1483); + setState(1490); match(BREAK); - setState(1485); + setState(1492); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { case 1: { - setState(1484); + setState(1491); match(IDENTIFIER); } break; @@ -9793,18 +9843,18 @@ public T accept(ParseTreeVisitor visitor) { public final ContinueStmtContext continueStmt() throws RecognitionException { ContinueStmtContext _localctx = new ContinueStmtContext(_ctx, getState()); - enterRule(_localctx, 260, RULE_continueStmt); + enterRule(_localctx, 262, RULE_continueStmt); try { enterOuterAlt(_localctx, 1); { - setState(1487); + setState(1494); match(CONTINUE); - setState(1489); + setState(1496); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { case 1: { - setState(1488); + setState(1495); match(IDENTIFIER); } break; @@ -9839,13 +9889,13 @@ public T accept(ParseTreeVisitor visitor) { public final GotoStmtContext gotoStmt() throws RecognitionException { GotoStmtContext _localctx = new GotoStmtContext(_ctx, getState()); - enterRule(_localctx, 262, RULE_gotoStmt); + enterRule(_localctx, 264, RULE_gotoStmt); try { enterOuterAlt(_localctx, 1); { - setState(1491); + setState(1498); match(GOTO); - setState(1492); + setState(1499); match(IDENTIFIER); } } @@ -9876,11 +9926,11 @@ public T accept(ParseTreeVisitor visitor) { public final FallthroughStmtContext fallthroughStmt() throws RecognitionException { FallthroughStmtContext _localctx = new FallthroughStmtContext(_ctx, getState()); - enterRule(_localctx, 264, RULE_fallthroughStmt); + enterRule(_localctx, 266, RULE_fallthroughStmt); try { enterOuterAlt(_localctx, 1); { - setState(1494); + setState(1501); match(FALLTHROUGH); } } @@ -9930,61 +9980,61 @@ public T accept(ParseTreeVisitor visitor) { public final IfStmtContext ifStmt() throws RecognitionException { IfStmtContext _localctx = new IfStmtContext(_ctx, getState()); - enterRule(_localctx, 266, RULE_ifStmt); + enterRule(_localctx, 268, RULE_ifStmt); try { enterOuterAlt(_localctx, 1); { - setState(1496); + setState(1503); match(IF); - setState(1505); + setState(1512); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { case 1: { - setState(1497); + setState(1504); expression(0); } break; case 2: { - setState(1498); + setState(1505); eos(); - setState(1499); + setState(1506); expression(0); } break; case 3: { - setState(1501); + setState(1508); simpleStmt(); - setState(1502); + setState(1509); eos(); - setState(1503); + setState(1510); expression(0); } break; } - setState(1507); + setState(1514); block(); - setState(1513); + setState(1520); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { case 1: { - setState(1508); + setState(1515); match(ELSE); - setState(1511); + setState(1518); _errHandler.sync(this); switch (_input.LA(1)) { case IF: { - setState(1509); + setState(1516); ifStmt(); } break; case L_CURLY: { - setState(1510); + setState(1517); block(); } break; @@ -10028,22 +10078,22 @@ public T accept(ParseTreeVisitor visitor) { public final SwitchStmtContext switchStmt() throws RecognitionException { SwitchStmtContext _localctx = new SwitchStmtContext(_ctx, getState()); - enterRule(_localctx, 268, RULE_switchStmt); + enterRule(_localctx, 270, RULE_switchStmt); try { - setState(1517); + setState(1524); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1515); + setState(1522); exprSwitchStmt(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1516); + setState(1523); typeSwitchStmt(); } break; @@ -10093,24 +10143,24 @@ public T accept(ParseTreeVisitor visitor) { public final ExprSwitchStmtContext exprSwitchStmt() throws RecognitionException { ExprSwitchStmtContext _localctx = new ExprSwitchStmtContext(_ctx, getState()); - enterRule(_localctx, 270, RULE_exprSwitchStmt); + enterRule(_localctx, 272, RULE_exprSwitchStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1519); + setState(1526); match(SWITCH); - setState(1530); + setState(1537); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { case 1: { - setState(1521); + setState(1528); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1520); + setState(1527); expression(0); } } @@ -10119,24 +10169,24 @@ public final ExprSwitchStmtContext exprSwitchStmt() throws RecognitionException break; case 2: { - setState(1524); + setState(1531); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { case 1: { - setState(1523); + setState(1530); simpleStmt(); } break; } - setState(1526); + setState(1533); eos(); - setState(1528); + setState(1535); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1527); + setState(1534); expression(0); } } @@ -10144,23 +10194,23 @@ public final ExprSwitchStmtContext exprSwitchStmt() throws RecognitionException } break; } - setState(1532); + setState(1539); match(L_CURLY); - setState(1536); + setState(1543); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(1533); + setState(1540); exprCaseClause(); } } - setState(1538); + setState(1545); _errHandler.sync(this); _la = _input.LA(1); } - setState(1539); + setState(1546); match(R_CURLY); } } @@ -10197,20 +10247,20 @@ public T accept(ParseTreeVisitor visitor) { public final ExprCaseClauseContext exprCaseClause() throws RecognitionException { ExprCaseClauseContext _localctx = new ExprCaseClauseContext(_ctx, getState()); - enterRule(_localctx, 272, RULE_exprCaseClause); + enterRule(_localctx, 274, RULE_exprCaseClause); try { enterOuterAlt(_localctx, 1); { - setState(1541); + setState(1548); exprSwitchCase(); - setState(1542); + setState(1549); match(COLON); - setState(1544); + setState(1551); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { case 1: { - setState(1543); + setState(1550); statementList(); } break; @@ -10248,24 +10298,24 @@ public T accept(ParseTreeVisitor visitor) { public final ExprSwitchCaseContext exprSwitchCase() throws RecognitionException { ExprSwitchCaseContext _localctx = new ExprSwitchCaseContext(_ctx, getState()); - enterRule(_localctx, 274, RULE_exprSwitchCase); + enterRule(_localctx, 276, RULE_exprSwitchCase); try { - setState(1549); + setState(1556); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { - setState(1546); + setState(1553); match(CASE); - setState(1547); + setState(1554); expressionList(); } break; case DEFAULT: enterOuterAlt(_localctx, 2); { - setState(1548); + setState(1555); match(DEFAULT); } break; @@ -10317,58 +10367,58 @@ public T accept(ParseTreeVisitor visitor) { public final TypeSwitchStmtContext typeSwitchStmt() throws RecognitionException { TypeSwitchStmtContext _localctx = new TypeSwitchStmtContext(_ctx, getState()); - enterRule(_localctx, 276, RULE_typeSwitchStmt); + enterRule(_localctx, 278, RULE_typeSwitchStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1551); + setState(1558); match(SWITCH); - setState(1560); + setState(1567); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { case 1: { - setState(1552); + setState(1559); typeSwitchGuard(); } break; case 2: { - setState(1553); + setState(1560); eos(); - setState(1554); + setState(1561); typeSwitchGuard(); } break; case 3: { - setState(1556); + setState(1563); simpleStmt(); - setState(1557); + setState(1564); eos(); - setState(1558); + setState(1565); typeSwitchGuard(); } break; } - setState(1562); + setState(1569); match(L_CURLY); - setState(1566); + setState(1573); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(1563); + setState(1570); typeCaseClause(); } } - setState(1568); + setState(1575); _errHandler.sync(this); _la = _input.LA(1); } - setState(1569); + setState(1576); match(R_CURLY); } } @@ -10407,31 +10457,31 @@ public T accept(ParseTreeVisitor visitor) { public final TypeSwitchGuardContext typeSwitchGuard() throws RecognitionException { TypeSwitchGuardContext _localctx = new TypeSwitchGuardContext(_ctx, getState()); - enterRule(_localctx, 278, RULE_typeSwitchGuard); + enterRule(_localctx, 280, RULE_typeSwitchGuard); try { enterOuterAlt(_localctx, 1); { - setState(1573); + setState(1580); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { case 1: { - setState(1571); + setState(1578); match(IDENTIFIER); - setState(1572); + setState(1579); match(DECLARE_ASSIGN); } break; } - setState(1575); + setState(1582); primaryExpr(0); - setState(1576); + setState(1583); match(DOT); - setState(1577); + setState(1584); match(L_PAREN); - setState(1578); + setState(1585); match(TYPE); - setState(1579); + setState(1586); match(R_PAREN); } } @@ -10468,20 +10518,20 @@ public T accept(ParseTreeVisitor visitor) { public final TypeCaseClauseContext typeCaseClause() throws RecognitionException { TypeCaseClauseContext _localctx = new TypeCaseClauseContext(_ctx, getState()); - enterRule(_localctx, 280, RULE_typeCaseClause); + enterRule(_localctx, 282, RULE_typeCaseClause); try { enterOuterAlt(_localctx, 1); { - setState(1581); + setState(1588); typeSwitchCase(); - setState(1582); + setState(1589); match(COLON); - setState(1584); + setState(1591); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) { case 1: { - setState(1583); + setState(1590); statementList(); } break; @@ -10519,24 +10569,24 @@ public T accept(ParseTreeVisitor visitor) { public final TypeSwitchCaseContext typeSwitchCase() throws RecognitionException { TypeSwitchCaseContext _localctx = new TypeSwitchCaseContext(_ctx, getState()); - enterRule(_localctx, 282, RULE_typeSwitchCase); + enterRule(_localctx, 284, RULE_typeSwitchCase); try { - setState(1589); + setState(1596); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { - setState(1586); + setState(1593); match(CASE); - setState(1587); + setState(1594); typeList(); } break; case DEFAULT: enterOuterAlt(_localctx, 2); { - setState(1588); + setState(1595); match(DEFAULT); } break; @@ -10584,12 +10634,12 @@ public T accept(ParseTreeVisitor visitor) { public final TypeListContext typeList() throws RecognitionException { TypeListContext _localctx = new TypeListContext(_ctx, getState()); - enterRule(_localctx, 284, RULE_typeList); + enterRule(_localctx, 286, RULE_typeList); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1593); + setState(1600); _errHandler.sync(this); switch (_input.LA(1)) { case GHOST: @@ -10612,28 +10662,28 @@ public final TypeListContext typeList() throws RecognitionException { case STAR: case RECEIVE: { - setState(1591); + setState(1598); type_(); } break; case NIL_LIT: { - setState(1592); + setState(1599); match(NIL_LIT); } break; default: throw new NoViableAltException(this); } - setState(1602); + setState(1609); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { - setState(1595); + setState(1602); match(COMMA); - setState(1598); + setState(1605); _errHandler.sync(this); switch (_input.LA(1)) { case GHOST: @@ -10656,13 +10706,13 @@ public final TypeListContext typeList() throws RecognitionException { case STAR: case RECEIVE: { - setState(1596); + setState(1603); type_(); } break; case NIL_LIT: { - setState(1597); + setState(1604); match(NIL_LIT); } break; @@ -10671,7 +10721,7 @@ public final TypeListContext typeList() throws RecognitionException { } } } - setState(1604); + setState(1611); _errHandler.sync(this); _la = _input.LA(1); } @@ -10712,30 +10762,30 @@ public T accept(ParseTreeVisitor visitor) { public final SelectStmtContext selectStmt() throws RecognitionException { SelectStmtContext _localctx = new SelectStmtContext(_ctx, getState()); - enterRule(_localctx, 286, RULE_selectStmt); + enterRule(_localctx, 288, RULE_selectStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1605); + setState(1612); match(SELECT); - setState(1606); + setState(1613); match(L_CURLY); - setState(1610); + setState(1617); _errHandler.sync(this); _la = _input.LA(1); while (_la==DEFAULT || _la==CASE) { { { - setState(1607); + setState(1614); commClause(); } } - setState(1612); + setState(1619); _errHandler.sync(this); _la = _input.LA(1); } - setState(1613); + setState(1620); match(R_CURLY); } } @@ -10772,20 +10822,20 @@ public T accept(ParseTreeVisitor visitor) { public final CommClauseContext commClause() throws RecognitionException { CommClauseContext _localctx = new CommClauseContext(_ctx, getState()); - enterRule(_localctx, 288, RULE_commClause); + enterRule(_localctx, 290, RULE_commClause); try { enterOuterAlt(_localctx, 1); { - setState(1615); + setState(1622); commCase(); - setState(1616); + setState(1623); match(COLON); - setState(1618); + setState(1625); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { case 1: { - setState(1617); + setState(1624); statementList(); } break; @@ -10826,28 +10876,28 @@ public T accept(ParseTreeVisitor visitor) { public final CommCaseContext commCase() throws RecognitionException { CommCaseContext _localctx = new CommCaseContext(_ctx, getState()); - enterRule(_localctx, 290, RULE_commCase); + enterRule(_localctx, 292, RULE_commCase); try { - setState(1626); + setState(1633); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { - setState(1620); + setState(1627); match(CASE); - setState(1623); + setState(1630); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { case 1: { - setState(1621); + setState(1628); sendStmt(); } break; case 2: { - setState(1622); + setState(1629); recvStmt(); } break; @@ -10857,7 +10907,7 @@ public final CommCaseContext commCase() throws RecognitionException { case DEFAULT: enterOuterAlt(_localctx, 2); { - setState(1625); + setState(1632); match(DEFAULT); } break; @@ -10903,31 +10953,31 @@ public T accept(ParseTreeVisitor visitor) { public final RecvStmtContext recvStmt() throws RecognitionException { RecvStmtContext _localctx = new RecvStmtContext(_ctx, getState()); - enterRule(_localctx, 292, RULE_recvStmt); + enterRule(_localctx, 294, RULE_recvStmt); try { enterOuterAlt(_localctx, 1); { - setState(1634); + setState(1641); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { case 1: { - setState(1628); + setState(1635); expressionList(); - setState(1629); + setState(1636); match(ASSIGN); } break; case 2: { - setState(1631); + setState(1638); identifierList(); - setState(1632); + setState(1639); match(DECLARE_ASSIGN); } break; } - setState(1636); + setState(1643); ((RecvStmtContext)_localctx).recvExpr = expression(0); } } @@ -10970,24 +11020,24 @@ public T accept(ParseTreeVisitor visitor) { public final ForStmtContext forStmt() throws RecognitionException { ForStmtContext _localctx = new ForStmtContext(_ctx, getState()); - enterRule(_localctx, 294, RULE_forStmt); + enterRule(_localctx, 296, RULE_forStmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1638); + setState(1645); match(FOR); - setState(1646); + setState(1653); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { case 1: { - setState(1640); + setState(1647); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1639); + setState(1646); expression(0); } } @@ -10996,18 +11046,18 @@ public final ForStmtContext forStmt() throws RecognitionException { break; case 2: { - setState(1642); + setState(1649); forClause(); } break; case 3: { - setState(1644); + setState(1651); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1643); + setState(1650); rangeClause(); } } @@ -11015,7 +11065,7 @@ public final ForStmtContext forStmt() throws RecognitionException { } break; } - setState(1648); + setState(1655); block(); } } @@ -11062,41 +11112,41 @@ public T accept(ParseTreeVisitor visitor) { public final ForClauseContext forClause() throws RecognitionException { ForClauseContext _localctx = new ForClauseContext(_ctx, getState()); - enterRule(_localctx, 296, RULE_forClause); + enterRule(_localctx, 298, RULE_forClause); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1651); + setState(1658); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) { case 1: { - setState(1650); + setState(1657); ((ForClauseContext)_localctx).initStmt = simpleStmt(); } break; } - setState(1653); + setState(1660); eos(); - setState(1655); + setState(1662); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { case 1: { - setState(1654); + setState(1661); expression(0); } break; } - setState(1657); + setState(1664); eos(); - setState(1659); + setState(1666); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1658); + setState(1665); ((ForClauseContext)_localctx).postStmt = simpleStmt(); } } @@ -11133,13 +11183,13 @@ public T accept(ParseTreeVisitor visitor) { public final GoStmtContext goStmt() throws RecognitionException { GoStmtContext _localctx = new GoStmtContext(_ctx, getState()); - enterRule(_localctx, 298, RULE_goStmt); + enterRule(_localctx, 300, RULE_goStmt); try { enterOuterAlt(_localctx, 1); { - setState(1661); + setState(1668); match(GO); - setState(1662); + setState(1669); expression(0); } } @@ -11173,22 +11223,22 @@ public T accept(ParseTreeVisitor visitor) { public final TypeNameContext typeName() throws RecognitionException { TypeNameContext _localctx = new TypeNameContext(_ctx, getState()); - enterRule(_localctx, 300, RULE_typeName); + enterRule(_localctx, 302, RULE_typeName); try { - setState(1666); + setState(1673); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1664); + setState(1671); qualifiedIdent(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1665); + setState(1672); match(IDENTIFIER); } break; @@ -11228,17 +11278,17 @@ public T accept(ParseTreeVisitor visitor) { public final ArrayTypeContext arrayType() throws RecognitionException { ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState()); - enterRule(_localctx, 302, RULE_arrayType); + enterRule(_localctx, 304, RULE_arrayType); try { enterOuterAlt(_localctx, 1); { - setState(1668); + setState(1675); match(L_BRACKET); - setState(1669); + setState(1676); arrayLength(); - setState(1670); + setState(1677); match(R_BRACKET); - setState(1671); + setState(1678); elementType(); } } @@ -11271,11 +11321,11 @@ public T accept(ParseTreeVisitor visitor) { public final ArrayLengthContext arrayLength() throws RecognitionException { ArrayLengthContext _localctx = new ArrayLengthContext(_ctx, getState()); - enterRule(_localctx, 304, RULE_arrayLength); + enterRule(_localctx, 306, RULE_arrayLength); try { enterOuterAlt(_localctx, 1); { - setState(1673); + setState(1680); expression(0); } } @@ -11308,11 +11358,11 @@ public T accept(ParseTreeVisitor visitor) { public final ElementTypeContext elementType() throws RecognitionException { ElementTypeContext _localctx = new ElementTypeContext(_ctx, getState()); - enterRule(_localctx, 306, RULE_elementType); + enterRule(_localctx, 308, RULE_elementType); try { enterOuterAlt(_localctx, 1); { - setState(1675); + setState(1682); type_(); } } @@ -11346,13 +11396,13 @@ public T accept(ParseTreeVisitor visitor) { public final PointerTypeContext pointerType() throws RecognitionException { PointerTypeContext _localctx = new PointerTypeContext(_ctx, getState()); - enterRule(_localctx, 308, RULE_pointerType); + enterRule(_localctx, 310, RULE_pointerType); try { enterOuterAlt(_localctx, 1); { - setState(1677); + setState(1684); match(STAR); - setState(1678); + setState(1685); type_(); } } @@ -11387,15 +11437,15 @@ public T accept(ParseTreeVisitor visitor) { public final SliceTypeContext sliceType() throws RecognitionException { SliceTypeContext _localctx = new SliceTypeContext(_ctx, getState()); - enterRule(_localctx, 310, RULE_sliceType); + enterRule(_localctx, 312, RULE_sliceType); try { enterOuterAlt(_localctx, 1); { - setState(1680); + setState(1687); match(L_BRACKET); - setState(1681); + setState(1688); match(R_BRACKET); - setState(1682); + setState(1689); elementType(); } } @@ -11434,19 +11484,19 @@ public T accept(ParseTreeVisitor visitor) { public final MapTypeContext mapType() throws RecognitionException { MapTypeContext _localctx = new MapTypeContext(_ctx, getState()); - enterRule(_localctx, 312, RULE_mapType); + enterRule(_localctx, 314, RULE_mapType); try { enterOuterAlt(_localctx, 1); { - setState(1684); + setState(1691); match(MAP); - setState(1685); + setState(1692); match(L_BRACKET); - setState(1686); + setState(1693); type_(); - setState(1687); + setState(1694); match(R_BRACKET); - setState(1688); + setState(1695); elementType(); } } @@ -11481,37 +11531,37 @@ public T accept(ParseTreeVisitor visitor) { public final ChannelTypeContext channelType() throws RecognitionException { ChannelTypeContext _localctx = new ChannelTypeContext(_ctx, getState()); - enterRule(_localctx, 314, RULE_channelType); + enterRule(_localctx, 316, RULE_channelType); try { enterOuterAlt(_localctx, 1); { - setState(1695); + setState(1702); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) { case 1: { - setState(1690); + setState(1697); match(CHAN); } break; case 2: { - setState(1691); + setState(1698); match(CHAN); - setState(1692); + setState(1699); match(RECEIVE); } break; case 3: { - setState(1693); + setState(1700); match(RECEIVE); - setState(1694); + setState(1701); match(CHAN); } break; } - setState(1697); + setState(1704); elementType(); } } @@ -11545,13 +11595,13 @@ public T accept(ParseTreeVisitor visitor) { public final FunctionTypeContext functionType() throws RecognitionException { FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState()); - enterRule(_localctx, 316, RULE_functionType); + enterRule(_localctx, 318, RULE_functionType); try { enterOuterAlt(_localctx, 1); { - setState(1699); + setState(1706); match(FUNC); - setState(1700); + setState(1707); signature(); } } @@ -11587,24 +11637,24 @@ public T accept(ParseTreeVisitor visitor) { public final SignatureContext signature() throws RecognitionException { SignatureContext _localctx = new SignatureContext(_ctx, getState()); - enterRule(_localctx, 318, RULE_signature); + enterRule(_localctx, 320, RULE_signature); try { - setState(1706); + setState(1713); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1702); + setState(1709); parameters(); - setState(1703); + setState(1710); result(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1705); + setState(1712); parameters(); } break; @@ -11642,22 +11692,22 @@ public T accept(ParseTreeVisitor visitor) { public final ResultContext result() throws RecognitionException { ResultContext _localctx = new ResultContext(_ctx, getState()); - enterRule(_localctx, 320, RULE_result); + enterRule(_localctx, 322, RULE_result); try { - setState(1710); + setState(1717); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1708); + setState(1715); parameters(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1709); + setState(1716); type_(); } break; @@ -11701,45 +11751,45 @@ public T accept(ParseTreeVisitor visitor) { public final ParametersContext parameters() throws RecognitionException { ParametersContext _localctx = new ParametersContext(_ctx, getState()); - enterRule(_localctx, 322, RULE_parameters); + enterRule(_localctx, 324, RULE_parameters); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1712); + setState(1719); match(L_PAREN); - setState(1724); + setState(1731); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 83350678101032960L) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1441152431101575619L) != 0)) { { - setState(1713); + setState(1720); parameterDecl(); - setState(1718); + setState(1725); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,170,_ctx); + _alt = getInterpreter().adaptivePredict(_input,171,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1714); + setState(1721); match(COMMA); - setState(1715); + setState(1722); parameterDecl(); } } } - setState(1720); + setState(1727); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,170,_ctx); + _alt = getInterpreter().adaptivePredict(_input,171,_ctx); } - setState(1722); + setState(1729); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1721); + setState(1728); match(COMMA); } } @@ -11747,7 +11797,7 @@ public final ParametersContext parameters() throws RecognitionException { } } - setState(1726); + setState(1733); match(R_PAREN); } } @@ -11786,28 +11836,28 @@ public T accept(ParseTreeVisitor visitor) { public final ConversionContext conversion() throws RecognitionException { ConversionContext _localctx = new ConversionContext(_ctx, getState()); - enterRule(_localctx, 324, RULE_conversion); + enterRule(_localctx, 326, RULE_conversion); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1728); + setState(1735); nonNamedType(); - setState(1729); + setState(1736); match(L_PAREN); - setState(1730); + setState(1737); expression(0); - setState(1732); + setState(1739); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1731); + setState(1738); match(COMMA); } } - setState(1734); + setState(1741); match(R_PAREN); } } @@ -11845,9 +11895,9 @@ public T accept(ParseTreeVisitor visitor) { public final NonNamedTypeContext nonNamedType() throws RecognitionException { NonNamedTypeContext _localctx = new NonNamedTypeContext(_ctx, getState()); - enterRule(_localctx, 326, RULE_nonNamedType); + enterRule(_localctx, 328, RULE_nonNamedType); try { - setState(1741); + setState(1748); _errHandler.sync(this); switch (_input.LA(1)) { case PRED: @@ -11861,18 +11911,18 @@ public final NonNamedTypeContext nonNamedType() throws RecognitionException { case RECEIVE: enterOuterAlt(_localctx, 1); { - setState(1736); + setState(1743); typeLit(); } break; case L_PAREN: enterOuterAlt(_localctx, 2); { - setState(1737); + setState(1744); match(L_PAREN); - setState(1738); + setState(1745); nonNamedType(); - setState(1739); + setState(1746); match(R_PAREN); } break; @@ -11917,33 +11967,33 @@ public T accept(ParseTreeVisitor visitor) { public final OperandContext operand() throws RecognitionException { OperandContext _localctx = new OperandContext(_ctx, getState()); - enterRule(_localctx, 328, RULE_operand); + enterRule(_localctx, 330, RULE_operand); try { - setState(1749); + setState(1756); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1743); + setState(1750); literal(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1744); + setState(1751); operandName(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1745); + setState(1752); match(L_PAREN); - setState(1746); + setState(1753); expression(0); - setState(1747); + setState(1754); match(R_PAREN); } break; @@ -11984,9 +12034,9 @@ public T accept(ParseTreeVisitor visitor) { public final LiteralContext literal() throws RecognitionException { LiteralContext _localctx = new LiteralContext(_ctx, getState()); - enterRule(_localctx, 330, RULE_literal); + enterRule(_localctx, 332, RULE_literal); try { - setState(1754); + setState(1761); _errHandler.sync(this); switch (_input.LA(1)) { case FLOAT_LIT: @@ -12003,7 +12053,7 @@ public final LiteralContext literal() throws RecognitionException { case INTERPRETED_STRING_LIT: enterOuterAlt(_localctx, 1); { - setState(1751); + setState(1758); basicLit(); } break; @@ -12021,7 +12071,7 @@ public final LiteralContext literal() throws RecognitionException { case L_BRACKET: enterOuterAlt(_localctx, 2); { - setState(1752); + setState(1759); compositeLit(); } break; @@ -12034,7 +12084,7 @@ public final LiteralContext literal() throws RecognitionException { case FUNC: enterOuterAlt(_localctx, 3); { - setState(1753); + setState(1760); functionLit(); } break; @@ -12074,12 +12124,12 @@ public T accept(ParseTreeVisitor visitor) { public final IntegerContext integer() throws RecognitionException { IntegerContext _localctx = new IntegerContext(_ctx, getState()); - enterRule(_localctx, 332, RULE_integer); + enterRule(_localctx, 334, RULE_integer); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1756); + setState(1763); _la = _input.LA(1); if ( !(((((_la - 138)) & ~0x3f) == 0 && ((1L << (_la - 138)) & 111L) != 0)) ) { _errHandler.recoverInline(this); @@ -12118,11 +12168,11 @@ public T accept(ParseTreeVisitor visitor) { public final OperandNameContext operandName() throws RecognitionException { OperandNameContext _localctx = new OperandNameContext(_ctx, getState()); - enterRule(_localctx, 334, RULE_operandName); + enterRule(_localctx, 336, RULE_operandName); try { enterOuterAlt(_localctx, 1); { - setState(1758); + setState(1765); match(IDENTIFIER); } } @@ -12157,15 +12207,15 @@ public T accept(ParseTreeVisitor visitor) { public final QualifiedIdentContext qualifiedIdent() throws RecognitionException { QualifiedIdentContext _localctx = new QualifiedIdentContext(_ctx, getState()); - enterRule(_localctx, 336, RULE_qualifiedIdent); + enterRule(_localctx, 338, RULE_qualifiedIdent); try { enterOuterAlt(_localctx, 1); { - setState(1760); + setState(1767); match(IDENTIFIER); - setState(1761); + setState(1768); match(DOT); - setState(1762); + setState(1769); match(IDENTIFIER); } } @@ -12201,13 +12251,13 @@ public T accept(ParseTreeVisitor visitor) { public final CompositeLitContext compositeLit() throws RecognitionException { CompositeLitContext _localctx = new CompositeLitContext(_ctx, getState()); - enterRule(_localctx, 338, RULE_compositeLit); + enterRule(_localctx, 340, RULE_compositeLit); try { enterOuterAlt(_localctx, 1); { - setState(1764); + setState(1771); literalType(); - setState(1765); + setState(1772); literalValue(); } } @@ -12243,26 +12293,26 @@ public T accept(ParseTreeVisitor visitor) { public final LiteralValueContext literalValue() throws RecognitionException { LiteralValueContext _localctx = new LiteralValueContext(_ctx, getState()); - enterRule(_localctx, 340, RULE_literalValue); + enterRule(_localctx, 342, RULE_literalValue); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1767); + setState(1774); match(L_CURLY); - setState(1772); + setState(1779); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2990104391687L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1768); + setState(1775); elementList(); - setState(1770); + setState(1777); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1769); + setState(1776); match(COMMA); } } @@ -12270,7 +12320,7 @@ public final LiteralValueContext literalValue() throws RecognitionException { } } - setState(1774); + setState(1781); match(R_CURLY); } } @@ -12310,30 +12360,30 @@ public T accept(ParseTreeVisitor visitor) { public final ElementListContext elementList() throws RecognitionException { ElementListContext _localctx = new ElementListContext(_ctx, getState()); - enterRule(_localctx, 342, RULE_elementList); + enterRule(_localctx, 344, RULE_elementList); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(1776); + setState(1783); keyedElement(); - setState(1781); + setState(1788); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,179,_ctx); + _alt = getInterpreter().adaptivePredict(_input,180,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(1777); + setState(1784); match(COMMA); - setState(1778); + setState(1785); keyedElement(); } } } - setState(1783); + setState(1790); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,179,_ctx); + _alt = getInterpreter().adaptivePredict(_input,180,_ctx); } } } @@ -12370,23 +12420,23 @@ public T accept(ParseTreeVisitor visitor) { public final KeyedElementContext keyedElement() throws RecognitionException { KeyedElementContext _localctx = new KeyedElementContext(_ctx, getState()); - enterRule(_localctx, 344, RULE_keyedElement); + enterRule(_localctx, 346, RULE_keyedElement); try { enterOuterAlt(_localctx, 1); { - setState(1787); + setState(1794); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) { case 1: { - setState(1784); + setState(1791); key(); - setState(1785); + setState(1792); match(COLON); } break; } - setState(1789); + setState(1796); element(); } } @@ -12422,9 +12472,9 @@ public T accept(ParseTreeVisitor visitor) { public final KeyContext key() throws RecognitionException { KeyContext _localctx = new KeyContext(_ctx, getState()); - enterRule(_localctx, 346, RULE_key); + enterRule(_localctx, 348, RULE_key); try { - setState(1793); + setState(1800); _errHandler.sync(this); switch (_input.LA(1)) { case FLOAT_LIT: @@ -12492,14 +12542,14 @@ public final KeyContext key() throws RecognitionException { case INTERPRETED_STRING_LIT: enterOuterAlt(_localctx, 1); { - setState(1791); + setState(1798); expression(0); } break; case L_CURLY: enterOuterAlt(_localctx, 2); { - setState(1792); + setState(1799); literalValue(); } break; @@ -12539,9 +12589,9 @@ public T accept(ParseTreeVisitor visitor) { public final ElementContext element() throws RecognitionException { ElementContext _localctx = new ElementContext(_ctx, getState()); - enterRule(_localctx, 348, RULE_element); + enterRule(_localctx, 350, RULE_element); try { - setState(1797); + setState(1804); _errHandler.sync(this); switch (_input.LA(1)) { case FLOAT_LIT: @@ -12609,14 +12659,14 @@ public final ElementContext element() throws RecognitionException { case INTERPRETED_STRING_LIT: enterOuterAlt(_localctx, 1); { - setState(1795); + setState(1802); expression(0); } break; case L_CURLY: enterOuterAlt(_localctx, 2); { - setState(1796); + setState(1803); literalValue(); } break; @@ -12665,32 +12715,32 @@ public T accept(ParseTreeVisitor visitor) { public final StructTypeContext structType() throws RecognitionException { StructTypeContext _localctx = new StructTypeContext(_ctx, getState()); - enterRule(_localctx, 350, RULE_structType); + enterRule(_localctx, 352, RULE_structType); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1799); + setState(1806); match(STRUCT); - setState(1800); + setState(1807); match(L_CURLY); - setState(1806); + setState(1813); _errHandler.sync(this); _la = _input.LA(1); while (_la==IDENTIFIER || _la==STAR) { { { - setState(1801); + setState(1808); fieldDecl(); - setState(1802); + setState(1809); eos(); } } - setState(1808); + setState(1815); _errHandler.sync(this); _la = _input.LA(1); } - setState(1809); + setState(1816); match(R_CURLY); } } @@ -12733,34 +12783,34 @@ public T accept(ParseTreeVisitor visitor) { public final FieldDeclContext fieldDecl() throws RecognitionException { FieldDeclContext _localctx = new FieldDeclContext(_ctx, getState()); - enterRule(_localctx, 352, RULE_fieldDecl); + enterRule(_localctx, 354, RULE_fieldDecl); try { enterOuterAlt(_localctx, 1); { - setState(1815); + setState(1822); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { case 1: { - setState(1811); + setState(1818); identifierList(); - setState(1812); + setState(1819); type_(); } break; case 2: { - setState(1814); + setState(1821); embeddedField(); } break; } - setState(1818); + setState(1825); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) { case 1: { - setState(1817); + setState(1824); ((FieldDeclContext)_localctx).tag = string_(); } break; @@ -12795,12 +12845,12 @@ public T accept(ParseTreeVisitor visitor) { public final String_Context string_() throws RecognitionException { String_Context _localctx = new String_Context(_ctx, getState()); - enterRule(_localctx, 354, RULE_string_); + enterRule(_localctx, 356, RULE_string_); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1820); + setState(1827); _la = _input.LA(1); if ( !(_la==RAW_STRING_LIT || _la==INTERPRETED_STRING_LIT) ) { _errHandler.recoverInline(this); @@ -12842,22 +12892,22 @@ public T accept(ParseTreeVisitor visitor) { public final EmbeddedFieldContext embeddedField() throws RecognitionException { EmbeddedFieldContext _localctx = new EmbeddedFieldContext(_ctx, getState()); - enterRule(_localctx, 356, RULE_embeddedField); + enterRule(_localctx, 358, RULE_embeddedField); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1823); + setState(1830); _errHandler.sync(this); _la = _input.LA(1); if (_la==STAR) { { - setState(1822); + setState(1829); match(STAR); } } - setState(1825); + setState(1832); typeName(); } } @@ -12892,15 +12942,15 @@ public T accept(ParseTreeVisitor visitor) { public final IndexContext index() throws RecognitionException { IndexContext _localctx = new IndexContext(_ctx, getState()); - enterRule(_localctx, 358, RULE_index); + enterRule(_localctx, 360, RULE_index); try { enterOuterAlt(_localctx, 1); { - setState(1827); + setState(1834); match(L_BRACKET); - setState(1828); + setState(1835); expression(0); - setState(1829); + setState(1836); match(R_BRACKET); } } @@ -12936,17 +12986,17 @@ public T accept(ParseTreeVisitor visitor) { public final TypeAssertionContext typeAssertion() throws RecognitionException { TypeAssertionContext _localctx = new TypeAssertionContext(_ctx, getState()); - enterRule(_localctx, 360, RULE_typeAssertion); + enterRule(_localctx, 362, RULE_typeAssertion); try { enterOuterAlt(_localctx, 1); { - setState(1831); + setState(1838); match(DOT); - setState(1832); + setState(1839); match(L_PAREN); - setState(1833); + setState(1840); type_(); - setState(1834); + setState(1841); match(R_PAREN); } } @@ -12989,39 +13039,39 @@ public T accept(ParseTreeVisitor visitor) { public final ArgumentsContext arguments() throws RecognitionException { ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); - enterRule(_localctx, 362, RULE_arguments); + enterRule(_localctx, 364, RULE_arguments); int _la; try { enterOuterAlt(_localctx, 1); { - setState(1836); + setState(1843); match(L_PAREN); - setState(1851); + setState(1858); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 571956053407067674L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 2440348577799L) != 0) || ((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 1587199L) != 0)) { { - setState(1843); + setState(1850); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) { case 1: { - setState(1837); + setState(1844); expressionList(); } break; case 2: { - setState(1838); + setState(1845); nonNamedType(); - setState(1841); + setState(1848); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,187,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) { case 1: { - setState(1839); + setState(1846); match(COMMA); - setState(1840); + setState(1847); expressionList(); } break; @@ -13029,22 +13079,22 @@ public final ArgumentsContext arguments() throws RecognitionException { } break; } - setState(1846); + setState(1853); _errHandler.sync(this); _la = _input.LA(1); if (_la==ELLIPSIS) { { - setState(1845); + setState(1852); match(ELLIPSIS); } } - setState(1849); + setState(1856); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { - setState(1848); + setState(1855); match(COMMA); } } @@ -13052,7 +13102,7 @@ public final ArgumentsContext arguments() throws RecognitionException { } } - setState(1853); + setState(1860); match(R_PAREN); } } @@ -13087,15 +13137,15 @@ public T accept(ParseTreeVisitor visitor) { public final MethodExprContext methodExpr() throws RecognitionException { MethodExprContext _localctx = new MethodExprContext(_ctx, getState()); - enterRule(_localctx, 364, RULE_methodExpr); + enterRule(_localctx, 366, RULE_methodExpr); try { enterOuterAlt(_localctx, 1); { - setState(1855); + setState(1862); nonNamedType(); - setState(1856); + setState(1863); match(DOT); - setState(1857); + setState(1864); match(IDENTIFIER); } } @@ -13128,11 +13178,11 @@ public T accept(ParseTreeVisitor visitor) { public final ReceiverTypeContext receiverType() throws RecognitionException { ReceiverTypeContext _localctx = new ReceiverTypeContext(_ctx, getState()); - enterRule(_localctx, 366, RULE_receiverType); + enterRule(_localctx, 368, RULE_receiverType); try { enterOuterAlt(_localctx, 1); { - setState(1859); + setState(1866); type_(); } } @@ -13165,36 +13215,36 @@ public T accept(ParseTreeVisitor visitor) { public final EosContext eos() throws RecognitionException { EosContext _localctx = new EosContext(_ctx, getState()); - enterRule(_localctx, 368, RULE_eos); + enterRule(_localctx, 370, RULE_eos); try { - setState(1865); + setState(1872); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(1861); + setState(1868); match(SEMI); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(1862); + setState(1869); match(EOF); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(1863); + setState(1870); match(EOS); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(1864); + setState(1871); if (!(this.closingBracket())) throw new FailedPredicateException(this, "this.closingBracket()"); } break; @@ -13213,13 +13263,13 @@ public final EosContext eos() throws RecognitionException { public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { switch (ruleIndex) { - case 82: + case 83: return expression_sempred((ExpressionContext)_localctx, predIndex); - case 90: + case 91: return primaryExpr_sempred((PrimaryExprContext)_localctx, predIndex); - case 120: + case 121: return statementList_sempred((StatementListContext)_localctx, predIndex); - case 184: + case 185: return eos_sempred((EosContext)_localctx, predIndex); } return true; @@ -13286,7 +13336,7 @@ private boolean eos_sempred(EosContext _localctx, int predIndex) { } public static final String _serializedATN = - "\u0004\u0001\u00a0\u074c\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ + "\u0004\u0001\u00a0\u0753\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+ "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+ "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+ @@ -13334,197 +13384,198 @@ private boolean eos_sempred(EosContext _localctx, int predIndex) { "\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007"+ "\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007"+ "\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007"+ - "\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0001\u0000\u0001"+ - "\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001"+ - "\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0005\u0003\u017f"+ - "\b\u0003\n\u0003\f\u0003\u0182\t\u0003\u0001\u0004\u0001\u0004\u0003\u0004"+ - "\u0186\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u018b\b"+ - "\u0005\n\u0005\f\u0005\u018e\t\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+ - "\u0001\u0005\u0001\u0005\u0005\u0005\u0195\b\u0005\n\u0005\f\u0005\u0198"+ - "\t\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u019d\b\u0005"+ - "\u0001\u0005\u0001\u0005\u0005\u0005\u01a1\b\u0005\n\u0005\f\u0005\u01a4"+ - "\t\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0005"+ - "\u0006\u01ab\b\u0006\n\u0006\f\u0006\u01ae\t\u0006\u0001\u0006\u0001\u0006"+ - "\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u01b5\b\u0006\n\u0006"+ - "\f\u0006\u01b8\t\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001"+ - "\b\u0001\b\u0001\t\u0001\t\u0001\t\u0005\t\u01c3\b\t\n\t\f\t\u01c6\t\t"+ - "\u0001\t\u0003\t\u01c9\b\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0005"+ - "\n\u01d0\b\n\n\n\f\n\u01d3\t\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n"+ - "\u0001\n\u0001\n\u0005\n\u01dc\b\n\n\n\f\n\u01df\t\n\u0001\n\u0003\n\u01e2"+ - "\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u01e8"+ - "\b\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0003"+ - "\f\u01f1\b\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ - "\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u01fb\b\u000f\u0001\u000f\u0001"+ - "\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ + "\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007"+ + "\u00b9\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001"+ + "\u0003\u0005\u0003\u0181\b\u0003\n\u0003\f\u0003\u0184\t\u0003\u0001\u0004"+ + "\u0001\u0004\u0003\u0004\u0188\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005"+ + "\u0005\u0005\u018d\b\u0005\n\u0005\f\u0005\u0190\t\u0005\u0001\u0005\u0001"+ + "\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u0197\b\u0005\n"+ + "\u0005\f\u0005\u019a\t\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003"+ + "\u0005\u019f\b\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u01a3\b\u0005"+ + "\n\u0005\f\u0005\u01a6\t\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001"+ + "\u0006\u0001\u0006\u0005\u0006\u01ad\b\u0006\n\u0006\f\u0006\u01b0\t\u0006"+ + "\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006"+ + "\u01b7\b\u0006\n\u0006\f\u0006\u01ba\t\u0006\u0001\u0007\u0001\u0007\u0001"+ + "\u0007\u0001\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0005\t\u01c5\b"+ + "\t\n\t\f\t\u01c8\t\t\u0001\t\u0003\t\u01cb\b\t\u0001\t\u0001\t\u0001\n"+ + "\u0001\n\u0001\n\u0005\n\u01d2\b\n\n\n\f\n\u01d5\t\n\u0001\n\u0001\n\u0001"+ + "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0005\n\u01de\b\n\n\n\f\n\u01e1\t\n"+ + "\u0001\n\u0003\n\u01e4\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+ + "\u0003\u000b\u01ea\b\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001"+ + "\f\u0001\f\u0003\f\u01f3\b\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001"+ + "\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u01fd\b\u000f\u0001"+ + "\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ - "\u0010\u0001\u0010\u0003\u0010\u020c\b\u0010\u0001\u0011\u0001\u0011\u0001"+ - "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+ - "\u0013\u0001\u0013\u0005\u0013\u0218\b\u0013\n\u0013\f\u0013\u021b\t\u0013"+ - "\u0001\u0013\u0003\u0013\u021e\b\u0013\u0001\u0014\u0001\u0014\u0001\u0014"+ - "\u0005\u0014\u0223\b\u0014\n\u0014\f\u0014\u0226\t\u0014\u0001\u0014\u0001"+ - "\u0014\u0001\u0015\u0005\u0015\u022b\b\u0015\n\u0015\f\u0015\u022e\t\u0015"+ - "\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0005\u0016\u0234\b\u0016"+ - "\n\u0016\f\u0016\u0237\t\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001"+ - "\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001"+ - "\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001"+ - "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001"+ - "\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ - "\u001c\u0001\u001c\u0003\u001c\u0256\b\u001c\u0001\u001c\u0001\u001c\u0001"+ - "\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0003\u001d\u025e\b\u001d\u0001"+ - "\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ - "\u001f\u0001 \u0001 \u0001 \u0001 \u0001 \u0001!\u0001!\u0001!\u0001!"+ - "\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0003\"\u0276\b\"\u0001"+ - "\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001"+ - "$\u0001$\u0001$\u0001$\u0001$\u0005$\u0287\b$\n$\f$\u028a\t$\u0001$\u0001"+ - "$\u0001%\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001&\u0005&\u0296"+ - "\b&\n&\f&\u0299\t&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ - "(\u0001(\u0001(\u0001(\u0003(\u02a5\b(\u0001)\u0001)\u0001)\u0001)\u0001"+ - ")\u0005)\u02ac\b)\n)\f)\u02af\t)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001"+ - "*\u0001*\u0001*\u0001*\u0001*\u0001*\u0003*\u02bc\b*\u0001+\u0001+\u0001"+ - "+\u0001+\u0001+\u0005+\u02c3\b+\n+\f+\u02c6\t+\u0001+\u0001+\u0001,\u0001"+ - ",\u0001,\u0001,\u0001,\u0005,\u02cf\b,\n,\f,\u02d2\t,\u0001,\u0001,\u0001"+ - "-\u0001-\u0001-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001.\u0001.\u0001"+ - ".\u0001.\u0001.\u0001.\u0001.\u0001.\u0003.\u02e6\b.\u0001/\u0001/\u0001"+ - "/\u0001/\u0001/\u0003/\u02ed\b/\u0001/\u0005/\u02f0\b/\n/\f/\u02f3\t/"+ - "\u0001/\u0001/\u0003/\u02f7\b/\u00010\u00010\u00010\u00010\u00010\u0001"+ - "0\u00010\u00010\u00030\u0301\b0\u00011\u00031\u0304\b1\u00011\u00011\u0003"+ - "1\u0308\b1\u00012\u00012\u00032\u030c\b2\u00013\u00013\u00013\u00013\u0005"+ - "3\u0312\b3\n3\f3\u0315\t3\u00013\u00013\u00014\u00014\u00014\u00034\u031c"+ - "\b4\u00015\u00015\u00015\u00035\u0321\b5\u00016\u00016\u00016\u00016\u0001"+ - "6\u00016\u00036\u0329\b6\u00036\u032b\b6\u00016\u00016\u00016\u00036\u0330"+ - "\b6\u00017\u00017\u00017\u00057\u0335\b7\n7\f7\u0338\t7\u00018\u00018"+ - "\u00018\u00018\u00018\u00038\u033f\b8\u00018\u00038\u0342\b8\u00018\u0001"+ - "8\u00019\u00019\u00039\u0348\b9\u00019\u00019\u00019\u00039\u034d\b9\u0003"+ - "9\u034f\b9\u00019\u00039\u0352\b9\u0001:\u0001:\u0001:\u0005:\u0357\b"+ - ":\n:\f:\u035a\t:\u0001;\u0001;\u0003;\u035e\b;\u0001;\u0001;\u0001<\u0001"+ - "<\u0001<\u0001<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001"+ - "=\u0001=\u0005=\u036f\b=\n=\f=\u0372\t=\u0001=\u0001=\u0001=\u0005=\u0377"+ - "\b=\n=\f=\u037a\t=\u0001=\u0003=\u037d\b=\u0001>\u0003>\u0380\b>\u0001"+ - ">\u0001>\u0001>\u0001>\u0003>\u0386\b>\u0001?\u0001?\u0003?\u038a\b?\u0001"+ - "?\u0003?\u038d\b?\u0001?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001@\u0001"+ - "@\u0003@\u0397\b@\u0001A\u0001A\u0001A\u0001A\u0001A\u0003A\u039e\bA\u0001"+ - "B\u0001B\u0001B\u0001B\u0001B\u0003B\u03a5\bB\u0001B\u0001B\u0001C\u0001"+ - "C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0003D\u03b1\bD\u0001E\u0001"+ - "E\u0001E\u0001E\u0003E\u03b7\bE\u0001F\u0001F\u0001F\u0001F\u0001F\u0003"+ - "F\u03be\bF\u0001G\u0001G\u0001G\u0003G\u03c3\bG\u0001H\u0001H\u0001H\u0001"+ - "H\u0003H\u03c9\bH\u0001I\u0001I\u0001I\u0001I\u0001I\u0001J\u0001J\u0001"+ - "J\u0001J\u0001J\u0003J\u03d5\bJ\u0001K\u0001K\u0001K\u0001K\u0003K\u03db"+ - "\bK\u0001K\u0001K\u0003K\u03df\bK\u0001L\u0001L\u0001L\u0001L\u0001M\u0001"+ - "M\u0003M\u03e7\bM\u0001M\u0001M\u0003M\u03eb\bM\u0001M\u0001M\u0001N\u0001"+ - "N\u0003N\u03f1\bN\u0001O\u0003O\u03f4\bO\u0001O\u0001O\u0001P\u0001P\u0003"+ - "P\u03fa\bP\u0001P\u0001P\u0001Q\u0003Q\u03ff\bQ\u0001Q\u0001Q\u0001R\u0001"+ - "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ - "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0003"+ - "R\u0418\bR\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ - "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ - "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ - "R\u0001R\u0001R\u0001R\u0001R\u0005R\u043b\bR\nR\fR\u043e\tR\u0001S\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u020e\b\u0010\u0001\u0011\u0001"+ + "\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u021a\b\u0013\n\u0013\f\u0013"+ + "\u021d\t\u0013\u0001\u0013\u0003\u0013\u0220\b\u0013\u0001\u0014\u0001"+ + "\u0014\u0001\u0014\u0005\u0014\u0225\b\u0014\n\u0014\f\u0014\u0228\t\u0014"+ + "\u0001\u0014\u0001\u0014\u0001\u0015\u0005\u0015\u022d\b\u0015\n\u0015"+ + "\f\u0015\u0230\t\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+ + "\u0005\u0016\u0236\b\u0016\n\u0016\f\u0016\u0239\t\u0016\u0001\u0016\u0001"+ + "\u0016\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001"+ + "\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+ + "\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ + "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u0258\b\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0003"+ + "\u001d\u0260\b\u001d\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001"+ + "\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+ + "!\u0001!\u0001!\u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\""+ + "\u0003\"\u0278\b\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#"+ + "\u0001#\u0001#\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0005$\u0289"+ + "\b$\n$\f$\u028c\t$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001%\u0001&\u0001"+ + "&\u0001&\u0001&\u0005&\u0298\b&\n&\f&\u029b\t&\u0001&\u0001&\u0001\'\u0001"+ + "\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0003(\u02a7\b(\u0001)"+ + "\u0001)\u0001)\u0001)\u0001)\u0005)\u02ae\b)\n)\f)\u02b1\t)\u0001)\u0001"+ + ")\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0003"+ + "*\u02be\b*\u0001+\u0001+\u0001+\u0001+\u0001+\u0005+\u02c5\b+\n+\f+\u02c8"+ + "\t+\u0001+\u0001+\u0001,\u0001,\u0001,\u0001,\u0001,\u0005,\u02d1\b,\n"+ + ",\f,\u02d4\t,\u0001,\u0001,\u0001-\u0003-\u02d9\b-\u0001-\u0001-\u0001"+ + ".\u0001.\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ + "/\u0001/\u0001/\u0001/\u0001/\u0001/\u0003/\u02ed\b/\u00010\u00010\u0001"+ + "0\u00010\u00010\u00030\u02f4\b0\u00010\u00050\u02f7\b0\n0\f0\u02fa\t0"+ + "\u00010\u00010\u00030\u02fe\b0\u00011\u00011\u00011\u00011\u00011\u0001"+ + "1\u00011\u00011\u00031\u0308\b1\u00012\u00032\u030b\b2\u00012\u00012\u0003"+ + "2\u030f\b2\u00013\u00013\u00033\u0313\b3\u00014\u00014\u00014\u00014\u0005"+ + "4\u0319\b4\n4\f4\u031c\t4\u00014\u00014\u00015\u00015\u00015\u00035\u0323"+ + "\b5\u00016\u00016\u00016\u00036\u0328\b6\u00017\u00017\u00017\u00017\u0001"+ + "7\u00017\u00037\u0330\b7\u00037\u0332\b7\u00017\u00017\u00017\u00037\u0337"+ + "\b7\u00018\u00018\u00018\u00058\u033c\b8\n8\f8\u033f\t8\u00019\u00019"+ + "\u00019\u00019\u00019\u00039\u0346\b9\u00019\u00039\u0349\b9\u00019\u0001"+ + "9\u0001:\u0001:\u0003:\u034f\b:\u0001:\u0001:\u0001:\u0003:\u0354\b:\u0003"+ + ":\u0356\b:\u0001:\u0003:\u0359\b:\u0001;\u0001;\u0001;\u0005;\u035e\b"+ + ";\n;\f;\u0361\t;\u0001<\u0001<\u0003<\u0365\b<\u0001<\u0001<\u0001=\u0001"+ + "=\u0001=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001>\u0001"+ + ">\u0001>\u0005>\u0376\b>\n>\f>\u0379\t>\u0001>\u0001>\u0001>\u0005>\u037e"+ + "\b>\n>\f>\u0381\t>\u0001>\u0003>\u0384\b>\u0001?\u0003?\u0387\b?\u0001"+ + "?\u0001?\u0001?\u0001?\u0003?\u038d\b?\u0001@\u0001@\u0003@\u0391\b@\u0001"+ + "@\u0003@\u0394\b@\u0001@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001A\u0001"+ + "A\u0003A\u039e\bA\u0001B\u0001B\u0001B\u0001B\u0001B\u0003B\u03a5\bB\u0001"+ + "C\u0001C\u0001C\u0001C\u0001C\u0003C\u03ac\bC\u0001C\u0001C\u0001D\u0001"+ + "D\u0001D\u0001D\u0001D\u0001E\u0001E\u0001E\u0003E\u03b8\bE\u0001F\u0001"+ + "F\u0001F\u0001F\u0003F\u03be\bF\u0001G\u0001G\u0001G\u0001G\u0001G\u0003"+ + "G\u03c5\bG\u0001H\u0001H\u0001H\u0003H\u03ca\bH\u0001I\u0001I\u0001I\u0001"+ + "I\u0003I\u03d0\bI\u0001J\u0001J\u0001J\u0001J\u0001J\u0001K\u0001K\u0001"+ + "K\u0001K\u0001K\u0003K\u03dc\bK\u0001L\u0001L\u0001L\u0001L\u0003L\u03e2"+ + "\bL\u0001L\u0001L\u0003L\u03e6\bL\u0001M\u0001M\u0001M\u0001M\u0001N\u0001"+ + "N\u0003N\u03ee\bN\u0001N\u0001N\u0003N\u03f2\bN\u0001N\u0001N\u0001O\u0001"+ + "O\u0003O\u03f8\bO\u0001P\u0003P\u03fb\bP\u0001P\u0001P\u0001Q\u0001Q\u0003"+ + "Q\u0401\bQ\u0001Q\u0001Q\u0001R\u0003R\u0406\bR\u0001R\u0001R\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0003"+ + "S\u041f\bS\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ - "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0003S\u0454"+ - "\bS\u0001T\u0001T\u0001T\u0001U\u0001U\u0001U\u0003U\u045c\bU\u0001V\u0001"+ - "V\u0001V\u0001W\u0001W\u0001W\u0001W\u0005W\u0465\bW\nW\fW\u0468\tW\u0001"+ - "W\u0001W\u0001W\u0001W\u0003W\u046e\bW\u0001X\u0001X\u0001X\u0001X\u0001"+ - "X\u0003X\u0475\bX\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ - "Y\u0003Y\u047f\bY\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ - "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u048d\bZ\u0001Z\u0001Z\u0001Z\u0001"+ - "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ - "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0005Z\u04a3\bZ\nZ\fZ\u04a6"+ - "\tZ\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0003\\\u04ad\b\\\u0001\\\u0001"+ - "\\\u0003\\\u04b1\b\\\u0001]\u0001]\u0003]\u04b5\b]\u0001]\u0003]\u04b8"+ - "\b]\u0001]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001^\u0003^\u04c1\b^\u0001"+ - "^\u0001^\u0005^\u04c5\b^\n^\f^\u04c8\t^\u0001^\u0001^\u0001_\u0001_\u0001"+ - "_\u0001_\u0001`\u0003`\u04d1\b`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001"+ - "`\u0003`\u04d9\b`\u0001`\u0001`\u0001`\u0001`\u0003`\u04df\b`\u0001a\u0001"+ - "a\u0001a\u0001a\u0001a\u0001a\u0001a\u0003a\u04e8\ba\u0001b\u0001b\u0001"+ - "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0003b\u04f3\bb\u0001c\u0001"+ - "c\u0001c\u0001d\u0001d\u0001d\u0001d\u0005d\u04fc\bd\nd\fd\u04ff\td\u0001"+ - "d\u0003d\u0502\bd\u0003d\u0504\bd\u0001d\u0001d\u0001e\u0001e\u0001e\u0001"+ - "e\u0001e\u0001e\u0001e\u0003e\u050f\be\u0001f\u0001f\u0001f\u0001f\u0001"+ - "f\u0001g\u0001g\u0003g\u0518\bg\u0001g\u0001g\u0003g\u051c\bg\u0001g\u0003"+ - "g\u051f\bg\u0001g\u0001g\u0001g\u0001g\u0001g\u0003g\u0526\bg\u0001g\u0001"+ - "g\u0001h\u0001h\u0001i\u0001i\u0001j\u0001j\u0001k\u0003k\u0531\bk\u0001"+ - "k\u0001k\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0003l\u053b\bl\u0001"+ - "l\u0001l\u0001l\u0001l\u0003l\u0541\bl\u0003l\u0543\bl\u0001m\u0001m\u0001"+ - "m\u0001n\u0001n\u0001o\u0001o\u0001o\u0003o\u054d\bo\u0001p\u0001p\u0001"+ - "p\u0001p\u0001p\u0001p\u0005p\u0555\bp\np\fp\u0558\tp\u0001p\u0003p\u055b"+ - "\bp\u0001q\u0001q\u0003q\u055f\bq\u0001q\u0001q\u0003q\u0563\bq\u0001"+ - "r\u0001r\u0001r\u0005r\u0568\br\nr\fr\u056b\tr\u0001s\u0001s\u0001s\u0005"+ - "s\u0570\bs\ns\fs\u0573\ts\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0005"+ - "t\u057b\bt\nt\ft\u057e\tt\u0001t\u0003t\u0581\bt\u0001u\u0001u\u0003u"+ - "\u0585\bu\u0001u\u0001u\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0005"+ - "v\u058f\bv\nv\fv\u0592\tv\u0001v\u0003v\u0595\bv\u0001w\u0001w\u0003w"+ - "\u0599\bw\u0001w\u0001w\u0001x\u0003x\u059e\bx\u0001x\u0003x\u05a1\bx"+ - "\u0001x\u0003x\u05a4\bx\u0001x\u0001x\u0001x\u0004x\u05a9\bx\u000bx\f"+ - "x\u05aa\u0001y\u0001y\u0001y\u0001y\u0001y\u0003y\u05b2\by\u0001z\u0001"+ - "z\u0001{\u0001{\u0001{\u0001{\u0001|\u0001|\u0001|\u0001}\u0001}\u0001"+ - "}\u0001}\u0001~\u0001~\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f"+ - "\u05c6\b\u007f\u0001\u0080\u0001\u0080\u0003\u0080\u05ca\b\u0080\u0001"+ - "\u0081\u0001\u0081\u0003\u0081\u05ce\b\u0081\u0001\u0082\u0001\u0082\u0003"+ - "\u0082\u05d2\b\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0084\u0001"+ - "\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001"+ - "\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u05e2\b\u0085\u0001"+ - "\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0003\u0085\u05e8\b\u0085\u0003"+ - "\u0085\u05ea\b\u0085\u0001\u0086\u0001\u0086\u0003\u0086\u05ee\b\u0086"+ - "\u0001\u0087\u0001\u0087\u0003\u0087\u05f2\b\u0087\u0001\u0087\u0003\u0087"+ - "\u05f5\b\u0087\u0001\u0087\u0001\u0087\u0003\u0087\u05f9\b\u0087\u0003"+ - "\u0087\u05fb\b\u0087\u0001\u0087\u0001\u0087\u0005\u0087\u05ff\b\u0087"+ - "\n\u0087\f\u0087\u0602\t\u0087\u0001\u0087\u0001\u0087\u0001\u0088\u0001"+ - "\u0088\u0001\u0088\u0003\u0088\u0609\b\u0088\u0001\u0089\u0001\u0089\u0001"+ - "\u0089\u0003\u0089\u060e\b\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0001"+ - "\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0003"+ - "\u008a\u0619\b\u008a\u0001\u008a\u0001\u008a\u0005\u008a\u061d\b\u008a"+ - "\n\u008a\f\u008a\u0620\t\u008a\u0001\u008a\u0001\u008a\u0001\u008b\u0001"+ - "\u008b\u0003\u008b\u0626\b\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+ - "\u008b\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c\u0001\u008c\u0003"+ - "\u008c\u0631\b\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0003\u008d\u0636"+ - "\b\u008d\u0001\u008e\u0001\u008e\u0003\u008e\u063a\b\u008e\u0001\u008e"+ - "\u0001\u008e\u0001\u008e\u0003\u008e\u063f\b\u008e\u0005\u008e\u0641\b"+ - "\u008e\n\u008e\f\u008e\u0644\t\u008e\u0001\u008f\u0001\u008f\u0001\u008f"+ - "\u0005\u008f\u0649\b\u008f\n\u008f\f\u008f\u064c\t\u008f\u0001\u008f\u0001"+ - "\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0653\b\u0090\u0001"+ - "\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u0658\b\u0091\u0001\u0091\u0003"+ - "\u0091\u065b\b\u0091\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+ - "\u0092\u0001\u0092\u0003\u0092\u0663\b\u0092\u0001\u0092\u0001\u0092\u0001"+ - "\u0093\u0001\u0093\u0003\u0093\u0669\b\u0093\u0001\u0093\u0001\u0093\u0003"+ - "\u0093\u066d\b\u0093\u0003\u0093\u066f\b\u0093\u0001\u0093\u0001\u0093"+ - "\u0001\u0094\u0003\u0094\u0674\b\u0094\u0001\u0094\u0001\u0094\u0003\u0094"+ - "\u0678\b\u0094\u0001\u0094\u0001\u0094\u0003\u0094\u067c\b\u0094\u0001"+ - "\u0095\u0001\u0095\u0001\u0095\u0001\u0096\u0001\u0096\u0003\u0096\u0683"+ - "\b\u0096\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001\u0097\u0001"+ - "\u0098\u0001\u0098\u0001\u0099\u0001\u0099\u0001\u009a\u0001\u009a\u0001"+ - "\u009a\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009b\u0001\u009c\u0001"+ - "\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009d\u0001"+ - "\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0003\u009d\u06a0\b\u009d\u0001"+ - "\u009d\u0001\u009d\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009f\u0001"+ - "\u009f\u0001\u009f\u0001\u009f\u0003\u009f\u06ab\b\u009f\u0001\u00a0\u0001"+ - "\u00a0\u0003\u00a0\u06af\b\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001"+ - "\u00a1\u0005\u00a1\u06b5\b\u00a1\n\u00a1\f\u00a1\u06b8\t\u00a1\u0001\u00a1"+ - "\u0003\u00a1\u06bb\b\u00a1\u0003\u00a1\u06bd\b\u00a1\u0001\u00a1\u0001"+ - "\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0003\u00a2\u06c5"+ - "\b\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001"+ - "\u00a3\u0001\u00a3\u0003\u00a3\u06ce\b\u00a3\u0001\u00a4\u0001\u00a4\u0001"+ - "\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0003\u00a4\u06d6\b\u00a4\u0001"+ - "\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u06db\b\u00a5\u0001\u00a6\u0001"+ - "\u00a6\u0001\u00a7\u0001\u00a7\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001"+ - "\u00a8\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001\u00aa\u0001\u00aa\u0001"+ - "\u00aa\u0003\u00aa\u06eb\b\u00aa\u0003\u00aa\u06ed\b\u00aa\u0001\u00aa"+ - "\u0001\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0005\u00ab\u06f4\b\u00ab"+ - "\n\u00ab\f\u00ab\u06f7\t\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003"+ - "\u00ac\u06fc\b\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0003"+ - "\u00ad\u0702\b\u00ad\u0001\u00ae\u0001\u00ae\u0003\u00ae\u0706\b\u00ae"+ - "\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0005\u00af"+ - "\u070d\b\u00af\n\u00af\f\u00af\u0710\t\u00af\u0001\u00af\u0001\u00af\u0001"+ - "\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0\u0718\b\u00b0\u0001"+ - "\u00b0\u0003\u00b0\u071b\b\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b2\u0003"+ - "\u00b2\u0720\b\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b3\u0001\u00b3\u0001"+ - "\u00b3\u0001\u00b3\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001"+ - "\u00b4\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0003"+ - "\u00b5\u0732\b\u00b5\u0003\u00b5\u0734\b\u00b5\u0001\u00b5\u0003\u00b5"+ - "\u0737\b\u00b5\u0001\u00b5\u0003\u00b5\u073a\b\u00b5\u0003\u00b5\u073c"+ - "\b\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001"+ - "\u00b6\u0001\u00b7\u0001\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001"+ - "\u00b8\u0003\u00b8\u074a\b\u00b8\u0001\u00b8\u0001\u02f1\u0002\u00a4\u00b4"+ - "\u00b9\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018"+ + "S\u0001S\u0001S\u0001S\u0001S\u0005S\u0442\bS\nS\fS\u0445\tS\u0001T\u0001"+ + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001"+ + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0003T\u045b"+ + "\bT\u0001U\u0001U\u0001U\u0001V\u0001V\u0001V\u0003V\u0463\bV\u0001W\u0001"+ + "W\u0001W\u0001X\u0001X\u0001X\u0001X\u0005X\u046c\bX\nX\fX\u046f\tX\u0001"+ + "X\u0001X\u0001X\u0001X\u0003X\u0475\bX\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ + "Y\u0003Y\u047c\bY\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+ + "Z\u0003Z\u0486\bZ\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001"+ + "[\u0001[\u0001[\u0001[\u0001[\u0003[\u0494\b[\u0001[\u0001[\u0001[\u0001"+ + "[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001"+ + "[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0005[\u04aa\b[\n[\f[\u04ad"+ + "\t[\u0001\\\u0001\\\u0001\\\u0001]\u0001]\u0003]\u04b4\b]\u0001]\u0001"+ + "]\u0003]\u04b8\b]\u0001^\u0001^\u0003^\u04bc\b^\u0001^\u0003^\u04bf\b"+ + "^\u0001^\u0001^\u0001_\u0001_\u0001_\u0001_\u0001_\u0003_\u04c8\b_\u0001"+ + "_\u0001_\u0005_\u04cc\b_\n_\f_\u04cf\t_\u0001_\u0001_\u0001`\u0001`\u0001"+ + "`\u0001`\u0001a\u0003a\u04d8\ba\u0001a\u0001a\u0001a\u0001a\u0001a\u0001"+ + "a\u0003a\u04e0\ba\u0001a\u0001a\u0001a\u0001a\u0003a\u04e6\ba\u0001b\u0001"+ + "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0003b\u04ef\bb\u0001c\u0001c\u0001"+ + "c\u0001c\u0001c\u0001c\u0001c\u0001c\u0001c\u0003c\u04fa\bc\u0001d\u0001"+ + "d\u0001d\u0001e\u0001e\u0001e\u0001e\u0005e\u0503\be\ne\fe\u0506\te\u0001"+ + "e\u0003e\u0509\be\u0003e\u050b\be\u0001e\u0001e\u0001f\u0001f\u0001f\u0001"+ + "f\u0001f\u0001f\u0001f\u0003f\u0516\bf\u0001g\u0001g\u0001g\u0001g\u0001"+ + "g\u0001h\u0001h\u0003h\u051f\bh\u0001h\u0001h\u0003h\u0523\bh\u0001h\u0003"+ + "h\u0526\bh\u0001h\u0001h\u0001h\u0001h\u0001h\u0003h\u052d\bh\u0001h\u0001"+ + "h\u0001i\u0001i\u0001j\u0001j\u0001k\u0001k\u0001l\u0003l\u0538\bl\u0001"+ + "l\u0001l\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0003m\u0542\bm\u0001"+ + "m\u0001m\u0001m\u0001m\u0003m\u0548\bm\u0003m\u054a\bm\u0001n\u0001n\u0001"+ + "n\u0001o\u0001o\u0001p\u0001p\u0001p\u0003p\u0554\bp\u0001q\u0001q\u0001"+ + "q\u0001q\u0001q\u0001q\u0005q\u055c\bq\nq\fq\u055f\tq\u0001q\u0003q\u0562"+ + "\bq\u0001r\u0001r\u0003r\u0566\br\u0001r\u0001r\u0003r\u056a\br\u0001"+ + "s\u0001s\u0001s\u0005s\u056f\bs\ns\fs\u0572\ts\u0001t\u0001t\u0001t\u0005"+ + "t\u0577\bt\nt\ft\u057a\tt\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0005"+ + "u\u0582\bu\nu\fu\u0585\tu\u0001u\u0003u\u0588\bu\u0001v\u0001v\u0003v"+ + "\u058c\bv\u0001v\u0001v\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0005"+ + "w\u0596\bw\nw\fw\u0599\tw\u0001w\u0003w\u059c\bw\u0001x\u0001x\u0003x"+ + "\u05a0\bx\u0001x\u0001x\u0001y\u0003y\u05a5\by\u0001y\u0003y\u05a8\by"+ + "\u0001y\u0003y\u05ab\by\u0001y\u0001y\u0001y\u0004y\u05b0\by\u000by\f"+ + "y\u05b1\u0001z\u0001z\u0001z\u0001z\u0001z\u0003z\u05b9\bz\u0001{\u0001"+ + "{\u0001|\u0001|\u0001|\u0001|\u0001}\u0001}\u0001}\u0001~\u0001~\u0001"+ + "~\u0001~\u0001\u007f\u0001\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0003"+ + "\u0080\u05cd\b\u0080\u0001\u0081\u0001\u0081\u0003\u0081\u05d1\b\u0081"+ + "\u0001\u0082\u0001\u0082\u0003\u0082\u05d5\b\u0082\u0001\u0083\u0001\u0083"+ + "\u0003\u0083\u05d9\b\u0083\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0085"+ + "\u0001\u0085\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086"+ + "\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0003\u0086\u05e9\b\u0086"+ + "\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0003\u0086\u05ef\b\u0086"+ + "\u0003\u0086\u05f1\b\u0086\u0001\u0087\u0001\u0087\u0003\u0087\u05f5\b"+ + "\u0087\u0001\u0088\u0001\u0088\u0003\u0088\u05f9\b\u0088\u0001\u0088\u0003"+ + "\u0088\u05fc\b\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u0600\b\u0088"+ + "\u0003\u0088\u0602\b\u0088\u0001\u0088\u0001\u0088\u0005\u0088\u0606\b"+ + "\u0088\n\u0088\f\u0088\u0609\t\u0088\u0001\u0088\u0001\u0088\u0001\u0089"+ + "\u0001\u0089\u0001\u0089\u0003\u0089\u0610\b\u0089\u0001\u008a\u0001\u008a"+ + "\u0001\u008a\u0003\u008a\u0615\b\u008a\u0001\u008b\u0001\u008b\u0001\u008b"+ + "\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b"+ + "\u0003\u008b\u0620\b\u008b\u0001\u008b\u0001\u008b\u0005\u008b\u0624\b"+ + "\u008b\n\u008b\f\u008b\u0627\t\u008b\u0001\u008b\u0001\u008b\u0001\u008c"+ + "\u0001\u008c\u0003\u008c\u062d\b\u008c\u0001\u008c\u0001\u008c\u0001\u008c"+ + "\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008d\u0001\u008d\u0001\u008d"+ + "\u0003\u008d\u0638\b\u008d\u0001\u008e\u0001\u008e\u0001\u008e\u0003\u008e"+ + "\u063d\b\u008e\u0001\u008f\u0001\u008f\u0003\u008f\u0641\b\u008f\u0001"+ + "\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u0646\b\u008f\u0005\u008f\u0648"+ + "\b\u008f\n\u008f\f\u008f\u064b\t\u008f\u0001\u0090\u0001\u0090\u0001\u0090"+ + "\u0005\u0090\u0650\b\u0090\n\u0090\f\u0090\u0653\t\u0090\u0001\u0090\u0001"+ + "\u0090\u0001\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u065a\b\u0091\u0001"+ + "\u0092\u0001\u0092\u0001\u0092\u0003\u0092\u065f\b\u0092\u0001\u0092\u0003"+ + "\u0092\u0662\b\u0092\u0001\u0093\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+ + "\u0093\u0001\u0093\u0003\u0093\u066a\b\u0093\u0001\u0093\u0001\u0093\u0001"+ + "\u0094\u0001\u0094\u0003\u0094\u0670\b\u0094\u0001\u0094\u0001\u0094\u0003"+ + "\u0094\u0674\b\u0094\u0003\u0094\u0676\b\u0094\u0001\u0094\u0001\u0094"+ + "\u0001\u0095\u0003\u0095\u067b\b\u0095\u0001\u0095\u0001\u0095\u0003\u0095"+ + "\u067f\b\u0095\u0001\u0095\u0001\u0095\u0003\u0095\u0683\b\u0095\u0001"+ + "\u0096\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097\u0003\u0097\u068a"+ + "\b\u0097\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001\u0098\u0001"+ + "\u0099\u0001\u0099\u0001\u009a\u0001\u009a\u0001\u009b\u0001\u009b\u0001"+ + "\u009b\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009c\u0001\u009d\u0001"+ + "\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009d\u0001\u009e\u0001"+ + "\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0003\u009e\u06a7\b\u009e\u0001"+ + "\u009e\u0001\u009e\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u00a0\u0001"+ + "\u00a0\u0001\u00a0\u0001\u00a0\u0003\u00a0\u06b2\b\u00a0\u0001\u00a1\u0001"+ + "\u00a1\u0003\u00a1\u06b6\b\u00a1\u0001\u00a2\u0001\u00a2\u0001\u00a2\u0001"+ + "\u00a2\u0005\u00a2\u06bc\b\u00a2\n\u00a2\f\u00a2\u06bf\t\u00a2\u0001\u00a2"+ + "\u0003\u00a2\u06c2\b\u00a2\u0003\u00a2\u06c4\b\u00a2\u0001\u00a2\u0001"+ + "\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0003\u00a3\u06cc"+ + "\b\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001"+ + "\u00a4\u0001\u00a4\u0003\u00a4\u06d5\b\u00a4\u0001\u00a5\u0001\u00a5\u0001"+ + "\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0003\u00a5\u06dd\b\u00a5\u0001"+ + "\u00a6\u0001\u00a6\u0001\u00a6\u0003\u00a6\u06e2\b\u00a6\u0001\u00a7\u0001"+ + "\u00a7\u0001\u00a8\u0001\u00a8\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0001"+ + "\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00ab\u0001\u00ab\u0001"+ + "\u00ab\u0003\u00ab\u06f2\b\u00ab\u0003\u00ab\u06f4\b\u00ab\u0001\u00ab"+ + "\u0001\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0005\u00ac\u06fb\b\u00ac"+ + "\n\u00ac\f\u00ac\u06fe\t\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad\u0003"+ + "\u00ad\u0703\b\u00ad\u0001\u00ad\u0001\u00ad\u0001\u00ae\u0001\u00ae\u0003"+ + "\u00ae\u0709\b\u00ae\u0001\u00af\u0001\u00af\u0003\u00af\u070d\b\u00af"+ + "\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0005\u00b0"+ + "\u0714\b\u00b0\n\u00b0\f\u00b0\u0717\t\u00b0\u0001\u00b0\u0001\u00b0\u0001"+ + "\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0003\u00b1\u071f\b\u00b1\u0001"+ + "\u00b1\u0003\u00b1\u0722\b\u00b1\u0001\u00b2\u0001\u00b2\u0001\u00b3\u0003"+ + "\u00b3\u0727\b\u00b3\u0001\u00b3\u0001\u00b3\u0001\u00b4\u0001\u00b4\u0001"+ + "\u00b4\u0001\u00b4\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0001"+ + "\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0003"+ + "\u00b6\u0739\b\u00b6\u0003\u00b6\u073b\b\u00b6\u0001\u00b6\u0003\u00b6"+ + "\u073e\b\u00b6\u0001\u00b6\u0003\u00b6\u0741\b\u00b6\u0003\u00b6\u0743"+ + "\b\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b7\u0001\u00b7\u0001\u00b7\u0001"+ + "\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001"+ + "\u00b9\u0003\u00b9\u0751\b\u00b9\u0001\u00b9\u0001\u02f8\u0002\u00a6\u00b6"+ + "\u00ba\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018"+ "\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080"+ "\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098"+ "\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0"+ @@ -13536,956 +13587,959 @@ private boolean eos_sempred(EosContext _localctx, int predIndex) { "\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140"+ "\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158"+ "\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170"+ - "\u0000\u0013\u0002\u0000eepp\u0001\u0000\u0017\u0018\u0001\u0000\u0005"+ - "\b\u0001\u0000AB\u0001\u0000(*\u0002\u0000(*,,\u0001\u0000\u0083\u0089"+ - "\u0001\u0000\u0014\u0015\u0002\u0000~\u0082\u0087\u0088\u0004\u0000##"+ - "qq}}\u0084\u0086\u0001\u0000\u001f!\u0001\u0000\u001c\u001e\u0002\u0000"+ + "\u0172\u0000\u0013\u0002\u0000eepp\u0001\u0000\u0017\u0018\u0001\u0000"+ + "\u0005\b\u0001\u0000AB\u0001\u0000(*\u0002\u0000(*,,\u0001\u0000\u0083"+ + "\u0089\u0001\u0000\u0014\u0015\u0002\u0000~\u0082\u0087\u0088\u0004\u0000"+ + "##qq}}\u0084\u0086\u0001\u0000\u001f!\u0001\u0000\u001c\u001e\u0002\u0000"+ "HIw|\u0004\u0000--0033]]\u0002\u0000}\u0082\u0084\u0088\u0001\u0000qr"+ "\u0002\u0000nn\u009f\u009f\u0002\u0000\u008a\u008d\u008f\u0090\u0001\u0000"+ - "\u0096\u0097\u07b5\u0000\u0172\u0001\u0000\u0000\u0000\u0002\u0175\u0001"+ - "\u0000\u0000\u0000\u0004\u0178\u0001\u0000\u0000\u0000\u0006\u017b\u0001"+ - "\u0000\u0000\u0000\b\u0183\u0001\u0000\u0000\u0000\n\u018c\u0001\u0000"+ - "\u0000\u0000\f\u01ac\u0001\u0000\u0000\u0000\u000e\u01b9\u0001\u0000\u0000"+ - "\u0000\u0010\u01bc\u0001\u0000\u0000\u0000\u0012\u01c4\u0001\u0000\u0000"+ - "\u0000\u0014\u01d1\u0001\u0000\u0000\u0000\u0016\u01e7\u0001\u0000\u0000"+ - "\u0000\u0018\u01f0\u0001\u0000\u0000\u0000\u001a\u01f2\u0001\u0000\u0000"+ - "\u0000\u001c\u01f4\u0001\u0000\u0000\u0000\u001e\u01f7\u0001\u0000\u0000"+ - "\u0000 \u020b\u0001\u0000\u0000\u0000\"\u020d\u0001\u0000\u0000\u0000"+ - "$\u020f\u0001\u0000\u0000\u0000&\u0214\u0001\u0000\u0000\u0000(\u021f"+ - "\u0001\u0000\u0000\u0000*\u022c\u0001\u0000\u0000\u0000,\u022f\u0001\u0000"+ - "\u0000\u0000.\u023a\u0001\u0000\u0000\u00000\u023c\u0001\u0000\u0000\u0000"+ - "2\u0241\u0001\u0000\u0000\u00004\u0246\u0001\u0000\u0000\u00006\u024b"+ - "\u0001\u0000\u0000\u00008\u0250\u0001\u0000\u0000\u0000:\u025d\u0001\u0000"+ - "\u0000\u0000<\u025f\u0001\u0000\u0000\u0000>\u0261\u0001\u0000\u0000\u0000"+ - "@\u0266\u0001\u0000\u0000\u0000B\u026b\u0001\u0000\u0000\u0000D\u0270"+ - "\u0001\u0000\u0000\u0000F\u0279\u0001\u0000\u0000\u0000H\u0280\u0001\u0000"+ - "\u0000\u0000J\u028d\u0001\u0000\u0000\u0000L\u0291\u0001\u0000\u0000\u0000"+ - "N\u029c\u0001\u0000\u0000\u0000P\u02a4\u0001\u0000\u0000\u0000R\u02a6"+ - "\u0001\u0000\u0000\u0000T\u02bb\u0001\u0000\u0000\u0000V\u02bd\u0001\u0000"+ - "\u0000\u0000X\u02c9\u0001\u0000\u0000\u0000Z\u02d5\u0001\u0000\u0000\u0000"+ - "\\\u02e5\u0001\u0000\u0000\u0000^\u02f1\u0001\u0000\u0000\u0000`\u0300"+ - "\u0001\u0000\u0000\u0000b\u0303\u0001\u0000\u0000\u0000d\u030b\u0001\u0000"+ - "\u0000\u0000f\u030d\u0001\u0000\u0000\u0000h\u0318\u0001\u0000\u0000\u0000"+ - "j\u0320\u0001\u0000\u0000\u0000l\u032f\u0001\u0000\u0000\u0000n\u0331"+ - "\u0001\u0000\u0000\u0000p\u0339\u0001\u0000\u0000\u0000r\u0347\u0001\u0000"+ - "\u0000\u0000t\u0353\u0001\u0000\u0000\u0000v\u035d\u0001\u0000\u0000\u0000"+ - "x\u0361\u0001\u0000\u0000\u0000z\u0367\u0001\u0000\u0000\u0000|\u037f"+ - "\u0001\u0000\u0000\u0000~\u0387\u0001\u0000\u0000\u0000\u0080\u0396\u0001"+ - "\u0000\u0000\u0000\u0082\u0398\u0001\u0000\u0000\u0000\u0084\u039f\u0001"+ - "\u0000\u0000\u0000\u0086\u03a8\u0001\u0000\u0000\u0000\u0088\u03ad\u0001"+ - "\u0000\u0000\u0000\u008a\u03b2\u0001\u0000\u0000\u0000\u008c\u03b8\u0001"+ - "\u0000\u0000\u0000\u008e\u03bf\u0001\u0000\u0000\u0000\u0090\u03c4\u0001"+ - "\u0000\u0000\u0000\u0092\u03ca\u0001\u0000\u0000\u0000\u0094\u03cf\u0001"+ - "\u0000\u0000\u0000\u0096\u03d6\u0001\u0000\u0000\u0000\u0098\u03e0\u0001"+ - "\u0000\u0000\u0000\u009a\u03e4\u0001\u0000\u0000\u0000\u009c\u03f0\u0001"+ - "\u0000\u0000\u0000\u009e\u03f3\u0001\u0000\u0000\u0000\u00a0\u03f7\u0001"+ - "\u0000\u0000\u0000\u00a2\u03fe\u0001\u0000\u0000\u0000\u00a4\u0417\u0001"+ - "\u0000\u0000\u0000\u00a6\u0453\u0001\u0000\u0000\u0000\u00a8\u0455\u0001"+ - "\u0000\u0000\u0000\u00aa\u0458\u0001\u0000\u0000\u0000\u00ac\u045d\u0001"+ - "\u0000\u0000\u0000\u00ae\u0466\u0001\u0000\u0000\u0000\u00b0\u0474\u0001"+ - "\u0000\u0000\u0000\u00b2\u047e\u0001\u0000\u0000\u0000\u00b4\u048c\u0001"+ - "\u0000\u0000\u0000\u00b6\u04a7\u0001\u0000\u0000\u0000\u00b8\u04aa\u0001"+ - "\u0000\u0000\u0000\u00ba\u04b2\u0001\u0000\u0000\u0000\u00bc\u04bb\u0001"+ - "\u0000\u0000\u0000\u00be\u04cb\u0001\u0000\u0000\u0000\u00c0\u04de\u0001"+ - "\u0000\u0000\u0000\u00c2\u04e7\u0001\u0000\u0000\u0000\u00c4\u04f2\u0001"+ - "\u0000\u0000\u0000\u00c6\u04f4\u0001\u0000\u0000\u0000\u00c8\u04f7\u0001"+ - "\u0000\u0000\u0000\u00ca\u050e\u0001\u0000\u0000\u0000\u00cc\u0510\u0001"+ - "\u0000\u0000\u0000\u00ce\u0515\u0001\u0000\u0000\u0000\u00d0\u0529\u0001"+ - "\u0000\u0000\u0000\u00d2\u052b\u0001\u0000\u0000\u0000\u00d4\u052d\u0001"+ - "\u0000\u0000\u0000\u00d6\u0530\u0001\u0000\u0000\u0000\u00d8\u053a\u0001"+ - "\u0000\u0000\u0000\u00da\u0544\u0001\u0000\u0000\u0000\u00dc\u0547\u0001"+ - "\u0000\u0000\u0000\u00de\u054c\u0001\u0000\u0000\u0000\u00e0\u054e\u0001"+ - "\u0000\u0000\u0000\u00e2\u055c\u0001\u0000\u0000\u0000\u00e4\u0564\u0001"+ - "\u0000\u0000\u0000\u00e6\u056c\u0001\u0000\u0000\u0000\u00e8\u0574\u0001"+ - "\u0000\u0000\u0000\u00ea\u0582\u0001\u0000\u0000\u0000\u00ec\u0588\u0001"+ - "\u0000\u0000\u0000\u00ee\u0596\u0001\u0000\u0000\u0000\u00f0\u05a8\u0001"+ - "\u0000\u0000\u0000\u00f2\u05b1\u0001\u0000\u0000\u0000\u00f4\u05b3\u0001"+ - "\u0000\u0000\u0000\u00f6\u05b5\u0001\u0000\u0000\u0000\u00f8\u05b9\u0001"+ - "\u0000\u0000\u0000\u00fa\u05bc\u0001\u0000\u0000\u0000\u00fc\u05c0\u0001"+ - "\u0000\u0000\u0000\u00fe\u05c2\u0001\u0000\u0000\u0000\u0100\u05c7\u0001"+ - "\u0000\u0000\u0000\u0102\u05cb\u0001\u0000\u0000\u0000\u0104\u05cf\u0001"+ - "\u0000\u0000\u0000\u0106\u05d3\u0001\u0000\u0000\u0000\u0108\u05d6\u0001"+ - "\u0000\u0000\u0000\u010a\u05d8\u0001\u0000\u0000\u0000\u010c\u05ed\u0001"+ - "\u0000\u0000\u0000\u010e\u05ef\u0001\u0000\u0000\u0000\u0110\u0605\u0001"+ - "\u0000\u0000\u0000\u0112\u060d\u0001\u0000\u0000\u0000\u0114\u060f\u0001"+ - "\u0000\u0000\u0000\u0116\u0625\u0001\u0000\u0000\u0000\u0118\u062d\u0001"+ - "\u0000\u0000\u0000\u011a\u0635\u0001\u0000\u0000\u0000\u011c\u0639\u0001"+ - "\u0000\u0000\u0000\u011e\u0645\u0001\u0000\u0000\u0000\u0120\u064f\u0001"+ - "\u0000\u0000\u0000\u0122\u065a\u0001\u0000\u0000\u0000\u0124\u0662\u0001"+ - "\u0000\u0000\u0000\u0126\u0666\u0001\u0000\u0000\u0000\u0128\u0673\u0001"+ - "\u0000\u0000\u0000\u012a\u067d\u0001\u0000\u0000\u0000\u012c\u0682\u0001"+ - "\u0000\u0000\u0000\u012e\u0684\u0001\u0000\u0000\u0000\u0130\u0689\u0001"+ - "\u0000\u0000\u0000\u0132\u068b\u0001\u0000\u0000\u0000\u0134\u068d\u0001"+ - "\u0000\u0000\u0000\u0136\u0690\u0001\u0000\u0000\u0000\u0138\u0694\u0001"+ - "\u0000\u0000\u0000\u013a\u069f\u0001\u0000\u0000\u0000\u013c\u06a3\u0001"+ - "\u0000\u0000\u0000\u013e\u06aa\u0001\u0000\u0000\u0000\u0140\u06ae\u0001"+ - "\u0000\u0000\u0000\u0142\u06b0\u0001\u0000\u0000\u0000\u0144\u06c0\u0001"+ - "\u0000\u0000\u0000\u0146\u06cd\u0001\u0000\u0000\u0000\u0148\u06d5\u0001"+ - "\u0000\u0000\u0000\u014a\u06da\u0001\u0000\u0000\u0000\u014c\u06dc\u0001"+ - "\u0000\u0000\u0000\u014e\u06de\u0001\u0000\u0000\u0000\u0150\u06e0\u0001"+ - "\u0000\u0000\u0000\u0152\u06e4\u0001\u0000\u0000\u0000\u0154\u06e7\u0001"+ - "\u0000\u0000\u0000\u0156\u06f0\u0001\u0000\u0000\u0000\u0158\u06fb\u0001"+ - "\u0000\u0000\u0000\u015a\u0701\u0001\u0000\u0000\u0000\u015c\u0705\u0001"+ - "\u0000\u0000\u0000\u015e\u0707\u0001\u0000\u0000\u0000\u0160\u0717\u0001"+ - "\u0000\u0000\u0000\u0162\u071c\u0001\u0000\u0000\u0000\u0164\u071f\u0001"+ - "\u0000\u0000\u0000\u0166\u0723\u0001\u0000\u0000\u0000\u0168\u0727\u0001"+ - "\u0000\u0000\u0000\u016a\u072c\u0001\u0000\u0000\u0000\u016c\u073f\u0001"+ - "\u0000\u0000\u0000\u016e\u0743\u0001\u0000\u0000\u0000\u0170\u0749\u0001"+ - "\u0000\u0000\u0000\u0172\u0173\u0003\u00a4R\u0000\u0173\u0174\u0005\u0000"+ - "\u0000\u0001\u0174\u0001\u0001\u0000\u0000\u0000\u0175\u0176\u0003\u00a6"+ - "S\u0000\u0176\u0177\u0005\u0000\u0000\u0001\u0177\u0003\u0001\u0000\u0000"+ - "\u0000\u0178\u0179\u0003\u00c2a\u0000\u0179\u017a\u0005\u0000\u0000\u0001"+ - "\u017a\u0005\u0001\u0000\u0000\u0000\u017b\u0180\u0003\b\u0004\u0000\u017c"+ - "\u017d\u0005m\u0000\u0000\u017d\u017f\u0003\b\u0004\u0000\u017e\u017c"+ - "\u0001\u0000\u0000\u0000\u017f\u0182\u0001\u0000\u0000\u0000\u0180\u017e"+ - "\u0001\u0000\u0000\u0000\u0180\u0181\u0001\u0000\u0000\u0000\u0181\u0007"+ - "\u0001\u0000\u0000\u0000\u0182\u0180\u0001\u0000\u0000\u0000\u0183\u0185"+ - "\u0005e\u0000\u0000\u0184\u0186\u0005<\u0000\u0000\u0185\u0184\u0001\u0000"+ - "\u0000\u0000\u0185\u0186\u0001\u0000\u0000\u0000\u0186\t\u0001\u0000\u0000"+ - "\u0000\u0187\u0188\u0003\u000e\u0007\u0000\u0188\u0189\u0003\u0170\u00b8"+ - "\u0000\u0189\u018b\u0001\u0000\u0000\u0000\u018a\u0187\u0001\u0000\u0000"+ - "\u0000\u018b\u018e\u0001\u0000\u0000\u0000\u018c\u018a\u0001\u0000\u0000"+ - "\u0000\u018c\u018d\u0001\u0000\u0000\u0000\u018d\u018f\u0001\u0000\u0000"+ - "\u0000\u018e\u018c\u0001\u0000\u0000\u0000\u018f\u0190\u0003\u00dam\u0000"+ - "\u0190\u0196\u0003\u0170\u00b8\u0000\u0191\u0192\u0003\u0014\n\u0000\u0192"+ - "\u0193\u0003\u0170\u00b8\u0000\u0193\u0195\u0001\u0000\u0000\u0000\u0194"+ - "\u0191\u0001\u0000\u0000\u0000\u0195\u0198\u0001\u0000\u0000\u0000\u0196"+ - "\u0194\u0001\u0000\u0000\u0000\u0196\u0197\u0001\u0000\u0000\u0000\u0197"+ - "\u01a2\u0001\u0000\u0000\u0000\u0198\u0196\u0001\u0000\u0000\u0000\u0199"+ - "\u019d\u0003\u0088D\u0000\u019a\u019d\u0003\u00deo\u0000\u019b\u019d\u0003"+ - "\u0016\u000b\u0000\u019c\u0199\u0001\u0000\u0000\u0000\u019c\u019a\u0001"+ - "\u0000\u0000\u0000\u019c\u019b\u0001\u0000\u0000\u0000\u019d\u019e\u0001"+ - "\u0000\u0000\u0000\u019e\u019f\u0003\u0170\u00b8\u0000\u019f\u01a1\u0001"+ - "\u0000\u0000\u0000\u01a0\u019c\u0001\u0000\u0000\u0000\u01a1\u01a4\u0001"+ - "\u0000\u0000\u0000\u01a2\u01a0\u0001\u0000\u0000\u0000\u01a2\u01a3\u0001"+ - "\u0000\u0000\u0000\u01a3\u01a5\u0001\u0000\u0000\u0000\u01a4\u01a2\u0001"+ - "\u0000\u0000\u0000\u01a5\u01a6\u0005\u0000\u0000\u0001\u01a6\u000b\u0001"+ - "\u0000\u0000\u0000\u01a7\u01a8\u0003\u000e\u0007\u0000\u01a8\u01a9\u0003"+ - "\u0170\u00b8\u0000\u01a9\u01ab\u0001\u0000\u0000\u0000\u01aa\u01a7\u0001"+ - "\u0000\u0000\u0000\u01ab\u01ae\u0001\u0000\u0000\u0000\u01ac\u01aa\u0001"+ - "\u0000\u0000\u0000\u01ac\u01ad\u0001\u0000\u0000\u0000\u01ad\u01af\u0001"+ - "\u0000\u0000\u0000\u01ae\u01ac\u0001\u0000\u0000\u0000\u01af\u01b0\u0003"+ - "\u00dam\u0000\u01b0\u01b6\u0003\u0170\u00b8\u0000\u01b1\u01b2\u0003\u0014"+ - "\n\u0000\u01b2\u01b3\u0003\u0170\u00b8\u0000\u01b3\u01b5\u0001\u0000\u0000"+ - "\u0000\u01b4\u01b1\u0001\u0000\u0000\u0000\u01b5\u01b8\u0001\u0000\u0000"+ - "\u0000\u01b6\u01b4\u0001\u0000\u0000\u0000\u01b6\u01b7\u0001\u0000\u0000"+ - "\u0000\u01b7\r\u0001\u0000\u0000\u0000\u01b8\u01b6\u0001\u0000\u0000\u0000"+ - "\u01b9\u01ba\u0005E\u0000\u0000\u01ba\u01bb\u0003\u00a4R\u0000\u01bb\u000f"+ - "\u0001\u0000\u0000\u0000\u01bc\u01bd\u0005F\u0000\u0000\u01bd\u01be\u0003"+ - "\u00a4R\u0000\u01be\u0011\u0001\u0000\u0000\u0000\u01bf\u01c0\u0003\u0010"+ - "\b\u0000\u01c0\u01c1\u0003\u0170\u00b8\u0000\u01c1\u01c3\u0001\u0000\u0000"+ - "\u0000\u01c2\u01bf\u0001\u0000\u0000\u0000\u01c3\u01c6\u0001\u0000\u0000"+ - "\u0000\u01c4\u01c2\u0001\u0000\u0000\u0000\u01c4\u01c5\u0001\u0000\u0000"+ + "\u0096\u0097\u07bc\u0000\u0174\u0001\u0000\u0000\u0000\u0002\u0177\u0001"+ + "\u0000\u0000\u0000\u0004\u017a\u0001\u0000\u0000\u0000\u0006\u017d\u0001"+ + "\u0000\u0000\u0000\b\u0185\u0001\u0000\u0000\u0000\n\u018e\u0001\u0000"+ + "\u0000\u0000\f\u01ae\u0001\u0000\u0000\u0000\u000e\u01bb\u0001\u0000\u0000"+ + "\u0000\u0010\u01be\u0001\u0000\u0000\u0000\u0012\u01c6\u0001\u0000\u0000"+ + "\u0000\u0014\u01d3\u0001\u0000\u0000\u0000\u0016\u01e9\u0001\u0000\u0000"+ + "\u0000\u0018\u01f2\u0001\u0000\u0000\u0000\u001a\u01f4\u0001\u0000\u0000"+ + "\u0000\u001c\u01f6\u0001\u0000\u0000\u0000\u001e\u01f9\u0001\u0000\u0000"+ + "\u0000 \u020d\u0001\u0000\u0000\u0000\"\u020f\u0001\u0000\u0000\u0000"+ + "$\u0211\u0001\u0000\u0000\u0000&\u0216\u0001\u0000\u0000\u0000(\u0221"+ + "\u0001\u0000\u0000\u0000*\u022e\u0001\u0000\u0000\u0000,\u0231\u0001\u0000"+ + "\u0000\u0000.\u023c\u0001\u0000\u0000\u00000\u023e\u0001\u0000\u0000\u0000"+ + "2\u0243\u0001\u0000\u0000\u00004\u0248\u0001\u0000\u0000\u00006\u024d"+ + "\u0001\u0000\u0000\u00008\u0252\u0001\u0000\u0000\u0000:\u025f\u0001\u0000"+ + "\u0000\u0000<\u0261\u0001\u0000\u0000\u0000>\u0263\u0001\u0000\u0000\u0000"+ + "@\u0268\u0001\u0000\u0000\u0000B\u026d\u0001\u0000\u0000\u0000D\u0272"+ + "\u0001\u0000\u0000\u0000F\u027b\u0001\u0000\u0000\u0000H\u0282\u0001\u0000"+ + "\u0000\u0000J\u028f\u0001\u0000\u0000\u0000L\u0293\u0001\u0000\u0000\u0000"+ + "N\u029e\u0001\u0000\u0000\u0000P\u02a6\u0001\u0000\u0000\u0000R\u02a8"+ + "\u0001\u0000\u0000\u0000T\u02bd\u0001\u0000\u0000\u0000V\u02bf\u0001\u0000"+ + "\u0000\u0000X\u02cb\u0001\u0000\u0000\u0000Z\u02d8\u0001\u0000\u0000\u0000"+ + "\\\u02dc\u0001\u0000\u0000\u0000^\u02ec\u0001\u0000\u0000\u0000`\u02f8"+ + "\u0001\u0000\u0000\u0000b\u0307\u0001\u0000\u0000\u0000d\u030a\u0001\u0000"+ + "\u0000\u0000f\u0312\u0001\u0000\u0000\u0000h\u0314\u0001\u0000\u0000\u0000"+ + "j\u031f\u0001\u0000\u0000\u0000l\u0327\u0001\u0000\u0000\u0000n\u0336"+ + "\u0001\u0000\u0000\u0000p\u0338\u0001\u0000\u0000\u0000r\u0340\u0001\u0000"+ + "\u0000\u0000t\u034e\u0001\u0000\u0000\u0000v\u035a\u0001\u0000\u0000\u0000"+ + "x\u0364\u0001\u0000\u0000\u0000z\u0368\u0001\u0000\u0000\u0000|\u036e"+ + "\u0001\u0000\u0000\u0000~\u0386\u0001\u0000\u0000\u0000\u0080\u038e\u0001"+ + "\u0000\u0000\u0000\u0082\u039d\u0001\u0000\u0000\u0000\u0084\u039f\u0001"+ + "\u0000\u0000\u0000\u0086\u03a6\u0001\u0000\u0000\u0000\u0088\u03af\u0001"+ + "\u0000\u0000\u0000\u008a\u03b4\u0001\u0000\u0000\u0000\u008c\u03b9\u0001"+ + "\u0000\u0000\u0000\u008e\u03bf\u0001\u0000\u0000\u0000\u0090\u03c6\u0001"+ + "\u0000\u0000\u0000\u0092\u03cb\u0001\u0000\u0000\u0000\u0094\u03d1\u0001"+ + "\u0000\u0000\u0000\u0096\u03d6\u0001\u0000\u0000\u0000\u0098\u03dd\u0001"+ + "\u0000\u0000\u0000\u009a\u03e7\u0001\u0000\u0000\u0000\u009c\u03eb\u0001"+ + "\u0000\u0000\u0000\u009e\u03f7\u0001\u0000\u0000\u0000\u00a0\u03fa\u0001"+ + "\u0000\u0000\u0000\u00a2\u03fe\u0001\u0000\u0000\u0000\u00a4\u0405\u0001"+ + "\u0000\u0000\u0000\u00a6\u041e\u0001\u0000\u0000\u0000\u00a8\u045a\u0001"+ + "\u0000\u0000\u0000\u00aa\u045c\u0001\u0000\u0000\u0000\u00ac\u045f\u0001"+ + "\u0000\u0000\u0000\u00ae\u0464\u0001\u0000\u0000\u0000\u00b0\u046d\u0001"+ + "\u0000\u0000\u0000\u00b2\u047b\u0001\u0000\u0000\u0000\u00b4\u0485\u0001"+ + "\u0000\u0000\u0000\u00b6\u0493\u0001\u0000\u0000\u0000\u00b8\u04ae\u0001"+ + "\u0000\u0000\u0000\u00ba\u04b1\u0001\u0000\u0000\u0000\u00bc\u04b9\u0001"+ + "\u0000\u0000\u0000\u00be\u04c2\u0001\u0000\u0000\u0000\u00c0\u04d2\u0001"+ + "\u0000\u0000\u0000\u00c2\u04e5\u0001\u0000\u0000\u0000\u00c4\u04ee\u0001"+ + "\u0000\u0000\u0000\u00c6\u04f9\u0001\u0000\u0000\u0000\u00c8\u04fb\u0001"+ + "\u0000\u0000\u0000\u00ca\u04fe\u0001\u0000\u0000\u0000\u00cc\u0515\u0001"+ + "\u0000\u0000\u0000\u00ce\u0517\u0001\u0000\u0000\u0000\u00d0\u051c\u0001"+ + "\u0000\u0000\u0000\u00d2\u0530\u0001\u0000\u0000\u0000\u00d4\u0532\u0001"+ + "\u0000\u0000\u0000\u00d6\u0534\u0001\u0000\u0000\u0000\u00d8\u0537\u0001"+ + "\u0000\u0000\u0000\u00da\u0541\u0001\u0000\u0000\u0000\u00dc\u054b\u0001"+ + "\u0000\u0000\u0000\u00de\u054e\u0001\u0000\u0000\u0000\u00e0\u0553\u0001"+ + "\u0000\u0000\u0000\u00e2\u0555\u0001\u0000\u0000\u0000\u00e4\u0563\u0001"+ + "\u0000\u0000\u0000\u00e6\u056b\u0001\u0000\u0000\u0000\u00e8\u0573\u0001"+ + "\u0000\u0000\u0000\u00ea\u057b\u0001\u0000\u0000\u0000\u00ec\u0589\u0001"+ + "\u0000\u0000\u0000\u00ee\u058f\u0001\u0000\u0000\u0000\u00f0\u059d\u0001"+ + "\u0000\u0000\u0000\u00f2\u05af\u0001\u0000\u0000\u0000\u00f4\u05b8\u0001"+ + "\u0000\u0000\u0000\u00f6\u05ba\u0001\u0000\u0000\u0000\u00f8\u05bc\u0001"+ + "\u0000\u0000\u0000\u00fa\u05c0\u0001\u0000\u0000\u0000\u00fc\u05c3\u0001"+ + "\u0000\u0000\u0000\u00fe\u05c7\u0001\u0000\u0000\u0000\u0100\u05c9\u0001"+ + "\u0000\u0000\u0000\u0102\u05ce\u0001\u0000\u0000\u0000\u0104\u05d2\u0001"+ + "\u0000\u0000\u0000\u0106\u05d6\u0001\u0000\u0000\u0000\u0108\u05da\u0001"+ + "\u0000\u0000\u0000\u010a\u05dd\u0001\u0000\u0000\u0000\u010c\u05df\u0001"+ + "\u0000\u0000\u0000\u010e\u05f4\u0001\u0000\u0000\u0000\u0110\u05f6\u0001"+ + "\u0000\u0000\u0000\u0112\u060c\u0001\u0000\u0000\u0000\u0114\u0614\u0001"+ + "\u0000\u0000\u0000\u0116\u0616\u0001\u0000\u0000\u0000\u0118\u062c\u0001"+ + "\u0000\u0000\u0000\u011a\u0634\u0001\u0000\u0000\u0000\u011c\u063c\u0001"+ + "\u0000\u0000\u0000\u011e\u0640\u0001\u0000\u0000\u0000\u0120\u064c\u0001"+ + "\u0000\u0000\u0000\u0122\u0656\u0001\u0000\u0000\u0000\u0124\u0661\u0001"+ + "\u0000\u0000\u0000\u0126\u0669\u0001\u0000\u0000\u0000\u0128\u066d\u0001"+ + "\u0000\u0000\u0000\u012a\u067a\u0001\u0000\u0000\u0000\u012c\u0684\u0001"+ + "\u0000\u0000\u0000\u012e\u0689\u0001\u0000\u0000\u0000\u0130\u068b\u0001"+ + "\u0000\u0000\u0000\u0132\u0690\u0001\u0000\u0000\u0000\u0134\u0692\u0001"+ + "\u0000\u0000\u0000\u0136\u0694\u0001\u0000\u0000\u0000\u0138\u0697\u0001"+ + "\u0000\u0000\u0000\u013a\u069b\u0001\u0000\u0000\u0000\u013c\u06a6\u0001"+ + "\u0000\u0000\u0000\u013e\u06aa\u0001\u0000\u0000\u0000\u0140\u06b1\u0001"+ + "\u0000\u0000\u0000\u0142\u06b5\u0001\u0000\u0000\u0000\u0144\u06b7\u0001"+ + "\u0000\u0000\u0000\u0146\u06c7\u0001\u0000\u0000\u0000\u0148\u06d4\u0001"+ + "\u0000\u0000\u0000\u014a\u06dc\u0001\u0000\u0000\u0000\u014c\u06e1\u0001"+ + "\u0000\u0000\u0000\u014e\u06e3\u0001\u0000\u0000\u0000\u0150\u06e5\u0001"+ + "\u0000\u0000\u0000\u0152\u06e7\u0001\u0000\u0000\u0000\u0154\u06eb\u0001"+ + "\u0000\u0000\u0000\u0156\u06ee\u0001\u0000\u0000\u0000\u0158\u06f7\u0001"+ + "\u0000\u0000\u0000\u015a\u0702\u0001\u0000\u0000\u0000\u015c\u0708\u0001"+ + "\u0000\u0000\u0000\u015e\u070c\u0001\u0000\u0000\u0000\u0160\u070e\u0001"+ + "\u0000\u0000\u0000\u0162\u071e\u0001\u0000\u0000\u0000\u0164\u0723\u0001"+ + "\u0000\u0000\u0000\u0166\u0726\u0001\u0000\u0000\u0000\u0168\u072a\u0001"+ + "\u0000\u0000\u0000\u016a\u072e\u0001\u0000\u0000\u0000\u016c\u0733\u0001"+ + "\u0000\u0000\u0000\u016e\u0746\u0001\u0000\u0000\u0000\u0170\u074a\u0001"+ + "\u0000\u0000\u0000\u0172\u0750\u0001\u0000\u0000\u0000\u0174\u0175\u0003"+ + "\u00a6S\u0000\u0175\u0176\u0005\u0000\u0000\u0001\u0176\u0001\u0001\u0000"+ + "\u0000\u0000\u0177\u0178\u0003\u00a8T\u0000\u0178\u0179\u0005\u0000\u0000"+ + "\u0001\u0179\u0003\u0001\u0000\u0000\u0000\u017a\u017b\u0003\u00c4b\u0000"+ + "\u017b\u017c\u0005\u0000\u0000\u0001\u017c\u0005\u0001\u0000\u0000\u0000"+ + "\u017d\u0182\u0003\b\u0004\u0000\u017e\u017f\u0005m\u0000\u0000\u017f"+ + "\u0181\u0003\b\u0004\u0000\u0180\u017e\u0001\u0000\u0000\u0000\u0181\u0184"+ + "\u0001\u0000\u0000\u0000\u0182\u0180\u0001\u0000\u0000\u0000\u0182\u0183"+ + "\u0001\u0000\u0000\u0000\u0183\u0007\u0001\u0000\u0000\u0000\u0184\u0182"+ + "\u0001\u0000\u0000\u0000\u0185\u0187\u0005e\u0000\u0000\u0186\u0188\u0005"+ + "<\u0000\u0000\u0187\u0186\u0001\u0000\u0000\u0000\u0187\u0188\u0001\u0000"+ + "\u0000\u0000\u0188\t\u0001\u0000\u0000\u0000\u0189\u018a\u0003\u000e\u0007"+ + "\u0000\u018a\u018b\u0003\u0172\u00b9\u0000\u018b\u018d\u0001\u0000\u0000"+ + "\u0000\u018c\u0189\u0001\u0000\u0000\u0000\u018d\u0190\u0001\u0000\u0000"+ + "\u0000\u018e\u018c\u0001\u0000\u0000\u0000\u018e\u018f\u0001\u0000\u0000"+ + "\u0000\u018f\u0191\u0001\u0000\u0000\u0000\u0190\u018e\u0001\u0000\u0000"+ + "\u0000\u0191\u0192\u0003\u00dcn\u0000\u0192\u0198\u0003\u0172\u00b9\u0000"+ + "\u0193\u0194\u0003\u0014\n\u0000\u0194\u0195\u0003\u0172\u00b9\u0000\u0195"+ + "\u0197\u0001\u0000\u0000\u0000\u0196\u0193\u0001\u0000\u0000\u0000\u0197"+ + "\u019a\u0001\u0000\u0000\u0000\u0198\u0196\u0001\u0000\u0000\u0000\u0198"+ + "\u0199\u0001\u0000\u0000\u0000\u0199\u01a4\u0001\u0000\u0000\u0000\u019a"+ + "\u0198\u0001\u0000\u0000\u0000\u019b\u019f\u0003\u008aE\u0000\u019c\u019f"+ + "\u0003\u00e0p\u0000\u019d\u019f\u0003\u0016\u000b\u0000\u019e\u019b\u0001"+ + "\u0000\u0000\u0000\u019e\u019c\u0001\u0000\u0000\u0000\u019e\u019d\u0001"+ + "\u0000\u0000\u0000\u019f\u01a0\u0001\u0000\u0000\u0000\u01a0\u01a1\u0003"+ + "\u0172\u00b9\u0000\u01a1\u01a3\u0001\u0000\u0000\u0000\u01a2\u019e\u0001"+ + "\u0000\u0000\u0000\u01a3\u01a6\u0001\u0000\u0000\u0000\u01a4\u01a2\u0001"+ + "\u0000\u0000\u0000\u01a4\u01a5\u0001\u0000\u0000\u0000\u01a5\u01a7\u0001"+ + "\u0000\u0000\u0000\u01a6\u01a4\u0001\u0000\u0000\u0000\u01a7\u01a8\u0005"+ + "\u0000\u0000\u0001\u01a8\u000b\u0001\u0000\u0000\u0000\u01a9\u01aa\u0003"+ + "\u000e\u0007\u0000\u01aa\u01ab\u0003\u0172\u00b9\u0000\u01ab\u01ad\u0001"+ + "\u0000\u0000\u0000\u01ac\u01a9\u0001\u0000\u0000\u0000\u01ad\u01b0\u0001"+ + "\u0000\u0000\u0000\u01ae\u01ac\u0001\u0000\u0000\u0000\u01ae\u01af\u0001"+ + "\u0000\u0000\u0000\u01af\u01b1\u0001\u0000\u0000\u0000\u01b0\u01ae\u0001"+ + "\u0000\u0000\u0000\u01b1\u01b2\u0003\u00dcn\u0000\u01b2\u01b8\u0003\u0172"+ + "\u00b9\u0000\u01b3\u01b4\u0003\u0014\n\u0000\u01b4\u01b5\u0003\u0172\u00b9"+ + "\u0000\u01b5\u01b7\u0001\u0000\u0000\u0000\u01b6\u01b3\u0001\u0000\u0000"+ + "\u0000\u01b7\u01ba\u0001\u0000\u0000\u0000\u01b8\u01b6\u0001\u0000\u0000"+ + "\u0000\u01b8\u01b9\u0001\u0000\u0000\u0000\u01b9\r\u0001\u0000\u0000\u0000"+ + "\u01ba\u01b8\u0001\u0000\u0000\u0000\u01bb\u01bc\u0005E\u0000\u0000\u01bc"+ + "\u01bd\u0003\u00a6S\u0000\u01bd\u000f\u0001\u0000\u0000\u0000\u01be\u01bf"+ + "\u0005F\u0000\u0000\u01bf\u01c0\u0003\u00a6S\u0000\u01c0\u0011\u0001\u0000"+ + "\u0000\u0000\u01c1\u01c2\u0003\u0010\b\u0000\u01c2\u01c3\u0003\u0172\u00b9"+ + "\u0000\u01c3\u01c5\u0001\u0000\u0000\u0000\u01c4\u01c1\u0001\u0000\u0000"+ "\u0000\u01c5\u01c8\u0001\u0000\u0000\u0000\u01c6\u01c4\u0001\u0000\u0000"+ - "\u0000\u01c7\u01c9\u0007\u0000\u0000\u0000\u01c8\u01c7\u0001\u0000\u0000"+ - "\u0000\u01c8\u01c9\u0001\u0000\u0000\u0000\u01c9\u01ca\u0001\u0000\u0000"+ - "\u0000\u01ca\u01cb\u0003\u00dcn\u0000\u01cb\u0013\u0001\u0000\u0000\u0000"+ - "\u01cc\u01cd\u0003\u0010\b\u0000\u01cd\u01ce\u0003\u0170\u00b8\u0000\u01ce"+ - "\u01d0\u0001\u0000\u0000\u0000\u01cf\u01cc\u0001\u0000\u0000\u0000\u01d0"+ - "\u01d3\u0001\u0000\u0000\u0000\u01d1\u01cf\u0001\u0000\u0000\u0000\u01d1"+ - "\u01d2\u0001\u0000\u0000\u0000\u01d2\u01e1\u0001\u0000\u0000\u0000\u01d3"+ - "\u01d1\u0001\u0000\u0000\u0000\u01d4\u01d5\u0005a\u0000\u0000\u01d5\u01e2"+ - "\u0003\u0012\t\u0000\u01d6\u01d7\u0005a\u0000\u0000\u01d7\u01dd\u0005"+ - "f\u0000\u0000\u01d8\u01d9\u0003\u0012\t\u0000\u01d9\u01da\u0003\u0170"+ - "\u00b8\u0000\u01da\u01dc\u0001\u0000\u0000\u0000\u01db\u01d8\u0001\u0000"+ - "\u0000\u0000\u01dc\u01df\u0001\u0000\u0000\u0000\u01dd\u01db\u0001\u0000"+ - "\u0000\u0000\u01dd\u01de\u0001\u0000\u0000\u0000\u01de\u01e0\u0001\u0000"+ - "\u0000\u0000\u01df\u01dd\u0001\u0000\u0000\u0000\u01e0\u01e2\u0005g\u0000"+ - "\u0000\u01e1\u01d4\u0001\u0000\u0000\u0000\u01e1\u01d6\u0001\u0000\u0000"+ - "\u0000\u01e2\u0015\u0001\u0000\u0000\u0000\u01e3\u01e8\u0003z=\u0000\u01e4"+ - "\u01e8\u0003\u0090H\u0000\u01e5\u01e8\u0003\u0094J\u0000\u01e6\u01e8\u0003"+ - "\u008eG\u0000\u01e7\u01e3\u0001\u0000\u0000\u0000\u01e7\u01e4\u0001\u0000"+ - "\u0000\u0000\u01e7\u01e5\u0001\u0000\u0000\u0000\u01e7\u01e6\u0001\u0000"+ - "\u0000\u0000\u01e8\u0017\u0001\u0000\u0000\u0000\u01e9\u01ea\u0005\u001b"+ - "\u0000\u0000\u01ea\u01f1\u0003\u00a6S\u0000\u01eb\u01ec\u0007\u0001\u0000"+ - "\u0000\u01ec\u01f1\u0003.\u0017\u0000\u01ed\u01ee\u0007\u0002\u0000\u0000"+ - "\u01ee\u01f1\u0003\u00a4R\u0000\u01ef\u01f1\u0003f3\u0000\u01f0\u01e9"+ - "\u0001\u0000\u0000\u0000\u01f0\u01eb\u0001\u0000\u0000\u0000\u01f0\u01ed"+ - "\u0001\u0000\u0000\u0000\u01f0\u01ef\u0001\u0000\u0000\u0000\u01f1\u0019"+ - "\u0001\u0000\u0000\u0000\u01f2\u01f3\u0003\u001c\u000e\u0000\u01f3\u001b"+ - "\u0001\u0000\u0000\u0000\u01f4\u01f5\u0003^/\u0000\u01f5\u01f6\u0003\u001e"+ - "\u000f\u0000\u01f6\u001d\u0001\u0000\u0000\u0000\u01f7\u01f8\u0005D\u0000"+ - "\u0000\u01f8\u01fa\u0005f\u0000\u0000\u01f9\u01fb\u0003\u00f0x\u0000\u01fa"+ - "\u01f9\u0001\u0000\u0000\u0000\u01fa\u01fb\u0001\u0000\u0000\u0000\u01fb"+ - "\u01fc\u0001\u0000\u0000\u0000\u01fc\u01fd\u0005g\u0000\u0000\u01fd\u001f"+ - "\u0001\u0000\u0000\u0000\u01fe\u020c\u0003F#\u0000\u01ff\u020c\u0003D"+ - "\"\u0000\u0200\u020c\u0003B!\u0000\u0201\u020c\u0003$\u0012\u0000\u0202"+ - "\u020c\u0003@ \u0000\u0203\u020c\u00038\u001c\u0000\u0204\u020c\u0003"+ - ">\u001f\u0000\u0205\u020c\u00036\u001b\u0000\u0206\u020c\u00032\u0019"+ - "\u0000\u0207\u020c\u00030\u0018\u0000\u0208\u020c\u00034\u001a\u0000\u0209"+ - "\u020c\u0003\"\u0011\u0000\u020a\u020c\u0003H$\u0000\u020b\u01fe\u0001"+ - "\u0000\u0000\u0000\u020b\u01ff\u0001\u0000\u0000\u0000\u020b\u0200\u0001"+ - "\u0000\u0000\u0000\u020b\u0201\u0001\u0000\u0000\u0000\u020b\u0202\u0001"+ - "\u0000\u0000\u0000\u020b\u0203\u0001\u0000\u0000\u0000\u020b\u0204\u0001"+ - "\u0000\u0000\u0000\u020b\u0205\u0001\u0000\u0000\u0000\u020b\u0206\u0001"+ - "\u0000\u0000\u0000\u020b\u0207\u0001\u0000\u0000\u0000\u020b\u0208\u0001"+ - "\u0000\u0000\u0000\u020b\u0209\u0001\u0000\u0000\u0000\u020b\u020a\u0001"+ - "\u0000\u0000\u0000\u020c!\u0001\u0000\u0000\u0000\u020d\u020e\u0007\u0003"+ - "\u0000\u0000\u020e#\u0001\u0000\u0000\u0000\u020f\u0210\u0005^\u0000\u0000"+ - "\u0210\u0211\u0005j\u0000\u0000\u0211\u0212\u0003\u00c2a\u0000\u0212\u0213"+ - "\u0005k\u0000\u0000\u0213%\u0001\u0000\u0000\u0000\u0214\u0219\u0003("+ - "\u0014\u0000\u0215\u0216\u0005m\u0000\u0000\u0216\u0218\u0003(\u0014\u0000"+ - "\u0217\u0215\u0001\u0000\u0000\u0000\u0218\u021b\u0001\u0000\u0000\u0000"+ - "\u0219\u0217\u0001\u0000\u0000\u0000\u0219\u021a\u0001\u0000\u0000\u0000"+ - "\u021a\u021d\u0001\u0000\u0000\u0000\u021b\u0219\u0001\u0000\u0000\u0000"+ - "\u021c\u021e\u0005m\u0000\u0000\u021d\u021c\u0001\u0000\u0000\u0000\u021d"+ - "\u021e\u0001\u0000\u0000\u0000\u021e\'\u0001\u0000\u0000\u0000\u021f\u0224"+ - "\u0005e\u0000\u0000\u0220\u0221\u0005m\u0000\u0000\u0221\u0223\u0005e"+ - "\u0000\u0000\u0222\u0220\u0001\u0000\u0000\u0000\u0223\u0226\u0001\u0000"+ - "\u0000\u0000\u0224\u0222\u0001\u0000\u0000\u0000\u0224\u0225\u0001\u0000"+ - "\u0000\u0000\u0225\u0227\u0001\u0000\u0000\u0000\u0226\u0224\u0001\u0000"+ - "\u0000\u0000\u0227\u0228\u0003\u0132\u0099\u0000\u0228)\u0001\u0000\u0000"+ - "\u0000\u0229\u022b\u0003,\u0016\u0000\u022a\u0229\u0001\u0000\u0000\u0000"+ - "\u022b\u022e\u0001\u0000\u0000\u0000\u022c\u022a\u0001\u0000\u0000\u0000"+ - "\u022c\u022d\u0001\u0000\u0000\u0000\u022d+\u0001\u0000\u0000\u0000\u022e"+ - "\u022c\u0001\u0000\u0000\u0000\u022f\u0230\u0005h\u0000\u0000\u0230\u0235"+ - "\u0003\u00a4R\u0000\u0231\u0232\u0005m\u0000\u0000\u0232\u0234\u0003\u00a4"+ - "R\u0000\u0233\u0231\u0001\u0000\u0000\u0000\u0234\u0237\u0001\u0000\u0000"+ - "\u0000\u0235\u0233\u0001\u0000\u0000\u0000\u0235\u0236\u0001\u0000\u0000"+ - "\u0000\u0236\u0238\u0001\u0000\u0000\u0000\u0237\u0235\u0001\u0000\u0000"+ - "\u0000\u0238\u0239\u0005i\u0000\u0000\u0239-\u0001\u0000\u0000\u0000\u023a"+ - "\u023b\u0003\u00b4Z\u0000\u023b/\u0001\u0000\u0000\u0000\u023c\u023d\u0005"+ - "1\u0000\u0000\u023d\u023e\u0005f\u0000\u0000\u023e\u023f\u0003\u00a4R"+ - "\u0000\u023f\u0240\u0005g\u0000\u0000\u02401\u0001\u0000\u0000\u0000\u0241"+ - "\u0242\u00057\u0000\u0000\u0242\u0243\u0005j\u0000\u0000\u0243\u0244\u0003"+ - "\u00c2a\u0000\u0244\u0245\u0005k\u0000\u0000\u02453\u0001\u0000\u0000"+ - "\u0000\u0246\u0247\u00052\u0000\u0000\u0247\u0248\u0005f\u0000\u0000\u0248"+ - "\u0249\u0003\u00a4R\u0000\u0249\u024a\u0005g\u0000\u0000\u024a5\u0001"+ - "\u0000\u0000\u0000\u024b\u024c\u0007\u0004\u0000\u0000\u024c\u024d\u0005"+ - "f\u0000\u0000\u024d\u024e\u0003\u00a4R\u0000\u024e\u024f\u0005g\u0000"+ - "\u0000\u024f7\u0001\u0000\u0000\u0000\u0250\u0255\u0005\u0011\u0000\u0000"+ - "\u0251\u0252\u0005j\u0000\u0000\u0252\u0253\u0003:\u001d\u0000\u0253\u0254"+ - "\u0005k\u0000\u0000\u0254\u0256\u0001\u0000\u0000\u0000\u0255\u0251\u0001"+ - "\u0000\u0000\u0000\u0255\u0256\u0001\u0000\u0000\u0000\u0256\u0257\u0001"+ - "\u0000\u0000\u0000\u0257\u0258\u0005f\u0000\u0000\u0258\u0259\u0003\u00a4"+ - "R\u0000\u0259\u025a\u0005g\u0000\u0000\u025a9\u0001\u0000\u0000\u0000"+ - "\u025b\u025e\u0003<\u001e\u0000\u025c\u025e\u0005\u0013\u0000\u0000\u025d"+ - "\u025b\u0001\u0000\u0000\u0000\u025d\u025c\u0001\u0000\u0000\u0000\u025e"+ - ";\u0001\u0000\u0000\u0000\u025f\u0260\u0005e\u0000\u0000\u0260=\u0001"+ - "\u0000\u0000\u0000\u0261\u0262\u0005\u0012\u0000\u0000\u0262\u0263\u0005"+ - "f\u0000\u0000\u0263\u0264\u0003\u00a4R\u0000\u0264\u0265\u0005g\u0000"+ - "\u0000\u0265?\u0001\u0000\u0000\u0000\u0266\u0267\u0005:\u0000\u0000\u0267"+ - "\u0268\u0005f\u0000\u0000\u0268\u0269\u0003\u00a4R\u0000\u0269\u026a\u0005"+ - "g\u0000\u0000\u026aA\u0001\u0000\u0000\u0000\u026b\u026c\u00059\u0000"+ - "\u0000\u026c\u026d\u0005f\u0000\u0000\u026d\u026e\u0003\u00a4R\u0000\u026e"+ - "\u026f\u0005g\u0000\u0000\u026fC\u0001\u0000\u0000\u0000\u0270\u0271\u0005"+ - "\u0016\u0000\u0000\u0271\u0272\u0005f\u0000\u0000\u0272\u0275\u0003\u00a4"+ - "R\u0000\u0273\u0274\u0005m\u0000\u0000\u0274\u0276\u0003\u00a4R\u0000"+ - "\u0275\u0273\u0001\u0000\u0000\u0000\u0275\u0276\u0001\u0000\u0000\u0000"+ - "\u0276\u0277\u0001\u0000\u0000\u0000\u0277\u0278\u0005g\u0000\u0000\u0278"+ - "E\u0001\u0000\u0000\u0000\u0279\u027a\u0007\u0004\u0000\u0000\u027a\u027b"+ - "\u0005j\u0000\u0000\u027b\u027c\u0003\u00a4R\u0000\u027c\u027d\u0005="+ - "\u0000\u0000\u027d\u027e\u0003\u00a4R\u0000\u027e\u027f\u0005k\u0000\u0000"+ - "\u027fG\u0001\u0000\u0000\u0000\u0280\u0281\u00056\u0000\u0000\u0281\u0282"+ - "\u0003\u00a4R\u0000\u0282\u0288\u0005h\u0000\u0000\u0283\u0284\u0003J"+ - "%\u0000\u0284\u0285\u0003\u0170\u00b8\u0000\u0285\u0287\u0001\u0000\u0000"+ - "\u0000\u0286\u0283\u0001\u0000\u0000\u0000\u0287\u028a\u0001\u0000\u0000"+ - "\u0000\u0288\u0286\u0001\u0000\u0000\u0000\u0288\u0289\u0001\u0000\u0000"+ - "\u0000\u0289\u028b\u0001\u0000\u0000\u0000\u028a\u0288\u0001\u0000\u0000"+ - "\u0000\u028b\u028c\u0005i\u0000\u0000\u028cI\u0001\u0000\u0000\u0000\u028d"+ - "\u028e\u0003j5\u0000\u028e\u028f\u0005o\u0000\u0000\u028f\u0290\u0003"+ - "\u00a4R\u0000\u0290K\u0001\u0000\u0000\u0000\u0291\u0292\u0005j\u0000"+ - "\u0000\u0292\u0297\u0003N\'\u0000\u0293\u0294\u0005m\u0000\u0000\u0294"+ - "\u0296\u0003N\'\u0000\u0295\u0293\u0001\u0000\u0000\u0000\u0296\u0299"+ - "\u0001\u0000\u0000\u0000\u0297\u0295\u0001\u0000\u0000\u0000\u0297\u0298"+ - "\u0001\u0000\u0000\u0000\u0298\u029a\u0001\u0000\u0000\u0000\u0299\u0297"+ - "\u0001\u0000\u0000\u0000\u029a\u029b\u0005k\u0000\u0000\u029bM\u0001\u0000"+ - "\u0000\u0000\u029c\u029d\u0003\u00a4R\u0000\u029d\u029e\u0005l\u0000\u0000"+ - "\u029e\u029f\u0003\u00a4R\u0000\u029fO\u0001\u0000\u0000\u0000\u02a0\u02a5"+ - "\u0003\\.\u0000\u02a1\u02a5\u0003Z-\u0000\u02a2\u02a5\u0003R)\u0000\u02a3"+ - "\u02a5\u0003V+\u0000\u02a4\u02a0\u0001\u0000\u0000\u0000\u02a4\u02a1\u0001"+ - "\u0000\u0000\u0000\u02a4\u02a2\u0001\u0000\u0000\u0000\u02a4\u02a3\u0001"+ - "\u0000\u0000\u0000\u02a5Q\u0001\u0000\u0000\u0000\u02a6\u02a7\u00053\u0000"+ - "\u0000\u02a7\u02ad\u0005h\u0000\u0000\u02a8\u02a9\u0003T*\u0000\u02a9"+ - "\u02aa\u0003\u0170\u00b8\u0000\u02aa\u02ac\u0001\u0000\u0000\u0000\u02ab"+ - "\u02a8\u0001\u0000\u0000\u0000\u02ac\u02af\u0001\u0000\u0000\u0000\u02ad"+ - "\u02ab\u0001\u0000\u0000\u0000\u02ad\u02ae\u0001\u0000\u0000\u0000\u02ae"+ - "\u02b0\u0001\u0000\u0000\u0000\u02af\u02ad\u0001\u0000\u0000\u0000\u02b0"+ - "\u02b1\u0005i\u0000\u0000\u02b1S\u0001\u0000\u0000\u0000\u02b2\u02b3\u0005"+ - "M\u0000\u0000\u02b3\u02b4\u0005e\u0000\u0000\u02b4\u02bc\u0003\u013e\u009f"+ - "\u0000\u02b5\u02b6\u00054\u0000\u0000\u02b6\u02b7\u0005h\u0000\u0000\u02b7"+ - "\u02b8\u0003\u00a4R\u0000\u02b8\u02b9\u0003\u0170\u00b8\u0000\u02b9\u02ba"+ - "\u0005i\u0000\u0000\u02ba\u02bc\u0001\u0000\u0000\u0000\u02bb\u02b2\u0001"+ - "\u0000\u0000\u0000\u02bb\u02b5\u0001\u0000\u0000\u0000\u02bcU\u0001\u0000"+ - "\u0000\u0000\u02bd\u02be\u00055\u0000\u0000\u02be\u02c4\u0005h\u0000\u0000"+ - "\u02bf\u02c0\u0003X,\u0000\u02c0\u02c1\u0003\u0170\u00b8\u0000\u02c1\u02c3"+ - "\u0001\u0000\u0000\u0000\u02c2\u02bf\u0001\u0000\u0000\u0000\u02c3\u02c6"+ - "\u0001\u0000\u0000\u0000\u02c4\u02c2\u0001\u0000\u0000\u0000\u02c4\u02c5"+ - "\u0001\u0000\u0000\u0000\u02c5\u02c7\u0001\u0000\u0000\u0000\u02c6\u02c4"+ - "\u0001\u0000\u0000\u0000\u02c7\u02c8\u0005i\u0000\u0000\u02c8W\u0001\u0000"+ - "\u0000\u0000\u02c9\u02ca\u0005e\u0000\u0000\u02ca\u02d0\u0005h\u0000\u0000"+ - "\u02cb\u02cc\u0003\u0160\u00b0\u0000\u02cc\u02cd\u0003\u0170\u00b8\u0000"+ - "\u02cd\u02cf\u0001\u0000\u0000\u0000\u02ce\u02cb\u0001\u0000\u0000\u0000"+ - "\u02cf\u02d2\u0001\u0000\u0000\u0000\u02d0\u02ce\u0001\u0000\u0000\u0000"+ - "\u02d0\u02d1\u0001\u0000\u0000\u0000\u02d1\u02d3\u0001\u0000\u0000\u0000"+ - "\u02d2\u02d0\u0001\u0000\u0000\u0000\u02d3\u02d4\u0005i\u0000\u0000\u02d4"+ - "Y\u0001\u0000\u0000\u0000\u02d5\u02d6\u0005\u001b\u0000\u0000\u02d6\u02d7"+ - "\u0005j\u0000\u0000\u02d7\u02d8\u0005k\u0000\u0000\u02d8\u02d9\u0003\u0132"+ - "\u0099\u0000\u02d9[\u0001\u0000\u0000\u0000\u02da\u02db\u0007\u0005\u0000"+ - "\u0000\u02db\u02dc\u0005j\u0000\u0000\u02dc\u02dd\u0003\u00c2a\u0000\u02dd"+ - "\u02de\u0005k\u0000\u0000\u02de\u02e6\u0001\u0000\u0000\u0000\u02df\u02e0"+ - "\u0005+\u0000\u0000\u02e0\u02e1\u0005j\u0000\u0000\u02e1\u02e2\u0003\u00c2"+ - "a\u0000\u02e2\u02e3\u0005k\u0000\u0000\u02e3\u02e4\u0003\u00c2a\u0000"+ - "\u02e4\u02e6\u0001\u0000\u0000\u0000\u02e5\u02da\u0001\u0000\u0000\u0000"+ - "\u02e5\u02df\u0001\u0000\u0000\u0000\u02e6]\u0001\u0000\u0000\u0000\u02e7"+ - "\u02ed\u0003`0\u0000\u02e8\u02e9\u0005\u000e\u0000\u0000\u02e9\u02ed\u0006"+ - "/\uffff\uffff\u0000\u02ea\u02eb\u0005C\u0000\u0000\u02eb\u02ed\u0006/"+ - "\uffff\uffff\u0000\u02ec\u02e7\u0001\u0000\u0000\u0000\u02ec\u02e8\u0001"+ - "\u0000\u0000\u0000\u02ec\u02ea\u0001\u0000\u0000\u0000\u02ed\u02ee\u0001"+ - "\u0000\u0000\u0000\u02ee\u02f0\u0003\u0170\u00b8\u0000\u02ef\u02ec\u0001"+ - "\u0000\u0000\u0000\u02f0\u02f3\u0001\u0000\u0000\u0000\u02f1\u02f2\u0001"+ - "\u0000\u0000\u0000\u02f1\u02ef\u0001\u0000\u0000\u0000\u02f2\u02f6\u0001"+ - "\u0000\u0000\u0000\u02f3\u02f1\u0001\u0000\u0000\u0000\u02f4\u02f5\u0005"+ - "\u000e\u0000\u0000\u02f5\u02f7\u0006/\uffff\uffff\u0000\u02f6\u02f4\u0001"+ - "\u0000\u0000\u0000\u02f6\u02f7\u0001\u0000\u0000\u0000\u02f7_\u0001\u0000"+ - "\u0000\u0000\u02f8\u02f9\u0005\t\u0000\u0000\u02f9\u0301\u0003d2\u0000"+ - "\u02fa\u02fb\u0005\n\u0000\u0000\u02fb\u0301\u0003d2\u0000\u02fc\u02fd"+ - "\u0005\u000b\u0000\u0000\u02fd\u0301\u0003d2\u0000\u02fe\u02ff\u0005\r"+ - "\u0000\u0000\u02ff\u0301\u0003b1\u0000\u0300\u02f8\u0001\u0000\u0000\u0000"+ - "\u0300\u02fa\u0001\u0000\u0000\u0000\u0300\u02fc\u0001\u0000\u0000\u0000"+ - "\u0300\u02fe\u0001\u0000\u0000\u0000\u0301a\u0001\u0000\u0000\u0000\u0302"+ - "\u0304\u0003\u00e6s\u0000\u0303\u0302\u0001\u0000\u0000\u0000\u0303\u0304"+ - "\u0001\u0000\u0000\u0000\u0304\u0307\u0001\u0000\u0000\u0000\u0305\u0306"+ - "\u0005\\\u0000\u0000\u0306\u0308\u0003\u00a4R\u0000\u0307\u0305\u0001"+ - "\u0000\u0000\u0000\u0307\u0308\u0001\u0000\u0000\u0000\u0308c\u0001\u0000"+ - "\u0000\u0000\u0309\u030c\u0001\u0000\u0000\u0000\u030a\u030c\u0003\u00a4"+ - "R\u0000\u030b\u0309\u0001\u0000\u0000\u0000\u030b\u030a\u0001\u0000\u0000"+ - "\u0000\u030ce\u0001\u0000\u0000\u0000\u030d\u030e\u00056\u0000\u0000\u030e"+ - "\u030f\u0003\u00a4R\u0000\u030f\u0313\u0005h\u0000\u0000\u0310\u0312\u0003"+ - "h4\u0000\u0311\u0310\u0001\u0000\u0000\u0000\u0312\u0315\u0001\u0000\u0000"+ - "\u0000\u0313\u0311\u0001\u0000\u0000\u0000\u0313\u0314\u0001\u0000\u0000"+ - "\u0000\u0314\u0316\u0001\u0000\u0000\u0000\u0315\u0313\u0001\u0000\u0000"+ - "\u0000\u0316\u0317\u0005i\u0000\u0000\u0317g\u0001\u0000\u0000\u0000\u0318"+ - "\u0319\u0003j5\u0000\u0319\u031b\u0005o\u0000\u0000\u031a\u031c\u0003"+ - "\u00f0x\u0000\u031b\u031a\u0001\u0000\u0000\u0000\u031b\u031c\u0001\u0000"+ - "\u0000\u0000\u031ci\u0001\u0000\u0000\u0000\u031d\u031e\u0005P\u0000\u0000"+ - "\u031e\u0321\u0003l6\u0000\u031f\u0321\u0005L\u0000\u0000\u0320\u031d"+ - "\u0001\u0000\u0000\u0000\u0320\u031f\u0001\u0000\u0000\u0000\u0321k\u0001"+ - "\u0000\u0000\u0000\u0322\u0323\u0005%\u0000\u0000\u0323\u0330\u0005e\u0000"+ - "\u0000\u0324\u0325\u0003\u00cae\u0000\u0325\u032a\u0005h\u0000\u0000\u0326"+ - "\u0328\u0003n7\u0000\u0327\u0329\u0005m\u0000\u0000\u0328\u0327\u0001"+ - "\u0000\u0000\u0000\u0328\u0329\u0001\u0000\u0000\u0000\u0329\u032b\u0001"+ - "\u0000\u0000\u0000\u032a\u0326\u0001\u0000\u0000\u0000\u032a\u032b\u0001"+ - "\u0000\u0000\u0000\u032b\u032c\u0001\u0000\u0000\u0000\u032c\u032d\u0005"+ - "i\u0000\u0000\u032d\u0330\u0001\u0000\u0000\u0000\u032e\u0330\u0003\u00a4"+ - "R\u0000\u032f\u0322\u0001\u0000\u0000\u0000\u032f\u0324\u0001\u0000\u0000"+ - "\u0000\u032f\u032e\u0001\u0000\u0000\u0000\u0330m\u0001\u0000\u0000\u0000"+ - "\u0331\u0336\u0003l6\u0000\u0332\u0333\u0005m\u0000\u0000\u0333\u0335"+ - "\u0003l6\u0000\u0334\u0332\u0001\u0000\u0000\u0000\u0335\u0338\u0001\u0000"+ - "\u0000\u0000\u0336\u0334\u0001\u0000\u0000\u0000\u0336\u0337\u0001\u0000"+ - "\u0000\u0000\u0337o\u0001\u0000\u0000\u0000\u0338\u0336\u0001\u0000\u0000"+ - "\u0000\u0339\u033e\u0005h\u0000\u0000\u033a\u033b\u0005;\u0000\u0000\u033b"+ - "\u033c\u0003\u00e4r\u0000\u033c\u033d\u0003\u0170\u00b8\u0000\u033d\u033f"+ - "\u0001\u0000\u0000\u0000\u033e\u033a\u0001\u0000\u0000\u0000\u033e\u033f"+ - "\u0001\u0000\u0000\u0000\u033f\u0341\u0001\u0000\u0000\u0000\u0340\u0342"+ - "\u0003\u00f0x\u0000\u0341\u0340\u0001\u0000\u0000\u0000\u0341\u0342\u0001"+ - "\u0000\u0000\u0000\u0342\u0343\u0001\u0000\u0000\u0000\u0343\u0344\u0005"+ - "i\u0000\u0000\u0344q\u0001\u0000\u0000\u0000\u0345\u0348\u0003\u0150\u00a8"+ - "\u0000\u0346\u0348\u0005e\u0000\u0000\u0347\u0345\u0001\u0000\u0000\u0000"+ - "\u0347\u0346\u0001\u0000\u0000\u0000\u0348\u0351\u0001\u0000\u0000\u0000"+ - "\u0349\u034e\u0005h\u0000\u0000\u034a\u034c\u0003t:\u0000\u034b\u034d"+ - "\u0005m\u0000\u0000\u034c\u034b\u0001\u0000\u0000\u0000\u034c\u034d\u0001"+ - "\u0000\u0000\u0000\u034d\u034f\u0001\u0000\u0000\u0000\u034e\u034a\u0001"+ - "\u0000\u0000\u0000\u034e\u034f\u0001\u0000\u0000\u0000\u034f\u0350\u0001"+ - "\u0000\u0000\u0000\u0350\u0352\u0005i\u0000\u0000\u0351\u0349\u0001\u0000"+ - "\u0000\u0000\u0351\u0352\u0001\u0000\u0000\u0000\u0352s\u0001\u0000\u0000"+ - "\u0000\u0353\u0358\u0003v;\u0000\u0354\u0355\u0005m\u0000\u0000\u0355"+ - "\u0357\u0003v;\u0000\u0356\u0354\u0001\u0000\u0000\u0000\u0357\u035a\u0001"+ - "\u0000\u0000\u0000\u0358\u0356\u0001\u0000\u0000\u0000\u0358\u0359\u0001"+ - "\u0000\u0000\u0000\u0359u\u0001\u0000\u0000\u0000\u035a\u0358\u0001\u0000"+ - "\u0000\u0000\u035b\u035c\u0005e\u0000\u0000\u035c\u035e\u0005o\u0000\u0000"+ - "\u035d\u035b\u0001\u0000\u0000\u0000\u035d\u035e\u0001\u0000\u0000\u0000"+ - "\u035e\u035f\u0001\u0000\u0000\u0000\u035f\u0360\u0003\u00a4R\u0000\u0360"+ - "w\u0001\u0000\u0000\u0000\u0361\u0362\u0005G\u0000\u0000\u0362\u0363\u0003"+ - "\u00a4R\u0000\u0363\u0364\u0005\u000f\u0000\u0000\u0364\u0365\u0003r9"+ - "\u0000\u0365\u0366\u0003\u00eew\u0000\u0366y\u0001\u0000\u0000\u0000\u0367"+ - "\u0368\u0003\u00c2a\u0000\u0368\u0369\u0005\u000f\u0000\u0000\u0369\u037c"+ - "\u0003\u00c2a\u0000\u036a\u0370\u0005h\u0000\u0000\u036b\u036c\u0003\u0082"+ - "A\u0000\u036c\u036d\u0003\u0170\u00b8\u0000\u036d\u036f\u0001\u0000\u0000"+ - "\u0000\u036e\u036b\u0001\u0000\u0000\u0000\u036f\u0372\u0001\u0000\u0000"+ - "\u0000\u0370\u036e\u0001\u0000\u0000\u0000\u0370\u0371\u0001\u0000\u0000"+ - "\u0000\u0371\u0378\u0001\u0000\u0000\u0000\u0372\u0370\u0001\u0000\u0000"+ - "\u0000\u0373\u0374\u0003|>\u0000\u0374\u0375\u0003\u0170\u00b8\u0000\u0375"+ - "\u0377\u0001\u0000\u0000\u0000\u0376\u0373\u0001\u0000\u0000\u0000\u0377"+ - "\u037a\u0001\u0000\u0000\u0000\u0378\u0376\u0001\u0000\u0000\u0000\u0378"+ - "\u0379\u0001\u0000\u0000\u0000\u0379\u037b\u0001\u0000\u0000\u0000\u037a"+ - "\u0378\u0001\u0000\u0000\u0000\u037b\u037d\u0005i\u0000\u0000\u037c\u036a"+ - "\u0001\u0000\u0000\u0000\u037c\u037d\u0001\u0000\u0000\u0000\u037d{\u0001"+ - "\u0000\u0000\u0000\u037e\u0380\u0005\u000e\u0000\u0000\u037f\u037e\u0001"+ - "\u0000\u0000\u0000\u037f\u0380\u0001\u0000\u0000\u0000\u0380\u0381\u0001"+ - "\u0000\u0000\u0000\u0381\u0382\u0003~?\u0000\u0382\u0383\u0005e\u0000"+ - "\u0000\u0383\u0385\u0003\u013e\u009f\u0000\u0384\u0386\u0003\u00eew\u0000"+ - "\u0385\u0384\u0001\u0000\u0000\u0000\u0385\u0386\u0001\u0000\u0000\u0000"+ - "\u0386}\u0001\u0000\u0000\u0000\u0387\u0389\u0005f\u0000\u0000\u0388\u038a"+ - "\u0005e\u0000\u0000\u0389\u0388\u0001\u0000\u0000\u0000\u0389\u038a\u0001"+ - "\u0000\u0000\u0000\u038a\u038c\u0001\u0000\u0000\u0000\u038b\u038d\u0005"+ - "\u0087\u0000\u0000\u038c\u038b\u0001\u0000\u0000\u0000\u038c\u038d\u0001"+ - "\u0000\u0000\u0000\u038d\u038e\u0001\u0000\u0000\u0000\u038e\u038f\u0003"+ - "\u012c\u0096\u0000\u038f\u0390\u0005g\u0000\u0000\u0390\u007f\u0001\u0000"+ - "\u0000\u0000\u0391\u0397\u0003\u00b4Z\u0000\u0392\u0393\u0003\u00c2a\u0000"+ - "\u0393\u0394\u0005p\u0000\u0000\u0394\u0395\u0005e\u0000\u0000\u0395\u0397"+ - "\u0001\u0000\u0000\u0000\u0396\u0391\u0001\u0000\u0000\u0000\u0396\u0392"+ - "\u0001\u0000\u0000\u0000\u0397\u0081\u0001\u0000\u0000\u0000\u0398\u0399"+ - "\u00058\u0000\u0000\u0399\u039a\u0005e\u0000\u0000\u039a\u039d\u0005s"+ - "\u0000\u0000\u039b\u039e\u0003\u0080@\u0000\u039c\u039e\u0003\u014e\u00a7"+ - "\u0000\u039d\u039b\u0001\u0000\u0000\u0000\u039d\u039c\u0001\u0000\u0000"+ - "\u0000\u039e\u0083\u0001\u0000\u0000\u0000\u039f\u03a0\u0005/\u0000\u0000"+ - "\u03a0\u03a1\u0005f\u0000\u0000\u03a1\u03a4\u0003\u00c2a\u0000\u03a2\u03a3"+ - "\u0005m\u0000\u0000\u03a3\u03a5\u0003\u00e6s\u0000\u03a4\u03a2\u0001\u0000"+ - "\u0000\u0000\u03a4\u03a5\u0001\u0000\u0000\u0000\u03a5\u03a6\u0001\u0000"+ - "\u0000\u0000\u03a6\u03a7\u0005g\u0000\u0000\u03a7\u0085\u0001\u0000\u0000"+ - "\u0000\u03a8\u03a9\u0005.\u0000\u0000\u03a9\u03aa\u0005f\u0000\u0000\u03aa"+ - "\u03ab\u0003\u00c2a\u0000\u03ab\u03ac\u0005g\u0000\u0000\u03ac\u0087\u0001"+ - "\u0000\u0000\u0000\u03ad\u03b0\u0003^/\u0000\u03ae\u03b1\u0003\u008aE"+ - "\u0000\u03af\u03b1\u0003\u008cF\u0000\u03b0\u03ae\u0001\u0000\u0000\u0000"+ - "\u03b0\u03af\u0001\u0000\u0000\u0000\u03b1\u0089\u0001\u0000\u0000\u0000"+ - "\u03b2\u03b3\u0005M\u0000\u0000\u03b3\u03b4\u0005e\u0000\u0000\u03b4\u03b6"+ - "\u0003\u013e\u009f\u0000\u03b5\u03b7\u0003p8\u0000\u03b6\u03b5\u0001\u0000"+ - "\u0000\u0000\u03b6\u03b7\u0001\u0000\u0000\u0000\u03b7\u008b\u0001\u0000"+ - "\u0000\u0000\u03b8\u03b9\u0005M\u0000\u0000\u03b9\u03ba\u0003\u009aM\u0000"+ - "\u03ba\u03bb\u0005e\u0000\u0000\u03bb\u03bd\u0003\u013e\u009f\u0000\u03bc"+ - "\u03be\u0003p8\u0000\u03bd\u03bc\u0001\u0000\u0000\u0000\u03bd\u03be\u0001"+ - "\u0000\u0000\u0000\u03be\u008d\u0001\u0000\u0000\u0000\u03bf\u03c2\u0005"+ - "\u001b\u0000\u0000\u03c0\u03c3\u0003\u0088D\u0000\u03c1\u03c3\u0003\u00de"+ - "o\u0000\u03c2\u03c0\u0001\u0000\u0000\u0000\u03c2\u03c1\u0001\u0000\u0000"+ - "\u0000\u03c3\u008f\u0001\u0000\u0000\u0000\u03c4\u03c5\u00058\u0000\u0000"+ - "\u03c5\u03c6\u0005e\u0000\u0000\u03c6\u03c8\u0003\u0142\u00a1\u0000\u03c7"+ - "\u03c9\u0003\u0092I\u0000\u03c8\u03c7\u0001\u0000\u0000\u0000\u03c8\u03c9"+ - "\u0001\u0000\u0000\u0000\u03c9\u0091\u0001\u0000\u0000\u0000\u03ca\u03cb"+ - "\u0005h\u0000\u0000\u03cb\u03cc\u0003\u00a4R\u0000\u03cc\u03cd\u0003\u0170"+ - "\u00b8\u0000\u03cd\u03ce\u0005i\u0000\u0000\u03ce\u0093\u0001\u0000\u0000"+ - "\u0000\u03cf\u03d0\u00058\u0000\u0000\u03d0\u03d1\u0003\u009aM\u0000\u03d1"+ - "\u03d2\u0005e\u0000\u0000\u03d2\u03d4\u0003\u0142\u00a1\u0000\u03d3\u03d5"+ - "\u0003\u0092I\u0000\u03d4\u03d3\u0001\u0000\u0000\u0000\u03d4\u03d5\u0001"+ - "\u0000\u0000\u0000\u03d5\u0095\u0001\u0000\u0000\u0000\u03d6\u03de\u0003"+ - "\u0006\u0003\u0000\u03d7\u03da\u0003\u00c2a\u0000\u03d8\u03d9\u0005l\u0000"+ - "\u0000\u03d9\u03db\u0003\u00e6s\u0000\u03da\u03d8\u0001\u0000\u0000\u0000"+ - "\u03da\u03db\u0001\u0000\u0000\u0000\u03db\u03df\u0001\u0000\u0000\u0000"+ - "\u03dc\u03dd\u0005l\u0000\u0000\u03dd\u03df\u0003\u00e6s\u0000\u03de\u03d7"+ - "\u0001\u0000\u0000\u0000\u03de\u03dc\u0001\u0000\u0000\u0000\u03df\u0097"+ - "\u0001\u0000\u0000\u0000\u03e0\u03e1\u0003\u0006\u0003\u0000\u03e1\u03e2"+ - "\u0005s\u0000\u0000\u03e2\u03e3\u0003\u00e6s\u0000\u03e3\u0099\u0001\u0000"+ - "\u0000\u0000\u03e4\u03e6\u0005f\u0000\u0000\u03e5\u03e7\u0003\b\u0004"+ - "\u0000\u03e6\u03e5\u0001\u0000\u0000\u0000\u03e6\u03e7\u0001\u0000\u0000"+ - "\u0000\u03e7\u03e8\u0001\u0000\u0000\u0000\u03e8\u03ea\u0003\u00c2a\u0000"+ - "\u03e9\u03eb\u0005m\u0000\u0000\u03ea\u03e9\u0001\u0000\u0000\u0000\u03ea"+ - "\u03eb\u0001\u0000\u0000\u0000\u03eb\u03ec\u0001\u0000\u0000\u0000\u03ec"+ - "\u03ed\u0005g\u0000\u0000\u03ed\u009b\u0001\u0000\u0000\u0000\u03ee\u03f1"+ - "\u0003\u009eO\u0000\u03ef\u03f1\u0003\u00a0P\u0000\u03f0\u03ee\u0001\u0000"+ - "\u0000\u0000\u03f0\u03ef\u0001\u0000\u0000\u0000\u03f1\u009d\u0001\u0000"+ - "\u0000\u0000\u03f2\u03f4\u0003\u00e4r\u0000\u03f3\u03f2\u0001\u0000\u0000"+ - "\u0000\u03f3\u03f4\u0001\u0000\u0000\u0000\u03f4\u03f5\u0001\u0000\u0000"+ - "\u0000\u03f5\u03f6\u0003\u00a2Q\u0000\u03f6\u009f\u0001\u0000\u0000\u0000"+ - "\u03f7\u03f9\u0005\u001b\u0000\u0000\u03f8\u03fa\u0003\u00e4r\u0000\u03f9"+ - "\u03f8\u0001\u0000\u0000\u0000\u03f9\u03fa\u0001\u0000\u0000\u0000\u03fa"+ - "\u03fb\u0001\u0000\u0000\u0000\u03fb\u03fc\u0003\u00a2Q\u0000\u03fc\u00a1"+ - "\u0001\u0000\u0000\u0000\u03fd\u03ff\u0005t\u0000\u0000\u03fe\u03fd\u0001"+ - "\u0000\u0000\u0000\u03fe\u03ff\u0001\u0000\u0000\u0000\u03ff\u0400\u0001"+ - "\u0000\u0000\u0000\u0400\u0401\u0003\u00c2a\u0000\u0401\u00a3\u0001\u0000"+ - "\u0000\u0000\u0402\u0403\u0006R\uffff\uffff\u0000\u0403\u0404\u0007\u0006"+ - "\u0000\u0000\u0404\u0418\u0003\u00a4R\u000f\u0405\u0418\u0003\u00b4Z\u0000"+ - "\u0406\u0407\u0005\u0019\u0000\u0000\u0407\u0408\u0003.\u0017\u0000\u0408"+ - "\u0409\u0005\u001c\u0000\u0000\u0409\u040a\u0003\u00a4R\u0003\u040a\u0418"+ - "\u0001\u0000\u0000\u0000\u040b\u040c\u0005\u001a\u0000\u0000\u040c\u040d"+ - "\u0003\u0098L\u0000\u040d\u040e\u0005\u001c\u0000\u0000\u040e\u040f\u0003"+ - "\u00a4R\u0002\u040f\u0418\u0001\u0000\u0000\u0000\u0410\u0411\u0007\u0007"+ - "\u0000\u0000\u0411\u0412\u0003&\u0013\u0000\u0412\u0413\u0005o\u0000\u0000"+ - "\u0413\u0414\u0005o\u0000\u0000\u0414\u0415\u0003*\u0015\u0000\u0415\u0416"+ - "\u0003\u00a4R\u0001\u0416\u0418\u0001\u0000\u0000\u0000\u0417\u0402\u0001"+ - "\u0000\u0000\u0000\u0417\u0405\u0001\u0000\u0000\u0000\u0417\u0406\u0001"+ - "\u0000\u0000\u0000\u0417\u040b\u0001\u0000\u0000\u0000\u0417\u0410\u0001"+ - "\u0000\u0000\u0000\u0418\u043c\u0001\u0000\u0000\u0000\u0419\u041a\n\r"+ - "\u0000\u0000\u041a\u041b\u0007\b\u0000\u0000\u041b\u043b\u0003\u00a4R"+ - "\u000e\u041c\u041d\n\f\u0000\u0000\u041d\u041e\u0007\t\u0000\u0000\u041e"+ - "\u043b\u0003\u00a4R\r\u041f\u0420\n\u000b\u0000\u0000\u0420\u0421\u0007"+ - "\n\u0000\u0000\u0421\u043b\u0003\u00a4R\f\u0422\u0423\n\n\u0000\u0000"+ - "\u0423\u0424\u0007\u000b\u0000\u0000\u0424\u043b\u0003\u00a4R\u000b\u0425"+ - "\u0426\n\t\u0000\u0000\u0426\u0427\u0007\f\u0000\u0000\u0427\u043b\u0003"+ - "\u00a4R\n\u0428\u0429\n\u0007\u0000\u0000\u0429\u042a\u0005v\u0000\u0000"+ - "\u042a\u043b\u0003\u00a4R\b\u042b\u042c\n\u0006\u0000\u0000\u042c\u042d"+ - "\u0005u\u0000\u0000\u042d\u043b\u0003\u00a4R\u0007\u042e\u042f\n\u0005"+ - "\u0000\u0000\u042f\u0430\u0005\"\u0000\u0000\u0430\u043b\u0003\u00a4R"+ - "\u0005\u0431\u0432\n\u0004\u0000\u0000\u0432\u0433\u0005%\u0000\u0000"+ - "\u0433\u0434\u0003\u00a4R\u0000\u0434\u0435\u0005o\u0000\u0000\u0435\u0436"+ - "\u0003\u00a4R\u0004\u0436\u043b\u0001\u0000\u0000\u0000\u0437\u0438\n"+ - "\b\u0000\u0000\u0438\u0439\u0005\u000f\u0000\u0000\u0439\u043b\u0003r"+ - "9\u0000\u043a\u0419\u0001\u0000\u0000\u0000\u043a\u041c\u0001\u0000\u0000"+ - "\u0000\u043a\u041f\u0001\u0000\u0000\u0000\u043a\u0422\u0001\u0000\u0000"+ - "\u0000\u043a\u0425\u0001\u0000\u0000\u0000\u043a\u0428\u0001\u0000\u0000"+ - "\u0000\u043a\u042b\u0001\u0000\u0000\u0000\u043a\u042e\u0001\u0000\u0000"+ - "\u0000\u043a\u0431\u0001\u0000\u0000\u0000\u043a\u0437\u0001\u0000\u0000"+ - "\u0000\u043b\u043e\u0001\u0000\u0000\u0000\u043c\u043a\u0001\u0000\u0000"+ - "\u0000\u043c\u043d\u0001\u0000\u0000\u0000\u043d\u00a5\u0001\u0000\u0000"+ - "\u0000\u043e\u043c\u0001\u0000\u0000\u0000\u043f\u0454\u0003\u0018\f\u0000"+ - "\u0440\u0454\u0003\u001a\r\u0000\u0441\u0454\u0003\u00aaU\u0000\u0442"+ - "\u0454\u0003\u00a8T\u0000\u0443\u0454\u0003\u00deo\u0000\u0444\u0454\u0003"+ - "\u00fe\u007f\u0000\u0445\u0454\u0003\u00f2y\u0000\u0446\u0454\u0003\u012a"+ - "\u0095\u0000\u0447\u0454\u0003\u0100\u0080\u0000\u0448\u0454\u0003\u0102"+ - "\u0081\u0000\u0449\u0454\u0003\u0104\u0082\u0000\u044a\u0454\u0003\u0106"+ - "\u0083\u0000\u044b\u0454\u0003\u0108\u0084\u0000\u044c\u0454\u0003\u00ee"+ - "w\u0000\u044d\u0454\u0003\u010a\u0085\u0000\u044e\u0454\u0003\u010c\u0086"+ - "\u0000\u044f\u0454\u0003\u011e\u008f\u0000\u0450\u0454\u0003\u00acV\u0000"+ - "\u0451\u0454\u0003\u00b0X\u0000\u0452\u0454\u0003x<\u0000\u0453\u043f"+ - "\u0001\u0000\u0000\u0000\u0453\u0440\u0001\u0000\u0000\u0000\u0453\u0441"+ - "\u0001\u0000\u0000\u0000\u0453\u0442\u0001\u0000\u0000\u0000\u0453\u0443"+ - "\u0001\u0000\u0000\u0000\u0453\u0444\u0001\u0000\u0000\u0000\u0453\u0445"+ - "\u0001\u0000\u0000\u0000\u0453\u0446\u0001\u0000\u0000\u0000\u0453\u0447"+ - "\u0001\u0000\u0000\u0000\u0453\u0448\u0001\u0000\u0000\u0000\u0453\u0449"+ - "\u0001\u0000\u0000\u0000\u0453\u044a\u0001\u0000\u0000\u0000\u0453\u044b"+ - "\u0001\u0000\u0000\u0000\u0453\u044c\u0001\u0000\u0000\u0000\u0453\u044d"+ - "\u0001\u0000\u0000\u0000\u0453\u044e\u0001\u0000\u0000\u0000\u0453\u044f"+ - "\u0001\u0000\u0000\u0000\u0453\u0450\u0001\u0000\u0000\u0000\u0453\u0451"+ - "\u0001\u0000\u0000\u0000\u0453\u0452\u0001\u0000\u0000\u0000\u0454\u00a7"+ - "\u0001\u0000\u0000\u0000\u0455\u0456\u0005$\u0000\u0000\u0456\u0457\u0003"+ - "\u00a4R\u0000\u0457\u00a9\u0001\u0000\u0000\u0000\u0458\u0459\u0005X\u0000"+ - "\u0000\u0459\u045b\u0003\u00a4R\u0000\u045a\u045c\u0003\u00eew\u0000\u045b"+ - "\u045a\u0001\u0000\u0000\u0000\u045b\u045c\u0001\u0000\u0000\u0000\u045c"+ - "\u00ab\u0001\u0000\u0000\u0000\u045d\u045e\u0003\u00aeW\u0000\u045e\u045f"+ - "\u0003\u0126\u0093\u0000\u045f\u00ad\u0001\u0000\u0000\u0000\u0460\u0461"+ - "\u0005\f\u0000\u0000\u0461\u0462\u0003\u00a4R\u0000\u0462\u0463\u0003"+ - "\u0170\u00b8\u0000\u0463\u0465\u0001\u0000\u0000\u0000\u0464\u0460\u0001"+ - "\u0000\u0000\u0000\u0465\u0468\u0001\u0000\u0000\u0000\u0466\u0464\u0001"+ - "\u0000\u0000\u0000\u0466\u0467\u0001\u0000\u0000\u0000\u0467\u046d\u0001"+ - "\u0000\u0000\u0000\u0468\u0466\u0001\u0000\u0000\u0000\u0469\u046a\u0005"+ - "\r\u0000\u0000\u046a\u046b\u0003b1\u0000\u046b\u046c\u0003\u0170\u00b8"+ - "\u0000\u046c\u046e\u0001\u0000\u0000\u0000\u046d\u0469\u0001\u0000\u0000"+ - "\u0000\u046d\u046e\u0001\u0000\u0000\u0000\u046e\u00af\u0001\u0000\u0000"+ - "\u0000\u046f\u0470\u0005Q\u0000\u0000\u0470\u0475\u0003\u00a4R\u0000\u0471"+ - "\u0472\u0005Q\u0000\u0000\u0472\u0473\u0007\u0001\u0000\u0000\u0473\u0475"+ - "\u0003.\u0017\u0000\u0474\u046f\u0001\u0000\u0000\u0000\u0474\u0471\u0001"+ - "\u0000\u0000\u0000\u0475\u00b1\u0001\u0000\u0000\u0000\u0476\u047f\u0005"+ - "\u0003\u0000\u0000\u0477\u047f\u0005\u0004\u0000\u0000\u0478\u047f\u0005"+ - "d\u0000\u0000\u0479\u047f\u0003\u014c\u00a6\u0000\u047a\u047f\u0003\u0162"+ - "\u00b1\u0000\u047b\u047f\u0005\u0001\u0000\u0000\u047c\u047f\u0005\u008f"+ - "\u0000\u0000\u047d\u047f\u0005\u0090\u0000\u0000\u047e\u0476\u0001\u0000"+ - "\u0000\u0000\u047e\u0477\u0001\u0000\u0000\u0000\u047e\u0478\u0001\u0000"+ - "\u0000\u0000\u047e\u0479\u0001\u0000\u0000\u0000\u047e\u047a\u0001\u0000"+ - "\u0000\u0000\u047e\u047b\u0001\u0000\u0000\u0000\u047e\u047c\u0001\u0000"+ - "\u0000\u0000\u047e\u047d\u0001\u0000\u0000\u0000\u047f\u00b3\u0001\u0000"+ - "\u0000\u0000\u0480\u0481\u0006Z\uffff\uffff\u0000\u0481\u048d\u0003\u0148"+ - "\u00a4\u0000\u0482\u048d\u0003\u0144\u00a2\u0000\u0483\u048d\u0003\u016c"+ - "\u00b6\u0000\u0484\u048d\u0003 \u0010\u0000\u0485\u048d\u0003\u0086C\u0000"+ - "\u0486\u048d\u0003\u0084B\u0000\u0487\u0488\u0007\r\u0000\u0000\u0488"+ - "\u0489\u0005f\u0000\u0000\u0489\u048a\u0003\u00a4R\u0000\u048a\u048b\u0005"+ - "g\u0000\u0000\u048b\u048d\u0001\u0000\u0000\u0000\u048c\u0480\u0001\u0000"+ - "\u0000\u0000\u048c\u0482\u0001\u0000\u0000\u0000\u048c\u0483\u0001\u0000"+ - "\u0000\u0000\u048c\u0484\u0001\u0000\u0000\u0000\u048c\u0485\u0001\u0000"+ - "\u0000\u0000\u048c\u0486\u0001\u0000\u0000\u0000\u048c\u0487\u0001\u0000"+ - "\u0000\u0000\u048d\u04a4\u0001\u0000\u0000\u0000\u048e\u048f\n\t\u0000"+ - "\u0000\u048f\u0490\u0005p\u0000\u0000\u0490\u04a3\u0005e\u0000\u0000\u0491"+ - "\u0492\n\b\u0000\u0000\u0492\u04a3\u0003\u0166\u00b3\u0000\u0493\u0494"+ - "\n\u0007\u0000\u0000\u0494\u04a3\u0003\u00ceg\u0000\u0495\u0496\n\u0006"+ - "\u0000\u0000\u0496\u04a3\u0003L&\u0000\u0497\u0498\n\u0005\u0000\u0000"+ - "\u0498\u04a3\u0003\u0168\u00b4\u0000\u0499\u049a\n\u0004\u0000\u0000\u049a"+ - "\u04a3\u0003\u016a\u00b5\u0000\u049b\u049c\n\u0003\u0000\u0000\u049c\u049d"+ - "\u0003\u016a\u00b5\u0000\u049d\u049e\u0005\u0010\u0000\u0000\u049e\u049f"+ - "\u0003r9\u0000\u049f\u04a3\u0001\u0000\u0000\u0000\u04a0\u04a1\n\u0002"+ - "\u0000\u0000\u04a1\u04a3\u0003\u00ba]\u0000\u04a2\u048e\u0001\u0000\u0000"+ - "\u0000\u04a2\u0491\u0001\u0000\u0000\u0000\u04a2\u0493\u0001\u0000\u0000"+ - "\u0000\u04a2\u0495\u0001\u0000\u0000\u0000\u04a2\u0497\u0001\u0000\u0000"+ - "\u0000\u04a2\u0499\u0001\u0000\u0000\u0000\u04a2\u049b\u0001\u0000\u0000"+ - "\u0000\u04a2\u04a0\u0001\u0000\u0000\u0000\u04a3\u04a6\u0001\u0000\u0000"+ - "\u0000\u04a4\u04a2\u0001\u0000\u0000\u0000\u04a4\u04a5\u0001\u0000\u0000"+ - "\u0000\u04a5\u00b5\u0001\u0000\u0000\u0000\u04a6\u04a4\u0001\u0000\u0000"+ - "\u0000\u04a7\u04a8\u0003^/\u0000\u04a8\u04a9\u0003\u00b8\\\u0000\u04a9"+ - "\u00b7\u0001\u0000\u0000\u0000\u04aa\u04ac\u0005M\u0000\u0000\u04ab\u04ad"+ - "\u0005e\u0000\u0000\u04ac\u04ab\u0001\u0000\u0000\u0000\u04ac\u04ad\u0001"+ - "\u0000\u0000\u0000\u04ad\u04ae\u0001\u0000\u0000\u0000\u04ae\u04b0\u0003"+ - "\u013e\u009f\u0000\u04af\u04b1\u0003p8\u0000\u04b0\u04af\u0001\u0000\u0000"+ - "\u0000\u04b0\u04b1\u0001\u0000\u0000\u0000\u04b1\u00b9\u0001\u0000\u0000"+ - "\u0000\u04b2\u04b4\u0005&\u0000\u0000\u04b3\u04b5\u0003\u00e6s\u0000\u04b4"+ - "\u04b3\u0001\u0000\u0000\u0000\u04b4\u04b5\u0001\u0000\u0000\u0000\u04b5"+ - "\u04b7\u0001\u0000\u0000\u0000\u04b6\u04b8\u0005m\u0000\u0000\u04b7\u04b6"+ - "\u0001\u0000\u0000\u0000\u04b7\u04b8\u0001\u0000\u0000\u0000\u04b8\u04b9"+ - "\u0001\u0000\u0000\u0000\u04b9\u04ba\u0005\'\u0000\u0000\u04ba\u00bb\u0001"+ - "\u0000\u0000\u0000\u04bb\u04bc\u0005N\u0000\u0000\u04bc\u04c6\u0005h\u0000"+ - "\u0000\u04bd\u04c1\u0003\u00c0`\u0000\u04be\u04c1\u0003\u012c\u0096\u0000"+ - "\u04bf\u04c1\u0003\u00be_\u0000\u04c0\u04bd\u0001\u0000\u0000\u0000\u04c0"+ - "\u04be\u0001\u0000\u0000\u0000\u04c0\u04bf\u0001\u0000\u0000\u0000\u04c1"+ - "\u04c2\u0001\u0000\u0000\u0000\u04c2\u04c3\u0003\u0170\u00b8\u0000\u04c3"+ - "\u04c5\u0001\u0000\u0000\u0000\u04c4\u04c0\u0001\u0000\u0000\u0000\u04c5"+ - "\u04c8\u0001\u0000\u0000\u0000\u04c6\u04c4\u0001\u0000\u0000\u0000\u04c6"+ - "\u04c7\u0001\u0000\u0000\u0000\u04c7\u04c9\u0001\u0000\u0000\u0000\u04c8"+ - "\u04c6\u0001\u0000\u0000\u0000\u04c9\u04ca\u0005i\u0000\u0000\u04ca\u00bd"+ - "\u0001\u0000\u0000\u0000\u04cb\u04cc\u00058\u0000\u0000\u04cc\u04cd\u0005"+ - "e\u0000\u0000\u04cd\u04ce\u0003\u0142\u00a1\u0000\u04ce\u00bf\u0001\u0000"+ - "\u0000\u0000\u04cf\u04d1\u0005\u001b\u0000\u0000\u04d0\u04cf\u0001\u0000"+ - "\u0000\u0000\u04d0\u04d1\u0001\u0000\u0000\u0000\u04d1\u04d2\u0001\u0000"+ - "\u0000\u0000\u04d2\u04d3\u0003^/\u0000\u04d3\u04d4\u0005e\u0000\u0000"+ - "\u04d4\u04d5\u0003\u0142\u00a1\u0000\u04d5\u04d6\u0003\u0140\u00a0\u0000"+ - "\u04d6\u04df\u0001\u0000\u0000\u0000\u04d7\u04d9\u0005\u001b\u0000\u0000"+ - "\u04d8\u04d7\u0001\u0000\u0000\u0000\u04d8\u04d9\u0001\u0000\u0000\u0000"+ - "\u04d9\u04da\u0001\u0000\u0000\u0000\u04da\u04db\u0003^/\u0000\u04db\u04dc"+ - "\u0005e\u0000\u0000\u04dc\u04dd\u0003\u0142\u00a1\u0000\u04dd\u04df\u0001"+ - "\u0000\u0000\u0000\u04de\u04d0\u0001\u0000\u0000\u0000\u04de\u04d8\u0001"+ - "\u0000\u0000\u0000\u04df\u00c1\u0001\u0000\u0000\u0000\u04e0\u04e8\u0003"+ - "\u012c\u0096\u0000\u04e1\u04e8\u0003\u00c4b\u0000\u04e2\u04e8\u0003P("+ - "\u0000\u04e3\u04e4\u0005f\u0000\u0000\u04e4\u04e5\u0003\u00c2a\u0000\u04e5"+ - "\u04e6\u0005g\u0000\u0000\u04e6\u04e8\u0001\u0000\u0000\u0000\u04e7\u04e0"+ - "\u0001\u0000\u0000\u0000\u04e7\u04e1\u0001\u0000\u0000\u0000\u04e7\u04e2"+ - "\u0001\u0000\u0000\u0000\u04e7\u04e3\u0001\u0000\u0000\u0000\u04e8\u00c3"+ - "\u0001\u0000\u0000\u0000\u04e9\u04f3\u0003\u012e\u0097\u0000\u04ea\u04f3"+ - "\u0003\u015e\u00af\u0000\u04eb\u04f3\u0003\u0134\u009a\u0000\u04ec\u04f3"+ - "\u0003\u013c\u009e\u0000\u04ed\u04f3\u0003\u00bc^\u0000\u04ee\u04f3\u0003"+ - "\u0136\u009b\u0000\u04ef\u04f3\u0003\u0138\u009c\u0000\u04f0\u04f3\u0003"+ - "\u013a\u009d\u0000\u04f1\u04f3\u0003\u00c6c\u0000\u04f2\u04e9\u0001\u0000"+ - "\u0000\u0000\u04f2\u04ea\u0001\u0000\u0000\u0000\u04f2\u04eb\u0001\u0000"+ - "\u0000\u0000\u04f2\u04ec\u0001\u0000\u0000\u0000\u04f2\u04ed\u0001\u0000"+ - "\u0000\u0000\u04f2\u04ee\u0001\u0000\u0000\u0000\u04f2\u04ef\u0001\u0000"+ - "\u0000\u0000\u04f2\u04f0\u0001\u0000\u0000\u0000\u04f2\u04f1\u0001\u0000"+ - "\u0000\u0000\u04f3\u00c5\u0001\u0000\u0000\u0000\u04f4\u04f5\u00058\u0000"+ - "\u0000\u04f5\u04f6\u0003\u00c8d\u0000\u04f6\u00c7\u0001\u0000\u0000\u0000"+ - "\u04f7\u0503\u0005f\u0000\u0000\u04f8\u04fd\u0003\u00c2a\u0000\u04f9\u04fa"+ - "\u0005m\u0000\u0000\u04fa\u04fc\u0003\u00c2a\u0000\u04fb\u04f9\u0001\u0000"+ - "\u0000\u0000\u04fc\u04ff\u0001\u0000\u0000\u0000\u04fd\u04fb\u0001\u0000"+ - "\u0000\u0000\u04fd\u04fe\u0001\u0000\u0000\u0000\u04fe\u0501\u0001\u0000"+ - "\u0000\u0000\u04ff\u04fd\u0001\u0000\u0000\u0000\u0500\u0502\u0005m\u0000"+ - "\u0000\u0501\u0500\u0001\u0000\u0000\u0000\u0501\u0502\u0001\u0000\u0000"+ - "\u0000\u0502\u0504\u0001\u0000\u0000\u0000\u0503\u04f8\u0001\u0000\u0000"+ - "\u0000\u0503\u0504\u0001\u0000\u0000\u0000\u0504\u0505\u0001\u0000\u0000"+ - "\u0000\u0505\u0506\u0005g\u0000\u0000\u0506\u00c9\u0001\u0000\u0000\u0000"+ - "\u0507\u050f\u0003\u015e\u00af\u0000\u0508\u050f\u0003\u012e\u0097\u0000"+ - "\u0509\u050f\u0003\u00ccf\u0000\u050a\u050f\u0003\u0136\u009b\u0000\u050b"+ - "\u050f\u0003\u0138\u009c\u0000\u050c\u050f\u0003P(\u0000\u050d\u050f\u0003"+ - "\u012c\u0096\u0000\u050e\u0507\u0001\u0000\u0000\u0000\u050e\u0508\u0001"+ - "\u0000\u0000\u0000\u050e\u0509\u0001\u0000\u0000\u0000\u050e\u050a\u0001"+ - "\u0000\u0000\u0000\u050e\u050b\u0001\u0000\u0000\u0000\u050e\u050c\u0001"+ - "\u0000\u0000\u0000\u050e\u050d\u0001\u0000\u0000\u0000\u050f\u00cb\u0001"+ - "\u0000\u0000\u0000\u0510\u0511\u0005j\u0000\u0000\u0511\u0512\u0005t\u0000"+ - "\u0000\u0512\u0513\u0005k\u0000\u0000\u0513\u0514\u0003\u0132\u0099\u0000"+ - "\u0514\u00cd\u0001\u0000\u0000\u0000\u0515\u0525\u0005j\u0000\u0000\u0516"+ - "\u0518\u0003\u00d0h\u0000\u0517\u0516\u0001\u0000\u0000\u0000\u0517\u0518"+ - "\u0001\u0000\u0000\u0000\u0518\u0519\u0001\u0000\u0000\u0000\u0519\u051b"+ - "\u0005o\u0000\u0000\u051a\u051c\u0003\u00d2i\u0000\u051b\u051a\u0001\u0000"+ - "\u0000\u0000\u051b\u051c\u0001\u0000\u0000\u0000\u051c\u0526\u0001\u0000"+ - "\u0000\u0000\u051d\u051f\u0003\u00d0h\u0000\u051e\u051d\u0001\u0000\u0000"+ - "\u0000\u051e\u051f\u0001\u0000\u0000\u0000\u051f\u0520\u0001\u0000\u0000"+ - "\u0000\u0520\u0521\u0005o\u0000\u0000\u0521\u0522\u0003\u00d2i\u0000\u0522"+ - "\u0523\u0005o\u0000\u0000\u0523\u0524\u0003\u00d4j\u0000\u0524\u0526\u0001"+ - "\u0000\u0000\u0000\u0525\u0517\u0001\u0000\u0000\u0000\u0525\u051e\u0001"+ - "\u0000\u0000\u0000\u0526\u0527\u0001\u0000\u0000\u0000\u0527\u0528\u0005"+ - "k\u0000\u0000\u0528\u00cf\u0001\u0000\u0000\u0000\u0529\u052a\u0003\u00a4"+ - "R\u0000\u052a\u00d1\u0001\u0000\u0000\u0000\u052b\u052c\u0003\u00a4R\u0000"+ - "\u052c\u00d3\u0001\u0000\u0000\u0000\u052d\u052e\u0003\u00a4R\u0000\u052e"+ - "\u00d5\u0001\u0000\u0000\u0000\u052f\u0531\u0007\u000e\u0000\u0000\u0530"+ - "\u052f\u0001\u0000\u0000\u0000\u0530\u0531\u0001\u0000\u0000\u0000\u0531"+ - "\u0532\u0001\u0000\u0000\u0000\u0532\u0533\u0005l\u0000\u0000\u0533\u00d7"+ - "\u0001\u0000\u0000\u0000\u0534\u0535\u0003\u00e6s\u0000\u0535\u0536\u0005"+ - "l\u0000\u0000\u0536\u053b\u0001\u0000\u0000\u0000\u0537\u0538\u0003\u0006"+ - "\u0003\u0000\u0538\u0539\u0005s\u0000\u0000\u0539\u053b\u0001\u0000\u0000"+ - "\u0000\u053a\u0534\u0001\u0000\u0000\u0000\u053a\u0537\u0001\u0000\u0000"+ - "\u0000\u053a\u053b\u0001\u0000\u0000\u0000\u053b\u053c\u0001\u0000\u0000"+ - "\u0000\u053c\u053d\u0005]\u0000\u0000\u053d\u0542\u0003\u00a4R\u0000\u053e"+ - "\u0540\u0005J\u0000\u0000\u053f\u0541\u0005e\u0000\u0000\u0540\u053f\u0001"+ - "\u0000\u0000\u0000\u0540\u0541\u0001\u0000\u0000\u0000\u0541\u0543\u0001"+ - "\u0000\u0000\u0000\u0542\u053e\u0001\u0000\u0000\u0000\u0542\u0543\u0001"+ - "\u0000\u0000\u0000\u0543\u00d9\u0001\u0000\u0000\u0000\u0544\u0545\u0005"+ - "X\u0000\u0000\u0545\u0546\u0005e\u0000\u0000\u0546\u00db\u0001\u0000\u0000"+ - "\u0000\u0547\u0548\u0003\u0162\u00b1\u0000\u0548\u00dd\u0001\u0000\u0000"+ - "\u0000\u0549\u054d\u0003\u00e0p\u0000\u054a\u054d\u0003\u00e8t\u0000\u054b"+ - "\u054d\u0003\u00ecv\u0000\u054c\u0549\u0001\u0000\u0000\u0000\u054c\u054a"+ - "\u0001\u0000\u0000\u0000\u054c\u054b\u0001\u0000\u0000\u0000\u054d\u00df"+ - "\u0001\u0000\u0000\u0000\u054e\u055a\u0005Z\u0000\u0000\u054f\u055b\u0003"+ - "\u00e2q\u0000\u0550\u0556\u0005f\u0000\u0000\u0551\u0552\u0003\u00e2q"+ - "\u0000\u0552\u0553\u0003\u0170\u00b8\u0000\u0553\u0555\u0001\u0000\u0000"+ - "\u0000\u0554\u0551\u0001\u0000\u0000\u0000\u0555\u0558\u0001\u0000\u0000"+ - "\u0000\u0556\u0554\u0001\u0000\u0000\u0000\u0556\u0557\u0001\u0000\u0000"+ - "\u0000\u0557\u0559\u0001\u0000\u0000\u0000\u0558\u0556\u0001\u0000\u0000"+ - "\u0000\u0559\u055b\u0005g\u0000\u0000\u055a\u054f\u0001\u0000\u0000\u0000"+ - "\u055a\u0550\u0001\u0000\u0000\u0000\u055b\u00e1\u0001\u0000\u0000\u0000"+ - "\u055c\u0562\u0003\u00e4r\u0000\u055d\u055f\u0003\u00c2a\u0000\u055e\u055d"+ - "\u0001\u0000\u0000\u0000\u055e\u055f\u0001\u0000\u0000\u0000\u055f\u0560"+ - "\u0001\u0000\u0000\u0000\u0560\u0561\u0005l\u0000\u0000\u0561\u0563\u0003"+ - "\u00e6s\u0000\u0562\u055e\u0001\u0000\u0000\u0000\u0562\u0563\u0001\u0000"+ - "\u0000\u0000\u0563\u00e3\u0001\u0000\u0000\u0000\u0564\u0569\u0005e\u0000"+ - "\u0000\u0565\u0566\u0005m\u0000\u0000\u0566\u0568\u0005e\u0000\u0000\u0567"+ - "\u0565\u0001\u0000\u0000\u0000\u0568\u056b\u0001\u0000\u0000\u0000\u0569"+ - "\u0567\u0001\u0000\u0000\u0000\u0569\u056a\u0001\u0000\u0000\u0000\u056a"+ - "\u00e5\u0001\u0000\u0000\u0000\u056b\u0569\u0001\u0000\u0000\u0000\u056c"+ - "\u0571\u0003\u00a4R\u0000\u056d\u056e\u0005m\u0000\u0000\u056e\u0570\u0003"+ - "\u00a4R\u0000\u056f\u056d\u0001\u0000\u0000\u0000\u0570\u0573\u0001\u0000"+ - "\u0000\u0000\u0571\u056f\u0001\u0000\u0000\u0000\u0571\u0572\u0001\u0000"+ - "\u0000\u0000\u0572\u00e7\u0001\u0000\u0000\u0000\u0573\u0571\u0001\u0000"+ - "\u0000\u0000\u0574\u0580\u0005^\u0000\u0000\u0575\u0581\u0003\u00eau\u0000"+ - "\u0576\u057c\u0005f\u0000\u0000\u0577\u0578\u0003\u00eau\u0000\u0578\u0579"+ - "\u0003\u0170\u00b8\u0000\u0579\u057b\u0001\u0000\u0000\u0000\u057a\u0577"+ - "\u0001\u0000\u0000\u0000\u057b\u057e\u0001\u0000\u0000\u0000\u057c\u057a"+ - "\u0001\u0000\u0000\u0000\u057c\u057d\u0001\u0000\u0000\u0000\u057d\u057f"+ - "\u0001\u0000\u0000\u0000\u057e\u057c\u0001\u0000\u0000\u0000\u057f\u0581"+ - "\u0005g\u0000\u0000\u0580\u0575\u0001\u0000\u0000\u0000\u0580\u0576\u0001"+ - "\u0000\u0000\u0000\u0581\u00e9\u0001\u0000\u0000\u0000\u0582\u0584\u0005"+ - "e\u0000\u0000\u0583\u0585\u0005l\u0000\u0000\u0584\u0583\u0001\u0000\u0000"+ - "\u0000\u0584\u0585\u0001\u0000\u0000\u0000\u0585\u0586\u0001\u0000\u0000"+ - "\u0000\u0586\u0587\u0003\u00c2a\u0000\u0587\u00eb\u0001\u0000\u0000\u0000"+ - "\u0588\u0594\u0005c\u0000\u0000\u0589\u0595\u0003\u0096K\u0000\u058a\u0590"+ - "\u0005f\u0000\u0000\u058b\u058c\u0003\u0096K\u0000\u058c\u058d\u0003\u0170"+ - "\u00b8\u0000\u058d\u058f\u0001\u0000\u0000\u0000\u058e\u058b\u0001\u0000"+ - "\u0000\u0000\u058f\u0592\u0001\u0000\u0000\u0000\u0590\u058e\u0001\u0000"+ - "\u0000\u0000\u0590\u0591\u0001\u0000\u0000\u0000\u0591\u0593\u0001\u0000"+ - "\u0000\u0000\u0592\u0590\u0001\u0000\u0000\u0000\u0593\u0595\u0005g\u0000"+ - "\u0000\u0594\u0589\u0001\u0000\u0000\u0000\u0594\u058a\u0001\u0000\u0000"+ - "\u0000\u0595\u00ed\u0001\u0000\u0000\u0000\u0596\u0598\u0005h\u0000\u0000"+ - "\u0597\u0599\u0003\u00f0x\u0000\u0598\u0597\u0001\u0000\u0000\u0000\u0598"+ - "\u0599\u0001\u0000\u0000\u0000\u0599\u059a\u0001\u0000\u0000\u0000\u059a"+ - "\u059b\u0005i\u0000\u0000\u059b\u00ef\u0001\u0000\u0000\u0000\u059c\u059e"+ - "\u0005n\u0000\u0000\u059d\u059c\u0001\u0000\u0000\u0000\u059d\u059e\u0001"+ - "\u0000\u0000\u0000\u059e\u05a4\u0001\u0000\u0000\u0000\u059f\u05a1\u0005"+ - "\u009f\u0000\u0000\u05a0\u059f\u0001\u0000\u0000\u0000\u05a0\u05a1\u0001"+ - "\u0000\u0000\u0000\u05a1\u05a4\u0001\u0000\u0000\u0000\u05a2\u05a4\u0004"+ - "x\u0012\u0000\u05a3\u059d\u0001\u0000\u0000\u0000\u05a3\u05a0\u0001\u0000"+ - "\u0000\u0000\u05a3\u05a2\u0001\u0000\u0000\u0000\u05a4\u05a5\u0001\u0000"+ - "\u0000\u0000\u05a5\u05a6\u0003\u00a6S\u0000\u05a6\u05a7\u0003\u0170\u00b8"+ - "\u0000\u05a7\u05a9\u0001\u0000\u0000\u0000\u05a8\u05a3\u0001\u0000\u0000"+ - "\u0000\u05a9\u05aa\u0001\u0000\u0000\u0000\u05aa\u05a8\u0001\u0000\u0000"+ - "\u0000\u05aa\u05ab\u0001\u0000\u0000\u0000\u05ab\u00f1\u0001\u0000\u0000"+ - "\u0000\u05ac\u05b2\u0003\u00f6{\u0000\u05ad\u05b2\u0003\u00f8|\u0000\u05ae"+ - "\u05b2\u0003\u00fa}\u0000\u05af\u05b2\u0003\u00f4z\u0000\u05b0\u05b2\u0003"+ - "\u0098L\u0000\u05b1\u05ac\u0001\u0000\u0000\u0000\u05b1\u05ad\u0001\u0000"+ - "\u0000\u0000\u05b1\u05ae\u0001\u0000\u0000\u0000\u05b1\u05af\u0001\u0000"+ - "\u0000\u0000\u05b1\u05b0\u0001\u0000\u0000\u0000\u05b2\u00f3\u0001\u0000"+ - "\u0000\u0000\u05b3\u05b4\u0003\u00a4R\u0000\u05b4\u00f5\u0001\u0000\u0000"+ - "\u0000\u05b5\u05b6\u0003\u00a4R\u0000\u05b6\u05b7\u0005\u0089\u0000\u0000"+ - "\u05b7\u05b8\u0003\u00a4R\u0000\u05b8\u00f7\u0001\u0000\u0000\u0000\u05b9"+ - "\u05ba\u0003\u00a4R\u0000\u05ba\u05bb\u0007\u000f\u0000\u0000\u05bb\u00f9"+ - "\u0001\u0000\u0000\u0000\u05bc\u05bd\u0003\u00e6s\u0000\u05bd\u05be\u0003"+ - "\u00d6k\u0000\u05be\u05bf\u0003\u00e6s\u0000\u05bf\u00fb\u0001\u0000\u0000"+ - "\u0000\u05c0\u05c1\u0007\u0010\u0000\u0000\u05c1\u00fd\u0001\u0000\u0000"+ - "\u0000\u05c2\u05c3\u0005e\u0000\u0000\u05c3\u05c5\u0005o\u0000\u0000\u05c4"+ - "\u05c6\u0003\u00a6S\u0000\u05c5\u05c4\u0001\u0000\u0000\u0000\u05c5\u05c6"+ - "\u0001\u0000\u0000\u0000\u05c6\u00ff\u0001\u0000\u0000\u0000\u05c7\u05c9"+ - "\u0005b\u0000\u0000\u05c8\u05ca\u0003\u00e6s\u0000\u05c9\u05c8\u0001\u0000"+ - "\u0000\u0000\u05c9\u05ca\u0001\u0000\u0000\u0000\u05ca\u0101\u0001\u0000"+ - "\u0000\u0000\u05cb\u05cd\u0005K\u0000\u0000\u05cc\u05ce\u0005e\u0000\u0000"+ - "\u05cd\u05cc\u0001\u0000\u0000\u0000\u05cd\u05ce\u0001\u0000\u0000\u0000"+ - "\u05ce\u0103\u0001\u0000\u0000\u0000\u05cf\u05d1\u0005_\u0000\u0000\u05d0"+ - "\u05d2\u0005e\u0000\u0000\u05d1\u05d0\u0001\u0000\u0000\u0000\u05d1\u05d2"+ - "\u0001\u0000\u0000\u0000\u05d2\u0105\u0001\u0000\u0000\u0000\u05d3\u05d4"+ - "\u0005W\u0000\u0000\u05d4\u05d5\u0005e\u0000\u0000\u05d5\u0107\u0001\u0000"+ - "\u0000\u0000\u05d6\u05d7\u0005[\u0000\u0000\u05d7\u0109\u0001\u0000\u0000"+ - "\u0000\u05d8\u05e1\u0005\\\u0000\u0000\u05d9\u05e2\u0003\u00a4R\u0000"+ - "\u05da\u05db\u0003\u0170\u00b8\u0000\u05db\u05dc\u0003\u00a4R\u0000\u05dc"+ - "\u05e2\u0001\u0000\u0000\u0000\u05dd\u05de\u0003\u00f2y\u0000\u05de\u05df"+ - "\u0003\u0170\u00b8\u0000\u05df\u05e0\u0003\u00a4R\u0000\u05e0\u05e2\u0001"+ - "\u0000\u0000\u0000\u05e1\u05d9\u0001\u0000\u0000\u0000\u05e1\u05da\u0001"+ - "\u0000\u0000\u0000\u05e1\u05dd\u0001\u0000\u0000\u0000\u05e2\u05e3\u0001"+ - "\u0000\u0000\u0000\u05e3\u05e9\u0003\u00eew\u0000\u05e4\u05e7\u0005V\u0000"+ - "\u0000\u05e5\u05e8\u0003\u010a\u0085\u0000\u05e6\u05e8\u0003\u00eew\u0000"+ - "\u05e7\u05e5\u0001\u0000\u0000\u0000\u05e7\u05e6\u0001\u0000\u0000\u0000"+ - "\u05e8\u05ea\u0001\u0000\u0000\u0000\u05e9\u05e4\u0001\u0000\u0000\u0000"+ - "\u05e9\u05ea\u0001\u0000\u0000\u0000\u05ea\u010b\u0001\u0000\u0000\u0000"+ - "\u05eb\u05ee\u0003\u010e\u0087\u0000\u05ec\u05ee\u0003\u0114\u008a\u0000"+ - "\u05ed\u05eb\u0001\u0000\u0000\u0000\u05ed\u05ec\u0001\u0000\u0000\u0000"+ - "\u05ee\u010d\u0001\u0000\u0000\u0000\u05ef\u05fa\u0005Y\u0000\u0000\u05f0"+ - "\u05f2\u0003\u00a4R\u0000\u05f1\u05f0\u0001\u0000\u0000\u0000\u05f1\u05f2"+ - "\u0001\u0000\u0000\u0000\u05f2\u05fb\u0001\u0000\u0000\u0000\u05f3\u05f5"+ - "\u0003\u00f2y\u0000\u05f4\u05f3\u0001\u0000\u0000\u0000\u05f4\u05f5\u0001"+ - "\u0000\u0000\u0000\u05f5\u05f6\u0001\u0000\u0000\u0000\u05f6\u05f8\u0003"+ - "\u0170\u00b8\u0000\u05f7\u05f9\u0003\u00a4R\u0000\u05f8\u05f7\u0001\u0000"+ - "\u0000\u0000\u05f8\u05f9\u0001\u0000\u0000\u0000\u05f9\u05fb\u0001\u0000"+ - "\u0000\u0000\u05fa\u05f1\u0001\u0000\u0000\u0000\u05fa\u05f4\u0001\u0000"+ - "\u0000\u0000\u05fb\u05fc\u0001\u0000\u0000\u0000\u05fc\u0600\u0005h\u0000"+ - "\u0000\u05fd\u05ff\u0003\u0110\u0088\u0000\u05fe\u05fd\u0001\u0000\u0000"+ - "\u0000\u05ff\u0602\u0001\u0000\u0000\u0000\u0600\u05fe\u0001\u0000\u0000"+ - "\u0000\u0600\u0601\u0001\u0000\u0000\u0000\u0601\u0603\u0001\u0000\u0000"+ - "\u0000\u0602\u0600\u0001\u0000\u0000\u0000\u0603\u0604\u0005i\u0000\u0000"+ - "\u0604\u010f\u0001\u0000\u0000\u0000\u0605\u0606\u0003\u0112\u0089\u0000"+ - "\u0606\u0608\u0005o\u0000\u0000\u0607\u0609\u0003\u00f0x\u0000\u0608\u0607"+ - "\u0001\u0000\u0000\u0000\u0608\u0609\u0001\u0000\u0000\u0000\u0609\u0111"+ - "\u0001\u0000\u0000\u0000\u060a\u060b\u0005P\u0000\u0000\u060b\u060e\u0003"+ - "\u00e6s\u0000\u060c\u060e\u0005L\u0000\u0000\u060d\u060a\u0001\u0000\u0000"+ - "\u0000\u060d\u060c\u0001\u0000\u0000\u0000\u060e\u0113\u0001\u0000\u0000"+ - "\u0000\u060f\u0618\u0005Y\u0000\u0000\u0610\u0619\u0003\u0116\u008b\u0000"+ - "\u0611\u0612\u0003\u0170\u00b8\u0000\u0612\u0613\u0003\u0116\u008b\u0000"+ - "\u0613\u0619\u0001\u0000\u0000\u0000\u0614\u0615\u0003\u00f2y\u0000\u0615"+ - "\u0616\u0003\u0170\u00b8\u0000\u0616\u0617\u0003\u0116\u008b\u0000\u0617"+ - "\u0619\u0001\u0000\u0000\u0000\u0618\u0610\u0001\u0000\u0000\u0000\u0618"+ - "\u0611\u0001\u0000\u0000\u0000\u0618\u0614\u0001\u0000\u0000\u0000\u0619"+ - "\u061a\u0001\u0000\u0000\u0000\u061a\u061e\u0005h\u0000\u0000\u061b\u061d"+ - "\u0003\u0118\u008c\u0000\u061c\u061b\u0001\u0000\u0000\u0000\u061d\u0620"+ - "\u0001\u0000\u0000\u0000\u061e\u061c\u0001\u0000\u0000\u0000\u061e\u061f"+ - "\u0001\u0000\u0000\u0000\u061f\u0621\u0001\u0000\u0000\u0000\u0620\u061e"+ - "\u0001\u0000\u0000\u0000\u0621\u0622\u0005i\u0000\u0000\u0622\u0115\u0001"+ - "\u0000\u0000\u0000\u0623\u0624\u0005e\u0000\u0000\u0624\u0626\u0005s\u0000"+ - "\u0000\u0625\u0623\u0001\u0000\u0000\u0000\u0625\u0626\u0001\u0000\u0000"+ - "\u0000\u0626\u0627\u0001\u0000\u0000\u0000\u0627\u0628\u0003\u00b4Z\u0000"+ - "\u0628\u0629\u0005p\u0000\u0000\u0629\u062a\u0005f\u0000\u0000\u062a\u062b"+ - "\u0005^\u0000\u0000\u062b\u062c\u0005g\u0000\u0000\u062c\u0117\u0001\u0000"+ - "\u0000\u0000\u062d\u062e\u0003\u011a\u008d\u0000\u062e\u0630\u0005o\u0000"+ - "\u0000\u062f\u0631\u0003\u00f0x\u0000\u0630\u062f\u0001\u0000\u0000\u0000"+ - "\u0630\u0631\u0001\u0000\u0000\u0000\u0631\u0119\u0001\u0000\u0000\u0000"+ - "\u0632\u0633\u0005P\u0000\u0000\u0633\u0636\u0003\u011c\u008e\u0000\u0634"+ - "\u0636\u0005L\u0000\u0000\u0635\u0632\u0001\u0000\u0000\u0000\u0635\u0634"+ - "\u0001\u0000\u0000\u0000\u0636\u011b\u0001\u0000\u0000\u0000\u0637\u063a"+ - "\u0003\u00c2a\u0000\u0638\u063a\u0005d\u0000\u0000\u0639\u0637\u0001\u0000"+ - "\u0000\u0000\u0639\u0638\u0001\u0000\u0000\u0000\u063a\u0642\u0001\u0000"+ - "\u0000\u0000\u063b\u063e\u0005m\u0000\u0000\u063c\u063f\u0003\u00c2a\u0000"+ - "\u063d\u063f\u0005d\u0000\u0000\u063e\u063c\u0001\u0000\u0000\u0000\u063e"+ - "\u063d\u0001\u0000\u0000\u0000\u063f\u0641\u0001\u0000\u0000\u0000\u0640"+ - "\u063b\u0001\u0000\u0000\u0000\u0641\u0644\u0001\u0000\u0000\u0000\u0642"+ - "\u0640\u0001\u0000\u0000\u0000\u0642\u0643\u0001\u0000\u0000\u0000\u0643"+ - "\u011d\u0001\u0000\u0000\u0000\u0644\u0642\u0001\u0000\u0000\u0000\u0645"+ - "\u0646\u0005O\u0000\u0000\u0646\u064a\u0005h\u0000\u0000\u0647\u0649\u0003"+ - "\u0120\u0090\u0000\u0648\u0647\u0001\u0000\u0000\u0000\u0649\u064c\u0001"+ - "\u0000\u0000\u0000\u064a\u0648\u0001\u0000\u0000\u0000\u064a\u064b\u0001"+ - "\u0000\u0000\u0000\u064b\u064d\u0001\u0000\u0000\u0000\u064c\u064a\u0001"+ - "\u0000\u0000\u0000\u064d\u064e\u0005i\u0000\u0000\u064e\u011f\u0001\u0000"+ - "\u0000\u0000\u064f\u0650\u0003\u0122\u0091\u0000\u0650\u0652\u0005o\u0000"+ - "\u0000\u0651\u0653\u0003\u00f0x\u0000\u0652\u0651\u0001\u0000\u0000\u0000"+ - "\u0652\u0653\u0001\u0000\u0000\u0000\u0653\u0121\u0001\u0000\u0000\u0000"+ - "\u0654\u0657\u0005P\u0000\u0000\u0655\u0658\u0003\u00f6{\u0000\u0656\u0658"+ - "\u0003\u0124\u0092\u0000\u0657\u0655\u0001\u0000\u0000\u0000\u0657\u0656"+ - "\u0001\u0000\u0000\u0000\u0658\u065b\u0001\u0000\u0000\u0000\u0659\u065b"+ - "\u0005L\u0000\u0000\u065a\u0654\u0001\u0000\u0000\u0000\u065a\u0659\u0001"+ - "\u0000\u0000\u0000\u065b\u0123\u0001\u0000\u0000\u0000\u065c\u065d\u0003"+ - "\u00e6s\u0000\u065d\u065e\u0005l\u0000\u0000\u065e\u0663\u0001\u0000\u0000"+ - "\u0000\u065f\u0660\u0003\u00e4r\u0000\u0660\u0661\u0005s\u0000\u0000\u0661"+ - "\u0663\u0001\u0000\u0000\u0000\u0662\u065c\u0001\u0000\u0000\u0000\u0662"+ - "\u065f\u0001\u0000\u0000\u0000\u0662\u0663\u0001\u0000\u0000\u0000\u0663"+ - "\u0664\u0001\u0000\u0000\u0000\u0664\u0665\u0003\u00a4R\u0000\u0665\u0125"+ - "\u0001\u0000\u0000\u0000\u0666\u066e\u0005`\u0000\u0000\u0667\u0669\u0003"+ - "\u00a4R\u0000\u0668\u0667\u0001\u0000\u0000\u0000\u0668\u0669\u0001\u0000"+ - "\u0000\u0000\u0669\u066f\u0001\u0000\u0000\u0000\u066a\u066f\u0003\u0128"+ - "\u0094\u0000\u066b\u066d\u0003\u00d8l\u0000\u066c\u066b\u0001\u0000\u0000"+ - "\u0000\u066c\u066d\u0001\u0000\u0000\u0000\u066d\u066f\u0001\u0000\u0000"+ - "\u0000\u066e\u0668\u0001\u0000\u0000\u0000\u066e\u066a\u0001\u0000\u0000"+ - "\u0000\u066e\u066c\u0001\u0000\u0000\u0000\u066f\u0670\u0001\u0000\u0000"+ - "\u0000\u0670\u0671\u0003\u00eew\u0000\u0671\u0127\u0001\u0000\u0000\u0000"+ - "\u0672\u0674\u0003\u00f2y\u0000\u0673\u0672\u0001\u0000\u0000\u0000\u0673"+ - "\u0674\u0001\u0000\u0000\u0000\u0674\u0675\u0001\u0000\u0000\u0000\u0675"+ - "\u0677\u0003\u0170\u00b8\u0000\u0676\u0678\u0003\u00a4R\u0000\u0677\u0676"+ - "\u0001\u0000\u0000\u0000\u0677\u0678\u0001\u0000\u0000\u0000\u0678\u0679"+ - "\u0001\u0000\u0000\u0000\u0679\u067b\u0003\u0170\u00b8\u0000\u067a\u067c"+ - "\u0003\u00f2y\u0000\u067b\u067a\u0001\u0000\u0000\u0000\u067b\u067c\u0001"+ - "\u0000\u0000\u0000\u067c\u0129\u0001\u0000\u0000\u0000\u067d\u067e\u0005"+ - "R\u0000\u0000\u067e\u067f\u0003\u00a4R\u0000\u067f\u012b\u0001\u0000\u0000"+ - "\u0000\u0680\u0683\u0003\u0150\u00a8\u0000\u0681\u0683\u0005e\u0000\u0000"+ - "\u0682\u0680\u0001\u0000\u0000\u0000\u0682\u0681\u0001\u0000\u0000\u0000"+ - "\u0683\u012d\u0001\u0000\u0000\u0000\u0684\u0685\u0005j\u0000\u0000\u0685"+ - "\u0686\u0003\u0130\u0098\u0000\u0686\u0687\u0005k\u0000\u0000\u0687\u0688"+ - "\u0003\u0132\u0099\u0000\u0688\u012f\u0001\u0000\u0000\u0000\u0689\u068a"+ - "\u0003\u00a4R\u0000\u068a\u0131\u0001\u0000\u0000\u0000\u068b\u068c\u0003"+ - "\u00c2a\u0000\u068c\u0133\u0001\u0000\u0000\u0000\u068d\u068e\u0005\u0087"+ - "\u0000\u0000\u068e\u068f\u0003\u00c2a\u0000\u068f\u0135\u0001\u0000\u0000"+ - "\u0000\u0690\u0691\u0005j\u0000\u0000\u0691\u0692\u0005k\u0000\u0000\u0692"+ - "\u0693\u0003\u0132\u0099\u0000\u0693\u0137\u0001\u0000\u0000\u0000\u0694"+ - "\u0695\u0005S\u0000\u0000\u0695\u0696\u0005j\u0000\u0000\u0696\u0697\u0003"+ - "\u00c2a\u0000\u0697\u0698\u0005k\u0000\u0000\u0698\u0699\u0003\u0132\u0099"+ - "\u0000\u0699\u0139\u0001\u0000\u0000\u0000\u069a\u06a0\u0005U\u0000\u0000"+ - "\u069b\u069c\u0005U\u0000\u0000\u069c\u06a0\u0005\u0089\u0000\u0000\u069d"+ - "\u069e\u0005\u0089\u0000\u0000\u069e\u06a0\u0005U\u0000\u0000\u069f\u069a"+ - "\u0001\u0000\u0000\u0000\u069f\u069b\u0001\u0000\u0000\u0000\u069f\u069d"+ - "\u0001\u0000\u0000\u0000\u06a0\u06a1\u0001\u0000\u0000\u0000\u06a1\u06a2"+ - "\u0003\u0132\u0099\u0000\u06a2\u013b\u0001\u0000\u0000\u0000\u06a3\u06a4"+ - "\u0005M\u0000\u0000\u06a4\u06a5\u0003\u013e\u009f\u0000\u06a5\u013d\u0001"+ - "\u0000\u0000\u0000\u06a6\u06a7\u0003\u0142\u00a1\u0000\u06a7\u06a8\u0003"+ - "\u0140\u00a0\u0000\u06a8\u06ab\u0001\u0000\u0000\u0000\u06a9\u06ab\u0003"+ - "\u0142\u00a1\u0000\u06aa\u06a6\u0001\u0000\u0000\u0000\u06aa\u06a9\u0001"+ - "\u0000\u0000\u0000\u06ab\u013f\u0001\u0000\u0000\u0000\u06ac\u06af\u0003"+ - "\u0142\u00a1\u0000\u06ad\u06af\u0003\u00c2a\u0000\u06ae\u06ac\u0001\u0000"+ - "\u0000\u0000\u06ae\u06ad\u0001\u0000\u0000\u0000\u06af\u0141\u0001\u0000"+ - "\u0000\u0000\u06b0\u06bc\u0005f\u0000\u0000\u06b1\u06b6\u0003\u009cN\u0000"+ - "\u06b2\u06b3\u0005m\u0000\u0000\u06b3\u06b5\u0003\u009cN\u0000\u06b4\u06b2"+ - "\u0001\u0000\u0000\u0000\u06b5\u06b8\u0001\u0000\u0000\u0000\u06b6\u06b4"+ - "\u0001\u0000\u0000\u0000\u06b6\u06b7\u0001\u0000\u0000\u0000\u06b7\u06ba"+ - "\u0001\u0000\u0000\u0000\u06b8\u06b6\u0001\u0000\u0000\u0000\u06b9\u06bb"+ - "\u0005m\u0000\u0000\u06ba\u06b9\u0001\u0000\u0000\u0000\u06ba\u06bb\u0001"+ - "\u0000\u0000\u0000\u06bb\u06bd\u0001\u0000\u0000\u0000\u06bc\u06b1\u0001"+ - "\u0000\u0000\u0000\u06bc\u06bd\u0001\u0000\u0000\u0000\u06bd\u06be\u0001"+ - "\u0000\u0000\u0000\u06be\u06bf\u0005g\u0000\u0000\u06bf\u0143\u0001\u0000"+ - "\u0000\u0000\u06c0\u06c1\u0003\u0146\u00a3\u0000\u06c1\u06c2\u0005f\u0000"+ - "\u0000\u06c2\u06c4\u0003\u00a4R\u0000\u06c3\u06c5\u0005m\u0000\u0000\u06c4"+ - "\u06c3\u0001\u0000\u0000\u0000\u06c4\u06c5\u0001\u0000\u0000\u0000\u06c5"+ - "\u06c6\u0001\u0000\u0000\u0000\u06c6\u06c7\u0005g\u0000\u0000\u06c7\u0145"+ - "\u0001\u0000\u0000\u0000\u06c8\u06ce\u0003\u00c4b\u0000\u06c9\u06ca\u0005"+ - "f\u0000\u0000\u06ca\u06cb\u0003\u0146\u00a3\u0000\u06cb\u06cc\u0005g\u0000"+ - "\u0000\u06cc\u06ce\u0001\u0000\u0000\u0000\u06cd\u06c8\u0001\u0000\u0000"+ - "\u0000\u06cd\u06c9\u0001\u0000\u0000\u0000\u06ce\u0147\u0001\u0000\u0000"+ - "\u0000\u06cf\u06d6\u0003\u014a\u00a5\u0000\u06d0\u06d6\u0003\u014e\u00a7"+ - "\u0000\u06d1\u06d2\u0005f\u0000\u0000\u06d2\u06d3\u0003\u00a4R\u0000\u06d3"+ - "\u06d4\u0005g\u0000\u0000\u06d4\u06d6\u0001\u0000\u0000\u0000\u06d5\u06cf"+ - "\u0001\u0000\u0000\u0000\u06d5\u06d0\u0001\u0000\u0000\u0000\u06d5\u06d1"+ - "\u0001\u0000\u0000\u0000\u06d6\u0149\u0001\u0000\u0000\u0000\u06d7\u06db"+ - "\u0003\u00b2Y\u0000\u06d8\u06db\u0003\u0152\u00a9\u0000\u06d9\u06db\u0003"+ - "\u00b6[\u0000\u06da\u06d7\u0001\u0000\u0000\u0000\u06da\u06d8\u0001\u0000"+ - "\u0000\u0000\u06da\u06d9\u0001\u0000\u0000\u0000\u06db\u014b\u0001\u0000"+ - "\u0000\u0000\u06dc\u06dd\u0007\u0011\u0000\u0000\u06dd\u014d\u0001\u0000"+ - "\u0000\u0000\u06de\u06df\u0005e\u0000\u0000\u06df\u014f\u0001\u0000\u0000"+ - "\u0000\u06e0\u06e1\u0005e\u0000\u0000\u06e1\u06e2\u0005p\u0000\u0000\u06e2"+ - "\u06e3\u0005e\u0000\u0000\u06e3\u0151\u0001\u0000\u0000\u0000\u06e4\u06e5"+ - "\u0003\u00cae\u0000\u06e5\u06e6\u0003\u0154\u00aa\u0000\u06e6\u0153\u0001"+ - "\u0000\u0000\u0000\u06e7\u06ec\u0005h\u0000\u0000\u06e8\u06ea\u0003\u0156"+ - "\u00ab\u0000\u06e9\u06eb\u0005m\u0000\u0000\u06ea\u06e9\u0001\u0000\u0000"+ - "\u0000\u06ea\u06eb\u0001\u0000\u0000\u0000\u06eb\u06ed\u0001\u0000\u0000"+ - "\u0000\u06ec\u06e8\u0001\u0000\u0000\u0000\u06ec\u06ed\u0001\u0000\u0000"+ - "\u0000\u06ed\u06ee\u0001\u0000\u0000\u0000\u06ee\u06ef\u0005i\u0000\u0000"+ - "\u06ef\u0155\u0001\u0000\u0000\u0000\u06f0\u06f5\u0003\u0158\u00ac\u0000"+ - "\u06f1\u06f2\u0005m\u0000\u0000\u06f2\u06f4\u0003\u0158\u00ac\u0000\u06f3"+ - "\u06f1\u0001\u0000\u0000\u0000\u06f4\u06f7\u0001\u0000\u0000\u0000\u06f5"+ - "\u06f3\u0001\u0000\u0000\u0000\u06f5\u06f6\u0001\u0000\u0000\u0000\u06f6"+ - "\u0157\u0001\u0000\u0000\u0000\u06f7\u06f5\u0001\u0000\u0000\u0000\u06f8"+ - "\u06f9\u0003\u015a\u00ad\u0000\u06f9\u06fa\u0005o\u0000\u0000\u06fa\u06fc"+ - "\u0001\u0000\u0000\u0000\u06fb\u06f8\u0001\u0000\u0000\u0000\u06fb\u06fc"+ - "\u0001\u0000\u0000\u0000\u06fc\u06fd\u0001\u0000\u0000\u0000\u06fd\u06fe"+ - "\u0003\u015c\u00ae\u0000\u06fe\u0159\u0001\u0000\u0000\u0000\u06ff\u0702"+ - "\u0003\u00a4R\u0000\u0700\u0702\u0003\u0154\u00aa\u0000\u0701\u06ff\u0001"+ - "\u0000\u0000\u0000\u0701\u0700\u0001\u0000\u0000\u0000\u0702\u015b\u0001"+ - "\u0000\u0000\u0000\u0703\u0706\u0003\u00a4R\u0000\u0704\u0706\u0003\u0154"+ - "\u00aa\u0000\u0705\u0703\u0001\u0000\u0000\u0000\u0705\u0704\u0001\u0000"+ - "\u0000\u0000\u0706\u015d\u0001\u0000\u0000\u0000\u0707\u0708\u0005T\u0000"+ - "\u0000\u0708\u070e\u0005h\u0000\u0000\u0709\u070a\u0003\u0160\u00b0\u0000"+ - "\u070a\u070b\u0003\u0170\u00b8\u0000\u070b\u070d\u0001\u0000\u0000\u0000"+ - "\u070c\u0709\u0001\u0000\u0000\u0000\u070d\u0710\u0001\u0000\u0000\u0000"+ - "\u070e\u070c\u0001\u0000\u0000\u0000\u070e\u070f\u0001\u0000\u0000\u0000"+ - "\u070f\u0711\u0001\u0000\u0000\u0000\u0710\u070e\u0001\u0000\u0000\u0000"+ - "\u0711\u0712\u0005i\u0000\u0000\u0712\u015f\u0001\u0000\u0000\u0000\u0713"+ - "\u0714\u0003\u00e4r\u0000\u0714\u0715\u0003\u00c2a\u0000\u0715\u0718\u0001"+ - "\u0000\u0000\u0000\u0716\u0718\u0003\u0164\u00b2\u0000\u0717\u0713\u0001"+ - "\u0000\u0000\u0000\u0717\u0716\u0001\u0000\u0000\u0000\u0718\u071a\u0001"+ - "\u0000\u0000\u0000\u0719\u071b\u0003\u0162\u00b1\u0000\u071a\u0719\u0001"+ - "\u0000\u0000\u0000\u071a\u071b\u0001\u0000\u0000\u0000\u071b\u0161\u0001"+ - "\u0000\u0000\u0000\u071c\u071d\u0007\u0012\u0000\u0000\u071d\u0163\u0001"+ - "\u0000\u0000\u0000\u071e\u0720\u0005\u0087\u0000\u0000\u071f\u071e\u0001"+ - "\u0000\u0000\u0000\u071f\u0720\u0001\u0000\u0000\u0000\u0720\u0721\u0001"+ - "\u0000\u0000\u0000\u0721\u0722\u0003\u012c\u0096\u0000\u0722\u0165\u0001"+ - "\u0000\u0000\u0000\u0723\u0724\u0005j\u0000\u0000\u0724\u0725\u0003\u00a4"+ - "R\u0000\u0725\u0726\u0005k\u0000\u0000\u0726\u0167\u0001\u0000\u0000\u0000"+ - "\u0727\u0728\u0005p\u0000\u0000\u0728\u0729\u0005f\u0000\u0000\u0729\u072a"+ - "\u0003\u00c2a\u0000\u072a\u072b\u0005g\u0000\u0000\u072b\u0169\u0001\u0000"+ - "\u0000\u0000\u072c\u073b\u0005f\u0000\u0000\u072d\u0734\u0003\u00e6s\u0000"+ - "\u072e\u0731\u0003\u0146\u00a3\u0000\u072f\u0730\u0005m\u0000\u0000\u0730"+ - "\u0732\u0003\u00e6s\u0000\u0731\u072f\u0001\u0000\u0000\u0000\u0731\u0732"+ - "\u0001\u0000\u0000\u0000\u0732\u0734\u0001\u0000\u0000\u0000\u0733\u072d"+ - "\u0001\u0000\u0000\u0000\u0733\u072e\u0001\u0000\u0000\u0000\u0734\u0736"+ - "\u0001\u0000\u0000\u0000\u0735\u0737\u0005t\u0000\u0000\u0736\u0735\u0001"+ - "\u0000\u0000\u0000\u0736\u0737\u0001\u0000\u0000\u0000\u0737\u0739\u0001"+ - "\u0000\u0000\u0000\u0738\u073a\u0005m\u0000\u0000\u0739\u0738\u0001\u0000"+ - "\u0000\u0000\u0739\u073a\u0001\u0000\u0000\u0000\u073a\u073c\u0001\u0000"+ - "\u0000\u0000\u073b\u0733\u0001\u0000\u0000\u0000\u073b\u073c\u0001\u0000"+ - "\u0000\u0000\u073c\u073d\u0001\u0000\u0000\u0000\u073d\u073e\u0005g\u0000"+ - "\u0000\u073e\u016b\u0001\u0000\u0000\u0000\u073f\u0740\u0003\u0146\u00a3"+ - "\u0000\u0740\u0741\u0005p\u0000\u0000\u0741\u0742\u0005e\u0000\u0000\u0742"+ - "\u016d\u0001\u0000\u0000\u0000\u0743\u0744\u0003\u00c2a\u0000\u0744\u016f"+ - "\u0001\u0000\u0000\u0000\u0745\u074a\u0005n\u0000\u0000\u0746\u074a\u0005"+ - "\u0000\u0000\u0001\u0747\u074a\u0005\u009f\u0000\u0000\u0748\u074a\u0004"+ - "\u00b8\u0013\u0000\u0749\u0745\u0001\u0000\u0000\u0000\u0749\u0746\u0001"+ - "\u0000\u0000\u0000\u0749\u0747\u0001\u0000\u0000\u0000\u0749\u0748\u0001"+ - "\u0000\u0000\u0000\u074a\u0171\u0001\u0000\u0000\u0000\u00c1\u0180\u0185"+ - "\u018c\u0196\u019c\u01a2\u01ac\u01b6\u01c4\u01c8\u01d1\u01dd\u01e1\u01e7"+ - "\u01f0\u01fa\u020b\u0219\u021d\u0224\u022c\u0235\u0255\u025d\u0275\u0288"+ - "\u0297\u02a4\u02ad\u02bb\u02c4\u02d0\u02e5\u02ec\u02f1\u02f6\u0300\u0303"+ - "\u0307\u030b\u0313\u031b\u0320\u0328\u032a\u032f\u0336\u033e\u0341\u0347"+ - "\u034c\u034e\u0351\u0358\u035d\u0370\u0378\u037c\u037f\u0385\u0389\u038c"+ - "\u0396\u039d\u03a4\u03b0\u03b6\u03bd\u03c2\u03c8\u03d4\u03da\u03de\u03e6"+ - "\u03ea\u03f0\u03f3\u03f9\u03fe\u0417\u043a\u043c\u0453\u045b\u0466\u046d"+ - "\u0474\u047e\u048c\u04a2\u04a4\u04ac\u04b0\u04b4\u04b7\u04c0\u04c6\u04d0"+ - "\u04d8\u04de\u04e7\u04f2\u04fd\u0501\u0503\u050e\u0517\u051b\u051e\u0525"+ - "\u0530\u053a\u0540\u0542\u054c\u0556\u055a\u055e\u0562\u0569\u0571\u057c"+ - "\u0580\u0584\u0590\u0594\u0598\u059d\u05a0\u05a3\u05aa\u05b1\u05c5\u05c9"+ - "\u05cd\u05d1\u05e1\u05e7\u05e9\u05ed\u05f1\u05f4\u05f8\u05fa\u0600\u0608"+ - "\u060d\u0618\u061e\u0625\u0630\u0635\u0639\u063e\u0642\u064a\u0652\u0657"+ - "\u065a\u0662\u0668\u066c\u066e\u0673\u0677\u067b\u0682\u069f\u06aa\u06ae"+ - "\u06b6\u06ba\u06bc\u06c4\u06cd\u06d5\u06da\u06ea\u06ec\u06f5\u06fb\u0701"+ - "\u0705\u070e\u0717\u071a\u071f\u0731\u0733\u0736\u0739\u073b\u0749"; + "\u0000\u01c6\u01c7\u0001\u0000\u0000\u0000\u01c7\u01ca\u0001\u0000\u0000"+ + "\u0000\u01c8\u01c6\u0001\u0000\u0000\u0000\u01c9\u01cb\u0007\u0000\u0000"+ + "\u0000\u01ca\u01c9\u0001\u0000\u0000\u0000\u01ca\u01cb\u0001\u0000\u0000"+ + "\u0000\u01cb\u01cc\u0001\u0000\u0000\u0000\u01cc\u01cd\u0003\u00deo\u0000"+ + "\u01cd\u0013\u0001\u0000\u0000\u0000\u01ce\u01cf\u0003\u0010\b\u0000\u01cf"+ + "\u01d0\u0003\u0172\u00b9\u0000\u01d0\u01d2\u0001\u0000\u0000\u0000\u01d1"+ + "\u01ce\u0001\u0000\u0000\u0000\u01d2\u01d5\u0001\u0000\u0000\u0000\u01d3"+ + "\u01d1\u0001\u0000\u0000\u0000\u01d3\u01d4\u0001\u0000\u0000\u0000\u01d4"+ + "\u01e3\u0001\u0000\u0000\u0000\u01d5\u01d3\u0001\u0000\u0000\u0000\u01d6"+ + "\u01d7\u0005a\u0000\u0000\u01d7\u01e4\u0003\u0012\t\u0000\u01d8\u01d9"+ + "\u0005a\u0000\u0000\u01d9\u01df\u0005f\u0000\u0000\u01da\u01db\u0003\u0012"+ + "\t\u0000\u01db\u01dc\u0003\u0172\u00b9\u0000\u01dc\u01de\u0001\u0000\u0000"+ + "\u0000\u01dd\u01da\u0001\u0000\u0000\u0000\u01de\u01e1\u0001\u0000\u0000"+ + "\u0000\u01df\u01dd\u0001\u0000\u0000\u0000\u01df\u01e0\u0001\u0000\u0000"+ + "\u0000\u01e0\u01e2\u0001\u0000\u0000\u0000\u01e1\u01df\u0001\u0000\u0000"+ + "\u0000\u01e2\u01e4\u0005g\u0000\u0000\u01e3\u01d6\u0001\u0000\u0000\u0000"+ + "\u01e3\u01d8\u0001\u0000\u0000\u0000\u01e4\u0015\u0001\u0000\u0000\u0000"+ + "\u01e5\u01ea\u0003|>\u0000\u01e6\u01ea\u0003\u0092I\u0000\u01e7\u01ea"+ + "\u0003\u0096K\u0000\u01e8\u01ea\u0003\u0090H\u0000\u01e9\u01e5\u0001\u0000"+ + "\u0000\u0000\u01e9\u01e6\u0001\u0000\u0000\u0000\u01e9\u01e7\u0001\u0000"+ + "\u0000\u0000\u01e9\u01e8\u0001\u0000\u0000\u0000\u01ea\u0017\u0001\u0000"+ + "\u0000\u0000\u01eb\u01ec\u0005\u001b\u0000\u0000\u01ec\u01f3\u0003\u00a8"+ + "T\u0000\u01ed\u01ee\u0007\u0001\u0000\u0000\u01ee\u01f3\u0003.\u0017\u0000"+ + "\u01ef\u01f0\u0007\u0002\u0000\u0000\u01f0\u01f3\u0003\u00a6S\u0000\u01f1"+ + "\u01f3\u0003h4\u0000\u01f2\u01eb\u0001\u0000\u0000\u0000\u01f2\u01ed\u0001"+ + "\u0000\u0000\u0000\u01f2\u01ef\u0001\u0000\u0000\u0000\u01f2\u01f1\u0001"+ + "\u0000\u0000\u0000\u01f3\u0019\u0001\u0000\u0000\u0000\u01f4\u01f5\u0003"+ + "\u001c\u000e\u0000\u01f5\u001b\u0001\u0000\u0000\u0000\u01f6\u01f7\u0003"+ + "`0\u0000\u01f7\u01f8\u0003\u001e\u000f\u0000\u01f8\u001d\u0001\u0000\u0000"+ + "\u0000\u01f9\u01fa\u0005D\u0000\u0000\u01fa\u01fc\u0005f\u0000\u0000\u01fb"+ + "\u01fd\u0003\u00f2y\u0000\u01fc\u01fb\u0001\u0000\u0000\u0000\u01fc\u01fd"+ + "\u0001\u0000\u0000\u0000\u01fd\u01fe\u0001\u0000\u0000\u0000\u01fe\u01ff"+ + "\u0005g\u0000\u0000\u01ff\u001f\u0001\u0000\u0000\u0000\u0200\u020e\u0003"+ + "F#\u0000\u0201\u020e\u0003D\"\u0000\u0202\u020e\u0003B!\u0000\u0203\u020e"+ + "\u0003$\u0012\u0000\u0204\u020e\u0003@ \u0000\u0205\u020e\u00038\u001c"+ + "\u0000\u0206\u020e\u0003>\u001f\u0000\u0207\u020e\u00036\u001b\u0000\u0208"+ + "\u020e\u00032\u0019\u0000\u0209\u020e\u00030\u0018\u0000\u020a\u020e\u0003"+ + "4\u001a\u0000\u020b\u020e\u0003\"\u0011\u0000\u020c\u020e\u0003H$\u0000"+ + "\u020d\u0200\u0001\u0000\u0000\u0000\u020d\u0201\u0001\u0000\u0000\u0000"+ + "\u020d\u0202\u0001\u0000\u0000\u0000\u020d\u0203\u0001\u0000\u0000\u0000"+ + "\u020d\u0204\u0001\u0000\u0000\u0000\u020d\u0205\u0001\u0000\u0000\u0000"+ + "\u020d\u0206\u0001\u0000\u0000\u0000\u020d\u0207\u0001\u0000\u0000\u0000"+ + "\u020d\u0208\u0001\u0000\u0000\u0000\u020d\u0209\u0001\u0000\u0000\u0000"+ + "\u020d\u020a\u0001\u0000\u0000\u0000\u020d\u020b\u0001\u0000\u0000\u0000"+ + "\u020d\u020c\u0001\u0000\u0000\u0000\u020e!\u0001\u0000\u0000\u0000\u020f"+ + "\u0210\u0007\u0003\u0000\u0000\u0210#\u0001\u0000\u0000\u0000\u0211\u0212"+ + "\u0005^\u0000\u0000\u0212\u0213\u0005j\u0000\u0000\u0213\u0214\u0003\u00c4"+ + "b\u0000\u0214\u0215\u0005k\u0000\u0000\u0215%\u0001\u0000\u0000\u0000"+ + "\u0216\u021b\u0003(\u0014\u0000\u0217\u0218\u0005m\u0000\u0000\u0218\u021a"+ + "\u0003(\u0014\u0000\u0219\u0217\u0001\u0000\u0000\u0000\u021a\u021d\u0001"+ + "\u0000\u0000\u0000\u021b\u0219\u0001\u0000\u0000\u0000\u021b\u021c\u0001"+ + "\u0000\u0000\u0000\u021c\u021f\u0001\u0000\u0000\u0000\u021d\u021b\u0001"+ + "\u0000\u0000\u0000\u021e\u0220\u0005m\u0000\u0000\u021f\u021e\u0001\u0000"+ + "\u0000\u0000\u021f\u0220\u0001\u0000\u0000\u0000\u0220\'\u0001\u0000\u0000"+ + "\u0000\u0221\u0226\u0005e\u0000\u0000\u0222\u0223\u0005m\u0000\u0000\u0223"+ + "\u0225\u0005e\u0000\u0000\u0224\u0222\u0001\u0000\u0000\u0000\u0225\u0228"+ + "\u0001\u0000\u0000\u0000\u0226\u0224\u0001\u0000\u0000\u0000\u0226\u0227"+ + "\u0001\u0000\u0000\u0000\u0227\u0229\u0001\u0000\u0000\u0000\u0228\u0226"+ + "\u0001\u0000\u0000\u0000\u0229\u022a\u0003\u0134\u009a\u0000\u022a)\u0001"+ + "\u0000\u0000\u0000\u022b\u022d\u0003,\u0016\u0000\u022c\u022b\u0001\u0000"+ + "\u0000\u0000\u022d\u0230\u0001\u0000\u0000\u0000\u022e\u022c\u0001\u0000"+ + "\u0000\u0000\u022e\u022f\u0001\u0000\u0000\u0000\u022f+\u0001\u0000\u0000"+ + "\u0000\u0230\u022e\u0001\u0000\u0000\u0000\u0231\u0232\u0005h\u0000\u0000"+ + "\u0232\u0237\u0003\u00a6S\u0000\u0233\u0234\u0005m\u0000\u0000\u0234\u0236"+ + "\u0003\u00a6S\u0000\u0235\u0233\u0001\u0000\u0000\u0000\u0236\u0239\u0001"+ + "\u0000\u0000\u0000\u0237\u0235\u0001\u0000\u0000\u0000\u0237\u0238\u0001"+ + "\u0000\u0000\u0000\u0238\u023a\u0001\u0000\u0000\u0000\u0239\u0237\u0001"+ + "\u0000\u0000\u0000\u023a\u023b\u0005i\u0000\u0000\u023b-\u0001\u0000\u0000"+ + "\u0000\u023c\u023d\u0003\u00b6[\u0000\u023d/\u0001\u0000\u0000\u0000\u023e"+ + "\u023f\u00051\u0000\u0000\u023f\u0240\u0005f\u0000\u0000\u0240\u0241\u0003"+ + "\u00a6S\u0000\u0241\u0242\u0005g\u0000\u0000\u02421\u0001\u0000\u0000"+ + "\u0000\u0243\u0244\u00057\u0000\u0000\u0244\u0245\u0005j\u0000\u0000\u0245"+ + "\u0246\u0003\u00c4b\u0000\u0246\u0247\u0005k\u0000\u0000\u02473\u0001"+ + "\u0000\u0000\u0000\u0248\u0249\u00052\u0000\u0000\u0249\u024a\u0005f\u0000"+ + "\u0000\u024a\u024b\u0003\u00a6S\u0000\u024b\u024c\u0005g\u0000\u0000\u024c"+ + "5\u0001\u0000\u0000\u0000\u024d\u024e\u0007\u0004\u0000\u0000\u024e\u024f"+ + "\u0005f\u0000\u0000\u024f\u0250\u0003\u00a6S\u0000\u0250\u0251\u0005g"+ + "\u0000\u0000\u02517\u0001\u0000\u0000\u0000\u0252\u0257\u0005\u0011\u0000"+ + "\u0000\u0253\u0254\u0005j\u0000\u0000\u0254\u0255\u0003:\u001d\u0000\u0255"+ + "\u0256\u0005k\u0000\u0000\u0256\u0258\u0001\u0000\u0000\u0000\u0257\u0253"+ + "\u0001\u0000\u0000\u0000\u0257\u0258\u0001\u0000\u0000\u0000\u0258\u0259"+ + "\u0001\u0000\u0000\u0000\u0259\u025a\u0005f\u0000\u0000\u025a\u025b\u0003"+ + "\u00a6S\u0000\u025b\u025c\u0005g\u0000\u0000\u025c9\u0001\u0000\u0000"+ + "\u0000\u025d\u0260\u0003<\u001e\u0000\u025e\u0260\u0005\u0013\u0000\u0000"+ + "\u025f\u025d\u0001\u0000\u0000\u0000\u025f\u025e\u0001\u0000\u0000\u0000"+ + "\u0260;\u0001\u0000\u0000\u0000\u0261\u0262\u0005e\u0000\u0000\u0262="+ + "\u0001\u0000\u0000\u0000\u0263\u0264\u0005\u0012\u0000\u0000\u0264\u0265"+ + "\u0005f\u0000\u0000\u0265\u0266\u0003\u00a6S\u0000\u0266\u0267\u0005g"+ + "\u0000\u0000\u0267?\u0001\u0000\u0000\u0000\u0268\u0269\u0005:\u0000\u0000"+ + "\u0269\u026a\u0005f\u0000\u0000\u026a\u026b\u0003\u00a6S\u0000\u026b\u026c"+ + "\u0005g\u0000\u0000\u026cA\u0001\u0000\u0000\u0000\u026d\u026e\u00059"+ + "\u0000\u0000\u026e\u026f\u0005f\u0000\u0000\u026f\u0270\u0003\u00a6S\u0000"+ + "\u0270\u0271\u0005g\u0000\u0000\u0271C\u0001\u0000\u0000\u0000\u0272\u0273"+ + "\u0005\u0016\u0000\u0000\u0273\u0274\u0005f\u0000\u0000\u0274\u0277\u0003"+ + "\u00a6S\u0000\u0275\u0276\u0005m\u0000\u0000\u0276\u0278\u0003\u00a6S"+ + "\u0000\u0277\u0275\u0001\u0000\u0000\u0000\u0277\u0278\u0001\u0000\u0000"+ + "\u0000\u0278\u0279\u0001\u0000\u0000\u0000\u0279\u027a\u0005g\u0000\u0000"+ + "\u027aE\u0001\u0000\u0000\u0000\u027b\u027c\u0007\u0004\u0000\u0000\u027c"+ + "\u027d\u0005j\u0000\u0000\u027d\u027e\u0003\u00a6S\u0000\u027e\u027f\u0005"+ + "=\u0000\u0000\u027f\u0280\u0003\u00a6S\u0000\u0280\u0281\u0005k\u0000"+ + "\u0000\u0281G\u0001\u0000\u0000\u0000\u0282\u0283\u00056\u0000\u0000\u0283"+ + "\u0284\u0003\u00a6S\u0000\u0284\u028a\u0005h\u0000\u0000\u0285\u0286\u0003"+ + "J%\u0000\u0286\u0287\u0003\u0172\u00b9\u0000\u0287\u0289\u0001\u0000\u0000"+ + "\u0000\u0288\u0285\u0001\u0000\u0000\u0000\u0289\u028c\u0001\u0000\u0000"+ + "\u0000\u028a\u0288\u0001\u0000\u0000\u0000\u028a\u028b\u0001\u0000\u0000"+ + "\u0000\u028b\u028d\u0001\u0000\u0000\u0000\u028c\u028a\u0001\u0000\u0000"+ + "\u0000\u028d\u028e\u0005i\u0000\u0000\u028eI\u0001\u0000\u0000\u0000\u028f"+ + "\u0290\u0003l6\u0000\u0290\u0291\u0005o\u0000\u0000\u0291\u0292\u0003"+ + "\u00a6S\u0000\u0292K\u0001\u0000\u0000\u0000\u0293\u0294\u0005j\u0000"+ + "\u0000\u0294\u0299\u0003N\'\u0000\u0295\u0296\u0005m\u0000\u0000\u0296"+ + "\u0298\u0003N\'\u0000\u0297\u0295\u0001\u0000\u0000\u0000\u0298\u029b"+ + "\u0001\u0000\u0000\u0000\u0299\u0297\u0001\u0000\u0000\u0000\u0299\u029a"+ + "\u0001\u0000\u0000\u0000\u029a\u029c\u0001\u0000\u0000\u0000\u029b\u0299"+ + "\u0001\u0000\u0000\u0000\u029c\u029d\u0005k\u0000\u0000\u029dM\u0001\u0000"+ + "\u0000\u0000\u029e\u029f\u0003\u00a6S\u0000\u029f\u02a0\u0005l\u0000\u0000"+ + "\u02a0\u02a1\u0003\u00a6S\u0000\u02a1O\u0001\u0000\u0000\u0000\u02a2\u02a7"+ + "\u0003^/\u0000\u02a3\u02a7\u0003\\.\u0000\u02a4\u02a7\u0003R)\u0000\u02a5"+ + "\u02a7\u0003V+\u0000\u02a6\u02a2\u0001\u0000\u0000\u0000\u02a6\u02a3\u0001"+ + "\u0000\u0000\u0000\u02a6\u02a4\u0001\u0000\u0000\u0000\u02a6\u02a5\u0001"+ + "\u0000\u0000\u0000\u02a7Q\u0001\u0000\u0000\u0000\u02a8\u02a9\u00053\u0000"+ + "\u0000\u02a9\u02af\u0005h\u0000\u0000\u02aa\u02ab\u0003T*\u0000\u02ab"+ + "\u02ac\u0003\u0172\u00b9\u0000\u02ac\u02ae\u0001\u0000\u0000\u0000\u02ad"+ + "\u02aa\u0001\u0000\u0000\u0000\u02ae\u02b1\u0001\u0000\u0000\u0000\u02af"+ + "\u02ad\u0001\u0000\u0000\u0000\u02af\u02b0\u0001\u0000\u0000\u0000\u02b0"+ + "\u02b2\u0001\u0000\u0000\u0000\u02b1\u02af\u0001\u0000\u0000\u0000\u02b2"+ + "\u02b3\u0005i\u0000\u0000\u02b3S\u0001\u0000\u0000\u0000\u02b4\u02b5\u0005"+ + "M\u0000\u0000\u02b5\u02b6\u0005e\u0000\u0000\u02b6\u02be\u0003\u0140\u00a0"+ + "\u0000\u02b7\u02b8\u00054\u0000\u0000\u02b8\u02b9\u0005h\u0000\u0000\u02b9"+ + "\u02ba\u0003\u00a6S\u0000\u02ba\u02bb\u0003\u0172\u00b9\u0000\u02bb\u02bc"+ + "\u0005i\u0000\u0000\u02bc\u02be\u0001\u0000\u0000\u0000\u02bd\u02b4\u0001"+ + "\u0000\u0000\u0000\u02bd\u02b7\u0001\u0000\u0000\u0000\u02beU\u0001\u0000"+ + "\u0000\u0000\u02bf\u02c0\u00055\u0000\u0000\u02c0\u02c6\u0005h\u0000\u0000"+ + "\u02c1\u02c2\u0003X,\u0000\u02c2\u02c3\u0003\u0172\u00b9\u0000\u02c3\u02c5"+ + "\u0001\u0000\u0000\u0000\u02c4\u02c1\u0001\u0000\u0000\u0000\u02c5\u02c8"+ + "\u0001\u0000\u0000\u0000\u02c6\u02c4\u0001\u0000\u0000\u0000\u02c6\u02c7"+ + "\u0001\u0000\u0000\u0000\u02c7\u02c9\u0001\u0000\u0000\u0000\u02c8\u02c6"+ + "\u0001\u0000\u0000\u0000\u02c9\u02ca\u0005i\u0000\u0000\u02caW\u0001\u0000"+ + "\u0000\u0000\u02cb\u02cc\u0005e\u0000\u0000\u02cc\u02d2\u0005h\u0000\u0000"+ + "\u02cd\u02ce\u0003Z-\u0000\u02ce\u02cf\u0003\u0172\u00b9\u0000\u02cf\u02d1"+ + "\u0001\u0000\u0000\u0000\u02d0\u02cd\u0001\u0000\u0000\u0000\u02d1\u02d4"+ + "\u0001\u0000\u0000\u0000\u02d2\u02d0\u0001\u0000\u0000\u0000\u02d2\u02d3"+ + "\u0001\u0000\u0000\u0000\u02d3\u02d5\u0001\u0000\u0000\u0000\u02d4\u02d2"+ + "\u0001\u0000\u0000\u0000\u02d5\u02d6\u0005i\u0000\u0000\u02d6Y\u0001\u0000"+ + "\u0000\u0000\u02d7\u02d9\u0003\u00e6s\u0000\u02d8\u02d7\u0001\u0000\u0000"+ + "\u0000\u02d8\u02d9\u0001\u0000\u0000\u0000\u02d9\u02da\u0001\u0000\u0000"+ + "\u0000\u02da\u02db\u0003\u00c4b\u0000\u02db[\u0001\u0000\u0000\u0000\u02dc"+ + "\u02dd\u0005\u001b\u0000\u0000\u02dd\u02de\u0005j\u0000\u0000\u02de\u02df"+ + "\u0005k\u0000\u0000\u02df\u02e0\u0003\u0134\u009a\u0000\u02e0]\u0001\u0000"+ + "\u0000\u0000\u02e1\u02e2\u0007\u0005\u0000\u0000\u02e2\u02e3\u0005j\u0000"+ + "\u0000\u02e3\u02e4\u0003\u00c4b\u0000\u02e4\u02e5\u0005k\u0000\u0000\u02e5"+ + "\u02ed\u0001\u0000\u0000\u0000\u02e6\u02e7\u0005+\u0000\u0000\u02e7\u02e8"+ + "\u0005j\u0000\u0000\u02e8\u02e9\u0003\u00c4b\u0000\u02e9\u02ea\u0005k"+ + "\u0000\u0000\u02ea\u02eb\u0003\u00c4b\u0000\u02eb\u02ed\u0001\u0000\u0000"+ + "\u0000\u02ec\u02e1\u0001\u0000\u0000\u0000\u02ec\u02e6\u0001\u0000\u0000"+ + "\u0000\u02ed_\u0001\u0000\u0000\u0000\u02ee\u02f4\u0003b1\u0000\u02ef"+ + "\u02f0\u0005\u000e\u0000\u0000\u02f0\u02f4\u00060\uffff\uffff\u0000\u02f1"+ + "\u02f2\u0005C\u0000\u0000\u02f2\u02f4\u00060\uffff\uffff\u0000\u02f3\u02ee"+ + "\u0001\u0000\u0000\u0000\u02f3\u02ef\u0001\u0000\u0000\u0000\u02f3\u02f1"+ + "\u0001\u0000\u0000\u0000\u02f4\u02f5\u0001\u0000\u0000\u0000\u02f5\u02f7"+ + "\u0003\u0172\u00b9\u0000\u02f6\u02f3\u0001\u0000\u0000\u0000\u02f7\u02fa"+ + "\u0001\u0000\u0000\u0000\u02f8\u02f9\u0001\u0000\u0000\u0000\u02f8\u02f6"+ + "\u0001\u0000\u0000\u0000\u02f9\u02fd\u0001\u0000\u0000\u0000\u02fa\u02f8"+ + "\u0001\u0000\u0000\u0000\u02fb\u02fc\u0005\u000e\u0000\u0000\u02fc\u02fe"+ + "\u00060\uffff\uffff\u0000\u02fd\u02fb\u0001\u0000\u0000\u0000\u02fd\u02fe"+ + "\u0001\u0000\u0000\u0000\u02fea\u0001\u0000\u0000\u0000\u02ff\u0300\u0005"+ + "\t\u0000\u0000\u0300\u0308\u0003f3\u0000\u0301\u0302\u0005\n\u0000\u0000"+ + "\u0302\u0308\u0003f3\u0000\u0303\u0304\u0005\u000b\u0000\u0000\u0304\u0308"+ + "\u0003f3\u0000\u0305\u0306\u0005\r\u0000\u0000\u0306\u0308\u0003d2\u0000"+ + "\u0307\u02ff\u0001\u0000\u0000\u0000\u0307\u0301\u0001\u0000\u0000\u0000"+ + "\u0307\u0303\u0001\u0000\u0000\u0000\u0307\u0305\u0001\u0000\u0000\u0000"+ + "\u0308c\u0001\u0000\u0000\u0000\u0309\u030b\u0003\u00e8t\u0000\u030a\u0309"+ + "\u0001\u0000\u0000\u0000\u030a\u030b\u0001\u0000\u0000\u0000\u030b\u030e"+ + "\u0001\u0000\u0000\u0000\u030c\u030d\u0005\\\u0000\u0000\u030d\u030f\u0003"+ + "\u00a6S\u0000\u030e\u030c\u0001\u0000\u0000\u0000\u030e\u030f\u0001\u0000"+ + "\u0000\u0000\u030fe\u0001\u0000\u0000\u0000\u0310\u0313\u0001\u0000\u0000"+ + "\u0000\u0311\u0313\u0003\u00a6S\u0000\u0312\u0310\u0001\u0000\u0000\u0000"+ + "\u0312\u0311\u0001\u0000\u0000\u0000\u0313g\u0001\u0000\u0000\u0000\u0314"+ + "\u0315\u00056\u0000\u0000\u0315\u0316\u0003\u00a6S\u0000\u0316\u031a\u0005"+ + "h\u0000\u0000\u0317\u0319\u0003j5\u0000\u0318\u0317\u0001\u0000\u0000"+ + "\u0000\u0319\u031c\u0001\u0000\u0000\u0000\u031a\u0318\u0001\u0000\u0000"+ + "\u0000\u031a\u031b\u0001\u0000\u0000\u0000\u031b\u031d\u0001\u0000\u0000"+ + "\u0000\u031c\u031a\u0001\u0000\u0000\u0000\u031d\u031e\u0005i\u0000\u0000"+ + "\u031ei\u0001\u0000\u0000\u0000\u031f\u0320\u0003l6\u0000\u0320\u0322"+ + "\u0005o\u0000\u0000\u0321\u0323\u0003\u00f2y\u0000\u0322\u0321\u0001\u0000"+ + "\u0000\u0000\u0322\u0323\u0001\u0000\u0000\u0000\u0323k\u0001\u0000\u0000"+ + "\u0000\u0324\u0325\u0005P\u0000\u0000\u0325\u0328\u0003n7\u0000\u0326"+ + "\u0328\u0005L\u0000\u0000\u0327\u0324\u0001\u0000\u0000\u0000\u0327\u0326"+ + "\u0001\u0000\u0000\u0000\u0328m\u0001\u0000\u0000\u0000\u0329\u032a\u0005"+ + "%\u0000\u0000\u032a\u0337\u0005e\u0000\u0000\u032b\u032c\u0003\u00ccf"+ + "\u0000\u032c\u0331\u0005h\u0000\u0000\u032d\u032f\u0003p8\u0000\u032e"+ + "\u0330\u0005m\u0000\u0000\u032f\u032e\u0001\u0000\u0000\u0000\u032f\u0330"+ + "\u0001\u0000\u0000\u0000\u0330\u0332\u0001\u0000\u0000\u0000\u0331\u032d"+ + "\u0001\u0000\u0000\u0000\u0331\u0332\u0001\u0000\u0000\u0000\u0332\u0333"+ + "\u0001\u0000\u0000\u0000\u0333\u0334\u0005i\u0000\u0000\u0334\u0337\u0001"+ + "\u0000\u0000\u0000\u0335\u0337\u0003\u00a6S\u0000\u0336\u0329\u0001\u0000"+ + "\u0000\u0000\u0336\u032b\u0001\u0000\u0000\u0000\u0336\u0335\u0001\u0000"+ + "\u0000\u0000\u0337o\u0001\u0000\u0000\u0000\u0338\u033d\u0003n7\u0000"+ + "\u0339\u033a\u0005m\u0000\u0000\u033a\u033c\u0003n7\u0000\u033b\u0339"+ + "\u0001\u0000\u0000\u0000\u033c\u033f\u0001\u0000\u0000\u0000\u033d\u033b"+ + "\u0001\u0000\u0000\u0000\u033d\u033e\u0001\u0000\u0000\u0000\u033eq\u0001"+ + "\u0000\u0000\u0000\u033f\u033d\u0001\u0000\u0000\u0000\u0340\u0345\u0005"+ + "h\u0000\u0000\u0341\u0342\u0005;\u0000\u0000\u0342\u0343\u0003\u00e6s"+ + "\u0000\u0343\u0344\u0003\u0172\u00b9\u0000\u0344\u0346\u0001\u0000\u0000"+ + "\u0000\u0345\u0341\u0001\u0000\u0000\u0000\u0345\u0346\u0001\u0000\u0000"+ + "\u0000\u0346\u0348\u0001\u0000\u0000\u0000\u0347\u0349\u0003\u00f2y\u0000"+ + "\u0348\u0347\u0001\u0000\u0000\u0000\u0348\u0349\u0001\u0000\u0000\u0000"+ + "\u0349\u034a\u0001\u0000\u0000\u0000\u034a\u034b\u0005i\u0000\u0000\u034b"+ + "s\u0001\u0000\u0000\u0000\u034c\u034f\u0003\u0152\u00a9\u0000\u034d\u034f"+ + "\u0005e\u0000\u0000\u034e\u034c\u0001\u0000\u0000\u0000\u034e\u034d\u0001"+ + "\u0000\u0000\u0000\u034f\u0358\u0001\u0000\u0000\u0000\u0350\u0355\u0005"+ + "h\u0000\u0000\u0351\u0353\u0003v;\u0000\u0352\u0354\u0005m\u0000\u0000"+ + "\u0353\u0352\u0001\u0000\u0000\u0000\u0353\u0354\u0001\u0000\u0000\u0000"+ + "\u0354\u0356\u0001\u0000\u0000\u0000\u0355\u0351\u0001\u0000\u0000\u0000"+ + "\u0355\u0356\u0001\u0000\u0000\u0000\u0356\u0357\u0001\u0000\u0000\u0000"+ + "\u0357\u0359\u0005i\u0000\u0000\u0358\u0350\u0001\u0000\u0000\u0000\u0358"+ + "\u0359\u0001\u0000\u0000\u0000\u0359u\u0001\u0000\u0000\u0000\u035a\u035f"+ + "\u0003x<\u0000\u035b\u035c\u0005m\u0000\u0000\u035c\u035e\u0003x<\u0000"+ + "\u035d\u035b\u0001\u0000\u0000\u0000\u035e\u0361\u0001\u0000\u0000\u0000"+ + "\u035f\u035d\u0001\u0000\u0000\u0000\u035f\u0360\u0001\u0000\u0000\u0000"+ + "\u0360w\u0001\u0000\u0000\u0000\u0361\u035f\u0001\u0000\u0000\u0000\u0362"+ + "\u0363\u0005e\u0000\u0000\u0363\u0365\u0005o\u0000\u0000\u0364\u0362\u0001"+ + "\u0000\u0000\u0000\u0364\u0365\u0001\u0000\u0000\u0000\u0365\u0366\u0001"+ + "\u0000\u0000\u0000\u0366\u0367\u0003\u00a6S\u0000\u0367y\u0001\u0000\u0000"+ + "\u0000\u0368\u0369\u0005G\u0000\u0000\u0369\u036a\u0003\u00a6S\u0000\u036a"+ + "\u036b\u0005\u000f\u0000\u0000\u036b\u036c\u0003t:\u0000\u036c\u036d\u0003"+ + "\u00f0x\u0000\u036d{\u0001\u0000\u0000\u0000\u036e\u036f\u0003\u00c4b"+ + "\u0000\u036f\u0370\u0005\u000f\u0000\u0000\u0370\u0383\u0003\u00c4b\u0000"+ + "\u0371\u0377\u0005h\u0000\u0000\u0372\u0373\u0003\u0084B\u0000\u0373\u0374"+ + "\u0003\u0172\u00b9\u0000\u0374\u0376\u0001\u0000\u0000\u0000\u0375\u0372"+ + "\u0001\u0000\u0000\u0000\u0376\u0379\u0001\u0000\u0000\u0000\u0377\u0375"+ + "\u0001\u0000\u0000\u0000\u0377\u0378\u0001\u0000\u0000\u0000\u0378\u037f"+ + "\u0001\u0000\u0000\u0000\u0379\u0377\u0001\u0000\u0000\u0000\u037a\u037b"+ + "\u0003~?\u0000\u037b\u037c\u0003\u0172\u00b9\u0000\u037c\u037e\u0001\u0000"+ + "\u0000\u0000\u037d\u037a\u0001\u0000\u0000\u0000\u037e\u0381\u0001\u0000"+ + "\u0000\u0000\u037f\u037d\u0001\u0000\u0000\u0000\u037f\u0380\u0001\u0000"+ + "\u0000\u0000\u0380\u0382\u0001\u0000\u0000\u0000\u0381\u037f\u0001\u0000"+ + "\u0000\u0000\u0382\u0384\u0005i\u0000\u0000\u0383\u0371\u0001\u0000\u0000"+ + "\u0000\u0383\u0384\u0001\u0000\u0000\u0000\u0384}\u0001\u0000\u0000\u0000"+ + "\u0385\u0387\u0005\u000e\u0000\u0000\u0386\u0385\u0001\u0000\u0000\u0000"+ + "\u0386\u0387\u0001\u0000\u0000\u0000\u0387\u0388\u0001\u0000\u0000\u0000"+ + "\u0388\u0389\u0003\u0080@\u0000\u0389\u038a\u0005e\u0000\u0000\u038a\u038c"+ + "\u0003\u0140\u00a0\u0000\u038b\u038d\u0003\u00f0x\u0000\u038c\u038b\u0001"+ + "\u0000\u0000\u0000\u038c\u038d\u0001\u0000\u0000\u0000\u038d\u007f\u0001"+ + "\u0000\u0000\u0000\u038e\u0390\u0005f\u0000\u0000\u038f\u0391\u0005e\u0000"+ + "\u0000\u0390\u038f\u0001\u0000\u0000\u0000\u0390\u0391\u0001\u0000\u0000"+ + "\u0000\u0391\u0393\u0001\u0000\u0000\u0000\u0392\u0394\u0005\u0087\u0000"+ + "\u0000\u0393\u0392\u0001\u0000\u0000\u0000\u0393\u0394\u0001\u0000\u0000"+ + "\u0000\u0394\u0395\u0001\u0000\u0000\u0000\u0395\u0396\u0003\u012e\u0097"+ + "\u0000\u0396\u0397\u0005g\u0000\u0000\u0397\u0081\u0001\u0000\u0000\u0000"+ + "\u0398\u039e\u0003\u00b6[\u0000\u0399\u039a\u0003\u00c4b\u0000\u039a\u039b"+ + "\u0005p\u0000\u0000\u039b\u039c\u0005e\u0000\u0000\u039c\u039e\u0001\u0000"+ + "\u0000\u0000\u039d\u0398\u0001\u0000\u0000\u0000\u039d\u0399\u0001\u0000"+ + "\u0000\u0000\u039e\u0083\u0001\u0000\u0000\u0000\u039f\u03a0\u00058\u0000"+ + "\u0000\u03a0\u03a1\u0005e\u0000\u0000\u03a1\u03a4\u0005s\u0000\u0000\u03a2"+ + "\u03a5\u0003\u0082A\u0000\u03a3\u03a5\u0003\u0150\u00a8\u0000\u03a4\u03a2"+ + "\u0001\u0000\u0000\u0000\u03a4\u03a3\u0001\u0000\u0000\u0000\u03a5\u0085"+ + "\u0001\u0000\u0000\u0000\u03a6\u03a7\u0005/\u0000\u0000\u03a7\u03a8\u0005"+ + "f\u0000\u0000\u03a8\u03ab\u0003\u00c4b\u0000\u03a9\u03aa\u0005m\u0000"+ + "\u0000\u03aa\u03ac\u0003\u00e8t\u0000\u03ab\u03a9\u0001\u0000\u0000\u0000"+ + "\u03ab\u03ac\u0001\u0000\u0000\u0000\u03ac\u03ad\u0001\u0000\u0000\u0000"+ + "\u03ad\u03ae\u0005g\u0000\u0000\u03ae\u0087\u0001\u0000\u0000\u0000\u03af"+ + "\u03b0\u0005.\u0000\u0000\u03b0\u03b1\u0005f\u0000\u0000\u03b1\u03b2\u0003"+ + "\u00c4b\u0000\u03b2\u03b3\u0005g\u0000\u0000\u03b3\u0089\u0001\u0000\u0000"+ + "\u0000\u03b4\u03b7\u0003`0\u0000\u03b5\u03b8\u0003\u008cF\u0000\u03b6"+ + "\u03b8\u0003\u008eG\u0000\u03b7\u03b5\u0001\u0000\u0000\u0000\u03b7\u03b6"+ + "\u0001\u0000\u0000\u0000\u03b8\u008b\u0001\u0000\u0000\u0000\u03b9\u03ba"+ + "\u0005M\u0000\u0000\u03ba\u03bb\u0005e\u0000\u0000\u03bb\u03bd\u0003\u0140"+ + "\u00a0\u0000\u03bc\u03be\u0003r9\u0000\u03bd\u03bc\u0001\u0000\u0000\u0000"+ + "\u03bd\u03be\u0001\u0000\u0000\u0000\u03be\u008d\u0001\u0000\u0000\u0000"+ + "\u03bf\u03c0\u0005M\u0000\u0000\u03c0\u03c1\u0003\u009cN\u0000\u03c1\u03c2"+ + "\u0005e\u0000\u0000\u03c2\u03c4\u0003\u0140\u00a0\u0000\u03c3\u03c5\u0003"+ + "r9\u0000\u03c4\u03c3\u0001\u0000\u0000\u0000\u03c4\u03c5\u0001\u0000\u0000"+ + "\u0000\u03c5\u008f\u0001\u0000\u0000\u0000\u03c6\u03c9\u0005\u001b\u0000"+ + "\u0000\u03c7\u03ca\u0003\u008aE\u0000\u03c8\u03ca\u0003\u00e0p\u0000\u03c9"+ + "\u03c7\u0001\u0000\u0000\u0000\u03c9\u03c8\u0001\u0000\u0000\u0000\u03ca"+ + "\u0091\u0001\u0000\u0000\u0000\u03cb\u03cc\u00058\u0000\u0000\u03cc\u03cd"+ + "\u0005e\u0000\u0000\u03cd\u03cf\u0003\u0144\u00a2\u0000\u03ce\u03d0\u0003"+ + "\u0094J\u0000\u03cf\u03ce\u0001\u0000\u0000\u0000\u03cf\u03d0\u0001\u0000"+ + "\u0000\u0000\u03d0\u0093\u0001\u0000\u0000\u0000\u03d1\u03d2\u0005h\u0000"+ + "\u0000\u03d2\u03d3\u0003\u00a6S\u0000\u03d3\u03d4\u0003\u0172\u00b9\u0000"+ + "\u03d4\u03d5\u0005i\u0000\u0000\u03d5\u0095\u0001\u0000\u0000\u0000\u03d6"+ + "\u03d7\u00058\u0000\u0000\u03d7\u03d8\u0003\u009cN\u0000\u03d8\u03d9\u0005"+ + "e\u0000\u0000\u03d9\u03db\u0003\u0144\u00a2\u0000\u03da\u03dc\u0003\u0094"+ + "J\u0000\u03db\u03da\u0001\u0000\u0000\u0000\u03db\u03dc\u0001\u0000\u0000"+ + "\u0000\u03dc\u0097\u0001\u0000\u0000\u0000\u03dd\u03e5\u0003\u0006\u0003"+ + "\u0000\u03de\u03e1\u0003\u00c4b\u0000\u03df\u03e0\u0005l\u0000\u0000\u03e0"+ + "\u03e2\u0003\u00e8t\u0000\u03e1\u03df\u0001\u0000\u0000\u0000\u03e1\u03e2"+ + "\u0001\u0000\u0000\u0000\u03e2\u03e6\u0001\u0000\u0000\u0000\u03e3\u03e4"+ + "\u0005l\u0000\u0000\u03e4\u03e6\u0003\u00e8t\u0000\u03e5\u03de\u0001\u0000"+ + "\u0000\u0000\u03e5\u03e3\u0001\u0000\u0000\u0000\u03e6\u0099\u0001\u0000"+ + "\u0000\u0000\u03e7\u03e8\u0003\u0006\u0003\u0000\u03e8\u03e9\u0005s\u0000"+ + "\u0000\u03e9\u03ea\u0003\u00e8t\u0000\u03ea\u009b\u0001\u0000\u0000\u0000"+ + "\u03eb\u03ed\u0005f\u0000\u0000\u03ec\u03ee\u0003\b\u0004\u0000\u03ed"+ + "\u03ec\u0001\u0000\u0000\u0000\u03ed\u03ee\u0001\u0000\u0000\u0000\u03ee"+ + "\u03ef\u0001\u0000\u0000\u0000\u03ef\u03f1\u0003\u00c4b\u0000\u03f0\u03f2"+ + "\u0005m\u0000\u0000\u03f1\u03f0\u0001\u0000\u0000\u0000\u03f1\u03f2\u0001"+ + "\u0000\u0000\u0000\u03f2\u03f3\u0001\u0000\u0000\u0000\u03f3\u03f4\u0005"+ + "g\u0000\u0000\u03f4\u009d\u0001\u0000\u0000\u0000\u03f5\u03f8\u0003\u00a0"+ + "P\u0000\u03f6\u03f8\u0003\u00a2Q\u0000\u03f7\u03f5\u0001\u0000\u0000\u0000"+ + "\u03f7\u03f6\u0001\u0000\u0000\u0000\u03f8\u009f\u0001\u0000\u0000\u0000"+ + "\u03f9\u03fb\u0003\u00e6s\u0000\u03fa\u03f9\u0001\u0000\u0000\u0000\u03fa"+ + "\u03fb\u0001\u0000\u0000\u0000\u03fb\u03fc\u0001\u0000\u0000\u0000\u03fc"+ + "\u03fd\u0003\u00a4R\u0000\u03fd\u00a1\u0001\u0000\u0000\u0000\u03fe\u0400"+ + "\u0005\u001b\u0000\u0000\u03ff\u0401\u0003\u00e6s\u0000\u0400\u03ff\u0001"+ + "\u0000\u0000\u0000\u0400\u0401\u0001\u0000\u0000\u0000\u0401\u0402\u0001"+ + "\u0000\u0000\u0000\u0402\u0403\u0003\u00a4R\u0000\u0403\u00a3\u0001\u0000"+ + "\u0000\u0000\u0404\u0406\u0005t\u0000\u0000\u0405\u0404\u0001\u0000\u0000"+ + "\u0000\u0405\u0406\u0001\u0000\u0000\u0000\u0406\u0407\u0001\u0000\u0000"+ + "\u0000\u0407\u0408\u0003\u00c4b\u0000\u0408\u00a5\u0001\u0000\u0000\u0000"+ + "\u0409\u040a\u0006S\uffff\uffff\u0000\u040a\u040b\u0007\u0006\u0000\u0000"+ + "\u040b\u041f\u0003\u00a6S\u000f\u040c\u041f\u0003\u00b6[\u0000\u040d\u040e"+ + "\u0005\u0019\u0000\u0000\u040e\u040f\u0003.\u0017\u0000\u040f\u0410\u0005"+ + "\u001c\u0000\u0000\u0410\u0411\u0003\u00a6S\u0003\u0411\u041f\u0001\u0000"+ + "\u0000\u0000\u0412\u0413\u0005\u001a\u0000\u0000\u0413\u0414\u0003\u009a"+ + "M\u0000\u0414\u0415\u0005\u001c\u0000\u0000\u0415\u0416\u0003\u00a6S\u0002"+ + "\u0416\u041f\u0001\u0000\u0000\u0000\u0417\u0418\u0007\u0007\u0000\u0000"+ + "\u0418\u0419\u0003&\u0013\u0000\u0419\u041a\u0005o\u0000\u0000\u041a\u041b"+ + "\u0005o\u0000\u0000\u041b\u041c\u0003*\u0015\u0000\u041c\u041d\u0003\u00a6"+ + "S\u0001\u041d\u041f\u0001\u0000\u0000\u0000\u041e\u0409\u0001\u0000\u0000"+ + "\u0000\u041e\u040c\u0001\u0000\u0000\u0000\u041e\u040d\u0001\u0000\u0000"+ + "\u0000\u041e\u0412\u0001\u0000\u0000\u0000\u041e\u0417\u0001\u0000\u0000"+ + "\u0000\u041f\u0443\u0001\u0000\u0000\u0000\u0420\u0421\n\r\u0000\u0000"+ + "\u0421\u0422\u0007\b\u0000\u0000\u0422\u0442\u0003\u00a6S\u000e\u0423"+ + "\u0424\n\f\u0000\u0000\u0424\u0425\u0007\t\u0000\u0000\u0425\u0442\u0003"+ + "\u00a6S\r\u0426\u0427\n\u000b\u0000\u0000\u0427\u0428\u0007\n\u0000\u0000"+ + "\u0428\u0442\u0003\u00a6S\f\u0429\u042a\n\n\u0000\u0000\u042a\u042b\u0007"+ + "\u000b\u0000\u0000\u042b\u0442\u0003\u00a6S\u000b\u042c\u042d\n\t\u0000"+ + "\u0000\u042d\u042e\u0007\f\u0000\u0000\u042e\u0442\u0003\u00a6S\n\u042f"+ + "\u0430\n\u0007\u0000\u0000\u0430\u0431\u0005v\u0000\u0000\u0431\u0442"+ + "\u0003\u00a6S\b\u0432\u0433\n\u0006\u0000\u0000\u0433\u0434\u0005u\u0000"+ + "\u0000\u0434\u0442\u0003\u00a6S\u0007\u0435\u0436\n\u0005\u0000\u0000"+ + "\u0436\u0437\u0005\"\u0000\u0000\u0437\u0442\u0003\u00a6S\u0005\u0438"+ + "\u0439\n\u0004\u0000\u0000\u0439\u043a\u0005%\u0000\u0000\u043a\u043b"+ + "\u0003\u00a6S\u0000\u043b\u043c\u0005o\u0000\u0000\u043c\u043d\u0003\u00a6"+ + "S\u0004\u043d\u0442\u0001\u0000\u0000\u0000\u043e\u043f\n\b\u0000\u0000"+ + "\u043f\u0440\u0005\u000f\u0000\u0000\u0440\u0442\u0003t:\u0000\u0441\u0420"+ + "\u0001\u0000\u0000\u0000\u0441\u0423\u0001\u0000\u0000\u0000\u0441\u0426"+ + "\u0001\u0000\u0000\u0000\u0441\u0429\u0001\u0000\u0000\u0000\u0441\u042c"+ + "\u0001\u0000\u0000\u0000\u0441\u042f\u0001\u0000\u0000\u0000\u0441\u0432"+ + "\u0001\u0000\u0000\u0000\u0441\u0435\u0001\u0000\u0000\u0000\u0441\u0438"+ + "\u0001\u0000\u0000\u0000\u0441\u043e\u0001\u0000\u0000\u0000\u0442\u0445"+ + "\u0001\u0000\u0000\u0000\u0443\u0441\u0001\u0000\u0000\u0000\u0443\u0444"+ + "\u0001\u0000\u0000\u0000\u0444\u00a7\u0001\u0000\u0000\u0000\u0445\u0443"+ + "\u0001\u0000\u0000\u0000\u0446\u045b\u0003\u0018\f\u0000\u0447\u045b\u0003"+ + "\u001a\r\u0000\u0448\u045b\u0003\u00acV\u0000\u0449\u045b\u0003\u00aa"+ + "U\u0000\u044a\u045b\u0003\u00e0p\u0000\u044b\u045b\u0003\u0100\u0080\u0000"+ + "\u044c\u045b\u0003\u00f4z\u0000\u044d\u045b\u0003\u012c\u0096\u0000\u044e"+ + "\u045b\u0003\u0102\u0081\u0000\u044f\u045b\u0003\u0104\u0082\u0000\u0450"+ + "\u045b\u0003\u0106\u0083\u0000\u0451\u045b\u0003\u0108\u0084\u0000\u0452"+ + "\u045b\u0003\u010a\u0085\u0000\u0453\u045b\u0003\u00f0x\u0000\u0454\u045b"+ + "\u0003\u010c\u0086\u0000\u0455\u045b\u0003\u010e\u0087\u0000\u0456\u045b"+ + "\u0003\u0120\u0090\u0000\u0457\u045b\u0003\u00aeW\u0000\u0458\u045b\u0003"+ + "\u00b2Y\u0000\u0459\u045b\u0003z=\u0000\u045a\u0446\u0001\u0000\u0000"+ + "\u0000\u045a\u0447\u0001\u0000\u0000\u0000\u045a\u0448\u0001\u0000\u0000"+ + "\u0000\u045a\u0449\u0001\u0000\u0000\u0000\u045a\u044a\u0001\u0000\u0000"+ + "\u0000\u045a\u044b\u0001\u0000\u0000\u0000\u045a\u044c\u0001\u0000\u0000"+ + "\u0000\u045a\u044d\u0001\u0000\u0000\u0000\u045a\u044e\u0001\u0000\u0000"+ + "\u0000\u045a\u044f\u0001\u0000\u0000\u0000\u045a\u0450\u0001\u0000\u0000"+ + "\u0000\u045a\u0451\u0001\u0000\u0000\u0000\u045a\u0452\u0001\u0000\u0000"+ + "\u0000\u045a\u0453\u0001\u0000\u0000\u0000\u045a\u0454\u0001\u0000\u0000"+ + "\u0000\u045a\u0455\u0001\u0000\u0000\u0000\u045a\u0456\u0001\u0000\u0000"+ + "\u0000\u045a\u0457\u0001\u0000\u0000\u0000\u045a\u0458\u0001\u0000\u0000"+ + "\u0000\u045a\u0459\u0001\u0000\u0000\u0000\u045b\u00a9\u0001\u0000\u0000"+ + "\u0000\u045c\u045d\u0005$\u0000\u0000\u045d\u045e\u0003\u00a6S\u0000\u045e"+ + "\u00ab\u0001\u0000\u0000\u0000\u045f\u0460\u0005X\u0000\u0000\u0460\u0462"+ + "\u0003\u00a6S\u0000\u0461\u0463\u0003\u00f0x\u0000\u0462\u0461\u0001\u0000"+ + "\u0000\u0000\u0462\u0463\u0001\u0000\u0000\u0000\u0463\u00ad\u0001\u0000"+ + "\u0000\u0000\u0464\u0465\u0003\u00b0X\u0000\u0465\u0466\u0003\u0128\u0094"+ + "\u0000\u0466\u00af\u0001\u0000\u0000\u0000\u0467\u0468\u0005\f\u0000\u0000"+ + "\u0468\u0469\u0003\u00a6S\u0000\u0469\u046a\u0003\u0172\u00b9\u0000\u046a"+ + "\u046c\u0001\u0000\u0000\u0000\u046b\u0467\u0001\u0000\u0000\u0000\u046c"+ + "\u046f\u0001\u0000\u0000\u0000\u046d\u046b\u0001\u0000\u0000\u0000\u046d"+ + "\u046e\u0001\u0000\u0000\u0000\u046e\u0474\u0001\u0000\u0000\u0000\u046f"+ + "\u046d\u0001\u0000\u0000\u0000\u0470\u0471\u0005\r\u0000\u0000\u0471\u0472"+ + "\u0003d2\u0000\u0472\u0473\u0003\u0172\u00b9\u0000\u0473\u0475\u0001\u0000"+ + "\u0000\u0000\u0474\u0470\u0001\u0000\u0000\u0000\u0474\u0475\u0001\u0000"+ + "\u0000\u0000\u0475\u00b1\u0001\u0000\u0000\u0000\u0476\u0477\u0005Q\u0000"+ + "\u0000\u0477\u047c\u0003\u00a6S\u0000\u0478\u0479\u0005Q\u0000\u0000\u0479"+ + "\u047a\u0007\u0001\u0000\u0000\u047a\u047c\u0003.\u0017\u0000\u047b\u0476"+ + "\u0001\u0000\u0000\u0000\u047b\u0478\u0001\u0000\u0000\u0000\u047c\u00b3"+ + "\u0001\u0000\u0000\u0000\u047d\u0486\u0005\u0003\u0000\u0000\u047e\u0486"+ + "\u0005\u0004\u0000\u0000\u047f\u0486\u0005d\u0000\u0000\u0480\u0486\u0003"+ + "\u014e\u00a7\u0000\u0481\u0486\u0003\u0164\u00b2\u0000\u0482\u0486\u0005"+ + "\u0001\u0000\u0000\u0483\u0486\u0005\u008f\u0000\u0000\u0484\u0486\u0005"+ + "\u0090\u0000\u0000\u0485\u047d\u0001\u0000\u0000\u0000\u0485\u047e\u0001"+ + "\u0000\u0000\u0000\u0485\u047f\u0001\u0000\u0000\u0000\u0485\u0480\u0001"+ + "\u0000\u0000\u0000\u0485\u0481\u0001\u0000\u0000\u0000\u0485\u0482\u0001"+ + "\u0000\u0000\u0000\u0485\u0483\u0001\u0000\u0000\u0000\u0485\u0484\u0001"+ + "\u0000\u0000\u0000\u0486\u00b5\u0001\u0000\u0000\u0000\u0487\u0488\u0006"+ + "[\uffff\uffff\u0000\u0488\u0494\u0003\u014a\u00a5\u0000\u0489\u0494\u0003"+ + "\u0146\u00a3\u0000\u048a\u0494\u0003\u016e\u00b7\u0000\u048b\u0494\u0003"+ + " \u0010\u0000\u048c\u0494\u0003\u0088D\u0000\u048d\u0494\u0003\u0086C"+ + "\u0000\u048e\u048f\u0007\r\u0000\u0000\u048f\u0490\u0005f\u0000\u0000"+ + "\u0490\u0491\u0003\u00a6S\u0000\u0491\u0492\u0005g\u0000\u0000\u0492\u0494"+ + "\u0001\u0000\u0000\u0000\u0493\u0487\u0001\u0000\u0000\u0000\u0493\u0489"+ + "\u0001\u0000\u0000\u0000\u0493\u048a\u0001\u0000\u0000\u0000\u0493\u048b"+ + "\u0001\u0000\u0000\u0000\u0493\u048c\u0001\u0000\u0000\u0000\u0493\u048d"+ + "\u0001\u0000\u0000\u0000\u0493\u048e\u0001\u0000\u0000\u0000\u0494\u04ab"+ + "\u0001\u0000\u0000\u0000\u0495\u0496\n\t\u0000\u0000\u0496\u0497\u0005"+ + "p\u0000\u0000\u0497\u04aa\u0005e\u0000\u0000\u0498\u0499\n\b\u0000\u0000"+ + "\u0499\u04aa\u0003\u0168\u00b4\u0000\u049a\u049b\n\u0007\u0000\u0000\u049b"+ + "\u04aa\u0003\u00d0h\u0000\u049c\u049d\n\u0006\u0000\u0000\u049d\u04aa"+ + "\u0003L&\u0000\u049e\u049f\n\u0005\u0000\u0000\u049f\u04aa\u0003\u016a"+ + "\u00b5\u0000\u04a0\u04a1\n\u0004\u0000\u0000\u04a1\u04aa\u0003\u016c\u00b6"+ + "\u0000\u04a2\u04a3\n\u0003\u0000\u0000\u04a3\u04a4\u0003\u016c\u00b6\u0000"+ + "\u04a4\u04a5\u0005\u0010\u0000\u0000\u04a5\u04a6\u0003t:\u0000\u04a6\u04aa"+ + "\u0001\u0000\u0000\u0000\u04a7\u04a8\n\u0002\u0000\u0000\u04a8\u04aa\u0003"+ + "\u00bc^\u0000\u04a9\u0495\u0001\u0000\u0000\u0000\u04a9\u0498\u0001\u0000"+ + "\u0000\u0000\u04a9\u049a\u0001\u0000\u0000\u0000\u04a9\u049c\u0001\u0000"+ + "\u0000\u0000\u04a9\u049e\u0001\u0000\u0000\u0000\u04a9\u04a0\u0001\u0000"+ + "\u0000\u0000\u04a9\u04a2\u0001\u0000\u0000\u0000\u04a9\u04a7\u0001\u0000"+ + "\u0000\u0000\u04aa\u04ad\u0001\u0000\u0000\u0000\u04ab\u04a9\u0001\u0000"+ + "\u0000\u0000\u04ab\u04ac\u0001\u0000\u0000\u0000\u04ac\u00b7\u0001\u0000"+ + "\u0000\u0000\u04ad\u04ab\u0001\u0000\u0000\u0000\u04ae\u04af\u0003`0\u0000"+ + "\u04af\u04b0\u0003\u00ba]\u0000\u04b0\u00b9\u0001\u0000\u0000\u0000\u04b1"+ + "\u04b3\u0005M\u0000\u0000\u04b2\u04b4\u0005e\u0000\u0000\u04b3\u04b2\u0001"+ + "\u0000\u0000\u0000\u04b3\u04b4\u0001\u0000\u0000\u0000\u04b4\u04b5\u0001"+ + "\u0000\u0000\u0000\u04b5\u04b7\u0003\u0140\u00a0\u0000\u04b6\u04b8\u0003"+ + "r9\u0000\u04b7\u04b6\u0001\u0000\u0000\u0000\u04b7\u04b8\u0001\u0000\u0000"+ + "\u0000\u04b8\u00bb\u0001\u0000\u0000\u0000\u04b9\u04bb\u0005&\u0000\u0000"+ + "\u04ba\u04bc\u0003\u00e8t\u0000\u04bb\u04ba\u0001\u0000\u0000\u0000\u04bb"+ + "\u04bc\u0001\u0000\u0000\u0000\u04bc\u04be\u0001\u0000\u0000\u0000\u04bd"+ + "\u04bf\u0005m\u0000\u0000\u04be\u04bd\u0001\u0000\u0000\u0000\u04be\u04bf"+ + "\u0001\u0000\u0000\u0000\u04bf\u04c0\u0001\u0000\u0000\u0000\u04c0\u04c1"+ + "\u0005\'\u0000\u0000\u04c1\u00bd\u0001\u0000\u0000\u0000\u04c2\u04c3\u0005"+ + "N\u0000\u0000\u04c3\u04cd\u0005h\u0000\u0000\u04c4\u04c8\u0003\u00c2a"+ + "\u0000\u04c5\u04c8\u0003\u012e\u0097\u0000\u04c6\u04c8\u0003\u00c0`\u0000"+ + "\u04c7\u04c4\u0001\u0000\u0000\u0000\u04c7\u04c5\u0001\u0000\u0000\u0000"+ + "\u04c7\u04c6\u0001\u0000\u0000\u0000\u04c8\u04c9\u0001\u0000\u0000\u0000"+ + "\u04c9\u04ca\u0003\u0172\u00b9\u0000\u04ca\u04cc\u0001\u0000\u0000\u0000"+ + "\u04cb\u04c7\u0001\u0000\u0000\u0000\u04cc\u04cf\u0001\u0000\u0000\u0000"+ + "\u04cd\u04cb\u0001\u0000\u0000\u0000\u04cd\u04ce\u0001\u0000\u0000\u0000"+ + "\u04ce\u04d0\u0001\u0000\u0000\u0000\u04cf\u04cd\u0001\u0000\u0000\u0000"+ + "\u04d0\u04d1\u0005i\u0000\u0000\u04d1\u00bf\u0001\u0000\u0000\u0000\u04d2"+ + "\u04d3\u00058\u0000\u0000\u04d3\u04d4\u0005e\u0000\u0000\u04d4\u04d5\u0003"+ + "\u0144\u00a2\u0000\u04d5\u00c1\u0001\u0000\u0000\u0000\u04d6\u04d8\u0005"+ + "\u001b\u0000\u0000\u04d7\u04d6\u0001\u0000\u0000\u0000\u04d7\u04d8\u0001"+ + "\u0000\u0000\u0000\u04d8\u04d9\u0001\u0000\u0000\u0000\u04d9\u04da\u0003"+ + "`0\u0000\u04da\u04db\u0005e\u0000\u0000\u04db\u04dc\u0003\u0144\u00a2"+ + "\u0000\u04dc\u04dd\u0003\u0142\u00a1\u0000\u04dd\u04e6\u0001\u0000\u0000"+ + "\u0000\u04de\u04e0\u0005\u001b\u0000\u0000\u04df\u04de\u0001\u0000\u0000"+ + "\u0000\u04df\u04e0\u0001\u0000\u0000\u0000\u04e0\u04e1\u0001\u0000\u0000"+ + "\u0000\u04e1\u04e2\u0003`0\u0000\u04e2\u04e3\u0005e\u0000\u0000\u04e3"+ + "\u04e4\u0003\u0144\u00a2\u0000\u04e4\u04e6\u0001\u0000\u0000\u0000\u04e5"+ + "\u04d7\u0001\u0000\u0000\u0000\u04e5\u04df\u0001\u0000\u0000\u0000\u04e6"+ + "\u00c3\u0001\u0000\u0000\u0000\u04e7\u04ef\u0003\u012e\u0097\u0000\u04e8"+ + "\u04ef\u0003\u00c6c\u0000\u04e9\u04ef\u0003P(\u0000\u04ea\u04eb\u0005"+ + "f\u0000\u0000\u04eb\u04ec\u0003\u00c4b\u0000\u04ec\u04ed\u0005g\u0000"+ + "\u0000\u04ed\u04ef\u0001\u0000\u0000\u0000\u04ee\u04e7\u0001\u0000\u0000"+ + "\u0000\u04ee\u04e8\u0001\u0000\u0000\u0000\u04ee\u04e9\u0001\u0000\u0000"+ + "\u0000\u04ee\u04ea\u0001\u0000\u0000\u0000\u04ef\u00c5\u0001\u0000\u0000"+ + "\u0000\u04f0\u04fa\u0003\u0130\u0098\u0000\u04f1\u04fa\u0003\u0160\u00b0"+ + "\u0000\u04f2\u04fa\u0003\u0136\u009b\u0000\u04f3\u04fa\u0003\u013e\u009f"+ + "\u0000\u04f4\u04fa\u0003\u00be_\u0000\u04f5\u04fa\u0003\u0138\u009c\u0000"+ + "\u04f6\u04fa\u0003\u013a\u009d\u0000\u04f7\u04fa\u0003\u013c\u009e\u0000"+ + "\u04f8\u04fa\u0003\u00c8d\u0000\u04f9\u04f0\u0001\u0000\u0000\u0000\u04f9"+ + "\u04f1\u0001\u0000\u0000\u0000\u04f9\u04f2\u0001\u0000\u0000\u0000\u04f9"+ + "\u04f3\u0001\u0000\u0000\u0000\u04f9\u04f4\u0001\u0000\u0000\u0000\u04f9"+ + "\u04f5\u0001\u0000\u0000\u0000\u04f9\u04f6\u0001\u0000\u0000\u0000\u04f9"+ + "\u04f7\u0001\u0000\u0000\u0000\u04f9\u04f8\u0001\u0000\u0000\u0000\u04fa"+ + "\u00c7\u0001\u0000\u0000\u0000\u04fb\u04fc\u00058\u0000\u0000\u04fc\u04fd"+ + "\u0003\u00cae\u0000\u04fd\u00c9\u0001\u0000\u0000\u0000\u04fe\u050a\u0005"+ + "f\u0000\u0000\u04ff\u0504\u0003\u00c4b\u0000\u0500\u0501\u0005m\u0000"+ + "\u0000\u0501\u0503\u0003\u00c4b\u0000\u0502\u0500\u0001\u0000\u0000\u0000"+ + "\u0503\u0506\u0001\u0000\u0000\u0000\u0504\u0502\u0001\u0000\u0000\u0000"+ + "\u0504\u0505\u0001\u0000\u0000\u0000\u0505\u0508\u0001\u0000\u0000\u0000"+ + "\u0506\u0504\u0001\u0000\u0000\u0000\u0507\u0509\u0005m\u0000\u0000\u0508"+ + "\u0507\u0001\u0000\u0000\u0000\u0508\u0509\u0001\u0000\u0000\u0000\u0509"+ + "\u050b\u0001\u0000\u0000\u0000\u050a\u04ff\u0001\u0000\u0000\u0000\u050a"+ + "\u050b\u0001\u0000\u0000\u0000\u050b\u050c\u0001\u0000\u0000\u0000\u050c"+ + "\u050d\u0005g\u0000\u0000\u050d\u00cb\u0001\u0000\u0000\u0000\u050e\u0516"+ + "\u0003\u0160\u00b0\u0000\u050f\u0516\u0003\u0130\u0098\u0000\u0510\u0516"+ + "\u0003\u00ceg\u0000\u0511\u0516\u0003\u0138\u009c\u0000\u0512\u0516\u0003"+ + "\u013a\u009d\u0000\u0513\u0516\u0003P(\u0000\u0514\u0516\u0003\u012e\u0097"+ + "\u0000\u0515\u050e\u0001\u0000\u0000\u0000\u0515\u050f\u0001\u0000\u0000"+ + "\u0000\u0515\u0510\u0001\u0000\u0000\u0000\u0515\u0511\u0001\u0000\u0000"+ + "\u0000\u0515\u0512\u0001\u0000\u0000\u0000\u0515\u0513\u0001\u0000\u0000"+ + "\u0000\u0515\u0514\u0001\u0000\u0000\u0000\u0516\u00cd\u0001\u0000\u0000"+ + "\u0000\u0517\u0518\u0005j\u0000\u0000\u0518\u0519\u0005t\u0000\u0000\u0519"+ + "\u051a\u0005k\u0000\u0000\u051a\u051b\u0003\u0134\u009a\u0000\u051b\u00cf"+ + "\u0001\u0000\u0000\u0000\u051c\u052c\u0005j\u0000\u0000\u051d\u051f\u0003"+ + "\u00d2i\u0000\u051e\u051d\u0001\u0000\u0000\u0000\u051e\u051f\u0001\u0000"+ + "\u0000\u0000\u051f\u0520\u0001\u0000\u0000\u0000\u0520\u0522\u0005o\u0000"+ + "\u0000\u0521\u0523\u0003\u00d4j\u0000\u0522\u0521\u0001\u0000\u0000\u0000"+ + "\u0522\u0523\u0001\u0000\u0000\u0000\u0523\u052d\u0001\u0000\u0000\u0000"+ + "\u0524\u0526\u0003\u00d2i\u0000\u0525\u0524\u0001\u0000\u0000\u0000\u0525"+ + "\u0526\u0001\u0000\u0000\u0000\u0526\u0527\u0001\u0000\u0000\u0000\u0527"+ + "\u0528\u0005o\u0000\u0000\u0528\u0529\u0003\u00d4j\u0000\u0529\u052a\u0005"+ + "o\u0000\u0000\u052a\u052b\u0003\u00d6k\u0000\u052b\u052d\u0001\u0000\u0000"+ + "\u0000\u052c\u051e\u0001\u0000\u0000\u0000\u052c\u0525\u0001\u0000\u0000"+ + "\u0000\u052d\u052e\u0001\u0000\u0000\u0000\u052e\u052f\u0005k\u0000\u0000"+ + "\u052f\u00d1\u0001\u0000\u0000\u0000\u0530\u0531\u0003\u00a6S\u0000\u0531"+ + "\u00d3\u0001\u0000\u0000\u0000\u0532\u0533\u0003\u00a6S\u0000\u0533\u00d5"+ + "\u0001\u0000\u0000\u0000\u0534\u0535\u0003\u00a6S\u0000\u0535\u00d7\u0001"+ + "\u0000\u0000\u0000\u0536\u0538\u0007\u000e\u0000\u0000\u0537\u0536\u0001"+ + "\u0000\u0000\u0000\u0537\u0538\u0001\u0000\u0000\u0000\u0538\u0539\u0001"+ + "\u0000\u0000\u0000\u0539\u053a\u0005l\u0000\u0000\u053a\u00d9\u0001\u0000"+ + "\u0000\u0000\u053b\u053c\u0003\u00e8t\u0000\u053c\u053d\u0005l\u0000\u0000"+ + "\u053d\u0542\u0001\u0000\u0000\u0000\u053e\u053f\u0003\u0006\u0003\u0000"+ + "\u053f\u0540\u0005s\u0000\u0000\u0540\u0542\u0001\u0000\u0000\u0000\u0541"+ + "\u053b\u0001\u0000\u0000\u0000\u0541\u053e\u0001\u0000\u0000\u0000\u0541"+ + "\u0542\u0001\u0000\u0000\u0000\u0542\u0543\u0001\u0000\u0000\u0000\u0543"+ + "\u0544\u0005]\u0000\u0000\u0544\u0549\u0003\u00a6S\u0000\u0545\u0547\u0005"+ + "J\u0000\u0000\u0546\u0548\u0005e\u0000\u0000\u0547\u0546\u0001\u0000\u0000"+ + "\u0000\u0547\u0548\u0001\u0000\u0000\u0000\u0548\u054a\u0001\u0000\u0000"+ + "\u0000\u0549\u0545\u0001\u0000\u0000\u0000\u0549\u054a\u0001\u0000\u0000"+ + "\u0000\u054a\u00db\u0001\u0000\u0000\u0000\u054b\u054c\u0005X\u0000\u0000"+ + "\u054c\u054d\u0005e\u0000\u0000\u054d\u00dd\u0001\u0000\u0000\u0000\u054e"+ + "\u054f\u0003\u0164\u00b2\u0000\u054f\u00df\u0001\u0000\u0000\u0000\u0550"+ + "\u0554\u0003\u00e2q\u0000\u0551\u0554\u0003\u00eau\u0000\u0552\u0554\u0003"+ + "\u00eew\u0000\u0553\u0550\u0001\u0000\u0000\u0000\u0553\u0551\u0001\u0000"+ + "\u0000\u0000\u0553\u0552\u0001\u0000\u0000\u0000\u0554\u00e1\u0001\u0000"+ + "\u0000\u0000\u0555\u0561\u0005Z\u0000\u0000\u0556\u0562\u0003\u00e4r\u0000"+ + "\u0557\u055d\u0005f\u0000\u0000\u0558\u0559\u0003\u00e4r\u0000\u0559\u055a"+ + "\u0003\u0172\u00b9\u0000\u055a\u055c\u0001\u0000\u0000\u0000\u055b\u0558"+ + "\u0001\u0000\u0000\u0000\u055c\u055f\u0001\u0000\u0000\u0000\u055d\u055b"+ + "\u0001\u0000\u0000\u0000\u055d\u055e\u0001\u0000\u0000\u0000\u055e\u0560"+ + "\u0001\u0000\u0000\u0000\u055f\u055d\u0001\u0000\u0000\u0000\u0560\u0562"+ + "\u0005g\u0000\u0000\u0561\u0556\u0001\u0000\u0000\u0000\u0561\u0557\u0001"+ + "\u0000\u0000\u0000\u0562\u00e3\u0001\u0000\u0000\u0000\u0563\u0569\u0003"+ + "\u00e6s\u0000\u0564\u0566\u0003\u00c4b\u0000\u0565\u0564\u0001\u0000\u0000"+ + "\u0000\u0565\u0566\u0001\u0000\u0000\u0000\u0566\u0567\u0001\u0000\u0000"+ + "\u0000\u0567\u0568\u0005l\u0000\u0000\u0568\u056a\u0003\u00e8t\u0000\u0569"+ + "\u0565\u0001\u0000\u0000\u0000\u0569\u056a\u0001\u0000\u0000\u0000\u056a"+ + "\u00e5\u0001\u0000\u0000\u0000\u056b\u0570\u0005e\u0000\u0000\u056c\u056d"+ + "\u0005m\u0000\u0000\u056d\u056f\u0005e\u0000\u0000\u056e\u056c\u0001\u0000"+ + "\u0000\u0000\u056f\u0572\u0001\u0000\u0000\u0000\u0570\u056e\u0001\u0000"+ + "\u0000\u0000\u0570\u0571\u0001\u0000\u0000\u0000\u0571\u00e7\u0001\u0000"+ + "\u0000\u0000\u0572\u0570\u0001\u0000\u0000\u0000\u0573\u0578\u0003\u00a6"+ + "S\u0000\u0574\u0575\u0005m\u0000\u0000\u0575\u0577\u0003\u00a6S\u0000"+ + "\u0576\u0574\u0001\u0000\u0000\u0000\u0577\u057a\u0001\u0000\u0000\u0000"+ + "\u0578\u0576\u0001\u0000\u0000\u0000\u0578\u0579\u0001\u0000\u0000\u0000"+ + "\u0579\u00e9\u0001\u0000\u0000\u0000\u057a\u0578\u0001\u0000\u0000\u0000"+ + "\u057b\u0587\u0005^\u0000\u0000\u057c\u0588\u0003\u00ecv\u0000\u057d\u0583"+ + "\u0005f\u0000\u0000\u057e\u057f\u0003\u00ecv\u0000\u057f\u0580\u0003\u0172"+ + "\u00b9\u0000\u0580\u0582\u0001\u0000\u0000\u0000\u0581\u057e\u0001\u0000"+ + "\u0000\u0000\u0582\u0585\u0001\u0000\u0000\u0000\u0583\u0581\u0001\u0000"+ + "\u0000\u0000\u0583\u0584\u0001\u0000\u0000\u0000\u0584\u0586\u0001\u0000"+ + "\u0000\u0000\u0585\u0583\u0001\u0000\u0000\u0000\u0586\u0588\u0005g\u0000"+ + "\u0000\u0587\u057c\u0001\u0000\u0000\u0000\u0587\u057d\u0001\u0000\u0000"+ + "\u0000\u0588\u00eb\u0001\u0000\u0000\u0000\u0589\u058b\u0005e\u0000\u0000"+ + "\u058a\u058c\u0005l\u0000\u0000\u058b\u058a\u0001\u0000\u0000\u0000\u058b"+ + "\u058c\u0001\u0000\u0000\u0000\u058c\u058d\u0001\u0000\u0000\u0000\u058d"+ + "\u058e\u0003\u00c4b\u0000\u058e\u00ed\u0001\u0000\u0000\u0000\u058f\u059b"+ + "\u0005c\u0000\u0000\u0590\u059c\u0003\u0098L\u0000\u0591\u0597\u0005f"+ + "\u0000\u0000\u0592\u0593\u0003\u0098L\u0000\u0593\u0594\u0003\u0172\u00b9"+ + "\u0000\u0594\u0596\u0001\u0000\u0000\u0000\u0595\u0592\u0001\u0000\u0000"+ + "\u0000\u0596\u0599\u0001\u0000\u0000\u0000\u0597\u0595\u0001\u0000\u0000"+ + "\u0000\u0597\u0598\u0001\u0000\u0000\u0000\u0598\u059a\u0001\u0000\u0000"+ + "\u0000\u0599\u0597\u0001\u0000\u0000\u0000\u059a\u059c\u0005g\u0000\u0000"+ + "\u059b\u0590\u0001\u0000\u0000\u0000\u059b\u0591\u0001\u0000\u0000\u0000"+ + "\u059c\u00ef\u0001\u0000\u0000\u0000\u059d\u059f\u0005h\u0000\u0000\u059e"+ + "\u05a0\u0003\u00f2y\u0000\u059f\u059e\u0001\u0000\u0000\u0000\u059f\u05a0"+ + "\u0001\u0000\u0000\u0000\u05a0\u05a1\u0001\u0000\u0000\u0000\u05a1\u05a2"+ + "\u0005i\u0000\u0000\u05a2\u00f1\u0001\u0000\u0000\u0000\u05a3\u05a5\u0005"+ + "n\u0000\u0000\u05a4\u05a3\u0001\u0000\u0000\u0000\u05a4\u05a5\u0001\u0000"+ + "\u0000\u0000\u05a5\u05ab\u0001\u0000\u0000\u0000\u05a6\u05a8\u0005\u009f"+ + "\u0000\u0000\u05a7\u05a6\u0001\u0000\u0000\u0000\u05a7\u05a8\u0001\u0000"+ + "\u0000\u0000\u05a8\u05ab\u0001\u0000\u0000\u0000\u05a9\u05ab\u0004y\u0012"+ + "\u0000\u05aa\u05a4\u0001\u0000\u0000\u0000\u05aa\u05a7\u0001\u0000\u0000"+ + "\u0000\u05aa\u05a9\u0001\u0000\u0000\u0000\u05ab\u05ac\u0001\u0000\u0000"+ + "\u0000\u05ac\u05ad\u0003\u00a8T\u0000\u05ad\u05ae\u0003\u0172\u00b9\u0000"+ + "\u05ae\u05b0\u0001\u0000\u0000\u0000\u05af\u05aa\u0001\u0000\u0000\u0000"+ + "\u05b0\u05b1\u0001\u0000\u0000\u0000\u05b1\u05af\u0001\u0000\u0000\u0000"+ + "\u05b1\u05b2\u0001\u0000\u0000\u0000\u05b2\u00f3\u0001\u0000\u0000\u0000"+ + "\u05b3\u05b9\u0003\u00f8|\u0000\u05b4\u05b9\u0003\u00fa}\u0000\u05b5\u05b9"+ + "\u0003\u00fc~\u0000\u05b6\u05b9\u0003\u00f6{\u0000\u05b7\u05b9\u0003\u009a"+ + "M\u0000\u05b8\u05b3\u0001\u0000\u0000\u0000\u05b8\u05b4\u0001\u0000\u0000"+ + "\u0000\u05b8\u05b5\u0001\u0000\u0000\u0000\u05b8\u05b6\u0001\u0000\u0000"+ + "\u0000\u05b8\u05b7\u0001\u0000\u0000\u0000\u05b9\u00f5\u0001\u0000\u0000"+ + "\u0000\u05ba\u05bb\u0003\u00a6S\u0000\u05bb\u00f7\u0001\u0000\u0000\u0000"+ + "\u05bc\u05bd\u0003\u00a6S\u0000\u05bd\u05be\u0005\u0089\u0000\u0000\u05be"+ + "\u05bf\u0003\u00a6S\u0000\u05bf\u00f9\u0001\u0000\u0000\u0000\u05c0\u05c1"+ + "\u0003\u00a6S\u0000\u05c1\u05c2\u0007\u000f\u0000\u0000\u05c2\u00fb\u0001"+ + "\u0000\u0000\u0000\u05c3\u05c4\u0003\u00e8t\u0000\u05c4\u05c5\u0003\u00d8"+ + "l\u0000\u05c5\u05c6\u0003\u00e8t\u0000\u05c6\u00fd\u0001\u0000\u0000\u0000"+ + "\u05c7\u05c8\u0007\u0010\u0000\u0000\u05c8\u00ff\u0001\u0000\u0000\u0000"+ + "\u05c9\u05ca\u0005e\u0000\u0000\u05ca\u05cc\u0005o\u0000\u0000\u05cb\u05cd"+ + "\u0003\u00a8T\u0000\u05cc\u05cb\u0001\u0000\u0000\u0000\u05cc\u05cd\u0001"+ + "\u0000\u0000\u0000\u05cd\u0101\u0001\u0000\u0000\u0000\u05ce\u05d0\u0005"+ + "b\u0000\u0000\u05cf\u05d1\u0003\u00e8t\u0000\u05d0\u05cf\u0001\u0000\u0000"+ + "\u0000\u05d0\u05d1\u0001\u0000\u0000\u0000\u05d1\u0103\u0001\u0000\u0000"+ + "\u0000\u05d2\u05d4\u0005K\u0000\u0000\u05d3\u05d5\u0005e\u0000\u0000\u05d4"+ + "\u05d3\u0001\u0000\u0000\u0000\u05d4\u05d5\u0001\u0000\u0000\u0000\u05d5"+ + "\u0105\u0001\u0000\u0000\u0000\u05d6\u05d8\u0005_\u0000\u0000\u05d7\u05d9"+ + "\u0005e\u0000\u0000\u05d8\u05d7\u0001\u0000\u0000\u0000\u05d8\u05d9\u0001"+ + "\u0000\u0000\u0000\u05d9\u0107\u0001\u0000\u0000\u0000\u05da\u05db\u0005"+ + "W\u0000\u0000\u05db\u05dc\u0005e\u0000\u0000\u05dc\u0109\u0001\u0000\u0000"+ + "\u0000\u05dd\u05de\u0005[\u0000\u0000\u05de\u010b\u0001\u0000\u0000\u0000"+ + "\u05df\u05e8\u0005\\\u0000\u0000\u05e0\u05e9\u0003\u00a6S\u0000\u05e1"+ + "\u05e2\u0003\u0172\u00b9\u0000\u05e2\u05e3\u0003\u00a6S\u0000\u05e3\u05e9"+ + "\u0001\u0000\u0000\u0000\u05e4\u05e5\u0003\u00f4z\u0000\u05e5\u05e6\u0003"+ + "\u0172\u00b9\u0000\u05e6\u05e7\u0003\u00a6S\u0000\u05e7\u05e9\u0001\u0000"+ + "\u0000\u0000\u05e8\u05e0\u0001\u0000\u0000\u0000\u05e8\u05e1\u0001\u0000"+ + "\u0000\u0000\u05e8\u05e4\u0001\u0000\u0000\u0000\u05e9\u05ea\u0001\u0000"+ + "\u0000\u0000\u05ea\u05f0\u0003\u00f0x\u0000\u05eb\u05ee\u0005V\u0000\u0000"+ + "\u05ec\u05ef\u0003\u010c\u0086\u0000\u05ed\u05ef\u0003\u00f0x\u0000\u05ee"+ + "\u05ec\u0001\u0000\u0000\u0000\u05ee\u05ed\u0001\u0000\u0000\u0000\u05ef"+ + "\u05f1\u0001\u0000\u0000\u0000\u05f0\u05eb\u0001\u0000\u0000\u0000\u05f0"+ + "\u05f1\u0001\u0000\u0000\u0000\u05f1\u010d\u0001\u0000\u0000\u0000\u05f2"+ + "\u05f5\u0003\u0110\u0088\u0000\u05f3\u05f5\u0003\u0116\u008b\u0000\u05f4"+ + "\u05f2\u0001\u0000\u0000\u0000\u05f4\u05f3\u0001\u0000\u0000\u0000\u05f5"+ + "\u010f\u0001\u0000\u0000\u0000\u05f6\u0601\u0005Y\u0000\u0000\u05f7\u05f9"+ + "\u0003\u00a6S\u0000\u05f8\u05f7\u0001\u0000\u0000\u0000\u05f8\u05f9\u0001"+ + "\u0000\u0000\u0000\u05f9\u0602\u0001\u0000\u0000\u0000\u05fa\u05fc\u0003"+ + "\u00f4z\u0000\u05fb\u05fa\u0001\u0000\u0000\u0000\u05fb\u05fc\u0001\u0000"+ + "\u0000\u0000\u05fc\u05fd\u0001\u0000\u0000\u0000\u05fd\u05ff\u0003\u0172"+ + "\u00b9\u0000\u05fe\u0600\u0003\u00a6S\u0000\u05ff\u05fe\u0001\u0000\u0000"+ + "\u0000\u05ff\u0600\u0001\u0000\u0000\u0000\u0600\u0602\u0001\u0000\u0000"+ + "\u0000\u0601\u05f8\u0001\u0000\u0000\u0000\u0601\u05fb\u0001\u0000\u0000"+ + "\u0000\u0602\u0603\u0001\u0000\u0000\u0000\u0603\u0607\u0005h\u0000\u0000"+ + "\u0604\u0606\u0003\u0112\u0089\u0000\u0605\u0604\u0001\u0000\u0000\u0000"+ + "\u0606\u0609\u0001\u0000\u0000\u0000\u0607\u0605\u0001\u0000\u0000\u0000"+ + "\u0607\u0608\u0001\u0000\u0000\u0000\u0608\u060a\u0001\u0000\u0000\u0000"+ + "\u0609\u0607\u0001\u0000\u0000\u0000\u060a\u060b\u0005i\u0000\u0000\u060b"+ + "\u0111\u0001\u0000\u0000\u0000\u060c\u060d\u0003\u0114\u008a\u0000\u060d"+ + "\u060f\u0005o\u0000\u0000\u060e\u0610\u0003\u00f2y\u0000\u060f\u060e\u0001"+ + "\u0000\u0000\u0000\u060f\u0610\u0001\u0000\u0000\u0000\u0610\u0113\u0001"+ + "\u0000\u0000\u0000\u0611\u0612\u0005P\u0000\u0000\u0612\u0615\u0003\u00e8"+ + "t\u0000\u0613\u0615\u0005L\u0000\u0000\u0614\u0611\u0001\u0000\u0000\u0000"+ + "\u0614\u0613\u0001\u0000\u0000\u0000\u0615\u0115\u0001\u0000\u0000\u0000"+ + "\u0616\u061f\u0005Y\u0000\u0000\u0617\u0620\u0003\u0118\u008c\u0000\u0618"+ + "\u0619\u0003\u0172\u00b9\u0000\u0619\u061a\u0003\u0118\u008c\u0000\u061a"+ + "\u0620\u0001\u0000\u0000\u0000\u061b\u061c\u0003\u00f4z\u0000\u061c\u061d"+ + "\u0003\u0172\u00b9\u0000\u061d\u061e\u0003\u0118\u008c\u0000\u061e\u0620"+ + "\u0001\u0000\u0000\u0000\u061f\u0617\u0001\u0000\u0000\u0000\u061f\u0618"+ + "\u0001\u0000\u0000\u0000\u061f\u061b\u0001\u0000\u0000\u0000\u0620\u0621"+ + "\u0001\u0000\u0000\u0000\u0621\u0625\u0005h\u0000\u0000\u0622\u0624\u0003"+ + "\u011a\u008d\u0000\u0623\u0622\u0001\u0000\u0000\u0000\u0624\u0627\u0001"+ + "\u0000\u0000\u0000\u0625\u0623\u0001\u0000\u0000\u0000\u0625\u0626\u0001"+ + "\u0000\u0000\u0000\u0626\u0628\u0001\u0000\u0000\u0000\u0627\u0625\u0001"+ + "\u0000\u0000\u0000\u0628\u0629\u0005i\u0000\u0000\u0629\u0117\u0001\u0000"+ + "\u0000\u0000\u062a\u062b\u0005e\u0000\u0000\u062b\u062d\u0005s\u0000\u0000"+ + "\u062c\u062a\u0001\u0000\u0000\u0000\u062c\u062d\u0001\u0000\u0000\u0000"+ + "\u062d\u062e\u0001\u0000\u0000\u0000\u062e\u062f\u0003\u00b6[\u0000\u062f"+ + "\u0630\u0005p\u0000\u0000\u0630\u0631\u0005f\u0000\u0000\u0631\u0632\u0005"+ + "^\u0000\u0000\u0632\u0633\u0005g\u0000\u0000\u0633\u0119\u0001\u0000\u0000"+ + "\u0000\u0634\u0635\u0003\u011c\u008e\u0000\u0635\u0637\u0005o\u0000\u0000"+ + "\u0636\u0638\u0003\u00f2y\u0000\u0637\u0636\u0001\u0000\u0000\u0000\u0637"+ + "\u0638\u0001\u0000\u0000\u0000\u0638\u011b\u0001\u0000\u0000\u0000\u0639"+ + "\u063a\u0005P\u0000\u0000\u063a\u063d\u0003\u011e\u008f\u0000\u063b\u063d"+ + "\u0005L\u0000\u0000\u063c\u0639\u0001\u0000\u0000\u0000\u063c\u063b\u0001"+ + "\u0000\u0000\u0000\u063d\u011d\u0001\u0000\u0000\u0000\u063e\u0641\u0003"+ + "\u00c4b\u0000\u063f\u0641\u0005d\u0000\u0000\u0640\u063e\u0001\u0000\u0000"+ + "\u0000\u0640\u063f\u0001\u0000\u0000\u0000\u0641\u0649\u0001\u0000\u0000"+ + "\u0000\u0642\u0645\u0005m\u0000\u0000\u0643\u0646\u0003\u00c4b\u0000\u0644"+ + "\u0646\u0005d\u0000\u0000\u0645\u0643\u0001\u0000\u0000\u0000\u0645\u0644"+ + "\u0001\u0000\u0000\u0000\u0646\u0648\u0001\u0000\u0000\u0000\u0647\u0642"+ + "\u0001\u0000\u0000\u0000\u0648\u064b\u0001\u0000\u0000\u0000\u0649\u0647"+ + "\u0001\u0000\u0000\u0000\u0649\u064a\u0001\u0000\u0000\u0000\u064a\u011f"+ + "\u0001\u0000\u0000\u0000\u064b\u0649\u0001\u0000\u0000\u0000\u064c\u064d"+ + "\u0005O\u0000\u0000\u064d\u0651\u0005h\u0000\u0000\u064e\u0650\u0003\u0122"+ + "\u0091\u0000\u064f\u064e\u0001\u0000\u0000\u0000\u0650\u0653\u0001\u0000"+ + "\u0000\u0000\u0651\u064f\u0001\u0000\u0000\u0000\u0651\u0652\u0001\u0000"+ + "\u0000\u0000\u0652\u0654\u0001\u0000\u0000\u0000\u0653\u0651\u0001\u0000"+ + "\u0000\u0000\u0654\u0655\u0005i\u0000\u0000\u0655\u0121\u0001\u0000\u0000"+ + "\u0000\u0656\u0657\u0003\u0124\u0092\u0000\u0657\u0659\u0005o\u0000\u0000"+ + "\u0658\u065a\u0003\u00f2y\u0000\u0659\u0658\u0001\u0000\u0000\u0000\u0659"+ + "\u065a\u0001\u0000\u0000\u0000\u065a\u0123\u0001\u0000\u0000\u0000\u065b"+ + "\u065e\u0005P\u0000\u0000\u065c\u065f\u0003\u00f8|\u0000\u065d\u065f\u0003"+ + "\u0126\u0093\u0000\u065e\u065c\u0001\u0000\u0000\u0000\u065e\u065d\u0001"+ + "\u0000\u0000\u0000\u065f\u0662\u0001\u0000\u0000\u0000\u0660\u0662\u0005"+ + "L\u0000\u0000\u0661\u065b\u0001\u0000\u0000\u0000\u0661\u0660\u0001\u0000"+ + "\u0000\u0000\u0662\u0125\u0001\u0000\u0000\u0000\u0663\u0664\u0003\u00e8"+ + "t\u0000\u0664\u0665\u0005l\u0000\u0000\u0665\u066a\u0001\u0000\u0000\u0000"+ + "\u0666\u0667\u0003\u00e6s\u0000\u0667\u0668\u0005s\u0000\u0000\u0668\u066a"+ + "\u0001\u0000\u0000\u0000\u0669\u0663\u0001\u0000\u0000\u0000\u0669\u0666"+ + "\u0001\u0000\u0000\u0000\u0669\u066a\u0001\u0000\u0000\u0000\u066a\u066b"+ + "\u0001\u0000\u0000\u0000\u066b\u066c\u0003\u00a6S\u0000\u066c\u0127\u0001"+ + "\u0000\u0000\u0000\u066d\u0675\u0005`\u0000\u0000\u066e\u0670\u0003\u00a6"+ + "S\u0000\u066f\u066e\u0001\u0000\u0000\u0000\u066f\u0670\u0001\u0000\u0000"+ + "\u0000\u0670\u0676\u0001\u0000\u0000\u0000\u0671\u0676\u0003\u012a\u0095"+ + "\u0000\u0672\u0674\u0003\u00dam\u0000\u0673\u0672\u0001\u0000\u0000\u0000"+ + "\u0673\u0674\u0001\u0000\u0000\u0000\u0674\u0676\u0001\u0000\u0000\u0000"+ + "\u0675\u066f\u0001\u0000\u0000\u0000\u0675\u0671\u0001\u0000\u0000\u0000"+ + "\u0675\u0673\u0001\u0000\u0000\u0000\u0676\u0677\u0001\u0000\u0000\u0000"+ + "\u0677\u0678\u0003\u00f0x\u0000\u0678\u0129\u0001\u0000\u0000\u0000\u0679"+ + "\u067b\u0003\u00f4z\u0000\u067a\u0679\u0001\u0000\u0000\u0000\u067a\u067b"+ + "\u0001\u0000\u0000\u0000\u067b\u067c\u0001\u0000\u0000\u0000\u067c\u067e"+ + "\u0003\u0172\u00b9\u0000\u067d\u067f\u0003\u00a6S\u0000\u067e\u067d\u0001"+ + "\u0000\u0000\u0000\u067e\u067f\u0001\u0000\u0000\u0000\u067f\u0680\u0001"+ + "\u0000\u0000\u0000\u0680\u0682\u0003\u0172\u00b9\u0000\u0681\u0683\u0003"+ + "\u00f4z\u0000\u0682\u0681\u0001\u0000\u0000\u0000\u0682\u0683\u0001\u0000"+ + "\u0000\u0000\u0683\u012b\u0001\u0000\u0000\u0000\u0684\u0685\u0005R\u0000"+ + "\u0000\u0685\u0686\u0003\u00a6S\u0000\u0686\u012d\u0001\u0000\u0000\u0000"+ + "\u0687\u068a\u0003\u0152\u00a9\u0000\u0688\u068a\u0005e\u0000\u0000\u0689"+ + "\u0687\u0001\u0000\u0000\u0000\u0689\u0688\u0001\u0000\u0000\u0000\u068a"+ + "\u012f\u0001\u0000\u0000\u0000\u068b\u068c\u0005j\u0000\u0000\u068c\u068d"+ + "\u0003\u0132\u0099\u0000\u068d\u068e\u0005k\u0000\u0000\u068e\u068f\u0003"+ + "\u0134\u009a\u0000\u068f\u0131\u0001\u0000\u0000\u0000\u0690\u0691\u0003"+ + "\u00a6S\u0000\u0691\u0133\u0001\u0000\u0000\u0000\u0692\u0693\u0003\u00c4"+ + "b\u0000\u0693\u0135\u0001\u0000\u0000\u0000\u0694\u0695\u0005\u0087\u0000"+ + "\u0000\u0695\u0696\u0003\u00c4b\u0000\u0696\u0137\u0001\u0000\u0000\u0000"+ + "\u0697\u0698\u0005j\u0000\u0000\u0698\u0699\u0005k\u0000\u0000\u0699\u069a"+ + "\u0003\u0134\u009a\u0000\u069a\u0139\u0001\u0000\u0000\u0000\u069b\u069c"+ + "\u0005S\u0000\u0000\u069c\u069d\u0005j\u0000\u0000\u069d\u069e\u0003\u00c4"+ + "b\u0000\u069e\u069f\u0005k\u0000\u0000\u069f\u06a0\u0003\u0134\u009a\u0000"+ + "\u06a0\u013b\u0001\u0000\u0000\u0000\u06a1\u06a7\u0005U\u0000\u0000\u06a2"+ + "\u06a3\u0005U\u0000\u0000\u06a3\u06a7\u0005\u0089\u0000\u0000\u06a4\u06a5"+ + "\u0005\u0089\u0000\u0000\u06a5\u06a7\u0005U\u0000\u0000\u06a6\u06a1\u0001"+ + "\u0000\u0000\u0000\u06a6\u06a2\u0001\u0000\u0000\u0000\u06a6\u06a4\u0001"+ + "\u0000\u0000\u0000\u06a7\u06a8\u0001\u0000\u0000\u0000\u06a8\u06a9\u0003"+ + "\u0134\u009a\u0000\u06a9\u013d\u0001\u0000\u0000\u0000\u06aa\u06ab\u0005"+ + "M\u0000\u0000\u06ab\u06ac\u0003\u0140\u00a0\u0000\u06ac\u013f\u0001\u0000"+ + "\u0000\u0000\u06ad\u06ae\u0003\u0144\u00a2\u0000\u06ae\u06af\u0003\u0142"+ + "\u00a1\u0000\u06af\u06b2\u0001\u0000\u0000\u0000\u06b0\u06b2\u0003\u0144"+ + "\u00a2\u0000\u06b1\u06ad\u0001\u0000\u0000\u0000\u06b1\u06b0\u0001\u0000"+ + "\u0000\u0000\u06b2\u0141\u0001\u0000\u0000\u0000\u06b3\u06b6\u0003\u0144"+ + "\u00a2\u0000\u06b4\u06b6\u0003\u00c4b\u0000\u06b5\u06b3\u0001\u0000\u0000"+ + "\u0000\u06b5\u06b4\u0001\u0000\u0000\u0000\u06b6\u0143\u0001\u0000\u0000"+ + "\u0000\u06b7\u06c3\u0005f\u0000\u0000\u06b8\u06bd\u0003\u009eO\u0000\u06b9"+ + "\u06ba\u0005m\u0000\u0000\u06ba\u06bc\u0003\u009eO\u0000\u06bb\u06b9\u0001"+ + "\u0000\u0000\u0000\u06bc\u06bf\u0001\u0000\u0000\u0000\u06bd\u06bb\u0001"+ + "\u0000\u0000\u0000\u06bd\u06be\u0001\u0000\u0000\u0000\u06be\u06c1\u0001"+ + "\u0000\u0000\u0000\u06bf\u06bd\u0001\u0000\u0000\u0000\u06c0\u06c2\u0005"+ + "m\u0000\u0000\u06c1\u06c0\u0001\u0000\u0000\u0000\u06c1\u06c2\u0001\u0000"+ + "\u0000\u0000\u06c2\u06c4\u0001\u0000\u0000\u0000\u06c3\u06b8\u0001\u0000"+ + "\u0000\u0000\u06c3\u06c4\u0001\u0000\u0000\u0000\u06c4\u06c5\u0001\u0000"+ + "\u0000\u0000\u06c5\u06c6\u0005g\u0000\u0000\u06c6\u0145\u0001\u0000\u0000"+ + "\u0000\u06c7\u06c8\u0003\u0148\u00a4\u0000\u06c8\u06c9\u0005f\u0000\u0000"+ + "\u06c9\u06cb\u0003\u00a6S\u0000\u06ca\u06cc\u0005m\u0000\u0000\u06cb\u06ca"+ + "\u0001\u0000\u0000\u0000\u06cb\u06cc\u0001\u0000\u0000\u0000\u06cc\u06cd"+ + "\u0001\u0000\u0000\u0000\u06cd\u06ce\u0005g\u0000\u0000\u06ce\u0147\u0001"+ + "\u0000\u0000\u0000\u06cf\u06d5\u0003\u00c6c\u0000\u06d0\u06d1\u0005f\u0000"+ + "\u0000\u06d1\u06d2\u0003\u0148\u00a4\u0000\u06d2\u06d3\u0005g\u0000\u0000"+ + "\u06d3\u06d5\u0001\u0000\u0000\u0000\u06d4\u06cf\u0001\u0000\u0000\u0000"+ + "\u06d4\u06d0\u0001\u0000\u0000\u0000\u06d5\u0149\u0001\u0000\u0000\u0000"+ + "\u06d6\u06dd\u0003\u014c\u00a6\u0000\u06d7\u06dd\u0003\u0150\u00a8\u0000"+ + "\u06d8\u06d9\u0005f\u0000\u0000\u06d9\u06da\u0003\u00a6S\u0000\u06da\u06db"+ + "\u0005g\u0000\u0000\u06db\u06dd\u0001\u0000\u0000\u0000\u06dc\u06d6\u0001"+ + "\u0000\u0000\u0000\u06dc\u06d7\u0001\u0000\u0000\u0000\u06dc\u06d8\u0001"+ + "\u0000\u0000\u0000\u06dd\u014b\u0001\u0000\u0000\u0000\u06de\u06e2\u0003"+ + "\u00b4Z\u0000\u06df\u06e2\u0003\u0154\u00aa\u0000\u06e0\u06e2\u0003\u00b8"+ + "\\\u0000\u06e1\u06de\u0001\u0000\u0000\u0000\u06e1\u06df\u0001\u0000\u0000"+ + "\u0000\u06e1\u06e0\u0001\u0000\u0000\u0000\u06e2\u014d\u0001\u0000\u0000"+ + "\u0000\u06e3\u06e4\u0007\u0011\u0000\u0000\u06e4\u014f\u0001\u0000\u0000"+ + "\u0000\u06e5\u06e6\u0005e\u0000\u0000\u06e6\u0151\u0001\u0000\u0000\u0000"+ + "\u06e7\u06e8\u0005e\u0000\u0000\u06e8\u06e9\u0005p\u0000\u0000\u06e9\u06ea"+ + "\u0005e\u0000\u0000\u06ea\u0153\u0001\u0000\u0000\u0000\u06eb\u06ec\u0003"+ + "\u00ccf\u0000\u06ec\u06ed\u0003\u0156\u00ab\u0000\u06ed\u0155\u0001\u0000"+ + "\u0000\u0000\u06ee\u06f3\u0005h\u0000\u0000\u06ef\u06f1\u0003\u0158\u00ac"+ + "\u0000\u06f0\u06f2\u0005m\u0000\u0000\u06f1\u06f0\u0001\u0000\u0000\u0000"+ + "\u06f1\u06f2\u0001\u0000\u0000\u0000\u06f2\u06f4\u0001\u0000\u0000\u0000"+ + "\u06f3\u06ef\u0001\u0000\u0000\u0000\u06f3\u06f4\u0001\u0000\u0000\u0000"+ + "\u06f4\u06f5\u0001\u0000\u0000\u0000\u06f5\u06f6\u0005i\u0000\u0000\u06f6"+ + "\u0157\u0001\u0000\u0000\u0000\u06f7\u06fc\u0003\u015a\u00ad\u0000\u06f8"+ + "\u06f9\u0005m\u0000\u0000\u06f9\u06fb\u0003\u015a\u00ad\u0000\u06fa\u06f8"+ + "\u0001\u0000\u0000\u0000\u06fb\u06fe\u0001\u0000\u0000\u0000\u06fc\u06fa"+ + "\u0001\u0000\u0000\u0000\u06fc\u06fd\u0001\u0000\u0000\u0000\u06fd\u0159"+ + "\u0001\u0000\u0000\u0000\u06fe\u06fc\u0001\u0000\u0000\u0000\u06ff\u0700"+ + "\u0003\u015c\u00ae\u0000\u0700\u0701\u0005o\u0000\u0000\u0701\u0703\u0001"+ + "\u0000\u0000\u0000\u0702\u06ff\u0001\u0000\u0000\u0000\u0702\u0703\u0001"+ + "\u0000\u0000\u0000\u0703\u0704\u0001\u0000\u0000\u0000\u0704\u0705\u0003"+ + "\u015e\u00af\u0000\u0705\u015b\u0001\u0000\u0000\u0000\u0706\u0709\u0003"+ + "\u00a6S\u0000\u0707\u0709\u0003\u0156\u00ab\u0000\u0708\u0706\u0001\u0000"+ + "\u0000\u0000\u0708\u0707\u0001\u0000\u0000\u0000\u0709\u015d\u0001\u0000"+ + "\u0000\u0000\u070a\u070d\u0003\u00a6S\u0000\u070b\u070d\u0003\u0156\u00ab"+ + "\u0000\u070c\u070a\u0001\u0000\u0000\u0000\u070c\u070b\u0001\u0000\u0000"+ + "\u0000\u070d\u015f\u0001\u0000\u0000\u0000\u070e\u070f\u0005T\u0000\u0000"+ + "\u070f\u0715\u0005h\u0000\u0000\u0710\u0711\u0003\u0162\u00b1\u0000\u0711"+ + "\u0712\u0003\u0172\u00b9\u0000\u0712\u0714\u0001\u0000\u0000\u0000\u0713"+ + "\u0710\u0001\u0000\u0000\u0000\u0714\u0717\u0001\u0000\u0000\u0000\u0715"+ + "\u0713\u0001\u0000\u0000\u0000\u0715\u0716\u0001\u0000\u0000\u0000\u0716"+ + "\u0718\u0001\u0000\u0000\u0000\u0717\u0715\u0001\u0000\u0000\u0000\u0718"+ + "\u0719\u0005i\u0000\u0000\u0719\u0161\u0001\u0000\u0000\u0000\u071a\u071b"+ + "\u0003\u00e6s\u0000\u071b\u071c\u0003\u00c4b\u0000\u071c\u071f\u0001\u0000"+ + "\u0000\u0000\u071d\u071f\u0003\u0166\u00b3\u0000\u071e\u071a\u0001\u0000"+ + "\u0000\u0000\u071e\u071d\u0001\u0000\u0000\u0000\u071f\u0721\u0001\u0000"+ + "\u0000\u0000\u0720\u0722\u0003\u0164\u00b2\u0000\u0721\u0720\u0001\u0000"+ + "\u0000\u0000\u0721\u0722\u0001\u0000\u0000\u0000\u0722\u0163\u0001\u0000"+ + "\u0000\u0000\u0723\u0724\u0007\u0012\u0000\u0000\u0724\u0165\u0001\u0000"+ + "\u0000\u0000\u0725\u0727\u0005\u0087\u0000\u0000\u0726\u0725\u0001\u0000"+ + "\u0000\u0000\u0726\u0727\u0001\u0000\u0000\u0000\u0727\u0728\u0001\u0000"+ + "\u0000\u0000\u0728\u0729\u0003\u012e\u0097\u0000\u0729\u0167\u0001\u0000"+ + "\u0000\u0000\u072a\u072b\u0005j\u0000\u0000\u072b\u072c\u0003\u00a6S\u0000"+ + "\u072c\u072d\u0005k\u0000\u0000\u072d\u0169\u0001\u0000\u0000\u0000\u072e"+ + "\u072f\u0005p\u0000\u0000\u072f\u0730\u0005f\u0000\u0000\u0730\u0731\u0003"+ + "\u00c4b\u0000\u0731\u0732\u0005g\u0000\u0000\u0732\u016b\u0001\u0000\u0000"+ + "\u0000\u0733\u0742\u0005f\u0000\u0000\u0734\u073b\u0003\u00e8t\u0000\u0735"+ + "\u0738\u0003\u0148\u00a4\u0000\u0736\u0737\u0005m\u0000\u0000\u0737\u0739"+ + "\u0003\u00e8t\u0000\u0738\u0736\u0001\u0000\u0000\u0000\u0738\u0739\u0001"+ + "\u0000\u0000\u0000\u0739\u073b\u0001\u0000\u0000\u0000\u073a\u0734\u0001"+ + "\u0000\u0000\u0000\u073a\u0735\u0001\u0000\u0000\u0000\u073b\u073d\u0001"+ + "\u0000\u0000\u0000\u073c\u073e\u0005t\u0000\u0000\u073d\u073c\u0001\u0000"+ + "\u0000\u0000\u073d\u073e\u0001\u0000\u0000\u0000\u073e\u0740\u0001\u0000"+ + "\u0000\u0000\u073f\u0741\u0005m\u0000\u0000\u0740\u073f\u0001\u0000\u0000"+ + "\u0000\u0740\u0741\u0001\u0000\u0000\u0000\u0741\u0743\u0001\u0000\u0000"+ + "\u0000\u0742\u073a\u0001\u0000\u0000\u0000\u0742\u0743\u0001\u0000\u0000"+ + "\u0000\u0743\u0744\u0001\u0000\u0000\u0000\u0744\u0745\u0005g\u0000\u0000"+ + "\u0745\u016d\u0001\u0000\u0000\u0000\u0746\u0747\u0003\u0148\u00a4\u0000"+ + "\u0747\u0748\u0005p\u0000\u0000\u0748\u0749\u0005e\u0000\u0000\u0749\u016f"+ + "\u0001\u0000\u0000\u0000\u074a\u074b\u0003\u00c4b\u0000\u074b\u0171\u0001"+ + "\u0000\u0000\u0000\u074c\u0751\u0005n\u0000\u0000\u074d\u0751\u0005\u0000"+ + "\u0000\u0001\u074e\u0751\u0005\u009f\u0000\u0000\u074f\u0751\u0004\u00b9"+ + "\u0013\u0000\u0750\u074c\u0001\u0000\u0000\u0000\u0750\u074d\u0001\u0000"+ + "\u0000\u0000\u0750\u074e\u0001\u0000\u0000\u0000\u0750\u074f\u0001\u0000"+ + "\u0000\u0000\u0751\u0173\u0001\u0000\u0000\u0000\u00c2\u0182\u0187\u018e"+ + "\u0198\u019e\u01a4\u01ae\u01b8\u01c6\u01ca\u01d3\u01df\u01e3\u01e9\u01f2"+ + "\u01fc\u020d\u021b\u021f\u0226\u022e\u0237\u0257\u025f\u0277\u028a\u0299"+ + "\u02a6\u02af\u02bd\u02c6\u02d2\u02d8\u02ec\u02f3\u02f8\u02fd\u0307\u030a"+ + "\u030e\u0312\u031a\u0322\u0327\u032f\u0331\u0336\u033d\u0345\u0348\u034e"+ + "\u0353\u0355\u0358\u035f\u0364\u0377\u037f\u0383\u0386\u038c\u0390\u0393"+ + "\u039d\u03a4\u03ab\u03b7\u03bd\u03c4\u03c9\u03cf\u03db\u03e1\u03e5\u03ed"+ + "\u03f1\u03f7\u03fa\u0400\u0405\u041e\u0441\u0443\u045a\u0462\u046d\u0474"+ + "\u047b\u0485\u0493\u04a9\u04ab\u04b3\u04b7\u04bb\u04be\u04c7\u04cd\u04d7"+ + "\u04df\u04e5\u04ee\u04f9\u0504\u0508\u050a\u0515\u051e\u0522\u0525\u052c"+ + "\u0537\u0541\u0547\u0549\u0553\u055d\u0561\u0565\u0569\u0570\u0578\u0583"+ + "\u0587\u058b\u0597\u059b\u059f\u05a4\u05a7\u05aa\u05b1\u05b8\u05cc\u05d0"+ + "\u05d4\u05d8\u05e8\u05ee\u05f0\u05f4\u05f8\u05fb\u05ff\u0601\u0607\u060f"+ + "\u0614\u061f\u0625\u062c\u0637\u063c\u0640\u0645\u0649\u0651\u0659\u065e"+ + "\u0661\u0669\u066f\u0673\u0675\u067a\u067e\u0682\u0689\u06a6\u06b1\u06b5"+ + "\u06bd\u06c1\u06c3\u06cb\u06d4\u06dc\u06e1\u06f1\u06f3\u06fc\u0702\u0708"+ + "\u070c\u0715\u071e\u0721\u0726\u0738\u073a\u073d\u0740\u0742\u0750"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); static { diff --git a/src/main/java/viper/gobra/frontend/GobraParserBaseVisitor.java b/src/main/java/viper/gobra/frontend/GobraParserBaseVisitor.java index 52b9990df..e05468128 100644 --- a/src/main/java/viper/gobra/frontend/GobraParserBaseVisitor.java +++ b/src/main/java/viper/gobra/frontend/GobraParserBaseVisitor.java @@ -1,4 +1,4 @@ -// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.12.0 +// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.13.0 package viper.gobra.frontend; import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; @@ -348,6 +348,13 @@ public class GobraParserBaseVisitor extends AbstractParseTreeVisitor imple * {@link #visitChildren} on {@code ctx}.

*/ @Override public T visitAdtClause(GobraParser.AdtClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAdtFieldDecl(GobraParser.AdtFieldDeclContext ctx) { return visitChildren(ctx); } /** * {@inheritDoc} * diff --git a/src/main/java/viper/gobra/frontend/GobraParserVisitor.java b/src/main/java/viper/gobra/frontend/GobraParserVisitor.java index 352f76c5e..c30ab42ee 100644 --- a/src/main/java/viper/gobra/frontend/GobraParserVisitor.java +++ b/src/main/java/viper/gobra/frontend/GobraParserVisitor.java @@ -1,4 +1,4 @@ -// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.12.0 +// Generated from src/main/antlr4/GobraParser.g4 by ANTLR 4.13.0 package viper.gobra.frontend; import org.antlr.v4.runtime.tree.ParseTreeVisitor; @@ -302,6 +302,12 @@ public interface GobraParserVisitor extends ParseTreeVisitor { * @return the visitor result */ T visitAdtClause(GobraParser.AdtClauseContext ctx); + /** + * Visit a parse tree produced by {@link GobraParser#adtFieldDecl}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdtFieldDecl(GobraParser.AdtFieldDeclContext ctx); /** * Visit a parse tree produced by {@link GobraParser#ghostSliceType}. * @param ctx the parse tree diff --git a/src/main/scala/viper/gobra/ast/frontend/AstPattern.scala b/src/main/scala/viper/gobra/ast/frontend/AstPattern.scala index 3a6cfdc9c..96d88e903 100644 --- a/src/main/scala/viper/gobra/ast/frontend/AstPattern.scala +++ b/src/main/scala/viper/gobra/ast/frontend/AstPattern.scala @@ -20,6 +20,7 @@ object AstPattern { sealed trait Type extends Pattern + case class Import(id: PIdnUse, symb: st.Import) extends Type with Symbolic case class NamedType(id: PIdnUse, symb: st.ActualTypeEntity) extends Type with Symbolic case class PointerType(base: PType) extends Type case class AdtClause(id: PIdnUse, symb: st.AdtClause) extends Type with Symbolic diff --git a/src/main/scala/viper/gobra/ast/internal/PrettyPrinter.scala b/src/main/scala/viper/gobra/ast/internal/PrettyPrinter.scala index b1197c095..4a950981e 100644 --- a/src/main/scala/viper/gobra/ast/internal/PrettyPrinter.scala +++ b/src/main/scala/viper/gobra/ast/internal/PrettyPrinter.scala @@ -417,6 +417,8 @@ class DefaultPrettyPrinter extends PrettyPrinter with kiama.output.PrettyPrinter def showPatternMatchCaseExp(c: PatternMatchCaseExp): Doc = "case" <+> showMatchPattern(c.mExp) <> ":" <+> showExpr(c.exp) + def showPatternMatchCaseAss(c: PatternMatchCaseAss): Doc = "case" <+> showMatchPattern(c.mExp) <> ":" <+> showAss(c.ass) + def showMatchPattern(expr: MatchPattern): Doc = expr match { case MatchBindVar(name, _) => name case MatchAdt(clause, expr) => clause.name <+> "{" <> ssep(expr map showMatchPattern, ",") <> "}" @@ -430,6 +432,9 @@ class DefaultPrettyPrinter extends PrettyPrinter with kiama.output.PrettyPrinter case ExprAssertion(exp) => showExpr(exp) case Let(left, right, exp) => "let" <+> showVar(left) <+> "==" <+> parens(showExpr(right)) <+> "in" <+> showAss(exp) + case PatternMatchAss(exp, cases, default) => "match" <+> showExpr(exp) <+> + block(ssep(cases map showPatternMatchCaseAss, line) <> (if (default.isDefined) line <> "default:" <+> showAss(default.get) else "")) + case MagicWand(left, right) => showAss(left) <+> "--*" <+> showAss(right) case Implication(left, right) => showExpr(left) <+> "==>" <+> showAss(right) case Access(e, FullPerm(_)) => "acc" <> parens(showAcc(e)) @@ -628,7 +633,7 @@ class DefaultPrettyPrinter extends PrettyPrinter with kiama.output.PrettyPrinter val entriesDoc = showList(entries){ case (x,y) => showExpr(x) <> ":" <+> showExpr(y) } showType(lit.typ) <+> braces(space <> entriesDoc <> (if (entries.nonEmpty) space else emptyDoc)) - case AdtConstructorLit(typ, _, args) => showType(typ) <> braces(showExprList(args)) + case lit: AdtConstructorLit => lit.clause.name <> braces(showExprList(lit.args)) } // variables diff --git a/src/main/scala/viper/gobra/ast/internal/Program.scala b/src/main/scala/viper/gobra/ast/internal/Program.scala index 7012d607f..b24042b03 100644 --- a/src/main/scala/viper/gobra/ast/internal/Program.scala +++ b/src/main/scala/viper/gobra/ast/internal/Program.scala @@ -472,6 +472,10 @@ case class PatternMatchExp(exp: Expr, typ: Type, cases: Vector[PatternMatchCaseE case class PatternMatchCaseExp(mExp: MatchPattern, exp: Expr)(val info: Source.Parser.Info) extends Node +case class PatternMatchAss(exp: Expr, cases: Vector[PatternMatchCaseAss], default: Option[Assertion])(val info: Source.Parser.Info) extends Assertion + +case class PatternMatchCaseAss(mExp: MatchPattern, ass: Assertion)(val info: Source.Parser.Info) extends Node + case class PatternMatchStmt(exp: Expr, cases: Vector[PatternMatchCaseStmt], strict: Boolean)(val info: Source.Parser.Info) extends Stmt case class PatternMatchCaseStmt(mExp: MatchPattern, body: Stmt)(val info: Source.Parser.Info) extends Node @@ -760,11 +764,7 @@ case class RangeSequence(low : Expr, high : Expr)(val info : Source.Parser.Info) * The appending of two sequences represented by `left` and `right` * (which should be of identical types as result of type checking). */ -case class SequenceAppend(left : Expr, right : Expr)(val info: Source.Parser.Info) extends BinaryExpr("++") { - /** Should be identical to `right.typ`. */ - require(left.typ.isInstanceOf[SequenceT] && right.typ.isInstanceOf[SequenceT], s"expected two sequences, but got ${left.typ} and ${right.typ} (${info.origin})") - override val typ : Type = SequenceT(left.typ.asInstanceOf[SequenceT].t, Addressability.rValue) -} +case class SequenceAppend(left : Expr, right : Expr, typ: Type)(val info: Source.Parser.Info) extends BinaryExpr("++") /** * Denotes a ghost collection update "`col`[`left` = `right`]", which results in a @@ -772,7 +772,6 @@ case class SequenceAppend(left : Expr, right : Expr)(val info: Source.Parser.Inf * `baseUnderlyingType` is the underlyingType of `base`'s type */ case class GhostCollectionUpdate(base : Expr, left : Expr, right : Expr, baseUnderlyingType: Type)(val info: Source.Parser.Info) extends Expr { - require(baseUnderlyingType.isInstanceOf[SequenceT] || baseUnderlyingType.isInstanceOf[MathMapT], s"expected sequence or mmap, but got ${base.typ} (${info.origin})") override val typ : Type = base.typ.withAddressability(Addressability.rValue) } @@ -784,8 +783,7 @@ case class GhostCollectionUpdate(base : Expr, left : Expr, right : Expr, baseUnd */ case class SequenceDrop(left : Expr, right : Expr)(val info: Source.Parser.Info) extends Expr { /** Is equal to the type of `left`. */ - require(left.typ.isInstanceOf[SequenceT]) - override val typ : Type = SequenceT(left.typ.asInstanceOf[SequenceT].t, Addressability.rValue) + override val typ : Type = left.typ.withAddressability(Addressability.rValue) } /** @@ -796,8 +794,7 @@ case class SequenceDrop(left : Expr, right : Expr)(val info: Source.Parser.Info) */ case class SequenceTake(left : Expr, right : Expr)(val info: Source.Parser.Info) extends Expr { /** Is equal to the type of `left`. */ - require(left.typ.isInstanceOf[SequenceT]) - override val typ : Type = SequenceT(left.typ.asInstanceOf[SequenceT].t, Addressability.rValue) + override val typ : Type = left.typ.withAddressability(Addressability.rValue) } /** @@ -805,7 +802,7 @@ case class SequenceTake(left : Expr, right : Expr)(val info: Source.Parser.Info) * represented by `expr`, to a (mathematical) sequence of type 't'. * Here `expr` is assumed to be either a sequence or an exclusive array. */ -case class SequenceConversion(expr : Expr)(val info: Source.Parser.Info) extends Expr { +case class SequenceConversion(expr: Expr)(val info: Source.Parser.Info) extends Expr { override val typ : Type = expr.typ match { case t: SequenceT => t case t: ArrayT => t.sequence @@ -821,55 +818,19 @@ case class SequenceConversion(expr : Expr)(val info: Source.Parser.Info) extends * Represents a (multi)set union "`left` union `right`", * where `left` and `right` should be (multi)sets of identical types. */ -case class Union(left : Expr, right : Expr)(val info : Source.Parser.Info) extends BinaryExpr("union") { - /** `left.typ` is expected to be identical to `right.typ`. */ - require( - (left.typ.isInstanceOf[SetT] && right.typ.isInstanceOf[SetT]) - || (left.typ.isInstanceOf[MultisetT] && right.typ.isInstanceOf[MultisetT]), - s"expected set or multiset, but got ${left.typ} and ${right.typ} (${info.origin})" - ) - override val typ : Type = left.typ match { - case t: SetT => SetT(t.t, Addressability.rValue) - case t: MultisetT => MultisetT(t.t, Addressability.rValue) - case _ => Violation.violation("expected set or type") - } -} +case class Union(left : Expr, right : Expr, typ: Type)(val info : Source.Parser.Info) extends BinaryExpr("union") /** * Represents a (multi)set intersection "`left` intersection `right`", * where `left` and `right` should be (multi)sets of identical types. */ -case class Intersection(left : Expr, right : Expr)(val info : Source.Parser.Info) extends BinaryExpr("intersection") { - /** `left.typ` is expected to be identical to `right.typ`. */ - require( - (left.typ.isInstanceOf[SetT] && right.typ.isInstanceOf[SetT]) - || (left.typ.isInstanceOf[MultisetT] && right.typ.isInstanceOf[MultisetT]), - s"expected set or multiset, but got ${left.typ} and ${right.typ} (${info.origin})" - ) - override val typ : Type = left.typ match { - case t: SetT => SetT(t.t, Addressability.rValue) - case t: MultisetT => MultisetT(t.t, Addressability.rValue) - case _ => Violation.violation("expected set or type") - } -} +case class Intersection(left : Expr, right : Expr, typ: Type)(val info : Source.Parser.Info) extends BinaryExpr("intersection") /** * Represents a (multi)set difference "`left` setminus `right`", * where `left` and `right` should be (multi)sets of identical types. */ -case class SetMinus(left : Expr, right : Expr)(val info : Source.Parser.Info) extends BinaryExpr("setminus") { - /** `left.typ` is expected to be identical to `right.typ`. */ - require( - (left.typ.isInstanceOf[SetT] && right.typ.isInstanceOf[SetT]) - || (left.typ.isInstanceOf[MultisetT] && right.typ.isInstanceOf[MultisetT]), - s"expected set or multiset, but got ${left.typ} and ${right.typ} (${info.origin})" - ) - override val typ : Type = left.typ match { - case t: SetT => SetT(t.t, Addressability.rValue) - case t: MultisetT => MultisetT(t.t, Addressability.rValue) - case _ => Violation.violation("expected set or type") - } -} +case class SetMinus(left : Expr, right : Expr, typ: Type)(val info : Source.Parser.Info) extends BinaryExpr("setminus") /** * Represents a subset relation "`left` subset `right`", where @@ -1572,14 +1533,16 @@ case class DomainT(name: String, addressability: Addressability) extends PrettyT DomainT(name, newAddressability) } -case class AdtT(name: String, addressability: Addressability) extends PrettyType(s"adt{ name is $name }") with TopType { +case class AdtT(name: String, definedName: String, addressability: Addressability) extends PrettyType(s"adt{ name is $name }") with TopType { override def equalsWithoutMod(t: Type): Boolean = t match { case o: AdtT => name == o.name case _ => false } + val definedType: DefinedT = DefinedT(definedName, addressability) + override def withAddressability(newAddressability: Addressability): Type = - AdtT(name, newAddressability) + AdtT(name, definedName, newAddressability) } case class AdtClauseT(name: String, adtT: AdtT, fields: Vector[Field], addressability: Addressability) extends PrettyType(fields.mkString(s"$name{", ", ", "}")) { diff --git a/src/main/scala/viper/gobra/frontend/Desugar.scala b/src/main/scala/viper/gobra/frontend/Desugar.scala index b0e751931..241421109 100644 --- a/src/main/scala/viper/gobra/frontend/Desugar.scala +++ b/src/main/scala/viper/gobra/frontend/Desugar.scala @@ -1378,7 +1378,8 @@ object Desugar extends LazyLogging { domain = in.MapKeys(c, underlyingType(exp.typ))(src) - visited <- leftOfAssignmentD(range.enumerated, info)(in.SetT(keyType, Addressability.exclusiveVariable)) + visitedT = in.SetT(keyType, Addressability.exclusiveVariable) + visited <- leftOfAssignmentD(range.enumerated, info)(visitedT) perm <- freshDeclaredExclusiveVar(in.PermissionT(Addressability.exclusiveVariable), n, info)(src) @@ -1411,7 +1412,7 @@ object Desugar extends LazyLogging { breakLoopLabel = in.Label(breakLoopLabelProxy)(src) visitedEqDomain = in.Assert(in.ExprAssertion(in.EqCmp( - in.SetMinus(visited.op, domain)(src), + in.SetMinus(visited.op, domain, visitedT)(src), in.SetLit(keyType, Vector.empty)(src) )(src))(src))(src) @@ -1424,7 +1425,7 @@ object Desugar extends LazyLogging { in.Negation(in.Contains(k, visited.op)(src))(src))(src))(src))(src) ) ++ (if (hasValue) Vector(in.Initialization(v)(src), singleAss(in.Assignee.Var(v), in.IndexedExp(c, k, underlyingType(exp.typ))(src))(src)) else Vector()))(src) - updateVisited = singleAss(visited, in.Union(visited.op, in.SetLit(keyType, Vector(k))(src))(src))(src) + updateVisited = singleAss(visited, in.Union(visited.op, in.SetLit(keyType, Vector(k))(src), visitedT)(src))(src) enc = in.Seqn(Vector( singleAss(in.Assignee.Var(c), exp)(src), @@ -1458,7 +1459,8 @@ object Desugar extends LazyLogging { domain = in.MapKeys(c, underlyingType(exp.typ))(src) - visited <- leftOfAssignmentD(range.enumerated, info)(in.SetT(keyType, Addressability.exclusiveVariable)) + visitedT = in.SetT(keyType, Addressability.exclusiveVariable) + visited <- leftOfAssignmentD(range.enumerated, info)(visitedT) perm <- freshDeclaredExclusiveVar(in.PermissionT(Addressability.exclusiveVariable), n, info)(src) @@ -1491,7 +1493,7 @@ object Desugar extends LazyLogging { breakLoopLabel = in.Label(breakLoopLabelProxy)(src) visitedEqDomain = in.Assert(in.ExprAssertion(in.EqCmp( - in.SetMinus(visited.op, domain)(src), + in.SetMinus(visited.op, domain, visitedT)(src), in.SetLit(keyType, Vector.empty)(src) )(src))(src))(src) @@ -1506,7 +1508,7 @@ object Desugar extends LazyLogging { singleAss(k, tempk)(src) ) ++ (if (hasValue) Vector(singleAss(v, in.IndexedExp(c, k.op, underlyingType(exp.typ))(src))(src)) else Vector()))(src) - updateVisited = singleAss(visited, in.Union(visited.op, in.SetLit(keyType, Vector(k.op))(src))(src))(src) + updateVisited = singleAss(visited, in.Union(visited.op, in.SetLit(keyType, Vector(k.op))(src), visitedT)(src))(src) enc = in.Seqn(Vector( singleAss(in.Assignee.Var(c), exp)(src), @@ -1775,6 +1777,7 @@ object Desugar extends LazyLogging { in.GoClosureCall(call.closure, call.args, call.spec)(src) case Right(call: in.PureClosureCall) => in.GoClosureCall(call.closure, call.args, call.spec)(src) + case _ => unexpectedExprError(exp) } case _ => unexpectedExprError(exp) } @@ -2028,19 +2031,19 @@ object Desugar extends LazyLogging { for { base <- exprD(ctx, info)(p.base) } yield p.symb match { - case st.AdtDestructor(decl, adtDecl, context) => - val adtT: AdtT = context.symbType(adtDecl).asInstanceOf[AdtT] + case dest: st.AdtDestructor => + val adtT = dest.context.symbType(dest.adtType).asInstanceOf[AdtT] in.AdtDestructor(base, in.Field( - nm.adtField(decl.id.name, adtT), - typeD(context.symbType(decl.typ), Addressability.mathDataStructureElement)(src), + nm.adtField(dest.decl.id.name, adtT.decl), + typeD(dest.context.symbType(dest.decl.typ), Addressability.mathDataStructureElement)(src), ghost = true )(src))(src) - case st.AdtDiscriminator(decl, adtDecl, context) => - val adtT: AdtT = context.symbType(adtDecl).asInstanceOf[AdtT] + case disc: st.AdtDiscriminator => + val declT = Type.DeclaredT(disc.typeDecl, disc.context) in.AdtDiscriminator( base, - adtClauseProxy(nm.adt(adtT), decl, context.getTypeInfo) + adtClauseProxy(nm.adt(declT), disc.decl, disc.context.getTypeInfo) )(src) case _ => violation("Expected AdtDiscriminator or AdtDestructor") @@ -3039,86 +3042,19 @@ object Desugar extends LazyLogging { compositeTypeD(t) match { case CompositeKind.Struct(it, ist) => - val fields = ist.fields - - if (lit.elems.exists(_.key.isEmpty)) { - // all elements are not keyed - val wArgs = fields.zip(lit.elems).map { case (f, PKeyedElement(_, exp)) => - val wv = exp match { - case PExpCompositeVal(ev) => exprD(ctx, info)(ev) - case PLitCompositeVal(lv) => literalValD(ctx, info)(lv, f.typ) - } - wv.map{ v => implicitConversion(v.typ, f.typ, v) } - } - - for { - args <- sequence(wArgs) - } yield in.StructLit(it, args)(src) - - } else { // all elements are keyed - // maps field names to fields - val fMap = fields.map(f => nm.inverse(f.name) -> f).toMap - // maps fields to given value (if one is given) - val vMap = lit.elems.map { - case PKeyedElement(Some(PIdentifierKey(key)), exp) => - val f = fMap(key.name) - val wv = exp match { - case PExpCompositeVal(ev) => exprD(ctx, info)(ev) - case PLitCompositeVal(lv) => literalValD(ctx, info)(lv, f.typ) - } - f -> wv.map{ v => implicitConversion(v.typ, f.typ, v) } - - case _ => Violation.violation("expected identifier as a key") - }.toMap - // list of value per field - val wArgs = fields.map { - case f if vMap.isDefinedAt(f) => vMap(f) - case f => unit(in.DfltVal(f.typ)(src)) - } + val signature = ist.fields.map(f => nm.inverse(f.name) -> f.typ) - for { - args <- sequence(wArgs) - } yield in.StructLit(it, args)(src) - } + for { + args <- structLitLikeArguments(ctx, info)(lit, signature) + } yield in.StructLit(it, args)(src) case CompositeKind.Adt(t) => - val fields = t.fields + val signature = t.fields.map(f => nm.inverse(f.name) -> f.typ) val proxy = in.AdtClauseProxy(t.name, t.adtT.name)(src) - if (lit.elems.exists(_.key.isEmpty)) { - //All elements are unkeyed - - val wArgs = fields.zip(lit.elems).map { case (f, PKeyedElement(_, exp)) => exp match { - case PExpCompositeVal(ev) => exprD(ctx, info)(ev) - case PLitCompositeVal(lv) => literalValD(ctx, info)(lv, f.typ) - }} - - for { - args <- sequence(wArgs) - } yield in.AdtConstructorLit(t.adtT, proxy, args)(src) - } else { - val fMap = fields.map({ f => nm.inverse(f.name) -> f }).toMap - - val vMap = lit.elems.map { - case PKeyedElement(Some(PIdentifierKey(key)), exp) => - val f = fMap(key.name) - exp match { - case PExpCompositeVal(ev) => f -> exprD(ctx, info)(ev) - case PLitCompositeVal(lv) => f -> literalValD(ctx, info)(lv, f.typ) - } - - case _ => Violation.violation("expected identifier as a key") - }.toMap - - val wArgs = fields.map { - case f if vMap.isDefinedAt(f) => vMap(f) - case f => unit(in.DfltVal(f.typ)(src)) - } - - for { - args <- sequence(wArgs) - } yield in.AdtConstructorLit(t.adtT, proxy, args)(src) - } + for { + args <- structLitLikeArguments(ctx, info)(lit, signature) + } yield in.AdtConstructorLit(t.adtT.definedType, proxy, args)(src) case CompositeKind.Array(in.ArrayT(len, typ, addressability)) => Violation.violation(addressability == Addressability.literal, "Literals have to be exclusive") @@ -3159,6 +3095,42 @@ object Desugar extends LazyLogging { } } + private def structLitLikeArguments(ctx: FunctionContext, info: TypeInfo)(lit: PLiteralValue, signature: Vector[(String, in.Type)]): Writer[Vector[in.Expr]] = { + val src = meta(lit, info) + + val wArgs = if (lit.elems.exists(_.key.isEmpty)) { + // all elements are not keyed + signature.zip(lit.elems).map { case (f, PKeyedElement(_, exp)) => + val wv = exp match { + case PExpCompositeVal(ev) => exprD(ctx, info)(ev) + case PLitCompositeVal(lv) => literalValD(ctx, info)(lv, f._2) + } + wv.map { v => implicitConversion(v.typ, f._2, v) } + } + } else { // all elements are keyed + // maps key names to field types + val typeMap = signature.toMap + // maps key names to given value (if one is given) + val vMap = lit.elems.map { + case PKeyedElement(Some(PIdentifierKey(key)), exp) => + val fieldType = typeMap(key.name) + val wv = exp match { + case PExpCompositeVal(ev) => exprD(ctx, info)(ev) + case PLitCompositeVal(lv) => literalValD(ctx, info)(lv, fieldType) + } + key.name -> wv.map { v => implicitConversion(v.typ, fieldType, v) } + + case _ => Violation.violation("expected identifier as a key") + }.toMap + // list of value per field + signature.map { + case f if vMap.isDefinedAt(f._1) => vMap(f._1) + case f => unit(in.DfltVal(f._2)(src)) + } + } + sequence(wArgs) + } + private def handleMapEntries(ctx: FunctionContext, info: TypeInfo)(lit: PLiteralValue, keys: in.Type, values: in.Type): Writer[Seq[(in.Expr, in.Expr)]] = { violation(keys.addressability.isExclusive, s"Map literal keys always have exclusive types, but got $keys") violation(values.addressability.isExclusive, s"Map literal values always have exclusive types, but got $values") @@ -3199,9 +3171,10 @@ object Desugar extends LazyLogging { var definedFPredicates: Map[in.FPredicateProxy, in.FPredicate] = Map.empty var definedFuncLiterals: Map[in.FunctionLitProxy, in.FunctionLitLike] = Map.empty + def registerDefinedType(t: Type.DeclaredT, addrMod: Addressability)(src: Meta): in.DefinedT = { // this type was declared in the current package - val name = nm.typ(t.decl.left.name, t.context) + val name = nm.declaredType(t) def register(addrMod: Addressability): Unit = { if (!definedTypesSet.contains(name, addrMod)) { @@ -3676,9 +3649,9 @@ object Desugar extends LazyLogging { var registeredAdts: Set[String] = Set.empty - def fieldDeclAdtD(decl: PFieldDecl, context: ExternalTypeInfo, adt: AdtT)(src: Meta): in.Field = { - val fieldName = nm.adtField(decl.id.name, adt) - val typ = typeD(context.symbType(decl.typ), Addressability.mathDataStructureElement)(src) + def fieldDeclAdtD(name: String, ftyp: Type, @unused context: ExternalTypeInfo, adt: AdtT)(src: Meta): in.Field = { + val fieldName = nm.adtField(name, adt.decl) + val typ = typeD(ftyp, Addressability.mathDataStructureElement)(src) in.Field(fieldName, typ, true)(src) } @@ -3688,11 +3661,11 @@ object Desugar extends LazyLogging { AdditionalMembers.addFinalizingComputation { () => val xInfo = t.context.getTypeInfo - - val clauses = t.decl.clauses.map { c => - val src = meta(c, xInfo) - val proxy = adtClauseProxy(aT.name, c, xInfo) - val fields = c.args.flatMap(_.fields).map(f => fieldDeclAdtD(f, t.context, t)(src)) + val adtDecl = t.adtDecl + val clauses = (adtDecl.clauses zip t.clauses).map { case (cDecl, c) => + val src = meta(cDecl, xInfo) + val proxy = adtClauseProxy(aT.name, cDecl, xInfo) + val fields = c.fields.map(f => fieldDeclAdtD(f._1, f._2, t.context, t)(src)) in.AdtClause(proxy, fields)(src) } @@ -3704,17 +3677,6 @@ object Desugar extends LazyLogging { } } - def getAdtClauseTagMap(t: Type.AdtT): Map[String, BigInt] = { - t.decl.clauses - .map(c => idName(c.id, t.context.getTypeInfo)) - .sortBy(s => s) - .zipWithIndex - .map { - case (s, i) => s -> BigInt(i) - } - .toMap - } - def embeddedTypeD(t: PEmbeddedType, addrMod: Addressability)(src: Meta): in.Type = t match { case PEmbeddedName(typ) => typeD(info.symbType(typ), addrMod)(src) case PEmbeddedPointer(typ) => @@ -3752,17 +3714,19 @@ object Desugar extends LazyLogging { registerType(in.StructT(inFields, addrMod)) case t: Type.AdtT => - val adtName = nm.adt(t) - val res = registerType(in.AdtT(adtName, addrMod)) + val adtName = nm.adt(t.declaredType) + val definedName = nm.declaredType(t.declaredType) + val res = registerType(in.AdtT(adtName, definedName, addrMod)) registerAdt(t, res) res case t: Type.AdtClauseT => - val tAdt = Type.AdtT(t.adtT, t.context) - val adt: in.AdtT = in.AdtT(nm.adt(tAdt), addrMod) - val fields: Vector[in.Field] = (t.fieldsWithTypes map { case (key: String, typ: Type) => - in.Field(nm.adtField(key, tAdt), typeD(typ, Addressability.mathDataStructureElement)(src), true)(src) - }).toVector + val adtName = nm.adt(t.declaredType) + val definedName = nm.declaredType(t.declaredType) + val adt: in.AdtT = in.AdtT(adtName, definedName, addrMod) + val fields: Vector[in.Field] = t.fields.map{ case (key: String, typ: Type) => + in.Field(nm.adtField(key, t.typeDecl), typeD(typ, Addressability.mathDataStructureElement)(src), true)(src) + } in.AdtClauseT(idName(t.decl.id, t.context.getTypeInfo), adt, fields, addrMod) case Type.PredT(args) => in.PredT(args.map(typeD(_, Addressability.rValue)(src)), Addressability.rValue) @@ -4077,7 +4041,7 @@ object Desugar extends LazyLogging { case p: PClosureImplProof => closureImplProofD(ctx)(p) case PExplicitGhostStatement(actual) => stmtD(ctx, info)(actual) - case PMatchStatement(exp, clauses, strict) => { + case PMatchStatement(exp, clauses, strict) => def goC(clause: PMatchStmtCase): Writer[in.PatternMatchCaseStmt] = { val body = block( @@ -4096,7 +4060,6 @@ object Desugar extends LazyLogging { e <- exprD(ctx, info)(exp) c <- sequence(clauses map goC) } yield in.PatternMatchStmt(e, c, strict)(src) - } case _ => ??? } @@ -4323,7 +4286,7 @@ object Desugar extends LazyLogging { case PSequenceAppend(left, right) => for { dleft <- go(left) dright <- go(right) - } yield in.SequenceAppend(dleft, dright)(src) + } yield in.SequenceAppend(dleft, dright, typ)(src) case PGhostCollectionUpdate(col, clauses) => clauses.foldLeft(go(col)) { case (dcol, clause) => for { @@ -4355,17 +4318,17 @@ object Desugar extends LazyLogging { case PUnion(left, right) => for { dleft <- go(left) dright <- go(right) - } yield in.Union(dleft, dright)(src) + } yield in.Union(dleft, dright, typ)(src) case PIntersection(left, right) => for { dleft <- go(left) dright <- go(right) - } yield in.Intersection(dleft, dright)(src) + } yield in.Intersection(dleft, dright, typ)(src) case PSetMinus(left, right) => for { dleft <- go(left) dright <- go(right) - } yield in.SetMinus(dleft, dright)(src) + } yield in.SetMinus(dleft, dright, typ)(src) case PSubset(left, right) => for { dleft <- go(left) @@ -4394,7 +4357,7 @@ object Desugar extends LazyLogging { dop <- go(op) } yield in.OptionGet(dop)(src) - case m@PMatchExp(exp, _) => + case m: PMatchExp => val defaultD: Writer[Option[in.Expr]] = if (m.hasDefault) { for { e <- exprD(ctx, info)(m.defaultClauses.head.exp) @@ -4409,7 +4372,7 @@ object Desugar extends LazyLogging { } yield in.PatternMatchCaseExp(p, e)(src) for { - e <- exprD(ctx, info)(exp) + e <- exprD(ctx, info)(m.exp) cs <- sequence(m.caseClauses map caseD) de <- defaultD } yield in.PatternMatchExp(e, typ, cs, de)(src) @@ -4546,6 +4509,27 @@ object Desugar extends LazyLogging { }) } yield lets + case m: PMatchExp => + val defaultD: Writer[Option[in.Assertion]] = if (m.hasDefault) { + for { + e <- assertionD(ctx, info)(m.defaultClauses.head.exp) + } yield Some(e) + } else { + unit(None) + } + + def caseD(c: PMatchExpCase): Writer[in.PatternMatchCaseAss] = for { + p <- matchPatternD(ctx, info)(c.pattern) + e <- assertionD(ctx, info)(c.exp) + } yield in.PatternMatchCaseAss(p, e)(src) + + for { + e <- exprD(ctx, info)(m.exp) + cs <- sequence(m.caseClauses map caseD) + de <- defaultD + } yield in.PatternMatchAss(e, cs, de)(src) + + case n: PInvoke => // a predicate invocation corresponds to a predicate access with full permissions // register the full permission AST node in the position manager such that its meta information @@ -4990,20 +4974,22 @@ object Desugar extends LazyLogging { } } + def declaredType(t: Type.DeclaredT): String = { + typ(t.decl.left.name, t.context) + } + def domain(s: DomainT): String = { val pom = s.context.getTypeInfo.tree.originalRoot.positions val hash = srcTextName(pom, s.decl.funcs, s.decl.axioms) s"$DOMAIN_PREFIX$$${topLevelName("")(hash, s.context)}" } - def adt(a: AdtT): String = { - val pom = a.context.getTypeInfo.tree.originalRoot.positions - val hash = srcTextName(pom, a.decl.clauses) - s"$ADT_PREFIX$$${topLevelName("")(hash, a.context)}" + def adt(t: Type.DeclaredT): String = { + s"$ADT_PREFIX$$${declaredType(t)}" } /** can be inversed with [[inverse]] */ - def adtField(n: String, @unused s: AdtT): String = s"$n$FIELD_PREFIX" + def adtField(n: String, @unused s: PTypeDef): String = s"$n$FIELD_PREFIX" def label(n: String): String = n match { case "#lhs" => "lhs" diff --git a/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala b/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala index c63d3911d..e22e611c2 100644 --- a/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala +++ b/src/main/scala/viper/gobra/frontend/ParseTreeTranslator.scala @@ -525,14 +525,26 @@ class ParseTreeTranslator(pom: PositionManager, source: Source, specOnly : Boole } override def visitAdtClause(ctx: AdtClauseContext): PAdtClause = { - val id = idnDef.unapply(ctx.IDENTIFIER()) - val fieldClauses = ctx.fieldDecl().asScala.toVector.map(visitFieldDecl) - val args = fieldClauses.collect{ case x: PFieldDecls => x } + val id = idnDef.unapply(ctx.IDENTIFIER()).get + val fieldClauses = ctx.adtFieldDecl().asScala.toVector.map(visitAdtFieldDecl) + val args = fieldClauses.zipWithIndex.map{ + case (AdtFieldDecl(Vector(), t), idx) => + PFieldDecls(Vector(PFieldDecl(PIdnDef(s"_${id.name}_$idx").at(t), t).at(t))).at(t) - // embedded fields and ghost struct clauses are not supported. - if (id.isEmpty || args.size != fieldClauses.size) fail(ctx) + case (AdtFieldDecl(xs, t), _) => + PFieldDecls(xs.map(x => PFieldDecl(x, t.copy).at(x))).at(t) + } - PAdtClause(id.get, args).at(ctx) + PAdtClause(id, args).at(ctx) + } + + case class AdtFieldDecl(vars: Vector[PIdnDef], typ: PType) + override def visitAdtFieldDecl(ctx: AdtFieldDeclContext): AdtFieldDecl = { + visitChildren(ctx) match { + case t: PType => AdtFieldDecl(Vector.empty, t) + case Vector(goIdnDefList(xs), t: PType) => AdtFieldDecl(xs, t) + case _ => fail(ctx) + } } override def visitMatchStmt(ctx: MatchStmtContext): PMatchStatement = { @@ -2309,21 +2321,24 @@ class ParseTreeTranslator(pom: PositionManager, source: Source, specOnly : Boole override def visitChildren(node: RuleNode): AnyRef = { node match { - case context: ParserRuleContext => { - context.children.asScala.view.map{n => - (n.accept(this), n) match { - case (p : PNode, ctx : ParserRuleContext) => p.at(ctx) - case (p : PNode, term : TerminalNode) => p.at(term) - case (p, _) => p + case context: ParserRuleContext => + if (context.children == null) Vector.empty + else { + context.children.asScala.view.map { n => + (n.accept(this), n) match { + case (p: PNode, ctx: ParserRuleContext) => p.at(ctx) + case (p: PNode, term: TerminalNode) => p.at(term) + case (p, _) => p + } + }.toVector match { + // make sure to avoid nested vectors of single items + case Vector(res) => res + case Vector("(", res, ")") => res + case v => v } - }.toVector match { - // make sure to avoid nested vectors of single items - case Vector(res) => res - case Vector("(", res, ")") => res - case v => v } - } - case x => violation(s"Expected ParserRuleContext, but got ${x}") + + case x => violation(s"Expected ParserRuleContext, but got $x") } } diff --git a/src/main/scala/viper/gobra/frontend/info/base/SymbolTable.scala b/src/main/scala/viper/gobra/frontend/info/base/SymbolTable.scala index d5b905bd9..8b96ff873 100644 --- a/src/main/scala/viper/gobra/frontend/info/base/SymbolTable.scala +++ b/src/main/scala/viper/gobra/frontend/info/base/SymbolTable.scala @@ -249,7 +249,7 @@ object SymbolTable extends Environments[Entity] { sealed trait GhostStructMember extends StructMember with GhostTypeMember - case class DomainFunction(decl: PDomainFunction, domain: PDomainType, context: ExternalTypeInfo) extends GhostRegular with WithArguments with WithResult { + case class DomainFunction(decl: PDomainFunction, domain: PDomainType, context: ExternalTypeInfo) extends GhostTypeMember with WithArguments with WithResult { override def rep: PNode = decl override val args: Vector[PParameter] = decl.args override val result: PResult = decl.result @@ -261,11 +261,13 @@ object SymbolTable extends Environments[Entity] { override def addressable: Boolean = false } - case class AdtClause(decl: PAdtClause, adtDecl: PAdtType, context: ExternalTypeInfo) extends GhostRegular { + case class AdtClause(decl: PAdtClause, typeDecl: PTypeDef, context: ExternalTypeInfo) extends GhostTypeMember with TypeEntity { + require(typeDecl.right.isInstanceOf[PAdtType]) + override def rep: PNode = decl + val adtDecl: PAdtType = typeDecl.right.asInstanceOf[PAdtType] def getName: String = decl.id.name - val fields: Vector[PFieldDecl] = decl.args.flatMap(f => f.fields) } @@ -273,13 +275,13 @@ object SymbolTable extends Environments[Entity] { def getName: String } - case class AdtDestructor(decl: PFieldDecl, adtType: PAdtType, context: ExternalTypeInfo) extends AdtMember { + case class AdtDestructor(decl: PFieldDecl, typeDecl: PTypeDef, adtType: PAdtType, context: ExternalTypeInfo) extends AdtMember { override def rep: PNode = decl override def getName: String = decl.id.name } - case class AdtDiscriminator(decl: PAdtClause, adtType: PAdtType, context: ExternalTypeInfo) extends AdtMember { + case class AdtDiscriminator(decl: PAdtClause, typeDecl: PTypeDef, adtType: PAdtType, context: ExternalTypeInfo) extends AdtMember { override def rep: PNode = decl override def getName: String = s"is${decl.id.name}" diff --git a/src/main/scala/viper/gobra/frontend/info/base/Type.scala b/src/main/scala/viper/gobra/frontend/info/base/Type.scala index 5604d4e22..66cb0fa49 100644 --- a/src/main/scala/viper/gobra/frontend/info/base/Type.scala +++ b/src/main/scala/viper/gobra/frontend/info/base/Type.scala @@ -8,7 +8,7 @@ package viper.gobra.frontend.info.base import org.bitbucket.inkytonik.kiama.==> import org.bitbucket.inkytonik.kiama.util.Messaging.Messages -import viper.gobra.ast.frontend.{PAdtClause, PAdtType, PDomainType, PImport, PInterfaceType, PNode, PStructType, PTypeDecl} +import viper.gobra.ast.frontend.{PAdtClause, PAdtType, PDomainType, PImport, PInterfaceType, PNode, PStructType, PTypeDecl, PTypeDef} import viper.gobra.frontend.info.ExternalTypeInfo import viper.gobra.util.TypeBounds @@ -56,18 +56,20 @@ object Type { case class DomainT(decl: PDomainType, context: ExternalTypeInfo) extends PrettyType("domain{...}") with ContextualType - case class AdtT(decl: PAdtType, context: ExternalTypeInfo) extends Type + case class AdtT(clauses: Vector[AdtClauseT], decl: PTypeDef, context: ExternalTypeInfo) extends PrettyType(decl.left.name) { + val adtDecl: PAdtType = decl.right.asInstanceOf[PAdtType] + val declaredType: DeclaredT = DeclaredT(decl, context) + } - case class AdtClauseT(fieldsToTypes: Map[String, Type], fields: Vector[String], decl: PAdtClause, adtT: PAdtType, context: ExternalTypeInfo) extends Type { - require(fields.forall(fieldsToTypes.isDefinedAt), "there must be a type for each key") + case class AdtClauseT(name: String, fields: Vector[(String, Type)], decl: PAdtClause, typeDecl: PTypeDef, context: ExternalTypeInfo) extends PrettyType(name) { + val adtDecl: PAdtType = typeDecl.right.asInstanceOf[PAdtType] + val typeMap: Map[String, Type] = fields.toMap + val declaredType: DeclaredT = DeclaredT(typeDecl, context) def typeAt(idx: Int): Type = { require(0 <= idx && idx < fields.size, s"index $idx is not within range of ADT fields (size ${fields.size})") - fieldsToTypes(fields(idx)) + fields(idx)._2 } - - lazy val fieldsWithTypes: Vector[(String, Type)] = fields.map(f => (f, fieldsToTypes(f))) - lazy val fieldTypes: Vector[Type] = fieldsWithTypes.map(_._2) } case class MapT(key: Type, elem: Type) extends PrettyType(s"map[$key]$elem") diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/property/Assignability.scala b/src/main/scala/viper/gobra/frontend/info/implementation/property/Assignability.scala index e79d3a9d3..1175fe801 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/property/Assignability.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/property/Assignability.scala @@ -98,7 +98,6 @@ trait Assignability extends BaseProperty { this: TypeInfoImpl => case (MultisetT(l), MultisetT(r)) => assignableTo.result(l,r) case (OptionT(l), OptionT(r)) => assignableTo.result(l, r) case (IntT(_), PermissionT) => successProp - case (c: AdtClauseT, UnderlyingType(t: AdtT)) if c.context == t.context && c.adtT == t.decl => successProp // conservative choice case _ => errorProp() @@ -162,18 +161,7 @@ trait Assignability extends BaseProperty { this: TypeInfoImpl => }) } else if (elems.size == s.embedded.size + s.fields.size) { propForall( - elems.map(_.exp).zip(s.fieldsAndEmbedded.values),/* - elems.map(_.exp).zip(decl.clauses.flatMap { cl => - def clauseInducedTypes(clause: PActualStructClause): Vector[Type] = clause match { - case PEmbeddedDecl(embeddedType, _) => Vector(context.typ(embeddedType)) - case PFieldDecls(fields) => fields map (f => context.typ(f.typ)) - } - - cl match { - case PExplicitGhostStructClause(c) => clauseInducedTypes(c) - case c: PActualStructClause => clauseInducedTypes(c) - } - }),*/ + elems.map(_.exp).zip(s.fieldsAndEmbedded.values), compositeValAssignableTo ) } else { @@ -184,7 +172,7 @@ trait Assignability extends BaseProperty { this: TypeInfoImpl => if (elems.isEmpty) { successProp } else if (elems.exists(_.key.nonEmpty)) { - val tmap: Map[String, Type] = a.fieldsToTypes + val tmap: Map[String, Type] = a.typeMap failedProp("for adt literals either all or none elements must be keyed", !elems.forall(_.key.nonEmpty)) and @@ -198,7 +186,7 @@ trait Assignability extends BaseProperty { this: TypeInfoImpl => }) } else if (elems.size == a.fields.size) { propForall( - elems.map(_.exp).zip(a.fieldTypes), + elems.map(_.exp).zip(a.fields.map(_._2)), compositeValAssignableTo ) } else { diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/property/Implements.scala b/src/main/scala/viper/gobra/frontend/info/implementation/property/Implements.scala index 5129fa76e..4ab3a32ce 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/property/Implements.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/property/Implements.scala @@ -6,7 +6,7 @@ package viper.gobra.frontend.info.implementation.property -import viper.gobra.ast.frontend.{PExplicitGhostStructClause, PInterfaceType, PTypeDef, AstPattern => ap} +import viper.gobra.ast.frontend.{PInterfaceType, PTypeDef, AstPattern => ap} import viper.gobra.frontend.info.base.SymbolTable.{MPredicateSpec, Method} import viper.gobra.frontend.info.base.{Type, SymbolTable => st} import viper.gobra.frontend.info.base.Type.{GhostCollectionType, NilType, Type} @@ -104,12 +104,13 @@ trait Implements { this: TypeInfoImpl => case Type.NilType | Type.BooleanT | _: Type.IntT | Type.StringT => true case ut: Type.PointerT => go(ut.elem) case ut: Type.StructT => - ut.decl.clauses.forall(!_.isInstanceOf[PExplicitGhostStructClause]) && - ut.clauses.forall{ case (_, (_, fieldType)) => go(fieldType) } + ut.clauses.forall{ case (_, (_, fieldType)) => go(fieldType) } case ut: Type.ArrayT => go(ut.elem) case _: Type.SliceT => true case _: Type.MapT => true case ut: Type.OptionT => go(ut.elem) + case ut: Type.AdtT => + ut.clauses.forall(_.fields.forall(f => go(f._2))) case ut: GhostCollectionType => go(ut.elem) case _: Type.InterfaceT => true case _ => false diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/property/TypeIdentity.scala b/src/main/scala/viper/gobra/frontend/info/implementation/property/TypeIdentity.scala index d46efbb34..e8a3c564a 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/property/TypeIdentity.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/property/TypeIdentity.scala @@ -39,7 +39,6 @@ trait TypeIdentity extends BaseProperty { this: TypeInfoImpl => case (OptionT(l), OptionT(r)) => identicalTypes(l, r) case (l: DomainT, r: DomainT) => l == r case (l: AdtT, r: AdtT) => l == r - case (l: AdtClauseT, r: AdtClauseT) => l == r case (StructT(clausesL, _, contextL), StructT(clausesR, _, contextR)) => contextL == contextR && clausesL.size == clausesR.size && clausesL.zip(clausesR).forall { diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/property/TypeMerging.scala b/src/main/scala/viper/gobra/frontend/info/implementation/property/TypeMerging.scala index 9aa0ffe51..b78a0ecda 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/property/TypeMerging.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/property/TypeMerging.scala @@ -7,7 +7,7 @@ package viper.gobra.frontend.info.implementation.property import viper.gobra.ast.internal.{Float32T, Float64T} -import viper.gobra.frontend.info.base.Type.{AdtClauseT, AdtT, ArrayT, ChannelT, GhostSliceT, IntT, InternalSingleMulti, InternalTupleT, MapT, MultisetT, PermissionT, PointerT, SequenceT, SetT, Single, SliceT, Type} +import viper.gobra.frontend.info.base.Type.{ArrayT, AssertionT, BooleanT, ChannelT, GhostSliceT, IntT, InternalTupleT, MapT, MultisetT, PermissionT, PointerT, SequenceT, SetT, Single, SliceT, Type} import viper.gobra.frontend.info.implementation.TypeInfoImpl trait TypeMerging extends BaseProperty { this: TypeInfoImpl => @@ -20,44 +20,40 @@ trait TypeMerging extends BaseProperty { this: TypeInfoImpl => // possible future improvement: if l is assignable to r, then return r instead of None (or vice versa) (l, r) match { case (Single(lst), Single(rst)) => - if (identicalTypes(lst, rst)) Some(lst) else { - (lst, rst) match { - case (a, UNTYPED_INT_CONST) if underlyingType(a).isInstanceOf[IntT] => Some(a) - case (UNTYPED_INT_CONST, b) if underlyingType(b).isInstanceOf[IntT] => Some(b) - case (a, UNTYPED_INT_CONST) if underlyingType(a).isInstanceOf[Float64T] => Some(a) - case (UNTYPED_INT_CONST, b) if underlyingType(b).isInstanceOf[Float64T] => Some(b) - case (a, UNTYPED_INT_CONST) if underlyingType(a).isInstanceOf[Float32T] => Some(a) - case (UNTYPED_INT_CONST, b) if underlyingType(b).isInstanceOf[Float32T] => Some(b) - case (IntT(_), PermissionT) => Some(PermissionT) - case (PermissionT, IntT(_)) => Some(PermissionT) - case (SequenceT(l), SequenceT(r)) => typeMerge(l,r) map SequenceT - case (SetT(l), SetT(r)) => typeMerge(l,r) map SetT - case (MultisetT(l), MultisetT(r)) => typeMerge(l,r) map MultisetT - case (ArrayT(len1, l), ArrayT(len2, r)) if len1 == len2 => typeMerge(l,r) map (ArrayT(len1, _)) - case (SliceT(l), SliceT(r)) => typeMerge(l,r) map SliceT - case (GhostSliceT(l), GhostSliceT(r)) => typeMerge(l,r) map GhostSliceT - case (MapT(k1, v1), MapT(k2, v2)) => for { - k <- typeMerge(k1, k2) - v <- typeMerge(v1, v2) - } yield MapT(k,v) - case (PointerT(l), PointerT(r)) => typeMerge(l,r) map PointerT - case (ChannelT(l, mod1), ChannelT(r, mod2)) if mod1 == mod2 => typeMerge(l,r) map (ChannelT(_,mod1)) - case (InternalTupleT(v1), InternalTupleT(v2)) => - val v = v1.zip(v2).map {case (l, r) => typeMerge(l, r)} - if (v.contains(None)) None else Some(InternalTupleT(v map (_.get))) - case (InternalSingleMulti(sin1, multi1), InternalSingleMulti(sin2, multi2)) => for { - sin <- typeMerge(sin1, sin2) - multi <- typeMerge(multi1, multi2) - } yield InternalSingleMulti(sin, multi.asInstanceOf[InternalTupleT]) + (lst, rst) match { + case (a, b) if identicalTypes(a,b) => Some(a) + case (a, b) if identicalTypes(underlyingType(a),b) => Some(a) + case (a, b) if identicalTypes(a,underlyingType(b)) => Some(b) - case (l: AdtClauseT, r: AdtClauseT) - if l.context == r.context && l.adtT == r.adtT => Some(AdtT(l.adtT, l.context)) - case (c: AdtClauseT, u@UnderlyingType(a: AdtT)) if c.context == a.context && c.adtT == a.decl => Some(u) - case (u@UnderlyingType(a: AdtT), c: AdtClauseT) if c.context == a.context && c.adtT == a.decl => Some(u) - - case _ => None - } + case (a, UNTYPED_INT_CONST) if underlyingType(a).isInstanceOf[IntT] => Some(a) + case (UNTYPED_INT_CONST, b) if underlyingType(b).isInstanceOf[IntT] => Some(b) + case (a, UNTYPED_INT_CONST) if underlyingType(a).isInstanceOf[Float64T] => Some(a) + case (UNTYPED_INT_CONST, b) if underlyingType(b).isInstanceOf[Float64T] => Some(b) + case (a, UNTYPED_INT_CONST) if underlyingType(a).isInstanceOf[Float32T] => Some(a) + case (UNTYPED_INT_CONST, b) if underlyingType(b).isInstanceOf[Float32T] => Some(b) + case (BooleanT, AssertionT) => Some(AssertionT) + case (AssertionT, BooleanT) => Some(AssertionT) + case (IntT(_), PermissionT) => Some(PermissionT) + case (PermissionT, IntT(_)) => Some(PermissionT) + case (SequenceT(l), SequenceT(r)) => typeMerge(l, r) map SequenceT + case (SetT(l), SetT(r)) => typeMerge(l, r) map SetT + case (MultisetT(l), MultisetT(r)) => typeMerge(l, r) map MultisetT + case (ArrayT(len1, l), ArrayT(len2, r)) if len1 == len2 => typeMerge(l, r) map (ArrayT(len1, _)) + case (SliceT(l), SliceT(r)) => typeMerge(l, r) map SliceT + case (GhostSliceT(l), GhostSliceT(r)) => typeMerge(l, r) map GhostSliceT + case (MapT(k1, v1), MapT(k2, v2)) => for { + k <- typeMerge(k1, k2) + v <- typeMerge(v1, v2) + } yield MapT(k, v) + case (PointerT(l), PointerT(r)) => typeMerge(l, r) map PointerT + case (ChannelT(l, mod1), ChannelT(r, mod2)) if mod1 == mod2 => typeMerge(l, r) map (ChannelT(_, mod1)) + case _ => None } + + case (InternalTupleT(v1), InternalTupleT(v2)) => + val v = v1.zip(v2).map { case (l, r) => typeMerge(l, r) } + if (v.contains(None)) None else Some(InternalTupleT(v map (_.get))) + case _ => None } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/AdvancedMemberSet.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/AdvancedMemberSet.scala index b05b5b470..43cc8d374 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/AdvancedMemberSet.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/AdvancedMemberSet.scala @@ -97,7 +97,9 @@ object AdvancedMemberSet { case Field(m, _, _) => m.id.name case Embbed(m, _, _) => m.id.name case t: AdtMember => t.getName + case t: AdtClause => t.getName case ml: BuiltInMethodLike => ml.tag.identifier + case f: DomainFunction => f.decl.id.name } extractMemberName(tm) -> tm diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/AmbiguityResolution.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/AmbiguityResolution.scala index 64b51d831..a6597b7e5 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/AmbiguityResolution.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/AmbiguityResolution.scala @@ -9,7 +9,7 @@ package viper.gobra.frontend.info.implementation.resolution import viper.gobra.ast.frontend._ import viper.gobra.ast.frontend.{AstPattern => ap} import viper.gobra.frontend.info.base.{SymbolTable => st} -import viper.gobra.frontend.info.base.Type.{ImportT, PredT, FunctionT} +import viper.gobra.frontend.info.base.Type.{AdtT, FunctionT, ImportT, PredT} import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.util.Violation.violation @@ -30,8 +30,8 @@ trait AmbiguityResolution { this: TypeInfoImpl => exprOrType(n.base) .fold( _ => Left(n), - symbType(_) match { // check if base is a package qualifier and id points to a type - case _: ImportT if pointsToType(n.id) => Right(n) + baseType => underlyingType(symbType(baseType)) match { // check if base is a package qualifier and id points to a type + case _: ImportT | _: AdtT if pointsToType(n.id) => Right(n) case _ => Left(n) }) @@ -50,6 +50,7 @@ trait AmbiguityResolution { this: TypeInfoImpl => case n: PNamedOperand => entity(n.id) match { + case s: st.Import => Some(ap.Import(n.id, s)) case s: st.NamedType => Some(ap.NamedType(n.id, s)) case s: st.Variable => s match { case g: st.GlobalVariable => Some(ap.GlobalVariable(n.id, g)) @@ -88,7 +89,7 @@ trait AmbiguityResolution { this: TypeInfoImpl => case (Right(base), Some((s: st.Method, path))) => Some(ap.MethodExpr(base, n.id, path, s)) case (Right(base), Some((s: st.MPredicate, path))) => Some(ap.PredicateExpr(base, n.id, path, s)) - // imported members + // imported members (also via adt) case (Right(_), Some((s: st.ActualTypeEntity, _))) => Some(ap.NamedType(n.id, s)) case (Right(_), Some((s: st.Constant, _))) => Some(ap.Constant(n.id, s)) case (Right(_), Some((s: st.GlobalVariable, _))) => Some(ap.GlobalVariable(n.id, s)) diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala index f38148c79..238158abf 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/MemberResolution.scala @@ -71,9 +71,9 @@ trait MemberResolution { this: TypeInfoImpl => // ADT /** Destructors and discriminator induced by adt clause */ - private def adtClauseMemberSet(decl: PAdtClause, adtDecl: PAdtType, ctx: ExternalTypeInfo): AdvancedMemberSet[AdtMember] = { - val fields = decl.args.flatMap(_.fields).map(f => AdtDestructor(f, adtDecl, ctx)) - val discriminator = AdtDiscriminator(decl, adtDecl, ctx) + private def adtClauseMemberSet(decl: PAdtClause, typeDecl: PTypeDef, adtDecl: PAdtType, ctx: ExternalTypeInfo): AdvancedMemberSet[AdtMember] = { + val fields = decl.args.flatMap(_.fields).map(f => AdtDestructor(f, typeDecl, adtDecl, ctx)) + val discriminator = AdtDiscriminator(decl, typeDecl, adtDecl, ctx) AdvancedMemberSet.init[AdtMember](discriminator +: fields) } @@ -89,13 +89,10 @@ trait MemberResolution { this: TypeInfoImpl => case PointerT(t) if !pastDeref => go(pastDeref = true)(t).ref case t: AdtT => - val clauseMemberSets = t.decl.clauses.map(adtClauseMemberSet(_, t.decl, t.context)) + val clauseMemberSets = t.adtDecl.clauses.map(adtClauseMemberSet(_, t.decl, t.adtDecl, t.context)) AdvancedMemberSet.union(clauseMemberSets) - case t: AdtClauseT => - val fields = t.decl.args.flatMap(_.fields).map(f => AdtDestructor(f, t.adtT, t.context)) - val discriminator = AdtDiscriminator(t.decl, t.adtT, t.context) - AdvancedMemberSet.init[AdtMember](discriminator +: fields) + case t: AdtClauseT => adtClauseMemberSet(t.decl, t.typeDecl, t.adtDecl, t.context) case _ => AdvancedMemberSet.empty } @@ -103,12 +100,46 @@ trait MemberResolution { this: TypeInfoImpl => go(pastDeref = false) } - val adtMemberSet: Type => AdvancedMemberSet[AdtMember] = + lazy val adtMemberSet: Type => AdvancedMemberSet[AdtMember] = attr[Type, AdvancedMemberSet[AdtMember]] { case Single(t) => adtSuffix(t) union pastPromotions(adtSuffix)(t) case _ => AdvancedMemberSet.empty } + lazy val adtConstructorSet: Type => AdvancedMemberSet[AdtClause] = { + + def constructorSuffix(t: Type): AdvancedMemberSet[AdtClause] = { + t match { + case t: AdtT => + AdvancedMemberSet.init( + t.adtDecl.clauses.map { clause => AdtClause(clause, t.decl, t.context) } + ) + case _ => AdvancedMemberSet.empty + } + } + + attr[Type, AdvancedMemberSet[AdtClause]] { + case Single(t) => constructorSuffix(t) union pastPromotions(constructorSuffix)(t) + case _ => AdvancedMemberSet.empty + } + } + + lazy val domainFunctionSet: Type => AdvancedMemberSet[DomainFunction] = { + + def domainSuffix(t: Type): AdvancedMemberSet[DomainFunction] = { + t match { + case t: DomainT => + AdvancedMemberSet.init(t.decl.funcs.map { f => DomainFunction(f, t.decl, t.context) }) + case _ => AdvancedMemberSet.empty + } + } + + attr[Type, AdvancedMemberSet[DomainFunction]] { + case Single(t) => domainSuffix(t) union pastPromotions(domainSuffix)(t) + case _ => AdvancedMemberSet.empty + } + } + // Methods private lazy val receiverMethodSetMap: Map[Type, AdvancedMemberSet[TypeMember]] = { @@ -322,7 +353,15 @@ trait MemberResolution { this: TypeInfoImpl => } case Right(typ) => // base is a type typeSymbType(typ) match { - case pkg: ImportT => tryPackageLookup(RegularImport(pkg.decl.importPath), id, pkg.decl) + case pkg: ImportT => + tryPackageLookup(RegularImport(pkg.decl.importPath), id, pkg.decl) + + case DeclaredT(PTypeDef(adt: PAdtType, _), ctx) => + adtConstructorSet(ctx.symbType(adt)).lookupWithPath(id.name) + + case DeclaredT(PTypeDef(domain: PDomainType, _), ctx) => + domainFunctionSet(ctx.symbType(domain)).lookupWithPath(id.name) + case t => tryMethodLikeLookup(t, id) } } @@ -389,7 +428,6 @@ trait MemberResolution { this: TypeInfoImpl => } } - /** lookup `id` in package `importTarget`. `errNode` is used as offending node. */ def tryPackageLookup(importTarget: AbstractImport, id: PIdnUse, errNode: PNode): Option[(Entity, Vector[MemberPath])] = { val foreignPkgResult = for { diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/NameResolution.scala b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/NameResolution.scala index 7925531d6..ee076f137 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/resolution/NameResolution.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/resolution/NameResolution.scala @@ -11,7 +11,7 @@ import viper.gobra.frontend.PackageResolver.RegularImport import viper.gobra.frontend.info.base.BuiltInMemberTag import viper.gobra.frontend.info.base.BuiltInMemberTag.{BuiltInFPredicateTag, BuiltInFunctionTag, BuiltInMPredicateTag, BuiltInMethodTag, BuiltInTypeTag} import viper.gobra.frontend.info.base.SymbolTable._ -import viper.gobra.frontend.info.base.Type.{AdtClauseT, InterfaceT, StructT} +import viper.gobra.frontend.info.base.Type.{AdtT, InterfaceT, StructT} import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.property.{AssignMode, StrictAssignMode} import viper.gobra.util.Violation @@ -92,7 +92,8 @@ trait NameResolution { case tree.parent.pair(decl: PDomainFunction, domain: PDomainType) => DomainFunction(decl, domain, this) - case tree.parent.pair(decl: PAdtClause, adtDecl: PAdtType) => AdtClause(decl, adtDecl, this) + case tree.parent.pair(decl: PAdtClause, tree.parent(typeDecl: PTypeDef)) => + AdtClause(decl, typeDecl, this) case tree.parent.pair(decl: PMatchBindVar, tree.parent.pair(_: PMatchStmtCase, matchE: PMatchStatement)) => MatchVariable(decl, matchE.exp, this) // match full expression of match statement @@ -249,8 +250,6 @@ trait NameResolution { private def packageLevelDefinitions(m: PMember): Vector[PIdnDef] = { /* Returns identifier definitions with a package scope occurring in a type. */ def leakingIdentifier(t: PType): Vector[PIdnDef] = t match { - case t: PDomainType => t.funcs.map(_.id) // domain functions - case t: PAdtType => t.clauses.map(_.id) // adt constructors case _ => Vector.empty } @@ -269,6 +268,36 @@ trait NameResolution { } } + /** + * returns the (package-level) identifiers defined by a member + * that have a priority lower than all other identifiers + */ + @scala.annotation.tailrec + private def latePackageLevelDefinitions(m: PMember): Vector[PIdnDef] = { + /* Returns identifier definitions with a package scope occurring in a type. */ + def leakingIdentifier(t: PType): Vector[PIdnDef] = t match { + case t: PDomainType => t.funcs.map(_.id) // domain functions + case t: PAdtType => t.clauses.map(_.id) // adt constructors + case _ => Vector.empty + } + + m match { + case a: PActualMember => a match { + case d: PTypeDecl => leakingIdentifier(d.right) + case _ => Vector.empty + } + case PExplicitGhostMember(a) => latePackageLevelDefinitions(a) + case _ => Vector.empty + } + } + + lazy val lateEnvironments: PPackage => Environment = + attr[PPackage, Environment] { p => + val definitions = p.declarations flatMap latePackageLevelDefinitions + val entities = definitions.map(d => serialize(d) -> defEntity(d)) + rootenv(entities: _*) + } + /** returns whether or not identified `id` is defined at node `n`. */ def isDefinedAt(id: PIdnNode, n: PNode): Boolean = isDefinedInScope(sequentialDefenv.in(n), serialize(id)) @@ -291,7 +320,13 @@ trait NameResolution { case c => Violation.violation(s"Only the root has no parent, but got $c") } - lazy val topLevelEnvironment: Environment = scopedDefenv(tree.originalRoot) + /** Symboltable imported by a package import. */ + lazy val topLevelEnvironment: Environment = { + val thisPkg = tree.originalRoot + val base = scopedDefenv(thisPkg) + val late = lateEnvironments(thisPkg) + base ++ late + } lazy val entity: PIdnNode => Entity = attr[PIdnNode, Entity] { @@ -321,7 +356,7 @@ trait NameResolution { // if the enclosing literal is a struct then id is a field case t: StructT => tryFieldLookup(t, id).map(_._1).getOrElse(UnknownEntity()) // if the enclosing literal is an adt clause then id is an adt field - case t: AdtClauseT => tryAdtMemberLookup(t, id).map(_._1).getOrElse(UnknownEntity()) + case t: AdtT => tryAdtMemberLookup(t, id).map(_._1).getOrElse(UnknownEntity()) // otherwise it is just a variable case _ => symbTableLookup(n) } @@ -384,8 +419,14 @@ trait NameResolution { case _ => None } + val level3: Level = n => + tryEnclosingPackage(n) match { + case Some(p) => tryLookup(lateEnvironments(p), serialize(n)) + case _ => None + } + /** order of precedence; first level has highest precedence */ - val levels: Seq[Level] = Seq(level0, level1, level2) + val levels: Seq[Level] = Seq(level0, level1, level2, level3) // returns first successfully defined entity otherwise `UnknownEntity()` levels.iterator.map(_(n)).find(_.isDefined).flatten.getOrElse(UnknownEntity()) diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ExprTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ExprTyping.scala index 40ad6d048..a050ad5a7 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ExprTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ExprTyping.scala @@ -146,11 +146,12 @@ trait ExprTyping extends BaseTyping { this: TypeInfoImpl => case Some(p: ap.AdtClause) => val fields = p.symb.fields.map(f => f.id.name -> p.symb.context.symbType(f.typ)) - AdtClauseT(fields.toMap, fields.map(_._1), p.symb.decl, p.symb.adtDecl, this) + AdtClauseT(p.symb.getName, fields, p.symb.decl, p.symb.typeDecl, p.symb.context) + case Some(p: ap.AdtField) => p.symb match { - case AdtDestructor(decl, _, context) => context.symbType(decl.typ) - case AdtDiscriminator(_, _, _) => BooleanT + case dest: AdtDestructor => dest.context.symbType(dest.decl.typ) + case _: AdtDiscriminator => BooleanT } // TODO: fully supporting packages results in further options: global variable @@ -1012,7 +1013,11 @@ trait ExprTyping extends BaseTyping { this: TypeInfoImpl => def expectedCompositeLitType(lit: PCompositeLit): Type = lit.typ match { case i: PImplicitSizeArrayType => ArrayT(lit.lit.elems.size, typeSymbType(i.elem)) - case t: PType => typeSymbType(t) + case t: PType => + typeSymbType(t) match { + case t: AdtClauseT => t.declaredType // adt constructors return the defined type + case t => t + } } private[typing] def wellDefIfConstExpr(expr: PExpression): Messages = underlyingType(typ(expr)) match { diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/IdTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/IdTyping.scala index c62376ec4..cd9c1b944 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/IdTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/IdTyping.scala @@ -158,7 +158,7 @@ trait IdTyping extends BaseTyping { this: TypeInfoImpl => // ADT clause is special since it is a type with a name that is not a named type case a: AdtClause => val fields = a.fields.map(f => f.id.name -> a.context.symbType(f.typ)) - AdtClauseT(fields.toMap, fields.map(_._1), a.decl, a.adtDecl, this) + AdtClauseT(a.getName, fields, a.decl, a.typeDecl, a.context) case BuiltInType(tag, _, _) => tag.typ case _ => violation(s"expected type, but got $id") diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/TypeTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/TypeTyping.scala index bbfa0a00f..993be91a3 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/TypeTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/TypeTyping.scala @@ -72,7 +72,7 @@ trait TypeTyping extends BaseTyping { this: TypeInfoImpl => isRecursiveInterface } - case t: PExpressionAndType => wellDefExprAndType(t).out + case t: PExpressionAndType => wellDefExprAndType(t).out ++ isType(t).out } lazy val typeSymbType: Typing[PType] = { @@ -156,9 +156,9 @@ trait TypeTyping extends BaseTyping { this: TypeInfoImpl => // ADT clause is special since it is a type with a name that is not a named type case Some(p: ap.AdtClause) => val fields = p.symb.fields.map(f => f.id.name -> p.symb.context.symbType(f.typ)) - AdtClauseT(fields.toMap, fields.map(_._1), p.symb.decl, p.symb.adtDecl, p.symb.context) + AdtClauseT(p.symb.getName, fields, p.symb.decl, p.symb.typeDecl, p.symb.context) - case _ => violation(s"expected type, but got $n") + case p => violation(s"expected type, but got $n with resolved pattern $p") } } diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala index 6713908d8..c4880f6c8 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostExprTyping.scala @@ -131,7 +131,7 @@ trait GhostExprTyping extends BaseTyping { this: TypeInfoImpl => case m@PMatchExp(exp, clauses) => val sameTypeE = allMergeableTypes.errors(clauses map { c => exprType(c.exp) })(exp) val patternE = m.caseClauses.flatMap(c => c.pattern match { - case PMatchAdt(clause, _) => assignableTo.errors(symbType(clause), exprType(exp))(c) + case p: PMatchAdt => assignableTo.errors(miscType(p), exprType(exp))(c) case _ => comparableTypes.errors((miscType(c.pattern), exprType(exp)))(c) }) val pureExpE = error(exp, "Expression has to be pure", !isPure(exp)(strong = false)) @@ -172,8 +172,10 @@ trait GhostExprTyping extends BaseTyping { this: TypeInfoImpl => case PSequenceAppend(left, right) => isExpr(left).out ++ isExpr(right).out ++ { val t1 = exprType(left) val t2 = exprType(right) - error(left, s"expected a sequence, but got $t1", !t1.isInstanceOf[SequenceT]) ++ - error(right, s"expected a sequence, but got $t2", !t2.isInstanceOf[SequenceT]) ++ + val ut1 = underlyingType(t1) + val ut2 = underlyingType(t2) + error(left, s"expected a sequence, but got $t1", !ut1.isInstanceOf[SequenceT]) ++ + error(right, s"expected a sequence, but got $t2", !ut2.isInstanceOf[SequenceT]) ++ mergeableTypes.errors(t1, t2)(expr) } case PSequenceConversion(op) => exprType(op) match { @@ -188,15 +190,17 @@ trait GhostExprTyping extends BaseTyping { this: TypeInfoImpl => case expr: PBinaryGhostExp => isExpr(expr.left).out ++ isExpr(expr.right).out ++ { val t1 = exprType(expr.left) val t2 = exprType(expr.right) - error(expr.left, s"expected an unordered collection, but got $t1", !t1.isInstanceOf[GhostUnorderedCollectionType]) ++ - error(expr.right, s"expected an unordered collection, but got $t2", !t2.isInstanceOf[GhostUnorderedCollectionType]) ++ + val ut1 = underlyingType(t1) + val ut2 = underlyingType(t2) + error(expr.left, s"expected an unordered collection, but got $t1", !ut1.isInstanceOf[GhostUnorderedCollectionType]) ++ + error(expr.right, s"expected an unordered collection, but got $t2", !ut2.isInstanceOf[GhostUnorderedCollectionType]) ++ mergeableTypes.errors(t1, t2)(expr) } - case PSetConversion(op) => exprType(op) match { + case PSetConversion(op) => underlyingType(exprType(op)) match { case SequenceT(_) | SetT(_) | OptionT(_) => isExpr(op).out case t => error(op, s"expected a sequence, set or option type, but got $t") } - case PMultisetConversion(op) => exprType(op) match { + case PMultisetConversion(op) => underlyingType(exprType(op)) match { case SequenceT(_) | MultisetT(_) | OptionT(_) => isExpr(op).out case t => error(op, s"expected a sequence, multiset or option type, but got $t") } @@ -278,7 +282,7 @@ trait GhostExprTyping extends BaseTyping { this: TypeInfoImpl => val lType = exprType(left) val rType = exprType(right) typeMerge(lType, rType) match { - case Some(seq@SequenceT(_)) => seq + case Some(seq) => seq case _ => violation(s"types $lType and $rType cannot be merged.") } case PSequenceConversion(op) => exprType(op) match { diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostIdTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostIdTyping.scala index a071b79af..5475fee63 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostIdTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostIdTyping.scala @@ -40,15 +40,9 @@ trait GhostIdTyping { this: TypeInfoImpl => case predicate: Predicate => FunctionT(predicate.args map predicate.context.typ, AssertionT) case func: DomainFunction => FunctionT(func.args map func.context.typ, func.context.typ(func.result.outs.head)) - case AdtClause(decl, adtDecl, context) => - val fields = decl.args.flatMap(_.fields).map(f => f.id.name -> context.symbType(f.typ)) - AdtClauseT( - fields.toMap, - fields.map(_._1), - decl, - adtDecl, - context - ) + case c: AdtClause => + val fields = c.fields.map(f => f.id.name -> c.context.symbType(f.typ)) + AdtClauseT(c.getName, fields, c.decl, c.typeDecl, c.context) case MatchVariable(decl, p, context) => p match { case PMatchAdt(clause, fields) => diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMiscTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMiscTyping.scala index 3ab5e4a53..ef273194c 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMiscTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostMiscTyping.scala @@ -10,7 +10,7 @@ import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, error, message, n import viper.gobra.ast.frontend._ import viper.gobra.frontend.info.base.SymbolTable import viper.gobra.frontend.info.base.SymbolTable.{BuiltInMPredicate, GhostTypeMember, MPredicateImpl, MPredicateSpec, MethodSpec} -import viper.gobra.frontend.info.base.Type.{AdtClauseT, AssertionT, BooleanT, FunctionT, PredT, Type, UnknownType} +import viper.gobra.frontend.info.base.Type.{AdtClauseT, AssertionT, BooleanT, DeclaredT, FunctionT, PredT, Type, UnknownType} import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.BaseTyping import viper.gobra.ast.frontend.{AstPattern => ap} @@ -55,7 +55,7 @@ trait GhostMiscTyping extends BaseTyping { this: TypeInfoImpl => case PMatchAdt(clause, fields) => symbType(clause) match { case t: AdtClauseT => val fieldTypes = fields.map(typ) - val clauseFieldTypes = t.fieldTypes + val clauseFieldTypes = t.fields.map(_._2) error(m, s"Expected ${clauseFieldTypes.size} patterns, but got ${fieldTypes.size}", clauseFieldTypes.size != fieldTypes.size) ++ fieldTypes.zip(clauseFieldTypes).flatMap(a => assignableTo.errors(a)(m)) case _ => violation("Pattern matching only works on ADT Literals") @@ -191,7 +191,11 @@ trait GhostMiscTyping extends BaseTyping { this: TypeInfoImpl => case _: PAdtClause => UnknownType case exp: PMatchPattern => exp match { case PMatchBindVar(idn) => idType(idn) - case PMatchAdt(clause, _) => symbType(clause) + case PMatchAdt(clause, _) => + symbType(clause) match { + case t: AdtClauseT => t.declaredType + case t => t + } case PMatchValue(lit) => typ(lit) case w: PMatchWildcard => wildcardMatchType(w) } @@ -207,9 +211,11 @@ trait GhostMiscTyping extends BaseTyping { this: TypeInfoImpl => case MPredicateImpl(decl, ctx) => FunctionT(decl.args map ctx.typ, AssertionT) case MPredicateSpec(decl, _, ctx) => FunctionT(decl.args map ctx.typ, AssertionT) case _: SymbolTable.GhostStructMember => ??? - case SymbolTable.AdtDestructor(decl, _, ctx) => ctx.symbType(decl.typ) + case dest: SymbolTable.AdtDestructor => dest.context.symbType(dest.decl.typ) case _: SymbolTable.AdtDiscriminator => BooleanT + case const: SymbolTable.AdtClause => DeclaredT(const.typeDecl, const.context) case BuiltInMPredicate(tag, _, _) => typ(tag) + case f: SymbolTable.DomainFunction => FunctionT(f.args map f.context.typ, f.context.typ(f.result)) } implicit lazy val wellDefSpec: WellDefinedness[PSpecification] = createWellDef { diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostStmtTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostStmtTyping.scala index cceeb8f22..702adfbdf 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostStmtTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostStmtTyping.scala @@ -29,7 +29,7 @@ trait GhostStmtTyping extends BaseTyping { this: TypeInfoImpl => error(n, "ghost error: expected ghostifiable statement", !optBlock.forall(_.isInstanceOf[PGhostifiableStatement])) case PApplyWand(wand) => assignableToSpec(wand) case PMatchStatement(exp, clauses, _) => clauses.flatMap(c => c.pattern match { - case PMatchAdt(clause, _) => assignableTo.errors(symbType(clause), exprType(exp))(c) + case p: PMatchAdt => assignableTo.errors(miscType(p), exprType(exp))(c) case _ => comparableTypes.errors((miscType(c.pattern), exprType(exp)))(c) }) ++ isPureExpr(exp) case p: PClosureImplProof => wellDefClosureImplProof(p) diff --git a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostTypeTyping.scala b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostTypeTyping.scala index 1c09b2279..fca06a828 100644 --- a/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostTypeTyping.scala +++ b/src/main/scala/viper/gobra/frontend/info/implementation/typing/ghost/GhostTypeTyping.scala @@ -6,11 +6,12 @@ package viper.gobra.frontend.info.implementation.typing.ghost -import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, noMessages} +import org.bitbucket.inkytonik.kiama.util.Messaging.{Messages, error, noMessages} import viper.gobra.ast.frontend._ import viper.gobra.frontend.info.base.Type._ import viper.gobra.frontend.info.implementation.TypeInfoImpl import viper.gobra.frontend.info.implementation.typing.BaseTyping +import viper.gobra.util.Violation trait GhostTypeTyping extends BaseTyping { this : TypeInfoImpl => @@ -23,7 +24,13 @@ trait GhostTypeTyping extends BaseTyping { this : TypeInfoImpl => case n: PGhostSliceType => isType(n.elem).out case _: PDomainType => noMessages - case _: PAdtType => noMessages + case n: PAdtType => n match { + case tree.parent(_: PTypeDef) => + val t = adtSymbType(n) + adtConstructorSet(t).errors(n) ++ adtMemberSet(t).errors(n) + + case _ => error(n, "Adt types are only allowed within type declarations.") + } } private[typing] def ghostTypeSymbType(typ : PGhostType) : Type = typ match { @@ -34,6 +41,20 @@ trait GhostTypeTyping extends BaseTyping { this : TypeInfoImpl => case POptionType(elem) => OptionT(typeSymbType(elem)) case PGhostSliceType(elem) => GhostSliceT(typeSymbType(elem)) case t: PDomainType => DomainT(t, this) - case a: PAdtType => AdtT(a, this) + case a: PAdtType => adtSymbType(a) + } + + /** Requires that the parent of a is PTypeDef. */ + private def adtSymbType(a: PAdtType): Type = { + a match { + case tree.parent(decl: PTypeDef) => + val clauses = a.clauses.map { clause => + val fields = clause.args.flatMap(_.fields.map(f => f.id.name -> typeSymbType(f.typ))) + AdtClauseT(clause.id.name, fields, clause, decl, this) + } + AdtT(clauses, decl, this) + + case _ => Violation.violation(s"$a is not within a type declaration") + } } } diff --git a/src/main/scala/viper/gobra/translator/encodings/adts/AdtEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/adts/AdtEncoding.scala index a13be34e1..03ab482c8 100644 --- a/src/main/scala/viper/gobra/translator/encodings/adts/AdtEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/adts/AdtEncoding.scala @@ -349,6 +349,13 @@ class AdtEncoding extends LeafTypeEncoding { } } + override def assertion(ctx: Context): in.Assertion ==> CodeWriter[vpr.Exp] = { + + default(super.assertion(ctx)) { + case p: in.PatternMatchAss => translatePatternMatchAss(p)(ctx) + } + } + override def statement(ctx: Context): in.Stmt ==> CodeWriter[vpr.Stmt] = { default(super.statement(ctx)) { case p: in.PatternMatchStmt => translatePatternMatch(p)(ctx) @@ -389,25 +396,29 @@ class AdtEncoding extends LeafTypeEncoding { def translateCase(c: in.PatternMatchCaseStmt): CodeWriter[vpr.Stmt] = { val (cPos, cInfo, cErrT) = c.vprMeta - for { - check <- translateMatchPatternCheck(s.exp, c.mExp)(ctx) - setExVarV <- setExVar(cPos, cInfo, cErrT) - ass <- translateMatchPatternDeclarations(s.exp, c.mExp)(ctx) - body <- seqn(ctx.statement(c.body)) - } yield vpr.If( - vpr.And(check, vpr.Not(checkExVar)(cPos, cInfo, cErrT))(cPos, cInfo, cErrT), // Check(pi, e) && !b - vpr.Seqn(Seq(setExVarV, ass, body), Seq.empty)(cPos, cInfo, cErrT), // b := true; Assign(pi, e); [si] - vpr.Seqn(Seq(), Seq())(cPos, cInfo, cErrT) // empty else - )(cPos, cInfo, cErrT) + seqn( + for { + check <- translateMatchPatternCheck(s.exp, c.mExp)(ctx) + setExVarV <- setExVar(cPos, cInfo, cErrT) + ass <- translateMatchPatternDeclarations(s.exp, c.mExp)(ctx) + body <- ctx.statement(c.body) + } yield vpr.If( + vpr.And(check, vpr.Not(checkExVar)(cPos, cInfo, cErrT))(cPos, cInfo, cErrT), // Check(pi, e) && !b + vpr.Seqn(Seq(setExVarV, ass, body), Seq.empty)(cPos, cInfo, cErrT), // b := true; Assign(pi, e); [si] + vpr.Seqn(Seq(), Seq())(cPos, cInfo, cErrT) // empty else + )(cPos, cInfo, cErrT) + ) } - for { + val res = for { _ <- local(checkExVarDecl) _ <- write(initialExVar) cs <- sequence(s.cases map translateCase) _ <- write(cs: _*) _ <- if (s.strict) assert(checkExVar, (info, _) => MatchError(info)) else unit(()) } yield vu.nop(sPos, sInfo, sErrT) + + res } /** @@ -453,6 +464,49 @@ class AdtEncoding extends LeafTypeEncoding { } } + /** + * [e match { case1 p1: e1; ...; caseN pN: eN }] -> + * asserting Check(p1, e) || ... || Check(pN, e) in Match(case1 p1: e1; ...; caseN pN: eN; default: dflt(T), e) + * [e match { case1 p1: e1; ...; caseN pN: eN; default: e_ }] -> + * Match(case1 p1: e1; ...; caseN pN: eN; default: e_, e) + * + * Match(default: e_, e) -> e_ + * Match(case1 p1: e1; ...; caseN pN: eN; default: e_, e) -> + * Check(p1, e) ? AssignIn(p1, e, [e1]) : Match(case p2: e2; ...; caseN pN: eN; default: e_, e) + * + */ + def translatePatternMatchAss(e: in.PatternMatchAss)(ctx: Context): CodeWriter[vpr.Exp] = { + + def translateCases(cases: Vector[in.PatternMatchCaseAss], dflt: in.Assertion): CodeWriter[vpr.Exp] = { + val (ePos, eInfo, eErrT) = if (cases.isEmpty) dflt.vprMeta else cases.head.vprMeta + cases match { + case c +: cs => + for { + check <- translateMatchPatternCheck(e.exp, c.mExp)(ctx) + body <- ctx.assertion(c.ass) + decl <- declareIn(e.exp, c.mExp, body)(ctx) + el <- translateCases(cs, dflt) + } yield vpr.CondExp(check, decl, el)(ePos, eInfo, eErrT) + case _ => ctx.assertion(dflt) + } + } + + if (e.default.isDefined) { + translateCases(e.cases, e.default.get) + } else { + val (pos, info, errT) = e.vprMeta + + val checkExpressionMatchesOnePattern = + sequence(e.cases.map(c => translateMatchPatternCheck(e.exp, c.mExp)(ctx))).map(vu.bigOr(_)(pos, info, errT)) + + for { + matching <- translateCases(e.cases, in.ExprAssertion(in.BoolLit(b = true)(e.info))(e.info)) + checks <- checkExpressionMatchesOnePattern + checkedMatching <- assert(checks, matching, (info, _) => MatchError(info))(ctx) + } yield checkedMatching + } + } + /** * Encodes the check whether `expr` matches pattern * diff --git a/src/main/scala/viper/gobra/translator/encodings/sequences/SequenceEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/sequences/SequenceEncoding.scala index b622f9df3..cba1ace53 100644 --- a/src/main/scala/viper/gobra/translator/encodings/sequences/SequenceEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/sequences/SequenceEncoding.scala @@ -149,25 +149,25 @@ class SequenceEncoding extends LeafTypeEncoding { highT <- goE(high) } yield vpr.RangeSeq(lowT, highT)(pos, info, errT) - case n@ in.SequenceAppend(left, right) => + case n: in.SequenceAppend => val (pos, info, errT) = n.vprMeta for { - leftT <- goE(left) - rightT <- goE(right) + leftT <- goE(n.left) + rightT <- goE(n.right) } yield vpr.SeqAppend(leftT, rightT)(pos, info, errT) - case n@ in.SequenceDrop(left, right) => + case n: in.SequenceDrop => val (pos, info, errT) = n.vprMeta for { - leftT <- goE(left) - rightT <- goE(right) + leftT <- goE(n.left) + rightT <- goE(n.right) } yield vpr.SeqDrop(leftT, rightT)(pos, info, errT) - case n@ in.SequenceTake(left, right) => + case n: in.SequenceTake => val (pos, info, errT) = n.vprMeta for { - leftT <- goE(left) - rightT <- goE(right) + leftT <- goE(n.left) + rightT <- goE(n.right) } yield vpr.SeqTake(leftT, rightT)(pos, info, errT) } } diff --git a/src/main/scala/viper/gobra/translator/encodings/sets/SetEncoding.scala b/src/main/scala/viper/gobra/translator/encodings/sets/SetEncoding.scala index d0418ce05..60075f11d 100644 --- a/src/main/scala/viper/gobra/translator/encodings/sets/SetEncoding.scala +++ b/src/main/scala/viper/gobra/translator/encodings/sets/SetEncoding.scala @@ -105,32 +105,32 @@ class SetEncoding extends LeafTypeEncoding { vE <- goE(e) } yield vpr.AnySetContains(vX, vE)(pos, info, errT) - case n@ in.Union(left, right) => + case n: in.Union => val (pos, info, errT) = n.vprMeta for { - leftT <- goE(left) - rightT <- goE(right) + leftT <- goE(n.left) + rightT <- goE(n.right) } yield vpr.AnySetUnion(leftT, rightT)(pos, info, errT) - case n@ in.Intersection(left, right) => + case n: in.Intersection => val (pos, info, errT) = n.vprMeta for { - leftT <- goE(left) - rightT <- goE(right) + leftT <- goE(n.left) + rightT <- goE(n.right) } yield vpr.AnySetIntersection(leftT, rightT)(pos, info, errT) - case n@ in.SetMinus(left, right) => + case n: in.SetMinus => val (pos, info, errT) = n.vprMeta for { - leftT <- goE(left) - rightT <- goE(right) + leftT <- goE(n.left) + rightT <- goE(n.right) } yield vpr.AnySetMinus(leftT, rightT)(pos, info, errT) - case n@ in.Subset(left, right) => + case n: in.Subset => val (pos, info, errT) = n.vprMeta for { - leftT <- goE(left) - rightT <- goE(right) + leftT <- goE(n.left) + rightT <- goE(n.right) } yield vpr.AnySetSubset(leftT, rightT)(pos, info, errT) } } diff --git a/src/main/scala/viper/gobra/translator/util/ViperWriter.scala b/src/main/scala/viper/gobra/translator/util/ViperWriter.scala index 3983445f9..21ee86494 100644 --- a/src/main/scala/viper/gobra/translator/util/ViperWriter.scala +++ b/src/main/scala/viper/gobra/translator/util/ViperWriter.scala @@ -61,8 +61,8 @@ object ViperWriter { def container(data: Vector[DataKind]): DataContainer[K] = { val (own, other) = data.foldLeft[(Vector[K], Vector[DataKind])]((Vector.empty, Vector.empty)){ case ((ow, ot), e) => ownKind(e) match { - case None => (ow, e +: ot) - case Some(k) => (k +: ow, ot) + case None => (ow, ot :+ e) + case Some(k) => (ow :+ k, ot) } } diff --git a/src/test/resources/regressions/issues/000589.gobra b/src/test/resources/regressions/issues/000589.gobra new file mode 100644 index 000000000..207b2d8d4 --- /dev/null +++ b/src/test/resources/regressions/issues/000589.gobra @@ -0,0 +1,26 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type list adt { + Empty{} + + Cons{ + head any + tail list + } +} + +ghost +decreases l +func length(l list) int { + match l { + case Empty{}: + //:: ExpectedOutput(assert_error:assertion_error) + assert false // <--- assert false here should be reachable + return 0 + default: + return 0 + } +} \ No newline at end of file diff --git a/src/test/resources/regressions/issues/000641.gobra b/src/test/resources/regressions/issues/000641.gobra new file mode 100644 index 000000000..7477f710f --- /dev/null +++ b/src/test/resources/regressions/issues/000641.gobra @@ -0,0 +1,19 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type X adt { + C{ c int } +} + +ghost +func foo1(x X) + +ghost +func (x X) bar1() + +func client() { + foo1(C{}) + C{}.bar1() +} \ No newline at end of file diff --git a/src/test/resources/regressions/issues/000655.gobra b/src/test/resources/regressions/issues/000655.gobra index fcafa8991..72202eb71 100644 --- a/src/test/resources/regressions/issues/000655.gobra +++ b/src/test/resources/regressions/issues/000655.gobra @@ -13,4 +13,25 @@ pure func foo(x pkg.List) bool { case pkg.Cons{?head, pkg.Nil{}}: true case _: false } -} \ No newline at end of file +} + +ghost +func foo2() { + var x pkg.Tree = pkg.Branch{} + y := pkg.Branch{Left: x} + z := pkg.Branch{Right: x} +} + +/* +// should work in the future: + +ghost +pure func foo3(x pkg.Tree) bool { + return match x { + case pkg.Tree.Leaf{}: true + case pkg.Branch{?left, pkg.Tree.Leaf{}}: true + case pkg.Tree.Branch{pkg.Tree.Leaf{}, ?right}: true + case _: false + } +} +*/ \ No newline at end of file diff --git a/src/test/resources/regressions/issues/000655/pkg/f.gobra b/src/test/resources/regressions/issues/000655/pkg/f.gobra index 2252d81b9..6df472b61 100644 --- a/src/test/resources/regressions/issues/000655/pkg/f.gobra +++ b/src/test/resources/regressions/issues/000655/pkg/f.gobra @@ -12,3 +12,11 @@ type List adt { Nil {} } +type Tree adt { + Leaf{} + Branch{ Left, Right Tree } +} + +func Leaf() { +} + diff --git a/src/test/resources/regressions/issues/000685.gobra b/src/test/resources/regressions/issues/000685.gobra new file mode 100644 index 000000000..98a8388b2 --- /dev/null +++ b/src/test/resources/regressions/issues/000685.gobra @@ -0,0 +1,23 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type X adt { + C{ c any } +} + +func foo() { + x := C{5} + var i any = x + + assert typeOf(i) == type[X] + assert i.(X).c == 5 + assert i == C{5} + + i = C{5} + + assert typeOf(i) == type[X] + assert i.(X).c == 5 + assert i == C{5} +} \ No newline at end of file diff --git a/src/test/resources/regressions/issues/000686-1.gobra b/src/test/resources/regressions/issues/000686-1.gobra new file mode 100644 index 000000000..8c76b33ee --- /dev/null +++ b/src/test/resources/regressions/issues/000686-1.gobra @@ -0,0 +1,23 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type X adt { + A { a int } + B { b bool } +} + +requires match x { + case A{5}: acc(c) + case _: acc(c) +} +func foo1(c *int, ghost x X) { +} + +requires match x { + case A{5}: acc(c) + case _: true +} +func foo2(c *int, ghost x X) { +} \ No newline at end of file diff --git a/src/test/resources/regressions/issues/000686-2.gobra b/src/test/resources/regressions/issues/000686-2.gobra new file mode 100644 index 000000000..c7a30bfe0 --- /dev/null +++ b/src/test/resources/regressions/issues/000686-2.gobra @@ -0,0 +1,18 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type X adt { + A { a int } + B { b bool } +} + +type A int + +func client1() { + x := X.A{} + y := B{} +} + + diff --git a/src/test/resources/regressions/issues/000686-3.gobra b/src/test/resources/regressions/issues/000686-3.gobra new file mode 100644 index 000000000..c145f4ba5 --- /dev/null +++ b/src/test/resources/regressions/issues/000686-3.gobra @@ -0,0 +1,19 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type X adt { + A { int } + B { bool; bool } + C {} + D { bool; z bool } + E { bool; x, y bool } + F { q X } +} + +func client() { + x := A{3} + y := C{} +} + diff --git a/src/test/resources/regressions/issues/000686-4.gobra b/src/test/resources/regressions/issues/000686-4.gobra new file mode 100644 index 000000000..435cb1095 --- /dev/null +++ b/src/test/resources/regressions/issues/000686-4.gobra @@ -0,0 +1,16 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type X seq[int] + +ghost +requires x == x ++ y +func client1(x seq[int], y X) + +ghost +requires typeOf(y) == type[X] +requires x == x ++ y.(X) +func client2(x seq[int], y any) + diff --git a/src/test/resources/regressions/issues/000686-5.gobra b/src/test/resources/regressions/issues/000686-5.gobra new file mode 100644 index 000000000..435cb1095 --- /dev/null +++ b/src/test/resources/regressions/issues/000686-5.gobra @@ -0,0 +1,16 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +type X seq[int] + +ghost +requires x == x ++ y +func client1(x seq[int], y X) + +ghost +requires typeOf(y) == type[X] +requires x == x ++ y.(X) +func client2(x seq[int], y any) + diff --git a/src/test/resources/regressions/issues/000686-6.gobra b/src/test/resources/regressions/issues/000686-6.gobra new file mode 100644 index 000000000..289612084 --- /dev/null +++ b/src/test/resources/regressions/issues/000686-6.gobra @@ -0,0 +1,12 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/publicdomain/zero/1.0/ + +package pkg + +//:: ExpectedOutput(type_error) +type X adt { + A { x int } + B { x int } +} + + diff --git a/src/test/scala/viper/gobra/ast/InternalPrettyPrinterUnitTests.scala b/src/test/scala/viper/gobra/ast/InternalPrettyPrinterUnitTests.scala index 13478a06a..926b112c9 100644 --- a/src/test/scala/viper/gobra/ast/InternalPrettyPrinterUnitTests.scala +++ b/src/test/scala/viper/gobra/ast/InternalPrettyPrinterUnitTests.scala @@ -211,7 +211,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi test("Printer: should show a set union as expected") { val expr = Union( LocalVar("s", setT(boolT))(Internal), - LocalVar("t", setT(boolT))(Internal) + LocalVar("t", setT(boolT))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -223,9 +224,11 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi val expr = Union( Union( LocalVar("s", setT(boolT))(Internal), - LocalVar("t", setT(boolT))(Internal) + LocalVar("t", setT(boolT))(Internal), + setT(boolT) )(Internal), - LocalVar("u", setT(boolT))(Internal) + LocalVar("u", setT(boolT))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -238,8 +241,10 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi LocalVar("s", setT(boolT))(Internal), Union( LocalVar("t", setT(boolT))(Internal), - LocalVar("u", setT(boolT))(Internal) - )(Internal) + LocalVar("u", setT(boolT))(Internal), + setT(boolT) + )(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -256,6 +261,7 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi LocalVar("t", sequenceT(boolT))(Internal), LocalVar("u", sequenceT(boolT))(Internal) ))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -266,7 +272,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi test("Printer: should show a set intersection as expected") { val expr = Intersection( LocalVar("s", setT(boolT))(Internal), - LocalVar("t", setT(boolT))(Internal) + LocalVar("t", setT(boolT))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -278,9 +285,11 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi val expr = Intersection( Intersection( LocalVar("s", setT(boolT))(Internal), - LocalVar("t", setT(boolT))(Internal) + LocalVar("t", setT(boolT))(Internal), + setT(boolT) )(Internal), - LocalVar("u", setT(boolT))(Internal) + LocalVar("u", setT(boolT))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -293,8 +302,10 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi LocalVar("s", setT(boolT))(Internal), Intersection( LocalVar("t", setT(boolT))(Internal), - LocalVar("u", setT(boolT))(Internal) - )(Internal) + LocalVar("u", setT(boolT))(Internal), + setT(boolT) + )(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -311,6 +322,7 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi LocalVar("t", boolT)(Internal), LocalVar("u", boolT)(Internal) ))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -321,7 +333,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi test("Printer: should show a set difference as expected") { val expr = SetMinus( LocalVar("s", setT(boolT))(Internal), - LocalVar("t", setT(boolT))(Internal) + LocalVar("t", setT(boolT))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -333,9 +346,11 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi val expr = SetMinus( SetMinus( LocalVar("s", setT(boolT))(Internal), - LocalVar("t", setT(boolT))(Internal) + LocalVar("t", setT(boolT))(Internal), + setT(boolT) )(Internal), - LocalVar("u", setT(boolT))(Internal) + LocalVar("u", setT(boolT))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -348,8 +363,10 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi LocalVar("s", setT(boolT))(Internal), SetMinus( LocalVar("t", setT(boolT))(Internal), - LocalVar("u", setT(boolT))(Internal) - )(Internal) + LocalVar("u", setT(boolT))(Internal), + setT(boolT) + )(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -366,6 +383,7 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi LocalVar("t", setT(boolT))(Internal), LocalVar("u", setT(boolT))(Internal) ))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -487,8 +505,9 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi val expr = Length( Intersection( LocalVar("s", setT(boolT))(Internal), - LocalVar("t", setT(boolT))(Internal) - )(Internal) + LocalVar("t", setT(boolT))(Internal), + setT(boolT) + )(Internal), )(Internal) frontend.show(expr) should matchPattern { @@ -584,7 +603,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi test("Printer: should correctly show the union of two multiset integer literals") { val expr = Union( MultisetLit(intT, Vector(IntLit(1)(Internal), IntLit(2)(Internal)))(Internal), - MultisetLit(intT, Vector(IntLit(3)(Internal)))(Internal) + MultisetLit(intT, Vector(IntLit(3)(Internal)))(Internal), + multisetT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -595,7 +615,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi test("Printer: should correctly show the intersection of two multiset integer literals") { val expr = Intersection( MultisetLit(intT, Vector(IntLit(1)(Internal), IntLit(2)(Internal)))(Internal), - MultisetLit(intT, Vector(IntLit(3)(Internal)))(Internal) + MultisetLit(intT, Vector(IntLit(3)(Internal)))(Internal), + multisetT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -690,7 +711,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi val expr = SetConversion( SequenceAppend( LocalVar("xs", sequenceT(boolT))(Internal), - LocalVar("ys", sequenceT(boolT))(Internal) + LocalVar("ys", sequenceT(boolT))(Internal), + sequenceT(boolT) )(Internal) )(Internal) @@ -702,7 +724,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi test("Printer: should correctly show the union of two set conversions") { val expr = Union( SetConversion(LocalVar("xs", sequenceT(boolT))(Internal))(Internal), - SetConversion(LocalVar("ys", sequenceT(boolT))(Internal))(Internal) + SetConversion(LocalVar("ys", sequenceT(boolT))(Internal))(Internal), + setT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -764,7 +787,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi val expr = MultisetConversion( SequenceAppend( LocalVar("xs", sequenceT(boolT))(Internal), - LocalVar("ys", sequenceT(boolT))(Internal) + LocalVar("ys", sequenceT(boolT))(Internal), + sequenceT(boolT) )(Internal) )(Internal) @@ -776,7 +800,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi test("Printer: should correctly show the union of two multiset conversions") { val expr = Union( MultisetConversion(LocalVar("xs", sequenceT(boolT))(Internal))(Internal), - MultisetConversion(LocalVar("ys", sequenceT(boolT))(Internal))(Internal) + MultisetConversion(LocalVar("ys", sequenceT(boolT))(Internal))(Internal), + multisetT(boolT) )(Internal) frontend.show(expr) should matchPattern { @@ -884,7 +909,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi val expr = Length( SequenceAppend( SequenceLit(1, boolT, Map(BigInt(0) -> BoolLit(false)(Internal)))(Internal), - LocalVar("xs", sequenceT(boolT))(Internal) + LocalVar("xs", sequenceT(boolT))(Internal), + sequenceT(boolT) )(Internal) )(Internal) @@ -1096,7 +1122,8 @@ class InternalPrettyPrinterUnitTests extends AnyFunSuite with Matchers with Insi test("Printer: should correctly show the append of two sequence conversion operations") { val expr = SequenceAppend( SequenceConversion(LocalVar("xs", sequenceT(intT))(Internal))(Internal), - SequenceConversion(LocalVar("a", exclusiveArrayT(6, intT))(Internal))(Internal) + SequenceConversion(LocalVar("a", exclusiveArrayT(6, intT))(Internal))(Internal), + sequenceT(intT) )(Internal) frontend.show(expr) should matchPattern { From ac59357695123ad47cbed04a06f106bde9c6d8b9 Mon Sep 17 00:00:00 2001 From: viper-admin <59963956+viper-admin@users.noreply.github.com> Date: Sat, 7 Oct 2023 17:55:56 +0200 Subject: [PATCH 54/54] Updates submodules (#688) Co-authored-by: jcp19 --- viperserver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/viperserver b/viperserver index e68d7d2d8..031099450 160000 --- a/viperserver +++ b/viperserver @@ -1 +1 @@ -Subproject commit e68d7d2d8cc04f4a95d9846682425dd6e3b07ff4 +Subproject commit 0310994503fd1f6d538277b25e51ee4ef52e9b41