{"version":3,"sources":["compiler.umd.js"],"names":["global","factory","exports","module","define","amd","ng","compiler","this","__extends","d","b","__","constructor","extendStatics","prototype","Object","create","Inject","Attribute","Query","Directive","Component","Pipe","Input","Output","HostBinding","HostListener","NgModule","ModuleWithProviders","SchemaMetadata","MetadataFactory","makeMetadataFactory","name","props","args","_i","arguments","length","values","apply","__assign","ngMetadataName","isTypeOf","obj","Route","dashCaseToCamelCase","input","replace","DASH_CASE_REGEXP","m","toUpperCase","splitAtColon","defaultValues","_splitAt","splitAtPeriod","character","characterIndex","indexOf","slice","trim","visitValue","value","visitor","context","Array","isArray","visitArray","isStrictStringMap","visitStringMap","visitPrimitive","visitOther","isDefined","val","undefined","noUndefined","syntaxError","msg","parseErrors","error","Error","ERROR_SYNTAX_ERROR","ERROR_PARSE_ERRORS","isSyntaxError","getParseErrors","escapeRegExp","s","getPrototypeOf","STRING_MAP_PROTO","utf8Encode","str","encoded","index","codePoint","charCodeAt","low","String","fromCharCode","stringify","token","map","join","overriddenName","res","toString","newLineIndex","substring","resolveForwardRef","type","hasOwnProperty","isPromise","then","templateVisitAll","asts","result","visit","ast","forEach","astResult","push","preserveWhitespacesDefault","preserveWhitespacesOption","defaultSetting","_sanitizeIdentifier","identifierName","compileIdentifier","reference","ref","StaticSymbol","identifier","_anonymousTypeIndex","identifierModuleUrl","filePath","viewClassName","compType","embeddedTemplateIndex","rendererTypeName","hostViewClassName","componentFactoryName","tokenName","tokenReference","_normalizeArray","flatten","list","reduce","flat","item","flatItem","concat","jitSourceUrl","url","templateSourceUrl","ngModuleType","compMeta","templateMeta","isInline","sharedStylesheetJitUrl","meta","id","pathParts","split","ngModuleJitUrl","moduleMeta","templateJitUrl","visitAll","nodes","spanOf","start","sourceSpan","offset","end","Element","endSourceSpan","children","findNode","position","path","_super","class_1","span","RecursiveVisitor","AstPath","assertArrayOfStrings","i","assertInterpolationSymbols","start_1","end_1","INTERPOLATION_BLACKLIST_REGEXPS","regexp","test","isStyleUrlResolvable","schemeMatch","match","URL_WITH_SCHEMA_REGEXP","extractStyleUrls","resolver","baseUrl","cssText","foundUrls","modifiedCssText","CSS_STRIPPABLE_COMMENT_REGEXP","CSS_IMPORT_REGEXP","resolve","StyleWithImports","splitNsName","elementName","colonIndex","isNgContainer","tagName","isNgContent","isNgTemplate","getNsPrefix","fullName","mergeNsAndName","prefix","localName","preparseElement","selectAttr","hrefAttr","relAttr","nonBindable","projectAs","attrs","attr","lcAttrName","toLowerCase","NG_CONTENT_SELECT_ATTR","LINK_STYLE_HREF_ATTR","LINK_STYLE_REL_ATTR","NG_NON_BINDABLE_ATTR","NG_PROJECT_AS","normalizeNgContentSelect","nodeName","PreparsedElementType","OTHER","NG_CONTENT","STYLE_ELEMENT","STYLE","SCRIPT_ELEMENT","SCRIPT","LINK_ELEMENT","LINK_STYLE_REL_VALUE","STYLESHEET","PreparsedElement","isDirectiveMetadata","createDirective","createComponent","findLast","arr","condition","isWhitespace","code","$TAB","$SPACE","$NBSP","isDigit","$0","$9","isAsciiLetter","$a","$z","$A","$Z","isAsciiHexDigit","$f","$F","newCharacterToken","Token","TokenType","Character","newIdentifierToken","text","Identifier","newKeywordToken","Keyword","newOperatorToken","Operator","newStringToken","newNumberToken","n","Number","newErrorToken","message","isIdentifierStart","$_","$$","isIdentifier","scanner","_Scanner","peek","advance","$EOF","isIdentifierPart","isExponentStart","$e","$E","isExponentSign","$MINUS","$PLUS","isQuote","$SQ","$DQ","$BT","unescape","$n","$LF","$FF","$r","$CR","$t","$v","$VTAB","parseIntAutoRadix","parseInt","isNaN","visitAstChildren","visitBinary","left","right","visitChain","expressions","visitConditional","trueExp","falseExp","visitFunctionCall","target","visitImplicitReceiver","visitInterpolation","visitKeyedRead","key","visitKeyedWrite","visitLiteralArray","visitLiteralMap","visitLiteralPrimitive","visitMethodCall","receiver","visitPipe","exp","visitPrefixNot","expression","visitNonNullAssert","visitPropertyRead","visitPropertyWrite","visitQuote","visitSafeMethodCall","visitSafePropertyRead","_createInterpolateRegExp","config","pattern","RegExp","typeSourceSpan","kind","moduleUrl","sourceFileName","sourceFile","ParseSourceFile","ParseSourceSpan","ParseLocation","tokenize","source","getTagDefinition","tokenizeExpansionForms","interpolationConfig","DEFAULT_INTERPOLATION_CONFIG","_Tokenizer","_unexpectedCharacterErrorMsg","charCode","_unknownEntityErrorMsg","entitySrc","isNotWhitespace","isNameEnd","$GT","$SLASH","$EQ","isPrefixEnd","isDigitEntityEnd","$SEMICOLON","isNamedEntityEnd","isExpansionFormStart","isInterpolationStart","$LBRACE","isExpansionCaseStart","compareCharCodeCaseInsensitive","code1","code2","toUpperCaseCharCode","mergeTextTokens","srcTokens","dstTokens","lastDstToken","TokenType$1","TEXT","parts","lastOnStack","stack","element","digest","sha1","serializeNodes","meaning","decimalDigest","_SerializerIgnoreIcuExpVisitor","computeMsgId","a","serializerVisitor","utf8","words32","stringToWords32","Endian","Big","len","w","_a","c","e","_b","h0","h1","h2","h3","h4","j","rol32","_c","fk","f","k","temp","add32","_d","_e","byteStringToHexString","words32ToByteString","fingerprint","hash32","hi","lo","him","lom","add64","rol64","byteStringToDecString","wordAt","Little","mix","sub32","add32to64","high","ah","al","bh","bl","carry","l","count","endian","byteAt","word","word32ToByteString","hex","decimal","toThePower","addBigInt","numberTimesBigInt","reverse","x","y","sum","Math","max","tmpSum","num","product","bToThePower","getHtmlTagDefinition","TAG_DEFINITIONS","_DEFAULT_TAG_DEFINITION","createI18nMessageFactory","_I18nVisitor","_expParser","description","toI18nMessage","_extractPlaceholderName","_CUSTOM_PH_EXP","extractMessages","implicitTags","implicitAttrs","_Visitor","extract","mergeTranslations","translations","merge","_isOpeningComment","Comment","startsWith","_isClosingComment","_getI18nAttr","p","find","_I18N_ATTR","_parseMessageMeta","i18n","idIndex","ID_SEPARATOR","descIndex","MEANING_SEPARATOR","meaningAndDesc","getXmlTagDefinition","_TAG_DEFINITION","serialize","node","_visitor","escapeXml","_ESCAPED_CHARS","entry","getCtypeForTag","tag","getTypeForTag","digest$1","toPublicName","internalName","createLazyProperty","messages","valueFn","defineProperty","configurable","enumerable","get","set","_","createSerializer","format","Xmb","Xtb","Xliff2","Xliff","ngfactoryFilePath","forceSourceFile","urlWithSuffix","splitTypescriptSuffix","normalizeGenFileSuffix","stripGeneratedFileSuffix","GENERATED_FILE","isGeneratedFile","endsWith","lastDot","lastIndexOf","srcFileSuffix","summaryFileName","fileName","STRIP_SRC_FILE_SUFFIXES","summaryForJitFileName","stripSummaryForJitFileSuffix","JIT_SUMMARY_FILE","summaryForJitName","symbolName","stripSummaryForJitNameSuffix","JIT_SUMMARY_NAME","isLoweredSymbol","LOWERED_SYMBOL","createLoweredSymbol","createTokenForReference","createTokenForExternalReference","reflector","resolveExternalReference","hasLifecycleHook","hook","getHookName","getAllLifecycleHooks","LIFECYCLE_HOOKS_VALUES","filter","LifecycleHooks","OnInit","OnDestroy","DoCheck","OnChanges","AfterContentInit","AfterContentChecked","AfterViewInit","AfterViewChecked","flattenArray","tree","out","dedupeArray","array","from","Set","flattenAndDedupeArray","isValidType","Type","extractIdentifiers","targetIdentifiers","_CompileValueConverter","stringifyType","componentStillLoadingError","ERROR_COMPONENT_TYPE","nullSafeIsEquivalent","base","other","isEquivalent","areAllEquivalent","findReadVarNames","stmts","_ReadVarVisitor","visitAllStatements","varNames","collectExternalReferences","_FindExternalReferencesVisitor","externalReferences","applySourceSpanToStatementIfNeeded","stmt","transformer","_ApplySourceSpanTransformer","visitStatement","applySourceSpanToExpressionIfNeeded","expr","visitExpression","variable","ReadVarExpr","importExpr","typeParams","ExternalExpr","importType","typeModifiers","expressionType","ExpressionType","literalArr","LiteralArrayExpr","literalMap","LiteralMapExpr","LiteralMapEntry","quoted","not","NotExpr","assertNotNull","AssertNotNull","fn","params","body","FunctionExpr","literal","LiteralExpr","_transformProvider","provider","useExisting","useValue","deps","useClass","useFactory","multi","_transformProviderAst","eager","providers","ProviderAst","multiProvider","providerType","lifecycleHooks","_resolveProvidersFromDirectives","directives","targetErrors","providersByToken","Map","directive","_resolveProviders","isComponent","ProviderAstType","dir","PublicService","viewProviders","PrivateService","targetProvidersByToken","resolvedProvider","ProviderError","isUseValue","_getViewQueries","component","viewQueryId","viewQueries","query","_addQueryToTokenMap","queryId","_getContentQueries","contentQueryStartId","contentQueryId","contentQueries","directiveIndex","queries","selectors","convertValueToOutputAst","ctx","_ValueOutputAstTransformer","providerDef","providerAst","flags","lifecycleHook","lifecycleHookToNodeFlag","multiProviderDef","singleProviderDef","providerExpr","depsExpr","tokenExpr","convertDeps","providerIndex","dep","depIndex","paramName","allParams","FnParam","DYNAMIC_TYPE","allDepDefs","depDef","exprs","depExprs","diDeps","instantiate","callFn","ReturnStatement","INFERRED_TYPE","providerMeta","NULL_EXPR","tokenMeta","isValue","isSkipSelf","isOptional","nodeFlag","componentFactoryResolverProviderDef","entryComponents","entryComponentFactories","entryComponent","componentFactory","Identifiers","ComponentFactoryResolver","classMeta","NgModuleRef","CodegenComponentFactoryResolver","toBase64String","b64","i1","i2","i3","toBase64Digit","toBase64VLQ","digit","B64_DIGITS","escapeIdentifier","escapeDollar","alwaysQuote","_SINGLE_QUOTE_ESCAPE_STRING_RE","_LEGAL_IDENTIFIER_RE","_createIndent","_INDENT_WITH","debugOutputAstAsTypeScript","converter","_TsEmitterVisitor","EmitterVisitorContext","createRoot","Statement","Expression","Type$1","visitType","toSource","registerContext","specs","specs_1","spec","SECURITY_SCHEMA","_isPixelDimensionStyle","prop","stripComments","_commentRe","extractCommentsWithHash","_commentWithHashRe","processRules","ruleCallback","inputWithEscapedBlocks","escapeBlocks","nextBlockIndex","escapedString","_ruleRe","selector","content","suffix","contentPrefix","BLOCK_PLACEHOLDER","blocks","rule","CssRule","inputParts","_curlyRe","resultParts","escapedBlocks","bracketCount","currentBlockParts","partIndex","part","CLOSE_CURLY","OPEN_CURLY","StringWithEscapedBlocks","getStylesVarName","hasPreserveWhitespacesAttr","some","PRESERVE_WS_ATTR_NAME","replaceNgsp","NGSP_UNICODE","removeWhitespaces","htmlAstWithErrors","ParseTreeResult","WhitespaceVisitor","rootNodes","errors","expandNodes","expander","_Expander","ExpansionResult","isExpanded","_expandPluralForm","cases","PLURAL_CASES","ExpansionError","valueSourceSpan","expansionResult","Attribute$1","switchAttr","switchValue","switchValueSourceSpan","_expandDefaultForm","_isAnimationLabel","calcPossibleSecurityContexts","registry","propName","isAttribute","ctxs","CssSelector","parse","elementNames","allKnownElementNames","notElementNames","notSelectors","isElementSelector","possibleElementNames","has","securityContext","SecurityContext","NONE","sort","warnOnlyOnce","warnings","warningCounts","splitExportAs","exportAs","splitClasses","classAttrValue","createElementCssSelector","attributes","cssSelector","elNameNoNs","setElement","attrName","attrNameNoNs","attrValue","addAttribute","CLASS_ATTR","className","addClassName","_isEmptyTextNode","Text","removeSummaryDuplicates","items","isEmptyExpression","ASTWithSource","EmptyExpr","isTemplate","el","enableLegacyTemplate","reportDeprecation","tagNoNs","TEMPLATE_ELEMENT","TEMPLATE_ELEMENT_DEPRECATION_WARNING","convertActionBinding","localResolver","implicitReceiver","action","bindingId","DefaultLocalResolver","actionWithoutBuiltins","convertPropertyBindingBuiltins","createLiteralArrayConverter","argCount","createLiteralMapConverter","keys","createPipeConverter","_AstToIrVisitor","actionStmts","flattenStatements","_Mode","prependTemporaryDecls","temporaryCount","lastIndex","preventDefaultVar","lastStatement","returnExpr","convertStmtIntoExpression","createPreventDefaultVar","cast","notIdentical","toDeclStmt","StmtModifier","Final","ConvertActionBindingResult","converterFactory","convertBuiltins","convertPropertyBinding","expressionWithoutBuiltins","form","currValExpr","createCurrValueExpr","outputExpr","temporaryDeclaration","BindingForm","TrySimple","ConvertPropertyBindingResult","_BuiltinAstConverter","temporaryName","temporaryNumber","DeclareVarStmt","statements","unshift","ensureStatementMode","mode","ensureExpressionMode","convertToStatementIfNeeded","toStmt","arg","output","ExpressionStatement","needsAdditionalRootNode","astNodes","lastAstNode","EmbeddedTemplateAst","hasViewContainer","ElementAst","NgContentAst","elementBindingDef","inputAst","dirAst","PropertyBindingType","Property","Animation","Class","Style","unit","fixedAttrsDef","elementAst","mapResult","attrAst","hostAttributes","prevValue","mergeAttributeValue","attrValue1","attrValue2","CLASS_ATTR$1","STYLE_ATTR","callCheckStmt","nodeIndex","CHECK_VAR","VIEW_VAR","callUnwrapValue","bindingIdx","unwrapValue","findStaticQueryIds","staticQueryIds","dynamicQueryIds","queryMatches","child","childData","add","delete","staticViewQueryIds","nodeStaticQueryIds","elementEventNameAndTarget","eventAst","isAnimation","phase","calcStaticDynamicQueryFlags","queryIds","isFirst","elementEventFullName","toTypeScript","file","preamble","genFileUrl","TypeScriptEmitter","emitStatements","listLazyRoutes","allLazyRoutes","transitiveModule","ROUTES","loadChildren","_collectLoadChildren","loadChildren_1","route","parseLazyRoute","routes","routes_1","routePath","routeName","referencedModule","moduleName","unescapeIdentifier","substr","unwrapResolvedMetadata","metadata","__symbolic","symbol","serializeSummaries","srcFileName","forJitCtx","summaryResolver","symbolResolver","symbols","types","toJsonSerializer","ToJsonSerializer","resolvedSymbol","addSummary","summary","json","forJitSerializer_1","ForJitSerializer","addSourceType","unprocessedSymbolSummariesBySymbol","isLibraryFile","addLibType","deserializeSummaries","symbolCache","libraryFileName","FromJsonDeserializer","deserialize","createForJitStub","outputCtx","createSummaryForJitFunction","fnName","ArrayType","Exported","isCall","isFunctionCall","isMethodCallOnVariable","_createEmptyStub","ComponentFactory","_resolveStyleStatements","compileResult","needsShim","fileSuffix","dependencies","setValue","getStaticSymbol","_stylesModuleUrl","stylesheetUrl","shim","analyzeNgModules","fileNames","host","staticSymbolResolver","metadataResolver","mergeAnalyzedFiles","_analyzeFilesIncludingNonProgramFiles","analyzeAndValidateNgModules","validateAnalyzedModules","analyzedModules","symbolsMissingModule","seenFiles","files","visitFile","isSourceFile","analyzedFile","analyzeFile","ngModules","ngModule","modules","modMeta","pipes","injectables","hasDecorators","exportsNonSourceFiles","getSymbolsOf","resolveSymbol","symbolMeta","isNgSymbol","isDirective","isPipe","isNgModule","getNgModuleMetadata","isInjectable","isValueExportingNonSourceFile","Visitor","_this","v","analyzedFiles","allNgModules","ngModuleByPipeOrDirective","allPipesAndDirectives","af","declaredDirectives","declaredPipes","mergeAndValidateNgFiles","indentStr","level","half","floor","formatChain","chain","indent","line","column","postfix","next","formattedError","FORMATTED_MESSAGE","isFormattedError","shouldIgnore","metadataError","advise","METADATA_ERROR","isMetadataError","expandedMessage","REFERENCE_TO_NONEXPORTED_CLASS","VARIABLE_NOT_INITIALIZED","DESTRUCTURE_NOT_SUPPORTED","COULD_NOT_RESOLVE_TYPE","typeName","FUNCTION_CALL_NOT_SUPPORTED","REFERENCE_TO_LOCAL_SYMBOL","LAMBDA_NOT_SUPPORTED","messageAdvise","errorSummary","mapStringMap","transform","HIDDEN_KEY","isPrimitive","o","formatMetadataMessageChain","formatMetadataError","createAotUrlResolver","basePath","resourceNameToFileName","createAotCompiler","compilerHost","options","errorCollector","urlResolver","StaticSymbolCache","AotSummaryResolver","StaticSymbolResolver","staticReflector","StaticReflector","htmlParser","I18NHtmlParser","HtmlParser","i18nFormat","missingTranslation","console","CompilerConfig","defaultEncapsulation","ViewEncapsulation","Emulated","useJit","preserveWhitespaces","strictInjectionParameters","normalizer","DirectiveNormalizer","loadResource","expressionParser","Parser","Lexer","elementSchemaRegistry","DomElementSchemaRegistry","tmplParser","TemplateParser","CompileMetadataResolver","NgModuleResolver","DirectiveResolver","PipeResolver","viewCompiler","ViewCompiler","typeCheckCompiler","TypeCheckCompiler","AotCompiler","StyleCompiler","NgModuleCompiler","interpretStatements","_ExecutionContext","StatementInterpreter","exportName","vars","_executeFunctionStatements","varValues","childCtx","createChildWihtLocalVars","createDynamicClass","_classStmt","_ctx","propertyDescriptors","getters","getter","instanceCtx","methods","method","paramNames","param","writable","ctorParamNames","constructorMethod","ctor","fields","field","superClass","parent","_declareFn","evalExpression","sourceUrl","createSourceMap","fnBody","fnArgNames","fnArgValues","argName","emptyFn","Function","bind","headerLines","toSourceMapGenerator","toJsComment","jitStatements","createSourceMaps","JitEmitterVisitor","createReturnStmt","getArgs","assertComponent","createOutputContext","genFilePath","runtime","createUrlResolverWithoutPackagePrefix","UrlResolver","createOfflineCompileUrlResolver","getUrlScheme","_split","_ComponentIndex","Scheme","_buildFromEncodedParts","opt_scheme","opt_userInfo","opt_domain","opt_port","opt_path","opt_queryData","opt_fragment","uri","_splitRe","_removeDotSegments","leadingSlash","trailingSlash","segments","up","pos","segment","pop","_joinAndCanonicalizePath","Path","UserInfo","Domain","Port","QueryData","Fragment","_resolveUrl","encodeURI","baseParts","setPrototypeOf","__proto__","assign","t","call","createInject","createInjectionToken","desc","_desc","createAttribute","attributeName","createContentChildren","data","first","isViewQuery","descendants","createContentChild","createViewChildren","createViewChild","Native","None","ChangeDetectionStrategy","OnPush","Default","changeDetection","createPipe","pure","createInput","bindingPropertyName","createOutput","createHostBinding","hostPropertyName","createHostListener","eventName","createNgModule","CUSTOM_ELEMENTS_SCHEMA","NO_ERRORS_SCHEMA","createOptional","createInjectable","createSelf","createSkipSelf","createHost","HTML","URL","RESOURCE_URL","NodeFlags","TypeElement","TypeText","ProjectedTemplate","CatRenderNode","TypeNgContent","TypePipe","TypePureArray","TypePureObject","TypePurePipe","CatPureExpression","TypeValueProvider","TypeClassProvider","TypeFactoryProvider","TypeUseExistingProvider","LazyProvider","PrivateProvider","TypeDirective","CatProviderNoDirective","CatProvider","EmbeddedViews","ComponentView","TypeContentQuery","TypeViewQuery","StaticQuery","DynamicQuery","CatQuery","Types","DepFlags","SkipSelf","Optional","Value","ArgumentType","Inline","Dynamic","BindingFlags","TypeElementAttribute","TypeElementClass","TypeElementStyle","TypeProperty","SyntheticProperty","SyntheticHostProperty","CatSyntheticProperty","QueryBindingType","First","All","QueryValueType","ElementRef","RenderElement","TemplateRef","ViewContainerRef","Provider","ViewFlags","MissingTranslationStrategy","Warning","Ignore","core","freeze","ValueTransformer","SyncAsync","assertSync","cb","all","syncAsyncValues","Promise","Version","full","splits","major","minor","patch","VERSION","TextAst","ngContentIndex","visitText","BoundTextAst","visitBoundText","AttrAst","visitAttr","BoundElementPropertyAst","visitElementProperty","BoundEventAst","handler","calcFullName","visitEvent","ReferenceAst","visitReference","VariableAst","visitVariable","inputs","outputs","references","visitElement","variables","visitEmbeddedTemplate","BoundDirectivePropertyAst","directiveName","templateName","visitDirectiveProperty","DirectiveAst","hostProperties","hostEvents","visitDirective","Builtin","visitNgContent","NullTemplateVisitor","RecursiveTemplateAstVisitor","visitChildren","results","jitDevMode","_f","members","assertNoMembers","JSON","cache","declarationFile","memberSuffix","HOST_REG_EXP","CompileSummaryKind","Injectable","CompileStylesheetMetadata","styles","styleUrls","CompileTemplateMetadata","encapsulation","template","templateUrl","htmlAst","externalStylesheets","animations","ngContentSelectors","interpolation","toSummary","CompileDirectiveMetadata","isHost","hostListeners","guards","componentViewType","rendererType","matches","inputsMap","bindConfig","outputsMap","summaryKind","CompilePipeMetadata","CompileNgModuleMetadata","exportedDirectives","exportedPipes","bootstrapComponents","importedModules","exportedModules","schemas","TransitiveCompileNgModuleMetadata","directivesSet","exportedDirectivesSet","pipesSet","exportedPipesSet","modulesSet","entryComponentsSet","addProvider","addDirective","addExportedDirective","addPipe","addExportedPipe","addModule","addEntryComponent","ec","componentType","ProviderMeta","parentOf","childOf","Expansion","visitExpansion","ExpansionCase","expSourceSpan","visitExpansionCase","valueSpan","visitAttribute","startSourceSpan","visitComment","InterpolationConfig","fromArray","markers","style","TagContentType","RAW_TEXT","ESCAPABLE_RAW_TEXT","PARSABLE_DATA","NAMED_ENTITIES","Aacute","aacute","Acirc","acirc","acute","AElig","aelig","Agrave","agrave","alefsym","Alpha","alpha","amp","and","ang","apos","Aring","aring","asymp","Atilde","atilde","Auml","auml","bdquo","Beta","beta","brvbar","bull","cap","Ccedil","ccedil","cedil","cent","Chi","chi","circ","clubs","cong","copy","crarr","cup","curren","dagger","Dagger","darr","dArr","deg","Delta","delta","diams","divide","Eacute","eacute","Ecirc","ecirc","Egrave","egrave","empty","emsp","ensp","Epsilon","epsilon","equiv","Eta","eta","ETH","eth","Euml","euml","euro","exist","fnof","forall","frac12","frac14","frac34","frasl","Gamma","gamma","ge","gt","harr","hArr","hearts","hellip","Iacute","iacute","Icirc","icirc","iexcl","Igrave","igrave","image","infin","int","Iota","iota","iquest","isin","Iuml","iuml","Kappa","kappa","Lambda","lambda","lang","laquo","larr","lArr","lceil","ldquo","le","lfloor","lowast","loz","lrm","lsaquo","lsquo","lt","macr","mdash","micro","middot","minus","Mu","mu","nabla","nbsp","ndash","ne","ni","notin","nsub","Ntilde","ntilde","Nu","nu","Oacute","oacute","Ocirc","ocirc","OElig","oelig","Ograve","ograve","oline","Omega","omega","Omicron","omicron","oplus","or","ordf","ordm","Oslash","oslash","Otilde","otilde","otimes","Ouml","ouml","para","permil","perp","Phi","phi","Pi","pi","piv","plusmn","pound","prime","Prime","prod","Psi","psi","quot","radic","rang","raquo","rarr","rArr","rceil","rdquo","real","reg","rfloor","Rho","rho","rlm","rsaquo","rsquo","sbquo","Scaron","scaron","sdot","sect","shy","Sigma","sigma","sigmaf","sim","spades","sub","sube","sup","sup1","sup2","sup3","supe","szlig","Tau","tau","there4","Theta","theta","thetasym","thinsp","THORN","thorn","tilde","times","trade","Uacute","uacute","uarr","uArr","Ucirc","ucirc","Ugrave","ugrave","uml","upsih","Upsilon","upsilon","Uuml","uuml","weierp","Xi","xi","Yacute","yacute","yen","yuml","Yuml","Zeta","zeta","zwj","zwnj","_resourceLoader","_urlResolver","_htmlParser","_config","_resourceLoaderCache","clearCache","clear","clearCacheFor","normalizedDirective","stylesheet","_fetch","normalizeTemplate","prenormData","_preParseTemplate","preparsedTemplate","_normalizeTemplateMetadata","prenomData","_preparseLoadedTemplate","templateAbsUrl","rootNodesAndErrors","templateMetadataStyles","_normalizeStylesheet","TemplatePreparseVisitor","templateStyles","inlineStyleUrls","_loadMissingExternalStylesheets","_normalizeLoadedTemplateMetadata","stylesheets","_inlineStyles","styleUrl","targetStyles","loadedStylesheets","loadedStyle","allStyleUrls","allStyles","styleWithImports","ngNonBindableStackCount","preparsedElement","textContent_1","QUERY_METADATA_IDENTIFIERS","_reflector","typeMetadata","annotations","throwIfNotFound","propertyMetadata","propMetadata","_mergeWithPropertyMetadata","dm","directiveType","hostBinding","startWith","hostListener","_merge","_extractPublicName","def","_dedupeBindings","bindings","names","publicNames","reversedResult","binding","name_1","mergedInputs","mergedOutputs","mergedHost","mergedQueries","comp","moduleId","KEYWORDS","tokens","scanToken","numValue","strValue","isCharacter","isNumber","isString","isOperator","operater","isKeyword","isKeywordLet","isKeywordAs","isKeywordNull","isKeywordUndefined","isKeywordTrue","isKeywordFalse","isKeywordThis","isError","toNumber","EOF","scanIdentifier","scanNumber","scanCharacter","scanString","scanOperator","scanComplexOperator","one","twoCode","two","threeCode","three","simple","parseFloat","quote","buffer","marker","unescapedCode","last","ParserError","errLocation","ctxLocation","ParseSpan","AST","Quote","uninterpretedExpression","location","ImplicitReceiver","Chain","Conditional","PropertyRead","PropertyWrite","SafePropertyRead","KeyedRead","KeyedWrite","BindingPipe","LiteralPrimitive","LiteralArray","LiteralMap","Interpolation","strings","Binary","operation","PrefixNot","NonNullAssert","MethodCall","SafeMethodCall","FunctionCall","TemplateBinding","keyIsVar","NullAstVisitor","RecursiveAstVisitor","AstTransformer","SplitInterpolation","offsets","TemplateBindingParseResult","templateBindings","_lexer","parseAction","_checkNoInterpolation","sourceToLex","_stripComments","_ParseAST","parseChain","parseBinding","_parseBindingAst","parseSimpleBinding","SimpleExpressionChecker","check","_reportError","_parseQuote","prefixSeparatorIndex","parseTemplateBindings","prefixToken","prefixTokens","parseInterpolation","splitInterpolation","expressionText","_findInterpolationErrorColumn","wrapLiteralPrimitive","_commentStart","outerQuote","char","nextChar","partInErrIdx","inputLength","rparensExpected","rbracketsExpected","rbracesExpected","inputIndex","optionalCharacter","peekKeywordLet","peekKeywordAs","expectCharacter","optionalOperator","op","expectOperator","operator","expectIdentifierOrKeyword","expectIdentifierOrKeywordOrString","parsePipe","parseExpression","parseConditional","parseLogicalOr","yes","no","parseLogicalAnd","parseEquality","parseRelational","parseAdditive","parseMultiplicative","parsePrefix","parseCallChain","parsePrimary","parseAccessMemberOrMethodCall","parseCallArguments","elements","parseExpressionList","parseLiteralMap","literalValue","terminator","isSafe","positionals","expectTemplateBindingKey","operatorFound","rawKey","name_2","letStart","letName","locationText","skip","col","moveBy","ch","priorLine","getContext","maxChars","maxLines","startOffset","endOffset","ctxChars","ctxLines","before","after","details","ParseErrorLevel","WARNING","ERROR","ParseError","contextualMessage","TAG_OPEN_START","TAG_OPEN_END","TAG_OPEN_END_VOID","TAG_CLOSE","COMMENT_START","COMMENT_END","CDATA_START","CDATA_END","ATTR_NAME","ATTR_VALUE","DOC_TYPE","EXPANSION_FORM_START","EXPANSION_CASE_VALUE","EXPANSION_CASE_EXP_START","EXPANSION_CASE_EXP_END","EXPANSION_FORM_END","Token$1","TokenError","errorMsg","tokenType","TokenizeResult","_CR_OR_CRLF_REGEXP","_ControlFlowError","_file","_getTagDefinition","_tokenizeIcu","_interpolationConfig","_peek","_nextPeek","_index","_line","_column","_expansionCaseStack","_inInterpolation","_input","_length","_advance","_processCarriageReturns","_getLocation","_attemptCharCode","_consumeCdata","_consumeComment","_consumeDocType","_consumeTagClose","_consumeTagOpen","_tokenizeExpansionForm","_consumeText","_beginToken","_endToken","_consumeExpansionFormStart","_isInExpansionForm","_consumeExpansionCaseStart","_isInExpansionCase","_consumeExpansionCaseEnd","_consumeExpansionFormEnd","_getSpan","_currentTokenStart","_currentTokenType","_createError","_attemptCharCodeCaseInsensitive","_requireCharCode","_attemptStr","chars","initialPosition","_savePosition","_restorePosition","_attemptStrCaseInsensitive","_requireStr","_attemptCharCodeUntilFn","predicate","_requireCharCodeUntilFn","_attemptUntilChar","_readChar","decodeEntities","_decodeEntity","startPosition","isHex","numberStart","strNum","entity","_consumeRawText","firstCharOfEnd","attemptEndRest","tagCloseStart","textStart","textToken","_consumePrefixAndName","nameOrPrefixStart","nameStart","lowercaseTagName","savedPos","_consumeTagOpenStart","_consumeAttributeName","_consumeAttributeValue","_consumeTagOpenEnd","contentTokenType","contentType","_consumeRawTextWithTagClose","prefixAndName","quoteChar","valueStart","_readUntil","_isTextEnd","nbTokens","TreeError","Parser$1","parseExpansionForms","tokensAndErrors","treeAndErrors","_TreeBuilder","build","_rootNodes","_errors","_elementStack","_consumeStartTag","_consumeEndTag","_closeVoidElement","_consumeExpansion","prev","_advanceIf","startToken","_addToParent","expCase","_parseExpansionCase","_collectExpansionExpTokens","parsedExp","expansionFormStack","parent_1","_getParentElement","ignoreFirstLf","isVoid","startTagToken","_consumeAttr","_getElementFullName","selfClosing","tagDef","canSelfClose","_pushElement","_popElement","parentEl","isClosedByChild","_getParentElementSkippingContainers","container","requireExtraParent","newParent","parentToAdd","_insertBeforeContainer","endTagToken","errMsg","stackIndex","splice","closedByParent","valueToken","parentElement","_SerializerVisitor","visitContainer","visitIcu","icu","strCases","visitTagPlaceholder","ph","startName","closeName","visitPlaceholder","visitIcuPlaceholder","Message","placeholders","placeholderToMessage","sources","startLine","startCol","endLine","endCol","Text$1","Container","Icu","TagPlaceholder","Placeholder","IcuPlaceholder","CloneVisitor","expressionPlaceholder","RecurseVisitor","HtmlTagDefinition","closedByChildren","requiredParents","implicitNamespacePrefix","currentParent","lcParent","area","embed","link","img","hr","br","track","wbr","thead","tbody","tfoot","tr","td","th","svg","math","li","dt","dd","rb","rt","rtc","rp","optgroup","option","pre","listing","script","title","textarea","TAG_TO_PLACEHOLDER_NAMES","A","B","BR","EM","H1","H2","H3","H4","H5","H6","HR","I","LI","LINK","OL","P","Q","S","SMALL","SUB","SUP","TBODY","TD","TFOOT","TH","THEAD","TR","TT","U","UL","PlaceholderRegistry","_placeHolderNameCounts","_signatureToName","getStartTagPlaceholderName","signature","_hashTag","upperTag","baseName","_generateUniqueName","getCloseTagPlaceholderName","_hashClosingTag","getPlaceholderName","upperName","uniqueName","getUniquePlaceholder","_expressionParser","_isIcu","_icuDepth","_placeholderRegistry","_placeholderToContent","_placeholderToMessage","i18nodes","startPhName","closePhName","attribute","_visitTextWithInterpolation","comment","i18nIcuCases","i18nIcu","caze","expPh","phName","icuCase","sDelimiter","eDelimiter","lastStringIdx","I18nError","_I18N_COMMENT_PREFIX_REGEXP","i18nCommentsWarned","ExtractionResult","_VisitorMode","Extract","Merge","_implicitTags","_implicitAttrs","_init","_inI18nBlock","_messages","_translations","wrapper","translatedNode","_mode","_mayBeAddBlockChildren","wasInIcu","_inIcu","_isInTranslatableSection","_addMessage","isOpening","isClosing","_inI18nNode","_depth","_blockStartDepth","_closeTranslatableSection","_blockChildren","_blockMeaningAndDesc","_translateMessage","warn","_openTranslatableSection","wasInI18nNode","wasInImplicitNode","_inImplicitNode","childNodes","translatedChildNodes","i18nAttr","i18nMeta","isImplicit","isTopLevelImplicit","isTranslatable","visited","_visitAttributesOf","translatedAttrs","_translateAttributes","_msgCountAtSectionStart","_createI18nMessage","explicitAttrNameToValue","implicitAttrNames","msgMeta","i18nParsedMessageMeta","translatedAttributes","directChildren","startIndex","XmlTagDefinition","XmlParser","Serializer","createNameMapper","SimplePlaceholderMapper","mapName","internalToPublic","publicToNextId","publicToInternal","toInternalName","publicName","visitPlaceholderName","nextId","_Visitor$1","visitTag","strAttrs","_serializeAttributes","strChildren","visitDeclaration","decl","visitDoctype","doctype","rootTag","dtd","Declaration","unescapedAttrs","Doctype","Tag","Text$2","unescapedValue","CR","ws","write","locale","_WriteVisitor","transUnits","contextTags","contextGroupTag","purpose","context-type","transUnit","datatype","priority","source-language","original","xliff","version","xmlns","encoding","load","xliffParser","XliffParser","msgIdToHtml","i18nNodesByMsgId","XmlToI18n","msgId","convert","i18nNodes","ctype","equiv-text","startTagPh","closeTagPh","equivText","_locale","_unitMlString","_msgIdToHtml","xml","idAttr","_addError","innerTextStart","innerTextEnd","innerText","localeAttr","expansion","expansionCase","xmlIcu","nameAttr","caseMap","_WriteVisitor$1","units","notes","category","srcLang","xliff2Parser","Xliff2Parser","XmlToI18n$1","_nextPlaceholderId","disp","tagPc","equivStart","equivEnd","dispStart","dispEnd","idStr","versionAttr","startAttr","endAttr","startId","endId","exampleVisitor","ExampleVisitor","_Visitor$2","rootNode","sourceTags","addDefaultExamples","startEx","closeEx","exTag","exText","xtbParser","XtbParser","XmlToI18n$2","xtb","_bundleDepth","langAttr","TranslationBundle","_i18nNodesByMsgId","mapperFactory","missingTranslationStrategy","_i18nToHtml","I18nToHtmlVisitor","serializer","srcMsg","html","_digest","_mapperFactory","_missingTranslationStrategy","_console","_contextStack","_convertToText","_srcMsg","_mapper","mapper","translationsFormat","_translationBundle","parseResult","CORE","ANALYZE_FOR_ENTRY_COMPONENTS","ChangeDetectorRef","QueryList","ComponentRef","NgModuleFactory","createModuleFactory","moduleDef","moduleProviderDef","RegisterModuleFactoryFn","Injector","LOCALE_ID","TRANSLATIONS_FORMAT","inlineInterpolate","interpolate","EMPTY_ARRAY","EMPTY_MAP","Renderer","viewDef","elementDef","anchorDef","textDef","directiveDef","queryDef","pureArrayDef","pureObjectDef","purePipeDef","pipeDef","nodeValue","ngContentDef","createRendererType2","RendererType2","ViewDefinition","createComponentFactory","_SELECTOR_REGEXP","classNames","_addResult","cssSel","current","inNot","exec","hasElementSelector","getMatchingElementTemplate","classAttr","klass","notSelector","SelectorMatcher","_elementMap","_elementPartialMap","_classMap","_classPartialMap","_attrValueMap","_attrValuePartialMap","_listContexts","createNotMatcher","notMatcher","addSelectables","cssSelectors","callbackCtxt","listContext","SelectorListContext","_addSelectable","matcher","selectable","SelectorContext","isTerminal","_addTerminal","_addPartial","terminalMap","terminalValuesMap","partialMap","partialValuesMap","terminalList","matchedCallback","alreadyMatched","_matchTerminal","_matchPartial","name_3","selectables","starSelectables","finalize","nestedSelector","cbContext","callback","_ngModuleResolver","_directiveResolver","_pipeResolver","_summaryResolver","_schemaRegistry","_directiveNormalizer","_staticSymbolCache","_errorCollector","_nonNormalizedDirectiveCache","_directiveCache","_summaryCache","_pipeCache","_ngModuleCache","_ngModuleOfTypes","getReflector","dirMeta","_createProxyClass","baseType","delegate","proxyClass","setDelegate","getGeneratedClass","dirType","getComponentViewClass","getHostComponentViewClass","getHostComponentType","HostClass","getRendererType","getComponentFactory","hostView","initComponentFactory","_loadSummary","typeSummary","resolveSummary","getHostComponentMetadata","hostViewType","hostType","loadDirectiveMetadata","isSync","getNonNormalizedDirectiveMetadata","annotation","createDirectiveMetadata","templateMetadata","normalizedDirMeta","componentModuleUrl","cacheEntry","nonNormalizedTemplateMetadata","changeDetectionStrategy","entryComponentMetadata","_getProvidersMetadata","_getEntryComponentMetadata","getDefaultComponentElementName","_getQueriesMetadata","_getTypeMetadata","getDirectiveMetadata","getDirectiveSummary","dirSummary","getNgModuleSummary","moduleType","alreadyCollecting","moduleSummary","loadNgModuleDirectiveAndPipeMetadata","loading","promise","_loadPipeMetadata","compileMeta","exportedNonModuleIdentifiers","imports","importedType","importedModuleType","moduleWithProviders","_checkSelfImport","_getTypeDescriptor","importedModuleSummary","exportedType","exportedModuleSummary","_getIdentifierMetadata","_getTransitiveNgModuleMetadata","declarations","declaredType","declaredIdentifier","_addTypeToModule","exportedId","bootstrap","provide","oldModule","modulesByToken","modSummary","mod","addedTokens","tokenRef","prevModules","moduleRef","ann","getInjectableSummary","_getInjectableMetadata","throwOnUnknownDeps","_getDependenciesMetadata","_getFactoryMetadata","getPipeMetadata","pipeType","pipeMeta","getPipeSummary","pipeSummary","getOrLoadPipeMetadata","pipeAnnotation","typeOrFunc","hasUnknownDeps","parameters","dependenciesMetadata","isSelf","paramEntry","_getTokenMetadata","depsTokens","targetEntryComponents","debugInfo","compileProviders","providerIdx","_validateProvider","providersInfo","soFar","seenProvider","seenProviderIdx","_getEntryComponentsFromProvider","getProviderMetadata","components","collectedIdentifiers","compileDeps","compileTypeMetadata","compileFactoryMetadata","propertyName","_getQueryMetadata","_queryVarBindings","q","varName","read","otherType","TypeModifier","Const","modifiers","hasModifier","modifier","BuiltinTypeName","Bool","Int","Inferred","BuiltinType","visitBuiltintType","visitExpressionType","of","visitArrayType","MapType","valueType","visitMapType","BOOL_TYPE","BinaryOperator","Equals","NotEquals","Identical","NotIdentical","Minus","Plus","Divide","Multiply","Modulo","And","Or","Lower","LowerEquals","Bigger","BiggerEquals","ReadPropExpr","ReadKeyExpr","callMethod","InvokeMethodExpr","InvokeFunctionExpr","InstantiateExpr","conditional","trueCase","falseCase","ConditionalExpr","equals","rhs","BinaryOperatorExpr","notEquals","identical","plus","multiply","modulo","lower","lowerEquals","bigger","biggerEquals","isBlank","TYPED_NULL_EXPR","CastExpr","BuiltinVar","This","Super","CatchError","CatchStack","builtin","visitReadVarExpr","WriteVarExpr","visitWriteVarExpr","WriteKeyExpr","visitWriteKeyExpr","WritePropExpr","visitWritePropExpr","BuiltinMethod","ConcatArray","SubscribeObservable","Bind","visitInvokeMethodExpr","visitInvokeFunctionExpr","classExpr","visitInstantiateExpr","visitLiteralExpr","visitExternalExpr","ExternalReference","visitConditionalExpr","visitNotExpr","visitAssertNotNullExpr","visitCastExpr","visitFunctionExpr","DeclareFunctionStmt","lhs","visitBinaryOperatorExpr","visitReadPropExpr","visitReadKeyExpr","entries","visitLiteralArrayExpr","visitLiteralMapExpr","CommaExpr","visitCommaExpr","Private","visitDeclareVarStmt","visitDeclareFunctionStmt","visitExpressionStmt","visitReturnStmt","AbstractClassPart","ClassMethod","ClassField","ClassGetter","ClassStmt","visitDeclareClassStmt","IfStmt","visitIfStmt","CommentStmt","visitCommentStmt","TryCatchStmt","bodyStmts","catchStmts","visitTryCatchStmt","ThrowStmt","visitThrowStmt","AstTransformer$1","transformExpr","transformStmt","visitAllExpressions","mapType","ctorMethod","RecursiveAstVisitor$1","_clone","clone","ProviderViewContext","ProviderElementContext","viewContext","_parent","_isViewRoot","_directiveAsts","refs","_sourceSpan","_transformedProviders","_seenProviders","_queriedTokens","transformedHasViewContainer","_attrs","directivesMeta","directiveAst","_allProviders","_contentQueries","_addQueryReadsTo","templateRefId","refAst","defaultQueryValue","_getOrCreateLocalProvider","afterElement","lazyProviders","eagerProviders","sortedProviderTypes","transformProviders","sortedDirectives","dir1","dir2","allMatches","defaultValue","queryReadTokens","_getQueriesFor","queryValue","currentEl","distance","requestingProviderType","transformedProviderAst","transformedProviders","transformedUseValue","transformedUseExisting","transformedDeps","existingDiDep","_getDependency","_getLocalDependency","currElement","currEager","prevElement","NgModuleProviderAnalyzer","extraProviders","errorString","requestorSourceSpan","foundLocal","quotedSet","NgModuleCompileResult","ngModuleFactoryVar","LOG_VAR","compile","ngModuleMeta","providerParser","providerDefs","ngModuleDef","ngModuleDefFactory","_createNgModuleFactory","registerFactoryStmt","createStub","ngModuleReference","ngModuleFactoryStmt","SourceMapGenerator","sourcesContent","lines","lastCol0","hasMappings","addSource","addLine","addMapping","col0","sourceLine0","sourceCol0","currentLine","toJSON","sourcesIndex","mappings","lastSourceIndex","lastSourceLine0","lastSourceCol0","segAsStr","sourceRoot","CATCH_ERROR_VAR$1","CATCH_STACK_VAR$1","_EmittedLine","partsLength","srcSpans","_indent","_classes","_preambleLineCount","_lines","println","lastPart","print","lineIsEmpty","_currentLine","lineLength","newLine","removeEmptyLastLine","incIndent","decIndent","pushClass","clazz","popClass","sourceLines","startsAtLine","firstOffsetMapped","mapFirstOffsetIfNeeded","lineIdx","spans","spanIdx","sourceLine","sourceCol","setPreambleLineCount","emittedLine","columnsLeft","AbstractEmitterVisitor","_escapeDollarInStrings","hasElseCase","lineWasEmpty","getBuiltinMethodName","opStr","visitAllObjects","separator","incrementedIndent","emitStatementsAndContext","emitSourceMaps","referenceFilter","preambleLines","reexports","exportedModuleName","reexportsCode","reexport","as","importsWithPrefixes","importedModuleName","sm","sourceText","typeExpression","defaultType","_visitIdentifier","_printColonType","_visitClassField","_visitClassConstructor","_visitClassGetter","_visitClassMethod","_visitParams","typeStr","size","metas","ElementSchemaRegistry","BOOLEAN","NUMBER","STRING","OBJECT","SCHEMA","_ATTR_TO_PROP","class","for","formaction","innerHtml","readonly","tabindex","_schema","encodedType","strType","strProperties","properties","typeNames","superName","superType","property","hasProperty","schemaMetas","schema","hasElement","getMappedPropName","validateProperty","validateAttribute","normalizeAnimationStyleProperty","normalizeAnimationStyleValue","camelCaseProp","userProvidedProp","strVal","valAndSuffixMatch","ShadowCss","strictStyling","shimCssText","hostSelector","commentsWithHash","_insertDirectives","_scopeCssText","_insertPolyfillDirectivesInCssText","_insertPolyfillRulesInCssText","_cssContentNextSelectorRe","_cssContentRuleRe","scopeSelector","unscopedRules","_extractUnscopedRulesFromCssText","_insertPolyfillHostInCssText","_convertColonHost","_convertColonHostContext","_convertShadowDOMSelectors","_scopeSelectors","r","_cssContentUnscopedRuleRe","_convertColonRule","_cssColonHostRe","_colonHostPartReplacer","_cssColonHostContextRe","_colonHostContextPartReplacer","regExp","partReplacer","_polyfillHostNoCombinator","_polyfillHost","_shadowDOMSelectorsRe","_scopeSelector","strict","_shadowDeepSelectors","deepParts","shallowPart","otherParts","_selectorNeedsScoping","_applyStrictSelectorScope","_applySelectorScope","_makeScopeMatcher","lre","rre","_selectorReSuffix","_applySimpleSelectorScope","_polyfillHostRe","replaceBy_1","_polyfillHostNoCombinatorRe","hnc","colon","isRe","_scopeSelectorPart","scopedP","safeContent","SafeSelector","scopedSelector","sep","hasHost","shouldScope","part_1","restore","_colonHostContextRe","_polyfillHostContext","_colonHostRe","keep","replaceBy","_content","pseudo","_parenSuffix","StylesCompileDependency","CompiledStylesheet","stylesVar","isShimmed","_shadowCss","compileComponent","_compileStyles","needsStyleShim","compileStyles","isComponentStylesheet","styleExpressions","plainStyle","_shimIfNeeded","exprIndex","SKIP_WS_TRIM_TAGS","WS_CHARS","NO_WS_REGEXP","WS_REPLACE_REGEXP","expanded","BoundPropertyType","DEFAULT","LITERAL_ATTR","ANIMATION","BoundProperty","isLiteral","BindingParser","_exprParser","_targetErrors","pipesByName","_usedPipes","pipe","getUsedPipes","createDirectiveHostPropertyAsts","elementSelector","boundProps_1","parsePropertyBinding","createElementPropertyAst","createDirectiveHostEventAsts","targetEventAsts_1","parseEvent","sourceInfo","_reportExpressionParserErrors","_checkPipes","parseInlineTemplateBinding","targetMatchableAttrs","targetProps","targetVars","_parseTemplateBindings","_parsePropertyAst","parseLiteralAttr","bindingsResult","warning","_parseAnimation","isAnimationProp","_parseBinding","parsePropertyInterpolation","isHostBinding","boundProp","bindingType","boundPropertyName","securityContexts","_validatePropertyOrAttributeName","nsSeparatorIdx","ns","targetEvents","_parseAnimationEvent","_parseEvent","_parseAction","errors_1","collector","PipeCollector","pipeName","isAttr","report","BIND_NAME_REGEXP","TEXT_CSS_SELECTOR","TemplateParseError","TemplateParseResult","templateAst","usedPipes","transforms","tryParse","htmlParseResult","getInterpolationConfig","tryParseHtml","expandHtml","uniqDirectives","uniqPipes","providerViewContext","bindingParser","parseVisitor","TemplateParseVisitor","EMPTY_ELEMENT_CONTEXT","_assertNoReferenceDuplicationOnTemplate","forced","expandedHtmlAst","existingReferences","_bindingParser","_schemas","selectorMatcher","directivesIndex","ngContentCount","findNgContentIndex","valueNoNgsp","queryStartIndex","matchableAttrs","elementOrDirectiveProps","elementOrDirectiveRefs","elementVars","events","templateElementOrDirectiveProps","templateMatchableAttrs","templateElementVars","hasInlineTemplates","isTemplateElement","templateBindingsSource","hasBinding","_parseAttr","normalizedName","_normalizeAttributeName","hasTemplateBinding","elementCssSelector","_parseDirectives","directiveMetas","matchElement","boundDirectivePropNames","directiveAsts","_createDirectiveAsts","elementProps","_createElementPropertyAsts","isViewRoot","providerContext","NON_BINDABLE_VISITOR","ElementContext","parsedElement","projectionSelector","every","_assertAllEventsPublishedByDirectives","_assertNoComponentsNorElementBindingsOnTemplate","transformedDirectiveAsts","_assertElementExists","_assertOnlyOneComponent","ngContentIndex_1","templateQueryStartIndex","templateSelector","templateDirectiveMetas","templateBoundDirectivePropNames","templateDirectiveAsts","templateElementProps","templateProviderContext","targetRefs","srcSpan","bindParts","_parseVariable","_parseReference","_parseAssignmentEvent","ElementOrDirectiveRef","elementSourceSpan","targetReferences","targetBoundDirectivePropNames","matchedReferences","directiveProperties","_checkPropertiesInSchema","_createDirectivePropertyAsts","elOrDirRef","isReferenceToDirective","refToken","boundProps","targetBoundDirectiveProps","boundPropsByName_1","dirProp","elProp","boundElementProps","_findComponentDirectives","_findComponentDirectiveNames","componentTypeNames","elName","allDirectiveEvents","event","NonBindableVisitor","attrNameAndValues","_ngContentIndexMatcher","_wildcardNgContentIndex","wildcardNgContentIndex","ngContentIndices","EventHandlerVars","allowDefault","General","_converterFactory","BuiltinFunctionCall","_localResolver","_implicitReceiver","_nodeMap","_resultMap","_currentTemporary","_visit","fnResult","convertedArgs","leftMostSafe","leftMostSafeNode","convertSafeAccess","_getLocal","getLocal","varExpr","guardedExpression","temporary","needsTemporary","allocateTemporary","access","releaseTemporary","visitSome","tempNumber","componentId","externalReferenceVars","embeddedViewCount","viewBuilderFactory","embeddedViewIndex","ViewBuilder","TypeCheckLocalResolver","defaultResolver","isHostComponent","refOutputVars","updates","actions","getOutputVar","getTypeGuardExpressions","guard","useIf","targetStatements","viewStmts","bindingCount","preprocessUpdateExpression","nameResolver","guardExpression","guardClause","viewName","viewFactory","visitElementOrTemplate","fullTemplateTypeCheck","childVisitor","outputVarType","outputAst","hostEventAst","currBuilder","varAst","pipeOutputVar","ViewCompileResult","viewClassVar","rendererTypeVar","renderComponentVarName","template_1","customRenderData","renderComponentVar","ViewBuilder$1","LOG_VAR$1","COMP_VAR","EVENT_NAME_VAR","ALLOW_DEFAULT_VAR","purePipeNodeIndices","refNodeIndices","_createPipe","queryIds_1","queryIndex","nodeFlags","nodeDef","_createNodeExpressions","updateRendererStmts","updateDirectivesStmts","nodeDefExprs","updateRendererFn","_createUpdateFn","updateDirectivesFn","viewFlags","updateStmts","updateFn","preStmts","astWithSource","inter","updateRendererExpressions","bindingIndex","_preprocessUpdateExpression","checkIndex","updateRenderer","_visitElementOrTemplate","queryMatchesExpr","childCount","_createElementHandleEventFn","usedEvents","dirHostBindings","hostBindings","inputDefs","outputDefs","compAst","compRendererType","compView","_visitComponentFactoryResolverProvider","dirIndex","localDirAst","_visitDirective","dirHostEvents","_visitProvider","queryMatchExprs","elementNodeIndex","_visitProviderOrDirective","mapValue","updateDirectiveExpressions","dirContextExpr","updateDirectives","_addProviderNode","componentDirMeta","providerFlags","currViewExpr","refNodeIndex","varValue","_createLiteralArrayConverter","valueExpr_1","_createLiteralMapConverter","valueExpr_2","_createPipeConverter","checkIndex_1","compViewExpr","compBuilder","pipeNodeIndex","pipeValueExpr_1","nodeValueExpr_1","diDep","createUpdateStatements","allowEmptyExprs","updateBindingCount","self","handlers","handleEventStmts","handleEventBindingCount","trueStmts","eventTarget","fullEventName","handleEventFn","MessageBundle","updateFromTemplate","htmlParserResult","i18nParserResult","getMessages","filterSources","mapperVisitor","MapPlaceholderNames","msgList","src","transformedMessage","GeneratedFile","srcFileUrl","sourceOrStmts","ResolvedStaticSymbol","staticSymbolCache","errorRecorder","metadataCache","resolvedSymbols","resolvedFilePaths","importAs","symbolResourcePaths","symbolFromFile","knownFileNameToModuleNames","staticSymbol","_resolveSymbolMembers","resultFromSummary","_resolveSymbolFromSummary","resultFromCache","_createSymbolsOf","getImportAs","useSummaries","baseSymbol","baseImportAs","summarizedFileName","summarizedName","getResourcePath","getTypeArity","arity","getKnownModuleName","recordImportAs","sourceSymbol","targetSymbol","recordModuleNameForFileName","invalidateFile","symbols_1","ignoreErrorsFor","recorder","baseResolvedSymbol","baseMetadata","statics","getModuleMetadata","metadataKey","decorators","summarySymbols","metadataSymbols","this_1","moduleExport","export","exportSymbol","symName","resolvedModule","resolveModule","createExport","topLevelSymbolNames_1","origins_1","origin","originFilePath","reportError","createResolvedSymbol","topLevelPath","topLevelSymbolNames","transformedMeta_1","_originalFileMemo","getOriginalName","getOutputName","ReferenceTransformer","functionParams","symbolic","oldLen","transformedMeta","unwrappedTransformedMeta","moduleMetadata","moduleMetadatas","getMetadataFor","maxVersion_1","md","errorMessage","getSymbolByModule","containingFile","moduleNameToFileName","indexBySymbol","reexportedBy","processedSummaryBySymbol","processedSummaries","unprocessedSummary","processedSummary","processValue","metadata_1","clone_1","declarationSymbol","ngModuleSummary","summary_1","summaries","reexportSymbol","__symbol","toSummaryFileName","visitStaticSymbol","loadSummary","isLibrary","exportAsArr","exportAsBySymbol","exportAsArr_1","ngModuleSymbols","serializeSummaryWithDeps","ngModuleSymbol","jitExportAsName","serializeSummaryRef","serializeSummary","typeSymbol","jitImportedSymbol","Transformer","allImportAs","serializedSymbol","fromSummaryFileName","StubEmitFlags","Basic","TypeCheck","_options","_host","_metadataResolver","_templateParser","_styleCompiler","_viewCompiler","_typeCheckCompiler","_ngModuleCompiler","_outputEmitter","_symbolResolver","_templateAstCache","_analyzedFiles","analyzeModulesSync","rootFiles","analyzeResult","analyzeModulesAsync","_analyzeFile","findGeneratedFileNames","genFileNames","allowEmptyCodegenFiles","enableSummariesForJit","dirSymbol","normalizedUrl","emitBasicStub","genFileName","originalFileName","_createOutputContext","originalFile","_createNgFactoryStub","_codegenSourceModule","emitTypeCheckStub","loadFilesAsync","loadingPromises","loadFilesSync","emitFlags","ngModuleIndex","_externalIdentifierReferences","typeIndex","dirId","_createTypeCheckBlock","references_1","_parseTemplate","parsedTemplate","emitMessageBundle","messageBundle","compMetas","emitAllImpls","_compileImplFile","generatedFiles","_createSummary","_compileModule","componentStylesheet","stylesheetMeta","_codegenStyles","_compileComponent","_compileComponentFactory","srcModule","ngFactoryCtx","symbolSummaries","typeData","forJitOutputCtx","summaryJson","normalizedLocale","hostMeta","hostViewFactoryVar","compFactoryVar","inputsExprs","outputsExprs","directiveIdentifiers","componentStyles","stylesExpr","viewResult","importModule","_fileNameToModuleName","selfReference","suppliedTypeParams","missingTypeParamsCount","allTypeParams","fill","memberName","importedFilePath","containingFilePath","fileNameToModuleName","stylesheetMetadata","compiledStylesheet","entryRoute","visitLazyRoute","seenRoutes","lazyRoutes","lazyRoutes_2","lazyRoute","lazyRoutes_1","ANGULAR_CORE","IGNORE","USE_VALUE","PROVIDE","REFERENCE_SET","knownMetadataClasses","knownMetadataFunctions","annotationCache","propertyCache","parameterCache","methodCache","staticCache","conversionMap","resolvedExternalReferences","annotationForParentClassWithSummaryKind","initializeConversionMap","kc","_registerDecoratorOrConstructor","kf","_registerFunction","findSymbolDeclaration","declarationSymbol_1","refSymbol","findDeclaration","tryFindDeclaration","resolvedMetadata","classMetadata","getTypeMetadata","parentType","findParentType","parentAnnotations","ownAnnotations_1","simplify","requiredAnnotationTypes","requiredType","parentPropMetadata_1","parentProp","members_1","propData","parameters_1","ctorData","rawParameterTypes","parameterDecorators_1","rawParamType","nestedResult","paramType","trySimplify","_methodNames","methodNames","parentMethodNames_1","members_2","isMethod","_staticMembers","staticMembers","staticMemberData","lcProperty","staticMembers_1","injectionToken","opaqueToken","originalRecorder","simplifyInContext","depth","resolveReferenceValue","simplifyEagerly","simplifyLazily","simplifyNested","nestedContext","summaryMsg","simplifyCall","functionSymbol","targetFunction","targetExpression","calling","value_1","defaults","functionScope","BindingScope","result_1","oldScope","scope","done","result_2","spreadArray","spreadArray_1","spreadItem","value_2","declarationValue","operand","indexTarget","member","selectContext","selectTarget","localValue","missing","argExpressions","reportingContext","PopulatedScope","summaryCache","loadedFilePaths","referringSrcFileName","referringLibFileName","rootSymbol","_loadSummaryFile","hasSummary","summaryFilePath","SummaryResolver","JitSummaryResolver","_summaries","instance","ReturnValue","debugAst","currCtx","CATCH_ERROR_VAR$2","CATCH_STACK_VAR$2","subscribe","fnExpr","AbstractJsEmitterVisitor","_evalArgNames","_evalArgValues","_evalExportedVars","resultVar","JitCompiler","_compilerConfig","getExtraNgModuleProviders","_compiledTemplateCache","_compiledHostTemplateCache","_compiledDirectiveWrapperCache","_compiledNgModuleCache","_sharedStylesheetCount","_addedAotSummaries","compileModuleSync","_compileModuleAndComponents","compileModuleAsync","compileModuleAndAllComponentsSync","_compileModuleAndAllComponents","compileModuleAndAllComponentsAsync","loadAotSummaries","_addAotSummaries","fn$$1","hasAotSummary","_filterJitIdentifiers","ids","_loadModules","_compileComponents","componentFactories","ngModuleFactory","mainModule","mainNgModule","nestedNgModule","_interpretOrJit","allComponentFactories","moduleByJitDirective","templates","transJitModules","localMod","localModuleMeta","dirRef","_createCompiledTemplate","_createCompiledHostTemplate","entryComponentType","_compileTemplate","compiledTemplate","viewDefFactory","CompiledTemplate","isCompiled","externalStylesheetsByModuleUrl","outputContext","_resolveStylesCompileResult","evalResult","viewClass","compiled","nestedCompileResult","nestedStylesArr","_resolveAndEvalStylesCompileResult","_viewClass","CompileReflector","UrlResolverImpl","_packagePrefix","resolvedUrl","resolvedParts","ResourceLoader","Extractor","extractor"],"mappings":";;;;;CAKC,SAAUA,OAAQC,SACC,gBAAZC,UAA0C,mBAAXC,QAAyBF,QAAQC,SACrD,kBAAXE,SAAyBA,OAAOC,IAAMD,OAAO,qBAAsB,WAAYH,SACrFA,SAASD,OAAOM,GAAKN,OAAOM,OAAUN,OAAOM,GAAGC,eAChDC,KAAM,SAAWN,SAAW,YAsB9B,SAASO,WAAUC,EAAGC,GAElB,QAASC,MAAOJ,KAAKK,YAAcH,EADnCI,cAAcJ,EAAGC,GAEjBD,EAAEK,UAAkB,OAANJ,EAAaK,OAAOC,OAAON,IAAMC,GAAGG,UAAYJ,EAAEI,UAAW,GAAIH;;;;;;;;;;;;AAmCnF,QAASM,WAMT,QAASC,cAKT,QAASC,UAmBT,QAASC,cAQT,QAASC,cAwBT,QAASC,SAKT,QAASC,UAKT,QAASC,WAKT,QAASC,gBAKT,QAASC,iBAKT,QAASC,aAKT,QAASC,wBAIT,QAASC,mBAsHT,QAASC,oBAOT,QAASC,qBAAoBC,KAAMC,OAC/B,GAAqBjC,SAAU,WAE3B,IAAK,GADDkC,SACKC,GAAK,EAAGA,GAAKC,UAAUC,OAAQF,KACpCD,KAAKC,IAAMC,UAAUD,GAEzB,IAAqBG,QAASL,MAAQA,MAAMM,UAAM,GAAQL,QAC1D,OAAOM,WAAWC,eAAgBT,MAAQM,QAI9C,OAFAtC,SAAQ0C,SAAW,SAAUC,KAAO,MAAOA,MAAOA,IAAIF,iBAAmBT,MACzEhC,QAAQyC,eAAiBT,KAClBhC,QAKX,QAAS4C,UAwET,QAASC,qBAAoBC,OACzB,MAAOA,OAAMC,QAAQC,iBAAkB,WAEnC,IAAK,GADDC,MACKd,GAAK,EAAGA,GAAKC,UAAUC,OAAQF,KACpCc,EAAEd,IAAMC,UAAUD,GAEtB,OAAOc,GAAE,GAAGC,gBAQpB,QAASC,cAAaL,MAAOM,eACzB,MAAOC,UAASP,MAAO,IAAKM,eAOhC,QAASE,eAAcR,MAAOM,eAC1B,MAAOC,UAASP,MAAO,IAAKM,eAQhC,QAASC,UAASP,MAAOS,UAAWH,eAChC,GAAqBI,gBAAiBV,MAAMW,QAAQF,UACpD,QAAuB,GAAnBC,eACOJ,eACHN,MAAMY,MAAM,EAAGF,gBAAgBG,OAAQb,MAAMY,MAAMF,eAAiB,GAAGG,QAQnF,QAASC,YAAWC,MAAOC,QAASC,SAChC,MAAIC,OAAMC,QAAQJ,OACPC,QAAQI,WAA4B,MAASH,SAEpDI,kBAAkBN,OACXC,QAAQM,eAAgC,MAASL,SAE/C,MAATF,OAAiC,gBAATA,QAAqC,gBAATA,QACpC,iBAATA,OACAC,QAAQO,eAAeR,MAAOE,SAElCD,QAAQQ,WAAWT,MAAOE,SAMrC,QAASQ,WAAUC,KACf,MAAe,QAARA,SAAwBC,KAARD,IAO3B,QAASE,aAAYF,KACjB,WAAeC,KAARD,IAAqC,KAAWA,IAgF3D,QAASG,aAAYC,IAAKC,aACtB,GAAqBC,OAAQC,MAAMH,IAInC,OAHA,OAA2BI,qBAAsB,EAC7CH,cACA,MAA2BI,oBAAsBJ,aAC9CC,MAQX,QAASI,eAAcJ,OACnB,MAAO,OAA2BE,oBAMtC,QAASG,gBAAeL,OACpB,MAAO,OAA2BG,wBAMtC,QAASG,cAAaC,GAClB,MAAOA,GAAEtC,QAAQ,6BAA8B,QAOnD,QAASoB,mBAAkBxB,KACvB,MAAsB,gBAARA,MAA4B,OAARA,KAAgB5B,OAAOuE,eAAe3C,OAAS4C,iBAMrF,QAASC,YAAWC,KAEhB,IAAK,GADgBC,SAAU,GACLC,MAAQ,EAAGA,MAAQF,IAAIpD,OAAQsD,QAAS,CAC9D,GAAqBC,WAAYH,IAAII,WAAWF,MAGhD,IAAIC,WAAa,OAAUA,WAAa,OAAUH,IAAIpD,OAAUsD,MAAQ,EAAI,CACxE,GAAqBG,KAAML,IAAII,WAAWF,MAAQ,EAC9CG,MAAO,OAAUA,KAAO,QACxBH,QACAC,WAAcA,UAAY,OAAW,IAAME,IAAM,MAAS,OAG9DF,WAAa,IACbF,SAAWK,OAAOC,aAAaJ,WAE1BA,WAAa,KAClBF,SAAWK,OAAOC,aAAeJ,WAAa,EAAK,GAAQ,IAAmB,GAAZA,UAAoB,KAEjFA,WAAa,MAClBF,SAAWK,OAAOC,aAAcJ,WAAa,GAAM,IAAQA,WAAa,EAAK,GAAQ,IAAmB,GAAZA,UAAoB,KAE3GA,WAAa,UAClBF,SAAWK,OAAOC,aAAeJ,WAAa,GAAM,EAAQ,IAAQA,WAAa,GAAM,GAAQ,IAAQA,WAAa,EAAK,GAAQ,IAAmB,GAAZA,UAAoB,MAGpK,MAAOF,SAUX,QAASO,WAAUC,OACf,GAAqB,gBAAVA,OACP,MAAOA,MAEX,IAAIA,gBAAiBlC,OACjB,MAAO,IAAMkC,MAAMC,IAAIF,WAAWG,KAAK,MAAQ,GAEnD,IAAa,MAATF,MACA,MAAO,GAAKA,KAEhB,IAAIA,MAAMG,eACN,MAAO,GAAKH,MAAMG,cAEtB,IAAIH,MAAMlE,KACN,MAAO,GAAKkE,MAAMlE,IAEtB,IAAqBsE,KAAMJ,MAAMK,UACjC,IAAW,MAAPD,IACA,MAAO,GAAKA,GAEhB,IAAqBE,cAAeF,IAAI7C,QAAQ,KAChD,QAAyB,IAAlB+C,aAAsBF,IAAMA,IAAIG,UAAU,EAAGD,cAOxD,QAASE,mBAAkBC,MACvB,MAAoB,kBAATA,OAAuBA,KAAKC,eAAe,mBAC3CD,OAGAA,KAQf,QAASE,WAAUlE,KAGf,QAASA,KAA2B,kBAAbA,KAAImE,KAusB/B,QAASC,kBAAiBjD,QAASkD,KAAMjD,aACrB,KAAZA,UAAsBA,QAAU,KACpC,IAAqBkD,WACAC,MAAQpD,QAAQoD,MACjC,SAAUC,KAAO,MAASrD,SAAc,MAAEqD,IAAKpD,UAAYoD,IAAID,MAAMpD,QAASC,UAC9E,SAAUoD,KAAO,MAAOA,KAAID,MAAMpD,QAASC,SAO/C,OANAiD,MAAKI,QAAQ,SAAUD,KACnB,GAAqBE,WAAYH,MAAMC,IACnCE,YACAJ,OAAOK,KAAKD,aAGbJ,OAgCX,QAASM,4BAA2BC,0BAA2BC,gBAE3D,WADuB,KAAnBA,iBAA6BA,gBAAiB,GACb,OAA9BD,0BAAqCC,eAAiBD,0BA4FjE,QAASE,qBAAoB1F,MACzB,MAAOA,MAAKe,QAAQ,MAAO,KAO/B,QAAS4E,gBAAeC,mBACpB,IAAKA,oBAAsBA,kBAAkBC,UACzC,MAAO,KAEX,IAAqBC,KAAMF,kBAAkBC,SAC7C,IAAIC,cAAeC,cACf,MAAOD,KAAI9F,IAEf,IAAI8F,IAAqB,gBACrB,MAAOA,KAAqB,eAEhC,IAAqBE,YAAa/B,UAAU6B,IAS5C,OARIE,YAAWvE,QAAQ,MAAQ,GAE3BuE,WAAa,aAAeC,sBAC5BH,IAAqB,gBAAIE,YAGzBA,WAAaN,oBAAoBM,YAE9BA,WAMX,QAASE,qBAAoBN,mBACzB,GAAqBE,KAAMF,kBAAkBC,SAC7C,OAAIC,eAAeC,cACRD,IAAIK,SAGR,KAAOlC,UAAU6B,KAO5B,QAASM,eAAcC,SAAUC,uBAC7B,MAAO,QAAUX,gBAAiBE,UAAWQ,WAAc,IAAMC,sBAMrE,QAASC,kBAAiBF,UACtB,MAAO,cAAgBV,gBAAiBE,UAAWQ,WAMvD,QAASG,mBAAkBH,UACvB,MAAO,YAAcV,gBAAiBE,UAAWQ,WAMrD,QAASI,sBAAqBJ,UAC1B,MAAOV,iBAAiBE,UAAWQ,WAAc,YA4CrD,QAASK,WAAUxC,OACf,MAAsB,OAAfA,MAAMrC,MAAgB6D,oBAAoBxB,MAAMrC,OAAS8D,eAAezB,MAAM8B,YAMzF,QAASW,gBAAezC,OACpB,MAAwB,OAApBA,MAAM8B,WACC9B,MAAM8B,WAAWH,UAGjB3B,MAAMrC,MA2YrB,QAAS+E,iBAAgBjG,KACrB,MAAOA,SAoBX,QAASkG,SAAQC,MACb,MAAOA,MAAKC,OAAO,SAAUC,KAAMC,MAC/B,GAAqBC,UAAWlF,MAAMC,QAAQgF,MAAQJ,QAAQI,MAAQA,IACtE,OAAO,MAA0BE,OAAOD,eAOhD,QAASE,cAAaC,KAGlB,MAAOA,KAAItG,QAAQ,2BAA4B,UAQnD,QAASuG,mBAAkBC,aAAcC,SAAUC,cAC/C,GAAqBJ,IAcrB,OATQA,KAJJI,aAAaC,SACTF,SAAS7C,KAAKkB,oBAAqBE,cAG7ByB,SAAS7C,KAAKkB,UAAUM,SAAW,IAAMqB,SAAS7C,KAAKkB,UAAU7F,KAAO,QAGxE2F,eAAe4B,cAAgB,IAAM5B,eAAe6B,SAAS7C,MAAQ,QAItD8C,aAAyB,YAE/CD,SAAS7C,KAAKkB,oBAAqBE,cAAesB,IAAMD,aAAaC,KAOhF,QAASM,wBAAuBC,KAAMC,IAClC,GAAqBC,WAA+BF,KAAe,UAAEG,MAAM,QAE3E,OAAOX,cAAa,OAASS,GADGC,UAAUA,UAAUzH,OAAS,GAChB,eAMjD,QAAS2H,gBAAeC,YACpB,MAAOb,cAAazB,eAAesC,WAAWtD,MAAQ,wBAO1D,QAASuD,gBAAeX,aAAcC,UAClC,MAAOJ,cAAazB,eAAe4B,cAAgB,IAAM5B,eAAe6B,SAAS7C,MAAQ,iBAyQ7F,QAASwD,UAASrG,QAASsG,MAAOrG,aACd,KAAZA,UAAsBA,QAAU,KACpC,IAAqBkD,WACAC,MAAQpD,QAAQoD,MACjC,SAAUC,KAAO,MAASrD,SAAc,MAAEqD,IAAKpD,UAAYoD,IAAID,MAAMpD,QAASC,UAC9E,SAAUoD,KAAO,MAAOA,KAAID,MAAMpD,QAASC,SAO/C,OANAqG,OAAMhD,QAAQ,SAAUD,KACpB,GAAqBE,WAAYH,MAAMC,IACnCE,YACAJ,OAAOK,KAAKD,aAGbJ,OA+GX,QAASoD,QAAOlD,KACZ,GAAqBmD,OAAQnD,IAAIoD,WAAWD,MAAME,OAC7BC,IAAMtD,IAAIoD,WAAWE,IAAID,MAS9C,OARIrD,eAAeuD,WACXvD,IAAIwD,cACJF,IAAMtD,IAAIwD,cAAcF,IAAID,OAEvBrD,IAAIyD,UAAYzD,IAAIyD,SAASvI,SAClCoI,IAAMJ,OAAOlD,IAAIyD,SAASzD,IAAIyD,SAASvI,OAAS,IAAIoI,OAGnDH,MAAOA,MAAOG,IAAKA,KAOhC,QAASI,UAAST,MAAOU,UACrB,GAAqBC,QA6BrB,OADAZ,UA3B+B,IAAmB,SAAUa,QAExD,QAASC,WACL,MAAkB,QAAXD,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KAsB/D,MAxBAC,WAAUyK,QAASD,QASnBC,QAAQnK,UAAUoG,MAKlB,SAAUC,IAAKpD,SACX,GAAqBmH,MAAOb,OAAOlD,IACnC,MAAI+D,KAAKZ,OAASQ,UAAYA,SAAWI,KAAKT,KAK1C,OAAO,CAJPM,MAAKzD,KAAKH,MAOX8D,SACTE,mBACgBf,OACX,GAAIgB,SAAQL,KAAMD;;;;;;;AAmB7B,QAASO,sBAAqBrD,WAAYnE,OACtC,GAAa,MAATA,MAAJ,CAGA,IAAKG,MAAMC,QAAQJ,OACf,KAAM,IAAIkB,OAAM,aAAeiD,WAAa,+BAEhD,KAAK,GAAqBsD,GAAI,EAAGA,EAAIzH,MAAMxB,OAAQiJ,GAAK,EACpD,GAAwB,gBAAbzH,OAAMyH,GACb,KAAM,IAAIvG,OAAM,aAAeiD,WAAa,iCAgBxD,QAASuD,4BAA2BvD,WAAYnE,OAC5C,KAAa,MAATA,OAAmBG,MAAMC,QAAQJ,QAA0B,GAAhBA,MAAMxB,QACjD,KAAM,IAAI0C,OAAM,aAAeiD,WAAa,kCAE3C,IAAa,MAATnE,MAAe,CACpB,GAAqB2H,SAA4B3H,MAAM,GAClC4H,MAA0B5H,MAAM,EAErD6H,iCAAgCtE,QAAQ,SAAUuE,QAC9C,GAAIA,OAAOC,KAAKJ,UAAYG,OAAOC,KAAKH,OACpC,KAAM,IAAI1G,OAAM,KAAOyG,QAAU,OAASC,MAAQ,iDA+DlE,QAASI,sBAAqBxC,KAC1B,GAAW,MAAPA,KAA8B,IAAfA,IAAIhH,QAA0B,KAAVgH,IAAI,GACvC,OAAO,CACX,IAAqByC,aAAczC,IAAI0C,MAAMC,uBAC7C,OAAuB,QAAhBF,aAA0C,WAAlBA,YAAY,IAAqC,SAAlBA,YAAY,GAU9E,QAASG,kBAAiBC,SAAUC,QAASC,SACzC,GAAqBC,cACAC,gBAAkBF,QAAQrJ,QAAQwJ,8BAA+B,IACjFxJ,QAAQyJ,kBAAmB,WAE5B,IAAK,GADDvJ,MACKd,GAAK,EAAGA,GAAKC,UAAUC,OAAQF,KACpCc,EAAEd,IAAMC,UAAUD,GAEtB,IAAqBkH,KAAMpG,EAAE,IAAMA,EAAE,EACrC,OAAK4I,sBAAqBxC,MAK1BgD,UAAU/E,KAAK4E,SAASO,QAAQN,QAAS9C,MAClC,IAHIpG,EAAE,IAKjB,OAAO,IAAIyJ,kBAAiBJ,gBAAiBD,WAkCjD,QAASM,aAAYC,aACjB,GAAsB,KAAlBA,YAAY,GACZ,OAAQ,KAAMA,YAElB,IAAqBC,YAAaD,YAAYnJ,QAAQ,IAAK,EAC3D,KAAmB,GAAfoJ,WACA,KAAM,IAAI9H,OAAM,uBAA0B6H,YAAc,gCAE5D,QAAQA,YAAYlJ,MAAM,EAAGmJ,YAAaD,YAAYlJ,MAAMmJ,WAAa,IAM7E,QAASC,eAAcC,SACnB,MAAmC,iBAA5BJ,YAAYI,SAAS,GAMhC,QAASC,aAAYD,SACjB,MAAmC,eAA5BJ,YAAYI,SAAS,GAMhC,QAASE,cAAaF,SAClB,MAAmC,gBAA5BJ,YAAYI,SAAS,GAMhC,QAASG,aAAYC,UACjB,MAAoB,QAAbA,SAAoB,KAAOR,YAAYQ,UAAU,GAO5D,QAASC,gBAAeC,OAAQC,WAC5B,MAAOD,QAAS,IAAMA,OAAS,IAAMC,UAAYA,UAkSrD,QAASC,iBAAgBpG,KACrB,GAAqBqG,YAA8B,KAC9BC,SAA4B,KAC5BC,QAA2B,KAC3BC,aAAc,EACdC,UAA6B,IAClDzG,KAAI0G,MAAMzG,QAAQ,SAAU0G,MACxB,GAAqBC,YAAaD,KAAK9L,KAAKgM,aACxCD,aAAcE,uBACdT,WAAaM,KAAKjK,MAEbkK,YAAcG,qBACnBT,SAAWK,KAAKjK,MAEXkK,YAAcI,oBACnBT,QAAUI,KAAKjK,MAEViK,KAAK9L,MAAQoM,qBAClBT,aAAc,EAETG,KAAK9L,MAAQqM,eACdP,KAAKjK,MAAMxB,OAAS,IACpBuL,UAAYE,KAAKjK,SAI7B2J,WAAac,yBAAyBd,WACtC,IAAqBe,UAAWpH,IAAInF,KAAKgM,cACpBrH,KAAO6H,qBAAqBC,KAajD,OAZIzB,aAAYuB,UACZ5H,KAAO6H,qBAAqBE,WAEvBH,UAAYI,cACjBhI,KAAO6H,qBAAqBI,MAEvBL,UAAYM,eACjBlI,KAAO6H,qBAAqBM,OAEvBP,UAAYQ,cAAgBrB,SAAWsB,uBAC5CrI,KAAO6H,qBAAqBS,YAEzB,GAAIC,kBAAiBvI,KAAM6G,WAAYC,SAAUE,YAAaC,WA6BzE,QAASU,0BAAyBd,YAC9B,MAAmB,QAAfA,YAA6C,IAAtBA,WAAWnL,OAC3B,IAEJmL,WA4mBX,QAAS2B,qBAAoBxI,MACzB,MAAOyI,iBAAgB1M,SAASiE,OAAS0I,gBAAgB3M,SAASiE,MAQtE,QAAS2I,UAASC,IAAKC,WACnB,IAAK,GAAqBlE,GAAIiE,IAAIlN,OAAS,EAAGiJ,GAAK,EAAGA,IAClD,GAAIkE,UAAUD,IAAIjE,IACd,MAAOiE,KAAIjE,EAGnB,OAAO,MA4EX,QAASmE,cAAaC,MAClB,MAAQA,OAAQC,MAAQD,MAAQE,QAAYF,MAAQG,MAMxD,QAASC,SAAQJ,MACb,MAAOK,KAAML,MAAQA,MAAQM,GAMjC,QAASC,eAAcP,MACnB,MAAOA,OAAQQ,IAAMR,MAAQS,IAAMT,MAAQU,IAAMV,MAAQW,GAM7D,QAASC,iBAAgBZ,MACrB,MAAOA,OAAQQ,IAAMR,MAAQa,IAAMb,MAAQU,IAAMV,MAAQc,IAAMV,QAAQJ,MA6M3E,QAASe,mBAAkB9K,MAAO+J,MAC9B,MAAO,IAAIgB,OAAM/K,MAAOgL,UAAUC,UAAWlB,KAAM3J,OAAOC,aAAa0J,OAO3E,QAASmB,oBAAmBlL,MAAOmL,MAC/B,MAAO,IAAIJ,OAAM/K,MAAOgL,UAAUI,WAAY,EAAGD,MAOrD,QAASE,iBAAgBrL,MAAOmL,MAC5B,MAAO,IAAIJ,OAAM/K,MAAOgL,UAAUM,QAAS,EAAGH,MAOlD,QAASI,kBAAiBvL,MAAOmL,MAC7B,MAAO,IAAIJ,OAAM/K,MAAOgL,UAAUQ,SAAU,EAAGL,MAOnD,QAASM,gBAAezL,MAAOmL,MAC3B,MAAO,IAAIJ,OAAM/K,MAAOgL,UAAU5K,OAAQ,EAAG+K,MAOjD,QAASO,gBAAe1L,MAAO2L,GAC3B,MAAO,IAAIZ,OAAM/K,MAAOgL,UAAUY,OAAQD,EAAG,IAOjD,QAASE,eAAc7L,MAAO8L,SAC1B,MAAO,IAAIf,OAAM/K,MAAOgL,UAAU5L,MAAO,EAAG0M,SAkShD,QAASC,mBAAkBhC,MACvB,MAAQQ,KAAMR,MAAQA,MAAQS,IAAQC,IAAMV,MAAQA,MAAQW,IACvDX,MAAQiC,IAAQjC,MAAQkC,GAMjC,QAASC,cAAa/O,OAClB,GAAoB,GAAhBA,MAAMT,OACN,OAAO,CACX,IAAqByP,SAAU,GAAIC,UAASjP,MAC5C,KAAK4O,kBAAkBI,QAAQE,MAC3B,OAAO,CAEX,KADAF,QAAQG,UACDH,QAAQE,OAASE,MAAM,CAC1B,IAAKC,iBAAiBL,QAAQE,MAC1B,OAAO,CACXF,SAAQG,UAEZ,OAAO,EAMX,QAASE,kBAAiBzC,MACtB,MAAOO,eAAcP,OAASI,QAAQJ,OAAUA,MAAQiC,IACnDjC,MAAQkC,GAMjB,QAASQ,iBAAgB1C,MACrB,MAAOA,OAAQ2C,IAAM3C,MAAQ4C,GAMjC,QAASC,gBAAe7C,MACpB,MAAOA,OAAQ8C,QAAU9C,MAAQ+C,MAMrC,QAASC,SAAQhD,MACb,MAAOA,QAASiD,KAAOjD,OAASkD,KAAOlD,OAASmD,IAMpD,QAASC,UAASpD,MACd,OAAQA,MACJ,IAAKqD,IACD,MAAOC,IACX,KAAKzC,IACD,MAAO0C,IACX,KAAKC,IACD,MAAOC,IACX,KAAKC,IACD,MAAOzD,KACX,KAAK0D,IACD,MAAOC,MACX,SACI,MAAO5D,OAOnB,QAAS6D,mBAAkBzC,MACvB,GAAqB7J,QAASuM,SAAS1C,KACvC,IAAI2C,MAAMxM,QACN,KAAM,IAAIlC,OAAM,wCAA0C+L,KAE9D,OAAO7J,QAq5CX,QAASyM,kBAAiBvM,IAAKrD,QAASC,SAKpC,QAASmD,OAAMC,KACXrD,QAAQoD,OAASpD,QAAQoD,MAAMC,IAAKpD,UAAYoD,IAAID,MAAMpD,QAASC,SAOvE,QAASoG,UAASnD,MAAQA,KAAKI,QAAQF,OACvCC,IAAID,OACAyM,YAIA,SAAUxM,KACND,MAAMC,IAAIyM,MACV1M,MAAMC,IAAI0M,QAEdC,WAIA,SAAU3M,KAAOgD,SAAShD,IAAI4M,cAC9BC,iBAIA,SAAU7M,KACND,MAAMC,IAAIqI,WACVtI,MAAMC,IAAI8M,SACV/M,MAAMC,IAAI+M,WAEdC,kBAIA,SAAUhN,KACFA,IAAIiN,QACJlN,MAAMC,IAAIiN,QAEdjK,SAAShD,IAAIjF,OAEjBmS,sBAIA,SAAUlN,OACVmN,mBAIA,SAAUnN,KAAOgD,SAAShD,IAAI4M,cAC9BQ,eAIA,SAAUpN,KACND,MAAMC,IAAIxE,KACVuE,MAAMC,IAAIqN,MAEdC,gBAIA,SAAUtN,KACND,MAAMC,IAAIxE,KACVuE,MAAMC,IAAIqN,KACVtN,MAAMC,IAAIxE,MAEd+R,kBAIA,SAAUvN,KAAOgD,SAAShD,IAAI4M,cAC9BY,gBAIA,SAAUxN,OACVyN,sBAIA,SAAUzN,OACV0N,gBAIA,SAAU1N,KACND,MAAMC,IAAI2N,UACV3K,SAAShD,IAAIjF,OAEjB6S,UAIA,SAAU5N,KACND,MAAMC,IAAI6N,KACV7K,SAAShD,IAAIjF,OAEjB+S,eAIA,SAAU9N,KAAOD,MAAMC,IAAI+N,aAC3BC,mBAIA,SAAUhO,KAAOD,MAAMC,IAAI+N,aAC3BE,kBAIA,SAAUjO,KAAOD,MAAMC,IAAI2N,WAC3BO,mBAIA,SAAUlO,KACND,MAAMC,IAAI2N,UACV5N,MAAMC,IAAItD,QAEdyR,WAIA,SAAUnO,OACVoO,oBAIA,SAAUpO,KACND,MAAMC,IAAI2N,UACV3K,SAAShD,IAAIjF,OAEjBsT,sBAIA,SAAUrO,KAAOD,MAAMC,IAAI2N,aAmCnC,QAASW,0BAAyBC,QAC9B,GAAqBC,SAAUvQ,aAAasQ,OAAOpL,OAAS,eAAiBlF,aAAasQ,OAAOjL,IACjG,OAAO,IAAImL,QAAOD,QAAS,KAm+C/B,QAASE,gBAAeC,KAAMnP,MAC1B,GAAqBoP,WAAY7N,oBAAoBvB,MAChCqP,eAA8B,MAAbD,UAAoB,MAAQD,KAAO,IAAMnO,eAAehB,MAAQ,OAASoP,UAC3G,MAAQD,KAAO,IAAMnO,eAAehB,MACnBsP,WAAa,GAAIC,iBAAgB,GAAIF,eAC1D,OAAO,IAAIG,iBAAgB,GAAIC,eAAcH,YAAa,GAAI,GAAI,GAAI,GAAIG,eAAcH,YAAa,GAAI,GAAI,IAyFjH,QAASI,UAASC,OAAQjN,IAAKkN,iBAAkBC,uBAAwBC,qBAGrE,WAF+B,KAA3BD,yBAAqCA,wBAAyB,OACtC,KAAxBC,sBAAkCA,oBAAsBC,8BACrD,GAAIC,YAAW,GAAIT,iBAAgBI,OAAQjN,KAAMkN,iBAAkBC,uBAAwBC,qBAC7FJ,WAOT,QAASO,8BAA6BC,UAElC,MAAO,0BADqBA,WAAa3E,KAAO,MAAQnM,OAAOC,aAAa6Q,WAClC,IAM9C,QAASC,wBAAuBC,WAC5B,MAAO,mBAAsBA,UAAY,oDA+1B7C,QAASC,iBAAgBtH,MACrB,OAAQD,aAAaC,OAASA,OAASwC,KAM3C,QAAS+E,WAAUvH,MACf,MAAOD,cAAaC,OAASA,OAASwH,KAAOxH,OAASyH,QAClDzH,OAASiD,KAAOjD,OAASkD,KAAOlD,OAAS0H,IAMjD,QAASC,aAAY3H,MACjB,OAAQA,KAAOQ,IAAMC,GAAKT,QAAUA,KAAOU,IAAMC,GAAKX,QACjDA,KAAOK,IAAML,KAAOM,IAM7B,QAASsH,kBAAiB5H,MACtB,MAAOA,OAAQ6H,YAAc7H,MAAQwC,OAAS5B,gBAAgBZ,MAMlE,QAAS8H,kBAAiB9H,MACtB,MAAOA,OAAQ6H,YAAc7H,MAAQwC,OAASjC,cAAcP,MAQhE,QAAS+H,sBAAqB3U,MAAO0H,OAAQiM,qBACzC,GAAqBiB,wBAAuBjB,qBAAsB3T,MAAMW,QAAQgT,oBAAoBnM,MAAOE,SAAWA,MACtH,OAAO1H,OAAM+C,WAAW2E,SAAWmN,UAAYD,qBAMnD,QAASE,sBAAqB5F,MAC1B,MAAOA,QAASoF,KAAOnH,cAAc+B,OAASlC,QAAQkC,MAO1D,QAAS6F,gCAA+BC,MAAOC,OAC3C,MAAOC,qBAAoBF,QAAUE,oBAAoBD,OAM7D,QAASC,qBAAoBtI,MACzB,MAAOA,OAAQQ,IAAMR,MAAQS,GAAKT,KAAOQ,GAAKE,GAAKV,KAMvD,QAASuI,iBAAgBC,WAGrB,IAAK,GAFgBC,cACAC,iBAAe3T,GACV6G,EAAI,EAAGA,EAAI4M,UAAU7V,OAAQiJ,IAAK,CACxD,GAAqBpF,OAAQgS,UAAU5M,EACnC8M,eAAgBA,aAAazR,MAAQ0R,YAAYC,MAAQpS,MAAMS,MAAQ0R,YAAYC,MACnFF,aAAaG,MAAM,IAAMrS,MAAMqS,MAAM,GACrCH,aAAa7N,WAAWE,IAAMvE,MAAMqE,WAAWE,MAG/C2N,aAAelS,MACfiS,UAAU7Q,KAAK8Q,eAGvB,MAAOD,WAqiBX,QAASK,aAAYC,MAAOC,SACxB,MAAOD,OAAMpW,OAAS,GAAKoW,MAAMA,MAAMpW,OAAS,KAAOqW;;;;;;;AAkB3D,QAASC,QAAOlH,SACZ,MAAOA,SAAQ5H,IAAM+O,KAAKC,eAAepH,QAAQrH,OAAOhE,KAAK,IAAO,IAAMqL,QAAQqH,QAAU,KAMhG,QAASC,eAActH,SACnB,GAAIA,QAAQ5H,GACR,MAAO4H,SAAQ5H,EAEnB,IAAqB/F,SAAU,GAAIkV,+BAEnC,OAAOC,cADsBxH,QAAQrH,MAAMjE,IAAI,SAAU+S,GAAK,MAAOA,GAAEhS,MAAMpD,QAAS,QAC5DsC,KAAK,IAAKqL,QAAQqH,SAqGhD,QAASD,gBAAezO,OACpB,MAAOA,OAAMjE,IAAI,SAAU+S,GAAK,MAAOA,GAAEhS,MAAMiS,kBAAmB,QA0CtE,QAASP,MAAKnT,KACV,GAAqB2T,MAAO5T,WAAWC,KAClB4T,QAAUC,gBAAgBF,KAAMG,OAAOC,KACvCC,IAAoB,EAAdL,KAAK/W,OACXqX,EAAI,GAAI1V,OAAM,IAC/B2V,IAAM,WAAY,WAAY,WAAY,UAAY,YAAaT,EAAIS,GAAG,GAAIjZ,EAAIiZ,GAAG,GAAIC,EAAID,GAAG,GAAIlZ,EAAIkZ,GAAG,GAAIE,EAAIF,GAAG,EAC1HN,SAAQI,KAAO,IAAM,KAAS,GAAKA,IAAM,GACzCJ,QAAiC,IAAvBI,IAAM,IAAM,GAAM,IAAWA,GACvC,KAAK,GAAqBnO,GAAI,EAAGA,EAAI+N,QAAQhX,OAAQiJ,GAAK,GAAI,CAE1D,IAAK,GADDwO,KAAMZ,EAAGxY,EAAGkZ,EAAGnZ,EAAGoZ,GAAIE,GAAKD,GAAG,GAAIE,GAAKF,GAAG,GAAIG,GAAKH,GAAG,GAAII,GAAKJ,GAAG,GAAIK,GAAKL,GAAG,GACxDM,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAEtCV,EAAEU,GADFA,EAAI,GACGf,QAAQ/N,EAAI8O,GAGZC,MAAMX,EAAEU,EAAI,GAAKV,EAAEU,EAAI,GAAKV,EAAEU,EAAI,IAAMV,EAAEU,EAAI,IAAK,EAE9D,IAAIE,IAAKC,GAAGH,EAAG1Z,EAAGkZ,EAAGnZ,GAAI+Z,EAAIF,GAAG,GAAIG,EAAIH,GAAG,GACtBI,MAAQL,MAAMnB,EAAG,GAAIsB,EAAGX,EAAGY,EAAGf,EAAEU,IAAIrR,OAAO4R,MAChEC,KAAMna,EAAGmZ,EAAGS,MAAM3Z,EAAG,IAAKwY,EAAGwB,MAAOb,EAAIe,GAAG,GAAIna,EAAIma,GAAG,GAAIhB,EAAIgB,GAAG,GAAIla,EAAIka,GAAG,GAAI1B,EAAI0B,GAAG,GAE3FC,IAAMF,MAAMzB,EAAGa,IAAKY,MAAMja,EAAGsZ,IAAKW,MAAMf,EAAGK,IAAKU,MAAMla,EAAGyZ,IAAKS,MAAMd,EAAGM,KAAMjB,EAAI2B,GAAG,GAAIna,EAAIma,GAAG,GAAIjB,EAAIiB,GAAG,GAAIpa,EAAIoa,GAAG,GAAIhB,EAAIgB,GAAG,GAEpI,MAAOC,uBAAsBC,qBAAqB7B,EAAGxY,EAAGkZ,EAAGnZ,EAAGoZ,IAC9D,IAAIe,IAAIC,GASZ,QAASN,IAAG5U,MAAOjF,EAAGkZ,EAAGnZ,GACrB,MAAIkF,OAAQ,IACCjF,EAAIkZ,GAAOlZ,EAAID,EAAI,YAE5BkF,MAAQ,IACAjF,EAAIkZ,EAAInZ,EAAG,YAEnBkF,MAAQ,IACCjF,EAAIkZ,EAAMlZ,EAAID,EAAMmZ,EAAInZ,EAAI,aAEjCC,EAAIkZ,EAAInZ,EAAG,YAYvB,QAASua,aAAYvV,KACjB,GAAqB2T,MAAO5T,WAAWC,KACnCkU,IAAMsB,OAAO7B,KAAM,GAAI6B,OAAO7B,KAAM,SAAU8B,GAAKvB,GAAG,GAAIwB,GAAKxB,GAAG,EAKtE,OAJU,IAANuB,IAAkB,GAANC,IAAiB,GAANA,KACvBD,IAAU,UACVC,KAAW,aAEPD,GAAIC,IAOhB,QAASlC,cAAarU,IAAKkU,SACvB,GAAIa,IAAKqB,YAAYpW,KAAMsW,GAAKvB,GAAG,GAAIwB,GAAKxB,GAAG,EAC/C,IAAIb,QAAS,CACT,GAAIgB,IAAKkB,YAAYlC,SAAUsC,IAAMtB,GAAG,GAAIuB,IAAMvB,GAAG,EACrDQ,IAAKgB,MAAMC,OAAOL,GAAIC,IAAK,IAAKC,IAAKC,MAAOH,GAAKZ,GAAG,GAAIa,GAAKb,GAAG,GAEpE,MAAOkB,uBAAsBT,qBAA0B,WAALG,GAAiBC,KACnE,IAAIb,IAOR,QAASW,QAAOxV,IAAKmU,GACjB,GACqBtO,GADjBqO,IAAM,WAAY,YAAaT,EAAIS,GAAG,GAAIjZ,EAAIiZ,GAAG,GAEhCF,IAAMhU,IAAIpD,MAC/B,KAAKiJ,EAAI,EAAGA,EAAI,IAAMmO,IAAKnO,GAAK,GAC5B4N,EAAIyB,MAAMzB,EAAGuC,OAAOhW,IAAK6F,EAAGiO,OAAOmC,SACnChb,EAAIia,MAAMja,EAAG+a,OAAOhW,IAAK6F,EAAI,EAAGiO,OAAOmC,SACvC9B,EAAIe,MAAMf,EAAG6B,OAAOhW,IAAK6F,EAAI,EAAGiO,OAAOmC,SACvC5B,GAAK6B,KAAKzC,EAAGxY,EAAGkZ,IAAKV,EAAIY,GAAG,GAAIpZ,EAAIoZ,GAAG,GAAIF,EAAIE,GAAG,EAOtD,OALAZ,GAAIyB,MAAMzB,EAAGuC,OAAOhW,IAAK6F,EAAGiO,OAAOmC,SACnChb,EAAIia,MAAMja,EAAG+a,OAAOhW,IAAK6F,EAAI,EAAGiO,OAAOmC,SAEvC9B,EAAIe,MAAMf,EAAGH,KACbG,EAAIe,MAAMf,EAAG6B,OAAOhW,IAAK6F,EAAI,EAAGiO,OAAOmC,SAAW,GAC3CC,KAAKzC,EAAGxY,EAAGkZ,IAAI,EACtB,IAAIE,IAMR,QAAS6B,KAAIhC,IACT,GAAIT,GAAIS,GAAG,GAAIjZ,EAAIiZ,GAAG,GAAIC,EAAID,GAAG,EA4BjC,OA3BAT,GAAI0C,MAAM1C,EAAGxY,GACbwY,EAAI0C,MAAM1C,EAAGU,GACbV,GAAKU,IAAM,GACXlZ,EAAIkb,MAAMlb,EAAGkZ,GACblZ,EAAIkb,MAAMlb,EAAGwY,GACbxY,GAAKwY,GAAK,EACVU,EAAIgC,MAAMhC,EAAGV,GACbU,EAAIgC,MAAMhC,EAAGlZ,GACbkZ,GAAKlZ,IAAM,GACXwY,EAAI0C,MAAM1C,EAAGxY,GACbwY,EAAI0C,MAAM1C,EAAGU,GACbV,GAAKU,IAAM,GACXlZ,EAAIkb,MAAMlb,EAAGkZ,GACblZ,EAAIkb,MAAMlb,EAAGwY,GACbxY,GAAKwY,GAAK,GACVU,EAAIgC,MAAMhC,EAAGV,GACbU,EAAIgC,MAAMhC,EAAGlZ,GACbkZ,GAAKlZ,IAAM,EACXwY,EAAI0C,MAAM1C,EAAGxY,GACbwY,EAAI0C,MAAM1C,EAAGU,GACbV,GAAKU,IAAM,EACXlZ,EAAIkb,MAAMlb,EAAGkZ,GACblZ,EAAIkb,MAAMlb,EAAGwY,GACbxY,GAAKwY,GAAK,GACVU,EAAIgC,MAAMhC,EAAGV,GACbU,EAAIgC,MAAMhC,EAAGlZ,GACbkZ,GAAKlZ,IAAM,IACHwY,EAAGxY,EAAGkZ,GAclB,QAASe,OAAMzB,EAAGxY,GACd,MAAOmb,WAAU3C,EAAGxY,GAAG,GAO3B,QAASmb,WAAU3C,EAAGxY,GAClB,GAAqBoF,MAAW,MAAJoT,IAAmB,MAAJxY,GACtBob,MAAQ5C,IAAM,KAAOxY,IAAM,KAAOoF,MAAQ,GAC/D,QAAQgW,OAAS,GAAKA,MAAQ,GAAa,MAANhW,KAOzC,QAASwV,OAAM3B,GAAIG,IACf,GAAIiC,IAAKpC,GAAG,GAAIqC,GAAKrC,GAAG,GACpBsC,GAAKnC,GAAG,GAAIoC,GAAKpC,GAAG,GACpBQ,GAAKuB,UAAUG,GAAIE,IAAKC,MAAQ7B,GAAG,GAAI8B,EAAI9B,GAAG,EAElD,QADyBK,MAAMA,MAAMoB,GAAIE,IAAKE,OACnCC,GAOf,QAASR,OAAM1C,EAAGxY,GACd,GAAqBoF,MAAW,MAAJoT,IAAmB,MAAJxY,EAE3C,QAD6BwY,GAAK,KAAOxY,GAAK,KAAOoF,KAAO,KAC5C,GAAa,MAANA,IAO3B,QAASuU,OAAMnB,EAAGmD,OACd,MAAQnD,IAAKmD,MAAUnD,IAAO,GAAKmD,MAOvC,QAASd,OAAM5B,GAAI0C,OACf,GAAInB,IAAKvB,GAAG,GAAIwB,GAAKxB,GAAG,EAGxB,QAF0BuB,IAAMmB,MAAUlB,KAAQ,GAAKkB,MAC7BlB,IAAMkB,MAAUnB,KAAQ,GAAKmB,OAQ3D,QAAS/C,iBAAgB7T,IAAK6W,QAE1B,IAAK,GADgBjD,SAAUrV,MAAOyB,IAAIpD,OAAS,IAAO,GAChCiJ,EAAI,EAAGA,EAAI+N,QAAQhX,OAAQiJ,IACjD+N,QAAQ/N,GAAKmQ,OAAOhW,IAAS,EAAJ6F,EAAOgR,OAEpC,OAAOjD,SAOX,QAASkD,QAAO9W,IAAKE,OACjB,MAAOA,QAASF,IAAIpD,OAAS,EAA4B,IAAxBoD,IAAII,WAAWF,OAQpD,QAAS8V,QAAOhW,IAAKE,MAAO2W,QACxB,GAAqBE,MAAO,CAC5B,IAAIF,SAAW/C,OAAOC,IAClB,IAAK,GAAqBlO,GAAI,EAAGA,EAAI,EAAGA,IACpCkR,MAAQD,OAAO9W,IAAKE,MAAQ2F,IAAO,GAAK,EAAIA,MAIhD,KAAK,GAAqBA,GAAI,EAAGA,EAAI,EAAGA,IACpCkR,MAAQD,OAAO9W,IAAKE,MAAQ2F,IAAM,EAAIA,CAG9C,OAAOkR,MAMX,QAASzB,qBAAoB1B,SACzB,MAAOA,SAAQtQ,OAAO,SAAUtD,IAAK+W,MAAQ,MAAO/W,KAAMgX,mBAAmBD,OAAU,IAM3F,QAASC,oBAAmBD,MAExB,IAAK,GADgB/W,KAAM,GACD6F,EAAI,EAAGA,EAAI,EAAGA,IACpC7F,KAAOM,OAAOC,aAAcwW,OAAS,GAAK,EAAIlR,GAAM,IAExD,OAAO7F,KAMX,QAASqV,uBAAsBrV,KAE3B,IAAK,GADgBiX,KAAM,GACDpR,EAAI,EAAGA,EAAI7F,IAAIpD,OAAQiJ,IAAK,CAClD,GAAqB5K,GAAI6b,OAAO9W,IAAK6F,EACrCoR,OAAQhc,IAAM,GAAG6F,SAAS,KAAW,GAAJ7F,GAAU6F,SAAS,IAExD,MAAOmW,KAAI1O,cAMf,QAASwN,uBAAsB/V,KAG3B,IAAK,GAFgBkX,SAAU,GACVC,WAAa,IACRtR,EAAI7F,IAAIpD,OAAS,EAAGiJ,GAAK,EAAGA,IAClDqR,QAAUE,UAAUF,QAASG,kBAAkBP,OAAO9W,IAAK6F,GAAIsR,aAC/DA,WAAaE,kBAAkB,IAAKF,WAExC,OAAOD,SAAQ5S,MAAM,IAAIgT,UAAU3W,KAAK,IAO5C,QAASyW,WAAUG,EAAGC,GAGlB,IAAK,GAFgBC,KAAM,GACNzD,IAAM0D,KAAKC,IAAIJ,EAAE3a,OAAQ4a,EAAE5a,QACtBiJ,EAAI,EAAoB6Q,MAAQ,EAAG7Q,EAAImO,KAAO0C,MAAO7Q,IAAK,CAChF,GAAqB+R,QAASlB,SAAUa,EAAE1R,IAAM,MAAO2R,EAAE3R,IAAM,EAC3D+R,SAAU,IACVlB,MAAQ,EACRe,KAAOG,OAAS,KAGhBlB,MAAQ,EACRe,KAAOG,QAGf,MAAOH,KAOX,QAASJ,mBAAkBQ,IAAK5c,GAG5B,IAFA,GAAqB6c,SAAU,GACVC,YAAc9c,EACpB,IAAR4c,IAAWA,OAAc,EAClB,EAANA,MACAC,QAAUV,UAAUU,QAASC,cACjCA,YAAcX,UAAUW,YAAaA,YAEzC,OAAOD,SAodX,QAASE,sBAAqB1Q,SAC1B,MAAO2Q,iBAAgB3Q,QAAQiB,gBAAkB2P,wBAkMrD,QAASC,0BAAyBnH,qBAC9B,GAAqB3S,SAAU,GAAI+Z,cAAaC,WAAYrH,oBAC5D,OAAO,UAAUrM,MAAO0O,QAASiF,YAAalU,IAC1C,MAAO/F,SAAQka,cAAc5T,MAAO0O,QAASiF,YAAalU,KA+LlE,QAASoU,yBAAwBnb,OAC7B,MAAOA,OAAMiH,MAAMmU,gBAAgB,GAkDvC,QAASC,iBAAgB/T,MAAOqM,oBAAqB2H,aAAcC,eAE/D,MAD+B,IAAIC,UAASF,aAAcC,eAC3CE,QAAQnU,MAAOqM,qBAUlC,QAAS+H,mBAAkBpU,MAAOqU,aAAchI,oBAAqB2H,aAAcC,eAE/E,MAD+B,IAAIC,UAASF,aAAcC,eAC3CK,MAAMtU,MAAOqU,aAAchI,qBAmiB9C,QAASkI,mBAAkBrN,GACvB,SAAUA,YAAasN,UAAWtN,EAAEzN,OAASyN,EAAEzN,MAAMgb,WAAW,SAMpE,QAASC,mBAAkBxN,GACvB,SAAUA,YAAasN,UAAWtN,EAAEzN,OAAqB,UAAZyN,EAAEzN,OAMnD,QAASkb,cAAaC,GAClB,MAAOA,GAAEnR,MAAMoR,KAAK,SAAUnR,MAAQ,MAAOA,MAAK9L,OAASkd,cAAkB,KAMjF,QAASC,mBAAkBC,MACvB,IAAKA,KACD,OAAStG,QAAS,GAAIiF,YAAa,GAAIlU,GAAI,GAC/C,IAAqBwV,SAAUD,KAAK3b,QAAQ6b,cACvBC,UAAYH,KAAK3b,QAAQ+b,mBAC1C7F,GAAM0F,SAAW,GAAMD,KAAK1b,MAAM,EAAG2b,SAAUD,KAAK1b,MAAM2b,QAAU,KAAOD,KAAM,IAAKK,eAAiB9F,GAAG,GAAI9P,GAAK8P,GAAG,GACtHG,GAAMyF,WAAa,GAClBE,eAAe/b,MAAM,EAAG6b,WAAYE,eAAe/b,MAAM6b,UAAY,KACrE,GAAIE,eACT,QAAS3G,QAD2BgB,GAAG,GACZiE,YAD8BjE,GAAG,GACPjQ,GAAIA,IA+C7D,QAAS6V,qBAAoB3S,SACzB,MAAO4S,iBAuRX,QAASC,WAAUxV,OACf,MAAOA,OAAMjE,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAM4Y,YAAc1Z,KAAK,IAkG5E,QAAS2Z,WAAUjP,MACf,MAAOkP,gBAAejX,OAAO,SAAU+H,KAAMmP,OAAS,MAAOnP,MAAK/N,QAAQkd,MAAM,GAAIA,MAAM,KAAQnP,MA8ftG,QAASoP,gBAAeC,KACpB,OAAQA,IAAInS,eACR,IAAK,KACD,MAAO,IACX,KAAK,MACD,MAAO,OACX,SACI,MAAO,KAAOmS,KA8iB1B,QAASC,eAAcD,KACnB,OAAQA,IAAInS,eACR,IAAK,KACL,IAAK,IACL,IAAK,IACL,IAAK,IACD,MAAO,KACX,KAAK,MACD,MAAO,OACX,KAAK,IACD,MAAO,MACX,SACI,MAAO,SA2NnB,QAASqS,UAAS5O,SACd,MAAOsH,eAActH,SAsEzB,QAAS6O,cAAaC,cAClB,MAAOA,cAAard,cAAcH,QAAQ,cAAe,KAgG7D,QAASyd,oBAAmBC,SAAU5W,GAAI6W,SACtC3f,OAAO4f,eAAeF,SAAU5W,IAC5B+W,cAAc,EACdC,YAAY,EACZC,IAAK,WACD,GAAqBjd,OAAQ6c,SAE7B,OADA3f,QAAO4f,eAAeF,SAAU5W,IAAMgX,YAAY,EAAMhd,MAAOA,QACxDA,OAEXkd,IAAK,SAAUC,GAAK,KAAM,IAAIjc,OAAM,6CA6oB5C,QAASkc,kBAAiBC,QAEtB,OADAA,QAAUA,QAAU,OAAOlT,eAEvB,IAAK,MACD,MAAO,IAAImT,IACf,KAAK,MACD,MAAO,IAAIC,IACf,KAAK,SACL,IAAK,OACD,MAAO,IAAIC,OACf,KAAK,QACL,IAAK,MACL,QACI,MAAO,IAAIC,QAwBvB,QAASC,mBAAkBpZ,SAAUqZ,qBACT,KAApBA,kBAA8BA,iBAAkB,EACpD,IAAqBC,eAAgBC,sBAAsBvZ,SAAUqZ,gBACrE,OAAOC,eAAc,GAAK,aAAeE,uBAAuBF,cAAc,IAMlF,QAASG,0BAAyBzZ,UAC9B,MAAOA,UAASpF,QAAQ8e,eAAgB,KAM5C,QAASC,iBAAgB3Z,UACrB,MAAO0Z,gBAAejW,KAAKzD,UAO/B,QAASuZ,uBAAsB3W,KAAMyW,iBAEjC,OADwB,KAApBA,kBAA8BA,iBAAkB,GAChDzW,KAAKgX,SAAS,SACd,OAAQhX,KAAKrH,MAAM,GAAI,GAAI8d,gBAAkB,MAAQ,QAEzD,IAAqBQ,SAAUjX,KAAKkX,YAAY,IAChD,QAAiB,IAAbD,SACQjX,KAAKtE,UAAU,EAAGub,SAAUjX,KAAKtE,UAAUub,WAE/CjX,KAAM,IAMlB,QAAS4W,wBAAuBO,eAC5B,MAAyB,SAAlBA,cAA2B,MAAQA,cAM9C,QAASC,iBAAgBC,UAErB,MAD6CA,UAASrf,QAAQsf,wBAAyB,IACxD,kBAOnC,QAASC,uBAAsBF,SAAUZ,qBACb,KAApBA,kBAA8BA,iBAAkB,EACpD,IAAqBC,eAAgBC,sBAAsBE,yBAAyBQ,UAAWZ,gBAC/F,OAAOC,eAAc,GAAK,aAAeA,cAAc,GAM3D,QAASc,8BAA6Bpa,UAClC,MAAOA,UAASpF,QAAQyf,iBAAkB,KAM9C,QAASC,mBAAkBC,YACvB,MAAOA,YAAa,YAMxB,QAASC,8BAA6BD,YAClC,MAAOA,YAAW3f,QAAQ6f,iBAAkB,IAOhD,QAASC,iBAAgB7gB,MACrB,MAAO8gB,gBAAelX,KAAK5J,MAM/B,QAAS+gB,qBAAoBlZ,IACzB,MAAO,IAAWA,GAoHtB,QAASmZ,yBAAwBnb,WAC7B,OAASG,YAAcH,UAAWA,YAOtC,QAASob,iCAAgCC,UAAWrb,WAChD,MAAOmb,yBAAwBE,UAAUC,yBAAyBtb,YA4CtE,QAASub,kBAAiBF,UAAWG,KAAMnd,OACvC,MAAOgd,WAAUE,iBAAiBld,MAAOod,YAAYD,OAOzD,QAASE,sBAAqBL,UAAWhd,OACrC,MAAOsd,wBAAuBC,OAAO,SAAUJ,MAAQ,MAAOD,kBAAiBF,UAAWG,KAAMnd,SAMpG,QAASod,aAAYD,MACjB,OAAQA,MACJ,IAAKK,gBAAeC,OAChB,MAAO,UACX,KAAKD,gBAAeE,UAChB,MAAO,aACX,KAAKF,gBAAeG,QAChB,MAAO,WACX,KAAKH,gBAAeI,UAChB,MAAO,aACX,KAAKJ,gBAAeK,iBAChB,MAAO,oBACX,KAAKL,gBAAeM,oBAChB,MAAO,uBACX,KAAKN,gBAAeO,cAChB,MAAO,iBACX,KAAKP,gBAAeQ,iBAChB,MAAO,sBAs5DnB,QAASC,cAAaC,KAAMC,KAExB,OADY,KAARA,MAAkBA,QAClBD,KACA,IAAK,GAAqB9Y,GAAI,EAAGA,EAAI8Y,KAAK/hB,OAAQiJ,IAAK,CACnD,GAAqBrC,MAAOvC,kBAAkB0d,KAAK9Y,GAC/CtH,OAAMC,QAAQgF,MACdkb,aAAalb,KAAMob,KAGnBA,IAAI/c,KAAK2B,MAIrB,MAAOob,KAMX,QAASC,aAAYC,OACjB,MAAIA,OACOvgB,MAAMwgB,KAAK,GAAIC,KAAIF,WAQlC,QAASG,uBAAsBN,MAC3B,MAAOE,aAAYH,aAAaC,OAMpC,QAASO,aAAY9gB,OACjB,MAAQA,iBAAiBkE,eAAkBlE,gBAAiB+gB,MAOhE,QAASC,oBAAmBhhB,MAAOihB,mBAC/BlhB,WAAWC,MAAO,GAAIkhB,wBAA0BD,mBA0BpD,QAASE,eAAcre,MACnB,MAAIA,gBAAgBoB,cACTpB,KAAK3E,KAAO,OAAS2E,KAAKwB,SAG1BlC,UAAUU,MAQzB,QAASse,4BAA2B5c,UAChC,GAAqBvD,OAAQC,MAAM,kCAAoCkB,UAAUoC,UAAY,0BAE7F,OADA,OAA2B6c,sBAAwB7c,SAC5CvD,MAsMX,QAASqgB,sBAAqBC,KAAMC,OAChC,MAAY,OAARD,MAAyB,MAATC,MACTD,MAAQC,MAEZD,KAAKE,aAAaD,OAQ7B,QAASE,kBAAiBH,KAAMC,OAC5B,GAAqB5L,KAAM2L,KAAK/iB,MAChC,IAAIoX,MAAQ4L,MAAMhjB,OACd,OAAO,CAEX,KAAK,GAAqBiJ,GAAI,EAAGA,EAAImO,IAAKnO,IACtC,IAAK8Z,KAAK9Z,GAAGga,aAAaD,MAAM/Z,IAC5B,OAAO,CAGf,QAAO,EAkiFX,QAASka,kBAAiBC,OACtB,GAAqB3hB,SAAU,GAAI4hB,gBAEnC,OADA5hB,SAAQ6hB,mBAAmBF,MAAO,MAC3B3hB,QAAQ8hB,SA2DnB,QAASC,2BAA0BJ,OAC/B,GAAqB3hB,SAAU,GAAIgiB,+BAEnC,OADAhiB,SAAQ6hB,mBAAmBF,MAAO,MAC3B3hB,QAAQiiB,mBA8BnB,QAASC,oCAAmCC,KAAM1b,YAC9C,IAAKA,WACD,MAAO0b,KAEX,IAAqBC,aAAc,GAAIC,6BAA4B5b,WACnE,OAAO0b,MAAKG,eAAeF,YAAa,MAO5C,QAASG,qCAAoCC,KAAM/b,YAC/C,IAAKA,WACD,MAAO+b,KAEX,IAAqBJ,aAAc,GAAIC,6BAA4B5b,WACnE,OAAO+b,MAAKC,gBAAgBL,YAAa,MAkE7C,QAASM,UAASxkB,KAAM2E,KAAM4D,YAC1B,MAAO,IAAIkc,aAAYzkB,KAAM2E,KAAM4D,YAQvC,QAASmc,YAAW7c,GAAI8c,WAAYpc,YAEhC,WADmB,KAAfoc,aAAyBA,WAAa,MACnC,GAAIC,cAAa/c,GAAI,KAAM8c,WAAYpc,YAQlD,QAASsc,YAAWhd,GAAI8c,WAAYG,eAGhC,WAFmB,KAAfH,aAAyBA,WAAa,UACpB,KAAlBG,gBAA4BA,cAAgB,MACnC,MAANjd,GAAakd,eAAeL,WAAW7c,GAAI8c,WAAY,MAAOG,eAAiB,KAO1F,QAASC,gBAAeT,KAAMQ,eAE1B,WADsB,KAAlBA,gBAA4BA,cAAgB,MACzC,GAAIE,gBAAeV,KAAMQ,eAQpC,QAASG,YAAW3kB,OAAQqE,KAAM4D,YAC9B,MAAO,IAAI2c,kBAAiB5kB,OAAQqE,KAAM4D,YAO9C,QAAS4c,YAAW7kB,OAAQqE,MAExB,WADa,KAATA,OAAmBA,KAAO,MACvB,GAAIygB,gBAAe9kB,OAAO6D,IAAI,SAAU0T,GAAK,MAAO,IAAIwN,iBAAgBxN,EAAErF,IAAKqF,EAAEhW,MAAOgW,EAAEyN,UAAa3gB,KAAM,MAOxH,QAAS4gB,KAAIjB,KAAM/b,YACf,MAAO,IAAIid,SAAQlB,KAAM/b,YAO7B,QAASkd,eAAcnB,KAAM/b,YACzB,MAAO,IAAImd,eAAcpB,KAAM/b,YASnC,QAASod,IAAGC,OAAQC,KAAMlhB,KAAM4D,YAC5B,MAAO,IAAIud,cAAaF,OAAQC,KAAMlhB,KAAM4D,YAQhD,QAASwd,SAAQlkB,MAAO8C,KAAM4D,YAC1B,MAAO,IAAIyd,aAAYnkB,MAAO8C,KAAM4D,YAmgBxC,QAAS0d,oBAAmBC,SAAUvO,IAClC,GAAIwO,aAAcxO,GAAGwO,YAAaC,SAAWzO,GAAGyO,SAAUC,KAAO1O,GAAG0O,IACpE,QACIniB,MAAOgiB,SAAShiB,MAChBoiB,SAAUJ,SAASI,SACnBH,YAAaA,YACbI,WAAYL,SAASK,WACrBH,SAAUA,SACVC,KAAMA,KACNG,MAAON,SAASM,OAQxB,QAASC,uBAAsBP,SAAUvO,IACrC,GAAI+O,OAAQ/O,GAAG+O,MAAOC,UAAYhP,GAAGgP,SACrC,OAAO,IAAIC,aAAYV,SAAShiB,MAAOgiB,SAASW,cAAeX,SAASQ,OAASA,MAAOC,UAAWT,SAASY,aAAcZ,SAASa,eAAgBb,SAAS3d,YAQhK,QAASye,iCAAgCC,WAAY1e,WAAY2e,cAC7D,GAAqBC,kBAAmB,GAAIC,IAW5C,OAVAH,YAAW7hB,QAAQ,SAAUiiB,WAEzBC,oBADqCpjB,OAAS8B,WAAYqhB,UAAU1iB,MAAQ2hB,SAAUe,UAAU1iB,OAC/D0iB,UAAUE,YAAcC,gBAAgBnoB,UAAYmoB,gBAAgBpoB,WAAW,EAAMmJ,WAAY2e,aAAcC,oBAGhGF,WAAWxF,OAAO,SAAUgG,KAAO,MAAOA,KAAIF,cAAgBpgB,OAAO8f,WAAWxF,OAAO,SAAUgG,KAAO,OAAQA,IAAIF,eAC3IniB,QAAQ,SAAUiiB,WAC3CC,kBAAkBD,UAAUV,UAAWa,gBAAgBE,eAAe,EAAOnf,WAAY2e,aAAcC,kBACvGG,kBAAkBD,UAAUM,cAAeH,gBAAgBI,gBAAgB,EAAOrf,WAAY2e,aAAcC,oBAEzGA,iBAWX,QAASG,mBAAkBX,UAAWG,aAAcJ,MAAOne,WAAY2e,aAAcW,wBACjFlB,UAAUvhB,QAAQ,SAAU8gB,UACxB,GAAqB4B,kBAAmBD,uBAAuB/I,IAAInY,eAAeuf,SAAShiB,OAI3F,IAHwB,MAApB4jB,oBAA8BA,iBAAiBjB,iBAAoBX,SAASM,OAC5EU,aAAa5hB,KAAK,GAAIyiB,eAAc,iEAAmErhB,UAAUohB,iBAAiB5jB,OAAQqE,aAEzIuf,iBAUI5B,SAASM,QACVsB,iBAAiBnB,UAAUtmB,OAAS,GAExCynB,iBAAiBnB,UAAUrhB,KAAK4gB,cAbb,CACnB,GAAqBa,gBAAiBb,SAAShiB,MAAM8B,YAC9BkgB,SAAShiB,MAAiB,WAAE6iB,eAC5Bb,SAAShiB,MAAiB,WAAE6iB,kBAE9BiB,aAAe9B,SAASI,UAAYJ,SAASC,aAAeD,SAASK,WAC1FuB,kBAAmB,GAAIlB,aAAYV,SAAShiB,QAASgiB,SAASM,MAAOE,OAASsB,YAAa9B,UAAWY,aAAcC,eAAgBxe,YACpIsf,uBAAuB9I,IAAIpY,eAAeuf,SAAShiB,OAAQ4jB,qBAcvE,QAASG,iBAAgBC,WAErB,GAAqBC,aAAc,EACdC,YAAc,GAAIhB,IAIvC,OAHIc,WAAUE,aACVF,UAAUE,YAAYhjB,QAAQ,SAAUijB,OAAS,MAAOC,qBAAoBF,aAAexgB,KAAMygB,MAAOE,QAASJ,kBAE9GC,YAOX,QAASI,oBAAmBC,oBAAqBxB,YAC7C,GAAqByB,gBAAiBD,oBACjBE,eAAiB,GAAIvB,IAM1C,OALAH,YAAW7hB,QAAQ,SAAUiiB,UAAWuB,gBAChCvB,UAAUwB,SACVxB,UAAUwB,QAAQzjB,QAAQ,SAAUijB,OAAS,MAAOC,qBAAoBK,gBAAkB/gB,KAAMygB,MAAOE,QAASG,uBAGjHC,eAOX,QAASL,qBAAoBnkB,IAAKkkB,OAC9BA,MAAMzgB,KAAKkhB,UAAU1jB,QAAQ,SAAUlB,OACnC,GAAqB+Z,OAAQ9Z,IAAI2a,IAAInY,eAAezC,OAC/C+Z,SACDA,SACA9Z,IAAI4a,IAAIpY,eAAezC,OAAQ+Z,QAEnCA,MAAM3Y,KAAK+iB,SAsBnB,QAASU,yBAAwBC,IAAKnnB,MAAO8C,MAEzC,WADa,KAATA,OAAmBA,KAAO,MACvB/C,WAAWC,MAAO,GAAIonB,4BAA2BD,KAAMrkB;;;;;;;AAuFlE,QAASukB,aAAYF,IAAKG,aACtB,GAAqBC,OAAQ,CACxBD,aAAYzC,QACb0C,OAAS,MAETD,YAAYrC,eAAiBU,gBAAgBI,iBAC7CwB,OAAS,MAEbD,YAAYpC,eAAe3hB,QAAQ,SAAUikB,eAErCA,gBAAkB3H,eAAeE,WACjCuH,YAAYrC,eAAiBU,gBAAgBpoB,WAC7C+pB,YAAYrC,eAAiBU,gBAAgBnoB,YAC7C+pB,OAASE,wBAAwBD,iBAGzC,IAAI1R,IAAKwR,YAAYtC,cACjB0C,iBAAiBP,IAAKI,MAAOD,YAAYxC,WACzC6C,kBAAkBR,IAAKI,MAAOD,YAAYrC,aAAcqC,YAAYxC,UAAU,GAClF,QACI8C,aAFkG9R,GAAG8R,aAGrGL,MAHmIzR,GAAGyR,MAGhHM,SAHkI/R,GAAG+R,SAI3JC,UAAWA,UAAUX,IAAKG,YAAYjlB,QAS9C,QAASqlB,kBAAiBP,IAAKI,MAAOzC,WAiClC,QAASiD,aAAYC,cAAexD,MAChC,MAAOA,MAAKliB,IAAI,SAAU2lB,IAAKC,UAC3B,GAAqBC,WAAY,IAAMH,cAAgB,IAAME,QAG7D,OAFAE,WAAU3kB,KAAK,GAAI4kB,SAAQF,UAAWG,eACtCC,WAAW9kB,KAAK+kB,OAAOrB,IAAKc,MACrBtF,SAASwF,aArCxB,GAAqBI,eACAH,aACAK,MAAQ3D,UAAUxiB,IAAI,SAAU+hB,SAAU2D,eAC3D,GAAqBvF,KACrB,IAAI4B,SAASI,SAAU,CACnB,GAAqBiE,UAAWX,YAAYC,cAAe3D,SAASG,MAAQH,SAASI,SAASkE,OAC9FlG,MAAO0E,IAAItE,WAAWwB,SAASI,SAASzgB,WAAW4kB,YAAYF,cAE9D,IAAIrE,SAASK,WAAY,CAC1B,GAAqBgE,UAAWX,YAAYC,cAAe3D,SAASG,MAAQH,SAASK,WAAWiE,OAChGlG,MAAO0E,IAAItE,WAAWwB,SAASK,WAAW1gB,WAAW6kB,OAAOH,cAE3D,IAAIrE,SAASC,YAAa,CAC3B,GAAqBoE,UAAWX,YAAYC,gBAAkB3lB,MAAOgiB,SAASC,cAC9E7B,MAAOiG,SAAS,OAGhBjG,MAAOyE,wBAAwBC,IAAK9C,SAASE,SAEjD,OAAO9B,OAGX,QACImF,aAFgC9D,GAAGsE,WAAY,GAAIU,iBAAgB1F,WAAWqF,SAAUM,eAGxFxB,MAAe,KAARA,MACPM,SAAUzE,WAAWmF,aAuB7B,QAASZ,mBAAkBR,IAAKI,MAAOtC,aAAc+D,cACjD,GAAqBpB,cACApD,IA6BrB,OA5BIS,gBAAiBU,gBAAgBpoB,WAAa0nB,eAAiBU,gBAAgBnoB,WAC/EoqB,aAAeT,IAAItE,WAA8BmG,aAAsB,SAAEhlB,WACzEujB,OAAS,MACT/C,KAAOwE,aAAaxE,MAA2BwE,aAAsB,SAAEL,QAGnEK,aAAavE,UACbmD,aAAeT,IAAItE,WAAWmG,aAAavE,SAASzgB,WACpDujB,OAAS,IACT/C,KAAOwE,aAAaxE,MAAQwE,aAAavE,SAASkE,QAE7CK,aAAatE,YAClBkD,aAAeT,IAAItE,WAAWmG,aAAatE,WAAW1gB,WACtDujB,OAAS,KACT/C,KAAOwE,aAAaxE,MAAQwE,aAAatE,WAAWiE,QAE/CK,aAAa1E,aAClBsD,aAAeqB,UACf1B,OAAS,KACT/C,OAAUniB,MAAO2mB,aAAa1E,gBAG9BsD,aAAeV,wBAAwBC,IAAK6B,aAAazE,UACzDgD,OAAS,IACT/C,UAICoD,aAAcA,aAAcL,MAAOA,MAAOM,SADnBzE,WAAWoB,KAAKliB,IAAI,SAAU2lB,KAAO,MAAOO,QAAOrB,IAAKc,SAQ5F,QAASH,WAAUX,IAAK+B,WACpB,MAAOA,WAAU/kB,WAAagjB,IAAItE,WAAWqG,UAAU/kB,WAAWH,WAC9DkgB,QAAQgF,UAAUlpB,OAO1B,QAASwoB,QAAOrB,IAAKc,KAGjB,GAAqBxF,MAAOwF,IAAIkB,QAAUjC,wBAAwBC,IAAKc,IAAIjoB,OAAS8nB,UAAUX,IAAwBc,IAAU,OAC3GV,MAAQ,CAU7B,OATIU,KAAImB,aACJ7B,OAAS,GAETU,IAAIoB,aACJ9B,OAAS,GAETU,IAAIkB,UACJ5B,OAAS,GAEI,IAAVA,MAAyB9E,KAAOW,YAAYc,QAAQqD,OAAQ9E,OAMvE,QAASgF,yBAAwBD,eAC7B,GAAqB8B,UAAW,CAChC,QAAQ9B,eACJ,IAAK3H,gBAAeM,oBAChBmJ,SAAW,OACX,MACJ,KAAKzJ,gBAAeK,iBAChBoJ,SAAW,OACX,MACJ,KAAKzJ,gBAAeQ,iBAChBiJ,SAAW,OACX,MACJ,KAAKzJ,gBAAeO,cAChBkJ,SAAW,OACX,MACJ,KAAKzJ,gBAAeG,QAChBsJ,SAAW,MACX,MACJ,KAAKzJ,gBAAeI,UAChBqJ,SAAW,MACX,MACJ,KAAKzJ,gBAAeE,UAChBuJ,SAAW,MACX,MACJ,KAAKzJ,gBAAeC,OAChBwJ,SAAW,MAGnB,MAAOA,UASX,QAASC,qCAAoClK,UAAW8H,IAAKI,MAAOiC,iBAChE,GAAqBC,yBAA0BD,gBAAgBlnB,IAAI,SAAUonB,gBAAkB,MAAOvC,KAAItE,WAAW6G,eAAeC,oBAC/GtnB,MAAQ+c,gCAAgCC,UAAWuK,YAAYC,0BAC/DC,WACjBnB,SACMQ,SAAS,EAAMnpB,MAAOojB,WAAWqG,2BACjCpnB,MAAOA,MAAO+mB,YAAY,EAAMC,YAAY,IAC5ChnB,MAAO+c,gCAAgCC,UAAWuK,YAAYG,eAEpE7E,kBACAlhB,UAAWqb,UAAUC,yBAAyBsK,YAAYI,kCAE1DlU,GAAK6R,kBAAkBR,IAAKI,MAAO5B,gBAAgBI,gBACnD1jB,MAAOA,MACPsiB,OAAO,EACPF,SAAUqF,WAEd,QAASlC,aADU9R,GAAG8R,aACeL,MADezR,GAAGyR,MACIM,SADc/R,GAAG+R,SACGC,UAAWA,UAAUX,IAAK9kB,QAmU7G,QAAS4nB,gBAAejqB,OACpB,GAAqBkqB,KAAM,EAC3BlqB,OAAQ2B,WAAW3B,MACnB,KAAK,GAAqByH,GAAI,EAAGA,EAAIzH,MAAMxB,QAAS,CAChD,GAAqB2rB,IAAKnqB,MAAMgC,WAAWyF,KACtB2iB,GAAKpqB,MAAMgC,WAAWyF,KACtB4iB,GAAKrqB,MAAMgC,WAAWyF,IAC3CyiB,MAAOI,cAAcH,IAAM,GAC3BD,KAAOI,eAAqB,EAALH,KAAW,GAAMva,MAAMwa,IAAM,EAAIA,IAAM,IAC9DF,KAAOta,MAAMwa,IAAM,IAAME,eAAqB,GAALF,KAAY,EAAMC,IAAM,GACjEH,KAAOta,MAAMwa,KAAOxa,MAAMya,IAAM,IAAMC,cAAmB,GAALD,IAExD,MAAOH,KAMX,QAASK,aAAYvqB,OACjBA,MAAQA,MAAQ,EAAsB,IAAfA,OAAU,GAASA,OAAS,CACnD,IAAqBwgB,KAAM,EAC3B,GAAG,CACC,GAAqBgK,OAAgB,GAARxqB,KAC7BA,SAAiB,EACbA,MAAQ,IACRwqB,OAAgB,IAEpBhK,KAAO8J,cAAcE,aAChBxqB,MAAQ,EACjB,OAAOwgB,KAOX,QAAS8J,eAActqB,OACnB,GAAIA,MAAQ,GAAKA,OAAS,GACtB,KAAM,IAAIkB,OAAM,6CAEpB,OAAOupB,YAAWzqB,OA01BtB,QAAS0qB,kBAAiBzrB,MAAO0rB,aAAcC,aAE3C,OADoB,KAAhBA,cAA0BA,aAAc,GAC/B,MAAT3rB,MACA,MAAO,KAEX,IAAqB+kB,MAAO/kB,MAAMC,QAAQ2rB,+BAAgC,WAEtE,IAAK,GADD3iB,UACK5J,GAAK,EAAGA,GAAKC,UAAUC,OAAQF,KACpC4J,MAAM5J,IAAMC,UAAUD,GAE1B,OAAgB,KAAZ4J,MAAM,GACCyiB,aAAe,MAAQ,IAEb,MAAZziB,MAAM,GACJ,MAEU,MAAZA,MAAM,GACJ,MAGA,KAAOA,MAAM,IAI5B,OADsC0iB,eAAgBE,qBAAqB/iB,KAAKic,MACxD,IAAMA,KAAO,IAAMA,KAM/C,QAAS+G,eAAcvS,OAEnB,IAAK,GADgB/V,KAAM,GACDgF,EAAI,EAAGA,EAAI+Q,MAAO/Q,IACxChF,KAAOuoB,YAEX,OAAOvoB;;;;;;;AAkBX,QAASwoB,4BAA2B3nB,KAChC,GAAqB4nB,WAAY,GAAIC,mBAChBhE,IAAMiE,sBAAsBC,YAgBjD,QAf4BlrB,MAAMC,QAAQkD,KAAOA,KAAOA,MACnDC,QAAQ,SAAUD,KACnB,GAAIA,cAAegoB,WACfhoB,IAAIif,eAAe2I,UAAW/D,SAE7B,IAAI7jB,cAAeioB,YACpBjoB,IAAIof,gBAAgBwI,UAAW/D,SAE9B,CAAA,KAAI7jB,cAAekoB,SAIpB,KAAM,IAAItqB,OAAM,0CAA4CoC,IAH5DA,KAAImoB,UAAUP,UAAW/D,QAM1BA,IAAIuE,WA0sBf,QAASC,iBAAgBxE,IAAKyE,OAC1B,IAAK,GAAIttB,IAAK,EAAGutB,QAAUD,MAAOttB,GAAKutB,QAAQrtB,OAAQF,KAAM,CACzD,GAAIwtB,MAAOD,QAAQvtB,GACnBytB,iBAAgBD,KAAK3hB,eAAiBgd,KAihB9C,QAAS6E,wBAAuBC,MAC5B,OAAQA,MACJ,IAAK,QACL,IAAK,SACL,IAAK,WACL,IAAK,YACL,IAAK,WACL,IAAK,YACL,IAAK,OACL,IAAK,MACL,IAAK,SACL,IAAK,QACL,IAAK,WACL,IAAK,eACL,IAAK,gBACL,IAAK,aACL,IAAK,cACL,IAAK,gBACL,IAAK,eACL,IAAK,YACL,IAAK,aACL,IAAK,eACL,IAAK,cACL,IAAK,eACL,IAAK,cACL,IAAK,iBACL,IAAK,kBACL,IAAK,mBACL,IAAK,oBACL,IAAK,aACD,OAAO,CACX,SACI,OAAO,GA0pBnB,QAASC,eAAcjtB,OACnB,MAAOA,OAAMC,QAAQitB,WAAY,IAOrC,QAASC,yBAAwBntB,OAC7B,MAAOA,OAAMiJ,MAAMmkB,wBAmBvB,QAASC,cAAartB,MAAOstB,cACzB,GAAqBC,wBAAyBC,aAAaxtB,OACtCytB,eAAiB,CACtC,OAAOF,wBAAuBG,cAAcztB,QAAQ0tB,QAAS,WAEzD,IAAK,GADDxtB,MACKd,GAAK,EAAGA,GAAKC,UAAUC,OAAQF,KACpCc,EAAEd,IAAMC,UAAUD,GAEtB,IAAqBuuB,UAAWztB,EAAE,GACb0tB,QAAU,GACVC,OAAS3tB,EAAE,GACX4tB,cAAgB,EACjCD,SAAUA,OAAO/R,WAAW,IAAMiS,qBAClCH,QAAUN,uBAAuBU,OAAOR,kBACxCK,OAASA,OAAOnqB,UAAUqqB,kBAAkBzuB,OAAS,GACrDwuB,cAAgB,IAEpB,IAAqBG,MAAOZ,aAAa,GAAIa,SAAQP,SAAUC,SAC/D,OAAO,GAAK1tB,EAAE,GAAK+tB,KAAKN,SAAWztB,EAAE,GAAK4tB,cAAgBG,KAAKL,QAAUC,SAcjF,QAASN,cAAaxtB,OAMlB,IAAK,GALgBouB,YAAapuB,MAAMiH,MAAMonB,UACzBC,eACAC,iBACAC,aAAe,EACfC,qBACKC,UAAY,EAAGA,UAAYN,WAAW7uB,OAAQmvB,YAAa,CACjF,GAAqBC,MAAOP,WAAWM,UACnCC,OAAQC,aACRJ,eAEAA,aAAe,EACfC,kBAAkBjqB,KAAKmqB,OAGnBF,kBAAkBlvB,OAAS,IAC3BgvB,cAAc/pB,KAAKiqB,kBAAkBnrB,KAAK,KAC1CgrB,YAAY9pB,KAAKwpB,mBACjBS,sBAEJH,YAAY9pB,KAAKmqB,OAEjBA,MAAQE,YACRL,eAOR,MAJIC,mBAAkBlvB,OAAS,IAC3BgvB,cAAc/pB,KAAKiqB,kBAAkBnrB,KAAK,KAC1CgrB,YAAY9pB,KAAKwpB,oBAEd,GAAIc,yBAAwBR,YAAYhrB,KAAK,IAAKirB,eA+I7D,QAASQ,kBAAiB3H,WACtB,GAAqBjjB,QAAS,QAI9B,OAHIijB,aACAjjB,QAAU,IAAMU,eAAeuiB,UAAUvjB,OAEtCM,OAyBX,QAAS6qB,4BAA2BjkB,OAChC,MAAOA,OAAMkkB,KAAK,SAAUjkB,MAAQ,MAAOA,MAAK9L,OAASgwB,wBAU7D,QAASC,aAAYpuB,OAEjB,MAAOA,OAAMd,QAAQ,GAAI6S,QAAOsc,aAAc,KAAM,KA0GxD,QAASC,mBAAkBC,mBACvB,MAAO,IAAIC,iBAAgBloB,SAAS,GAAImoB,mBAAqBF,kBAAkBG,WAAYH,kBAAkBI,QAyCjH,QAASC,aAAYroB,OACjB,GAAqBsoB,UAAW,GAAIC,UACpC,OAAO,IAAIC,iBAAgBzoB,SAASuoB,SAAUtoB,OAAQsoB,SAASG,WAAYH,SAASF,QA4GxF,QAASM,mBAAkB3rB,IAAKqrB,QAC5B,GAAqB5nB,UAAWzD,IAAI4rB,MAAM5sB,IAAI,SAAUyT,IACd,GAAlCoZ,aAAavvB,QAAQmW,EAAE/V,QAAiB+V,EAAE/V,MAAMkI,MAAM,WACtDymB,OAAOlrB,KAAK,GAAI2rB,gBAAerZ,EAAEsZ,gBAAiB,gDAAoDF,aAAa5sB,KAAK,OAE5H,IAAqB+sB,iBAAkBV,YAAY7Y,EAAE1E,WAErD,OADAsd,QAAOlrB,KAAK/E,MAAMiwB,OAAQW,gBAAgBX,QACnC,GAAI9nB,SAAQ,eAAgB,GAAI0oB,aAAY,eAAgB,GAAKxZ,EAAE/V,MAAO+V,EAAEsZ,kBAAmBC,gBAAgB/oB,MAAOwP,EAAErP,WAAYqP,EAAErP,WAAYqP,EAAErP,cAE1I8oB,WAAa,GAAID,aAAY,aAAcjsB,IAAImsB,YAAansB,IAAIosB,sBACrF,OAAO,IAAI7oB,SAAQ,gBAAiB2oB,YAAazoB,SAAUzD,IAAIoD,WAAYpD,IAAIoD,WAAYpD,IAAIoD,YAOnG,QAASipB,oBAAmBrsB,IAAKqrB,QAC7B,GAAqB5nB,UAAWzD,IAAI4rB,MAAM5sB,IAAI,SAAUyT,GACpD,GAAqBuZ,iBAAkBV,YAAY7Y,EAAE1E,WAErD,OADAsd,QAAOlrB,KAAK/E,MAAMiwB,OAAQW,gBAAgBX,QAC1B,UAAZ5Y,EAAE/V,MAEK,GAAI6G,SAAQ,eAAgB,GAAI0oB,aAAY,kBAAmB,GAAIxZ,EAAEsZ,kBAAmBC,gBAAgB/oB,MAAOwP,EAAErP,WAAYqP,EAAErP,WAAYqP,EAAErP,YAEjJ,GAAIG,SAAQ,eAAgB,GAAI0oB,aAAY,eAAgB,GAAKxZ,EAAE/V,MAAO+V,EAAEsZ,kBAAmBC,gBAAgB/oB,MAAOwP,EAAErP,WAAYqP,EAAErP,WAAYqP,EAAErP,cAE1I8oB,WAAa,GAAID,aAAY,aAAcjsB,IAAImsB,YAAansB,IAAIosB,sBACrF,OAAO,IAAI7oB,SAAQ,gBAAiB2oB,YAAazoB,SAAUzD,IAAIoD,WAAYpD,IAAIoD,WAAYpD,IAAIoD,YAmoBnG,QAASkpB,mBAAkBzxB,MACvB,MAAkB,KAAXA,KAAK,GAShB,QAAS0xB,8BAA6BC,SAAUjD,SAAUkD,SAAUC,aAChE,GAAqBC,QAQrB,OAPAC,aAAYC,MAAMtD,UAAUtpB,QAAQ,SAAUspB,UAC1C,GAAqBuD,cAAevD,SAAShY,SAAWgY,SAAShY,SAAWib,SAASO,uBAChEC,gBAAkB,GAAI1P,KAAIiM,SAAS0D,aAAa3Q,OAAO,SAAUiN,UAAY,MAAOA,UAAS2D,sBAC7GluB,IAAI,SAAUuqB,UAAY,MAAOA,UAAShY,WAC1B4b,qBAAuBL,aAAaxQ,OAAO,SAAU7W,aAAe,OAAQunB,gBAAgBI,IAAI3nB,cACrHknB,MAAKxsB,KAAK/E,MAAMuxB,KAAMQ,qBAAqBnuB,IAAI,SAAUyG,aAAe,MAAO+mB,UAASa,gBAAgB5nB,YAAagnB,SAAUC,kBAE5G,IAAhBC,KAAKzxB,QAAgBoyB,gBAAgBC,MAAQ1wB,MAAMwgB,KAAK,GAAIC,KAAIqP,OAAOa,OAiDlF,QAASC,cAAaC,UAClB,MAAO,UAAU/vB,OACb,OAAqC,IAAjC+vB,SAASpxB,QAAQqB,MAAMF,OACvBkwB,cAAchwB,MAAMF,MAAQkwB,cAAchwB,MAAMF,MAAQ,GAAK,EACtDkwB,cAAchwB,MAAMF,MAAQ,IAw+B/C,QAASmwB,eAAcC,UACnB,MAAOA,UAAWA,SAASjrB,MAAM,KAAK5D,IAAI,SAAU0T,GAAK,MAAOA,GAAElW,YAMtE,QAASsxB,cAAaC,gBAClB,MAAOA,gBAAevxB,OAAOoG,MAAM,QA+DvC,QAASorB,0BAAyBvoB,YAAawoB,YAC3C,GAAqBC,aAAc,GAAItB,aAClBuB,WAAa3oB,YAAYC,aAAa,EAC3DyoB,aAAYE,WAAWD,WACvB,KAAK,GAAqBhqB,GAAI,EAAGA,EAAI8pB,WAAW/yB,OAAQiJ,IAAK,CACzD,GAAqBkqB,UAAWJ,WAAW9pB,GAAG,GACzBmqB,aAAe9oB,YAAY6oB,UAAU,GACrCE,UAAYN,WAAW9pB,GAAG,EAE/C,IADA+pB,YAAYM,aAAaF,aAAcC,WACnCF,SAASxnB,eAAiB4nB,WAAY,CACPX,aAAaS,WACpCtuB,QAAQ,SAAUyuB,WAAa,MAAOR,aAAYS,aAAaD,cAG/E,MAAOR,aAQX,QAASU,kBAAiBlW,MACtB,MAAOA,gBAAgBmW,OAAoC,GAA5BnW,KAAKhc,MAAMF,OAAOtB,OAOrD,QAAS4zB,yBAAwBC,OAC7B,GAAqB/vB,KAAM,GAAIijB,IAM/B,OALA8M,OAAM9uB,QAAQ,SAAU6B,MACf9C,IAAI2a,IAAI7X,KAAKtC,KAAKkB,YACnB1B,IAAI4a,IAAI9X,KAAKtC,KAAKkB,UAAWoB,QAG9BjF,MAAMwgB,KAAKre,IAAI7D,UAM1B,QAAS6zB,mBAAkBhvB,KAIvB,MAHIA,eAAeivB,iBACfjvB,IAAMA,IAAIA,KAEPA,cAAekvB,WAQ1B,QAASC,YAAWC,GAAIC,qBAAsBC,mBAC1C,GAAIxpB,aAAaspB,GAAGv0B,MAChB,OAAO,CACX,IAAqB00B,SAAU/pB,YAAY4pB,GAAGv0B,MAAM,EAEpD,SAAI00B,QAAQ1oB,gBAAkB2oB,mBACtBH,sBAAwBE,QAAQ1oB,gBAAkB2oB,oBAClDF,kBAAkBG,qCAAyDL,GAAc,aAClF,GA2CnB,QAASM,sBAAqBC,cAAeC,iBAAkBC,OAAQC,WAC9DH,gBACDA,cAAgB,GAAII,sBAExB,IAAqBC,uBAAwBC,gCACzCC,4BAA6B,SAAUC,UAEnC,MAAO,UAAUp1B,MAAQ,MAAO+kB,YAAW/kB,QAE/Cq1B,0BAA2B,SAAUC,MAEjC,MAAO,UAAUl1B,QAQb,MAAO6kB,YAPwBqQ,KAAKrxB,IAAI,SAAUsU,EAAGnP,GACjD,OACIkJ,IAAKiG,EAAEjG,IACP3Q,MAAOvB,OAAOgJ,GACdgc,OAAQ7M,EAAE6M,aAM1BmQ,oBAAqB,SAAUz1B,MAC3B,KAAM,IAAI+C,OAAM,kEAAoE/C,QAEzFg1B,QACkBlzB,QAAU,GAAI4zB,iBAAgBZ,cAAeC,iBAAkBE,WAC/DU,cACrBC,mBAAkBT,sBAAsBjwB,MAAMpD,QAAS+zB,MAAM1I,WAAYwI,aACzEG,sBAAsBh0B,QAAQi0B,eAAgBd,UAAWU,YACzD,IAAqBK,WAAYL,YAAYt1B,OAAS,EACjC41B,kBAAqC,IAC1D,IAAID,WAAa,EAAG,CAChB,GAAqBE,eAAgBP,YAAYK,WAC5BG,WAAaC,0BAA0BF,cACxDC,cAGAF,kBAAoBI,wBAAwBpB,WAC5CU,YAAYK,WACRC,kBAAkBlX,IAAIoX,WAAWG,KAAKnM,cAAcoM,aAAaxQ,SAAQ,KACpEyQ,WAAW,MAAOC,aAAaC,SAGhD,MAAO,IAAIC,4BAA2BhB,YAAaM,mBAevD,QAASb,gCAA+BwB,iBAAkBzxB,KACtD,MAAO0xB,iBAAgBD,iBAAkBzxB,KA8B7C,QAAS2xB,wBAAuBhC,cAAeC,iBAAkBgC,0BAA2B9B,UAAW+B,MAC9FlC,gBACDA,cAAgB,GAAII,sBAExB,IAAqB+B,aAAcC,oBAAoBjC,WAClCxR,SACA3hB,QAAU,GAAI4zB,iBAAgBZ,cAAeC,iBAAkBE,WAC/DkC,WAAaJ,0BAA0B7xB,MAAMpD,QAAS+zB,MAAMzI,WACjF,IAAItrB,QAAQi0B,eACR,IAAK,GAAqBzsB,GAAI,EAAGA,EAAIxH,QAAQi0B,eAAgBzsB,IACzDma,MAAMne,KAAK8xB,qBAAqBnC,UAAW3rB,QAG9C,IAAI0tB,MAAQK,YAAYC,UACzB,MAAO,IAAIC,iCAAiCJ,WAGhD,OADA1T,OAAMne,KAAK2xB,YAAYlY,IAAIoY,YAAYX,WAAWrM,cAAesM,aAAaC,SACvE,GAAIa,8BAA6B9T,MAAOwT,aAOnD,QAASJ,iBAAgBD,iBAAkBzxB,KACvC,GAAqBrD,SAAU,GAAI01B,sBAAqBZ,iBACxD,OAAOzxB,KAAID,MAAMpD,SAOrB,QAAS21B,eAAcxC,UAAWyC,iBAC9B,MAAO,OAASzC,UAAY,IAAMyC,gBAOtC,QAASN,sBAAqBnC,UAAWyC,iBACrC,MAAO,IAAIC,gBAAeF,cAAcxC,UAAWyC,iBAAkB5M,WAQzE,QAASgL,uBAAsBC,eAAgBd,UAAW2C,YACtD,IAAK,GAAqBtuB,GAAIysB,eAAiB,EAAGzsB,GAAK,EAAGA,IACtDsuB,WAAWC,QAAQT,qBAAqBnC,UAAW3rB,IAe3D,QAASwuB,qBAAoBC,KAAM5yB,KAC/B,GAAI4yB,OAASlC,MAAM1I,UACf,KAAM,IAAIpqB,OAAM,iCAAmCoC,KAQ3D,QAAS6yB,sBAAqBD,KAAM5yB,KAChC,GAAI4yB,OAASlC,MAAMzI,WACf,KAAM,IAAIrqB,OAAM,mCAAqCoC,KAQ7D,QAAS8yB,4BAA2BF,KAAMzT,MACtC,MAAIyT,QAASlC,MAAM1I,UACR7I,KAAK4T,SAGL5T,KAg1Bf,QAASsR,mBAAkBuC,IAAKC,QACxBp2B,MAAMC,QAAQk2B,KACd,IAAyB/yB,QAAQ,SAAU6Y,OAAS,MAAO2X,mBAAkB3X,MAAOma,UAGpFA,OAAO9yB,KAAK6yB,KA0BpB,QAASjB,qBAAoBjC,WACzB,MAAOzQ,UAAS,WAAayQ,WAMjC,QAASoB,yBAAwBpB,WAC7B,MAAOzQ,UAAS,MAAQyQ,WAM5B,QAASmB,2BAA0BnS,MAC/B,MAAIA,gBAAgBoU,qBACTpU,KAAKK,KAEPL,eAAgB0G,iBACd1G,KAAKpiB,MAET,KAunDX,QAASy2B,yBAAwBC,UAC7B,GAAqBC,aAAcD,SAASA,SAASl4B,OAAS,EAC9D,OAAIm4B,uBAAuBC,qBAChBD,YAAYE,iBAEnBF,sBAAuBG,YACnB7tB,cAAc0tB,YAAYx4B,OAASw4B,YAAY5vB,SAASvI,OACjDi4B,wBAAwBE,YAAY5vB,UAExC4vB,YAAYE,iBAEhBF,sBAAuBI,cAOlC,QAASC,mBAAkBC,SAAUC,QACjC,OAAQD,SAASn0B,MACb,IAAKq0B,qBAAoB95B,UACrB,MAAO+lB,aACHc,QAAQ,GAA+BA,QAAQ+S,SAAS94B,MACxD+lB,QAAQ+S,SAAStG,kBAEzB,KAAKwG,qBAAoBC,SACrB,MAAOhU,aACHc,QAAQ,GAAuBA,QAAQ+S,SAAS94B,MAChD+lB,QAAQ+S,SAAStG,kBAEzB,KAAKwG,qBAAoBE,UAIrB,MAAOjU,aACHc,QAJ+B,GAC9BgT,QAAUA,OAAO1R,UAAUE,YAAc,GACtC,KAEkBxB,QAAQ,IAAM+S,SAAS94B,MAAO+lB,QAAQ+S,SAAStG,kBAE7E,KAAKwG,qBAAoBG,MACrB,MAAOlU,aAAYc,QAAQ,GAA2BA,QAAQ+S,SAAS94B,MAAO8qB,WAClF,KAAKkO,qBAAoBI,MACrB,MAAOnU,aACHc,QAAQ,GAA2BA,QAAQ+S,SAAS94B,MAAO+lB,QAAQ+S,SAASO,SAQ5F,QAASC,eAAcC,YACnB,GAAqBC,WAAYz6B,OAAOC,OAAO,KAW/C,OAVAu6B,YAAW1tB,MAAMzG,QAAQ,SAAUq0B,SAAWD,UAAUC,QAAQz5B,MAAQy5B,QAAQ53B,QAChF03B,WAAWtS,WAAW7hB,QAAQ,SAAU2zB,QACpCh6B,OAAOy2B,KAAKuD,OAAO1R,UAAUqS,gBAAgBt0B,QAAQ,SAAUpF,MAC3D,GAAqB6B,OAAQk3B,OAAO1R,UAAUqS,eAAe15B,MACxC25B,UAAYH,UAAUx5B,KAC3Cw5B,WAAUx5B,MAAqB,MAAb25B,UAAoBC,oBAAoB55B,KAAM25B,UAAW93B,OAASA,UAKrFojB,WAAWlmB,OAAOy2B,KAAKgE,WAAW7G,OAAOxuB,IAAI,SAAUqvB,UAAY,MAAOvO,aAAYc,QAAQyN,UAAWzN,QAAQyT,UAAUhG,gBAQtI,QAASoG,qBAAoBpG,SAAUqG,WAAYC,YAC/C,MAAItG,WAAYuG,cAAgBvG,UAAYwG,WACjCH,WAAa,IAAMC,WAGnBA,WAQf,QAASG,eAAcC,UAAW5P,OAC9B,MAAIA,OAAMjqB,OAAS,GACR85B,UAAUzP,QAAQ0P,SAAUrU,QAAQmU,WAAYnU,QAAQ,GAAkBd,WAAWqF,SAGrF6P,UAAUzP,QAAQ0P,SAAUrU,QAAQmU,WAAYnU,QAAQ,IAAiB5e,OAAOmjB,QAS/F,QAAS+P,iBAAgBH,UAAWI,WAAYhW,MAC5C,MAAOI,YAAW+G,YAAY8O,aAAa7P,QACvC0P,SAAUrU,QAAQmU,WAAYnU,QAAQuU,YAAahW,OAQ3D,QAASkW,oBAAmBpyB,MAAOnD,QA8B/B,WA7Be,KAAXA,SAAqBA,OAAS,GAAImiB,MACtChf,MAAMhD,QAAQ,SAAUyY,MACpB,GAAqB4c,gBAAiB,GAAIhY,KACrBiY,gBAAkB,GAAIjY,KACtBkY,iBAAgC,EACjD9c,gBAAgB8a,aAChB6B,mBAAmB3c,KAAKjV,SAAU3D,QAClC4Y,KAAKjV,SAASxD,QAAQ,SAAUw1B,OAC5B,GAAqBC,WAA+B51B,OAAO6Z,IAAI8b,MAC/DC,WAAUJ,eAAer1B,QAAQ,SAAUmjB,SAAW,MAAOkS,gBAAeK,IAAIvS,WAChFsS,UAAUH,gBAAgBt1B,QAAQ,SAAUmjB,SAAW,MAAOmS,iBAAgBI,IAAIvS,aAEtFoS,aAAe9c,KAAK8c,cAEf9c,eAAgB4a,uBACrB+B,mBAAmB3c,KAAKjV,SAAU3D,QAClC4Y,KAAKjV,SAASxD,QAAQ,SAAUw1B,OAC5B,GAAqBC,WAA+B51B,OAAO6Z,IAAI8b,MAC/DC,WAAUJ,eAAer1B,QAAQ,SAAUmjB,SAAW,MAAOmS,iBAAgBI,IAAIvS,WACjFsS,UAAUH,gBAAgBt1B,QAAQ,SAAUmjB,SAAW,MAAOmS,iBAAgBI,IAAIvS,aAEtFoS,aAAe9c,KAAK8c,cAEpBA,cACAA,aAAav1B,QAAQ,SAAU2E,OAAS,MAAO0wB,gBAAeK,IAAI/wB,MAAMwe,WAE5EmS,gBAAgBt1B,QAAQ,SAAUmjB,SAAW,MAAOkS,gBAAeM,OAAOxS,WAC1EtjB,OAAO8Z,IAAIlB,MAAQ4c,eAAgBA,eAAgBC,gBAAiBA,oBAEjEz1B,OAMX,QAAS+1B,oBAAmBC,oBACxB,GAAqBR,gBAAiB,GAAIhY,KACrBiY,gBAAkB,GAAIjY,IAM3C,OALAzgB,OAAMwgB,KAAKyY,mBAAmB36B,UAAU8E,QAAQ,SAAU6Y,OACtDA,MAAMwc,eAAer1B,QAAQ,SAAUmjB,SAAW,MAAOkS,gBAAeK,IAAIvS,WAC5EtK,MAAMyc,gBAAgBt1B,QAAQ,SAAUmjB,SAAW,MAAOmS,iBAAgBI,IAAIvS,aAElFmS,gBAAgBt1B,QAAQ,SAAUmjB,SAAW,MAAOkS,gBAAeM,OAAOxS,YACjEkS,eAAgBA,eAAgBC,gBAAiBA,iBAO9D,QAASQ,2BAA0BC,SAAUpC,QACzC,MAAIoC,UAASC,aAELp7B,KAAM,IAAMm7B,SAASn7B,KAAO,IAAMm7B,SAASE,MAC3CjpB,OAAQ2mB,QAAUA,OAAO1R,UAAUE,YAAc,YAAc,MAI5D4T,SASf,QAASG,6BAA4BC,SAAUhT,QAASiT,SACpD,GAAqBpS,OAAQ,CAS7B,QANIoS,UAAYD,SAASd,eAAelI,IAAIhK,UAAagT,SAASb,gBAAgBnI,IAAIhK,SAIlFa,OAAS,UAHTA,OAAS,UAKNA,MAOX,QAASqS,sBAAqBrpB,OAAQpS,MAClC,MAAOoS,QAASA,OAAS,IAAMpS,KAAOA,KA0N1C,QAAS07B,cAAaC,KAAMC,UAExB,OADiB,KAAbA,WAAuBA,SAAW,KACjCD,KAAKlY,MACN,KAAM,IAAI1gB,OAAM,oDAAsD44B,KAAKE,WAE/E,QAAO,GAAIC,oBAAoBC,eAAeJ,KAAKE,WAAYF,KAAKlY,MAAOmY;;;;;;;AAuB/E,QAASI,gBAAe/zB,WAAYiZ,WAEhC,IAAK,GADgB+a,kBACZ97B,GAAK,EAAGwX,GAAK1P,WAAWi0B,iBAAiBvV,UAAWxmB,GAAKwX,GAAGtX,OAAQF,KAAM,CAC/E,GAAI2X,IAAKH,GAAGxX,IAAK+lB,SAAWpO,GAAGoO,SAAUhoB,OAAS4Z,GAAG5Z,MACrD,IAAIyI,eAAeuf,SAAShiB,SAAWgd,UAAUib,OAE7C,IAAK,GADgBC,cAAeC,qBAAqBnW,SAASE,UACzD9N,GAAK,EAAGgkB,eAAiBF,aAAc9jB,GAAKgkB,eAAej8B,OAAQiY,KAAM,CAC9E,GAAIikB,OAAQD,eAAehkB,GAC3B2jB,eAAc32B,KAAKk3B,eAAeD,MAAOrb,UAAWhjB,OAAO2H,aAIvE,MAAOo2B,eAOX,QAASI,sBAAqBI,OAAQrqB,QAElC,OADe,KAAXA,SAAqBA,WACH,gBAAXqqB,QACPrqB,OAAO9M,KAAKm3B,YAEX,IAAIz6B,MAAMC,QAAQw6B,QACnB,IAAK,GAAIt8B,IAAK,EAAGu8B,SAAWD,OAAQt8B,GAAKu8B,SAASr8B,OAAQF,KAAM,CAC5D,GAAIo8B,OAAQG,SAASv8B,GACrBk8B,sBAAqBE,MAAOnqB,YAG3BqqB,QAAOL,aACZC,qBAAqBI,OAAOL,aAAchqB,QAErCqqB,OAAO7zB,UACZyzB,qBAAqBI,OAAO7zB,SAAUwJ,OAE1C,OAAOA,QAQX,QAASoqB,gBAAeD,MAAOrb,UAAWhjB,QACtC,GAAIyZ,IAAK4kB,MAAMx0B,MAAM,KAAM40B,UAAYhlB,GAAG,GAAIilB,UAAYjlB,GAAG,GACxCklB,iBAAmB3b,UAAUC,0BAC9C2b,WAAYH,UACZ38B,KAAM48B,WACP1+B,OAASA,OAAOiI,aAAW1D,GAC9B,QAAS85B,MAAOA,MAAOr+B,OAAQA,QAAU2+B,iBAAkBA,iBAAkBA,kBAwuBjF,QAASE,oBAAmB/2B,YACxB,MAAOA,YAAW6W,WAAW,OAAS7W,WAAWg3B,OAAO,GAAKh3B,WAMjE,QAASi3B,wBAAuBC,UAC5B,MAAIA,WAAoC,aAAxBA,SAASC,WACdD,SAASE,OAEbF,SAgBX,QAASG,oBAAmBC,YAAaC,UAAWC,gBAAiBC,eAAgBC,QAASC,OAC1F,GAAqBC,kBAAmB,GAAIC,kBAAiBJ,eAAgBD,gBAAiBF,YAI9FI,SAAQt4B,QAAQ,SAAU04B,gBACtB,MAAOF,kBAAiBG,YAAaX,OAAQU,eAAeV,OAAQF,SAAUY,eAAeZ,aAGjGS,MAAMv4B,QAAQ,SAAUuS,IACpB,GAAIqmB,SAAUrmB,GAAGqmB,OAAoBrmB,IAAGulB,QACxCU,kBAAiBG,YAAaX,OAAQY,QAAQr5B,KAAKkB,UAAWq3B,aAAUz6B,GAAWkC,KAAMq5B,WAE7F,IAAIrmB,IAAKimB,iBAAiBhgB,YAAaqgB,KAAOtmB,GAAGsmB,KAAMjL,SAAWrb,GAAGqb,QACrE,IAAIuK,UAAW,CACX,GAAqBW,oBAAqB,GAAIC,kBAAiBZ,UAAWE,eAAgBD,gBAC1FG,OAAMv4B,QAAQ,SAAUuS,IACpB,GAAIqmB,SAAUrmB,GAAGqmB,QAASd,SAAWvlB,GAAGulB,QACxCgB,oBAAmBE,cAAcJ,QAASd,YAE9CU,iBAAiBS,mCAAmCj5B,QAAQ,SAAU44B,SAC9DR,gBAAgBc,cAAcN,QAAQZ,OAAOj3B,WAAa63B,QAAQr5B,MAClEu5B,mBAAmBK,WAAWP,QAAQr5B,QAG9Cu5B,mBAAmBtgB,UAAUoV,UAEjC,OAASiL,KAAMA,KAAMjL,SAAUA,UASnC,QAASwL,sBAAqBC,YAAajB,gBAAiBkB,gBAAiBT,MAEzE,MADoC,IAAIU,sBAAqBF,YAAajB,iBACtDoB,YAAYF,gBAAiBT,MAOrD,QAASY,kBAAiBC,UAAWj5B,WACjC,MAAOk5B,6BAA4BD,UAAWj5B,UAAWilB,WAQ7D,QAASiU,6BAA4BD,UAAWj5B,UAAWhE,OACvD,GAAqBm9B,QAASve,kBAAkB5a,UAAU7F,KAC1D8+B,WAAUlH,WAAWtyB,KAAKqgB,OAAQ,GAAIgF,iBAAgB9oB,QAAS,GAAIo9B,WAAU9U,eAAeqM,WAAWwI,QACnGvI,aAAaC,MAAOD,aAAayI,YAugBzC,QAASC,QAAOjC,UACZ,MAAOA,WAAoC,SAAxBA,SAASC,WAMhC,QAASiC,gBAAelC,UACpB,MAAOiC,QAAOjC,WAAaD,uBAAuBC,SAAShqB,qBAAuBnN,cAMtF,QAASs5B,wBAAuBnC,UAC5B,MAAOiC,QAAOjC,WAAaA,SAAShqB,YAAiD,WAAnCgqB,SAAShqB,WAAWiqB,YAClEF,uBAAuBC,SAAShqB,WAAWA,qBAAuBnN,cAswB1E,QAASu5B,kBAAiBR,WAItBA,UAAUlH,WAAWtyB,KAAKof,WAAW+G,YAAY8T,kBAAkBrH,UASvE,QAASsH,yBAAwB/B,eAAgBgC,cAAeC,UAAWC,YACvEF,cAAcG,aAAax6B,QAAQ,SAAU0kB,KACzCA,IAAI+V,SAASpC,eAAeqC,gBAAgBC,iBAAiBjW,IAAI/V,UAAW2rB,UAAWC,YAAa7V,IAAI9pB,SAShH,QAAS+/B,kBAAiBC,cAAeC,KAAMrR,QAC3C,MAAYoR,gBAAiBC,KAAO,QAAU,IAAM,WAAarR,OAqBrE,QAASsR,kBAAiBC,UAAWC,KAAMC,qBAAsBC,kBAE7D,MAAOC,oBADsBC,sCAAsCL,UAAWC,KAAMC,qBAAsBC,mBAU9G,QAASG,6BAA4BN,UAAWC,KAAMC,qBAAsBC,kBACxE,MAAOI,yBAAwBR,iBAAiBC,UAAWC,KAAMC,qBAAsBC,mBAM3F,QAASI,yBAAwBC,iBAC7B,GAAIA,gBAAgBC,sBAAwBD,gBAAgBC,qBAAqBvgC,OAAQ,CAIrF,KAAMsC,aAH0Bg+B,gBAAgBC,qBAAqBz8B,IAAI,SAAUd,GAC/E,MAAO,yCAA2CA,EAAErD,KAAO,OAASqD,EAAE8C,SAAW,SAAW9C,EAAErD,KAAO,gCAE9EoE,KAAK,OAEpC,MAAOu8B,iBASX,QAASH,uCAAsCL,UAAWC,KAAMC,qBAAsBC,kBAClF,GAAqBO,WAAY,GAAIpe,KAChBqe,SACAC,UAAY,SAAU3gB,UACvC,GAAIygB,UAAUtO,IAAInS,YAAcggB,KAAKY,aAAa5gB,UAC9C,OAAO,CAEXygB,WAAU/F,IAAI1a,SACd,IAAqB6gB,cAAeC,YAAYd,KAAMC,qBAAsBC,iBAAkBlgB,SAC9F0gB,OAAMx7B,KAAK27B,cACXA,aAAaE,UAAU/7B,QAAQ,SAAUg8B,UACrCA,SAASlF,iBAAiBmF,QAAQj8B,QAAQ,SAAUk8B,SAAW,MAAOP,WAAUO,QAAQz7B,UAAUM,cAI1G,OADAg6B,WAAU/6B,QAAQ,SAAUgb,UAAY,MAAO2gB,WAAU3gB,YAClD0gB,MASX,QAASI,aAAYd,KAAMC,qBAAsBC,iBAAkBlgB,UAC/D,GAAqB6G,eACAsa,SACAC,eACAL,aACAM,cAAgBpB,qBAAqBoB,cAAcrhB,UACnDshB,uBAAwB,CAyC7C,OAnCKthB,UAASL,SAAS,WAAY0hB,eAC/BpB,qBAAqBsB,aAAavhB,UAAUhb,QAAQ,SAAUg4B,QAC1D,GAAqBU,gBAAiBuC,qBAAqBuB,cAAcxE,QACpDyE,WAAa/D,eAAeZ,QACjD,IAAK2E,YAAwC,UAA1BA,WAAW1E,WAA9B,CAGA,GAAqB2E,aAAa,CAClC,IAA8B,UAA1BD,WAAW1E,WACX,GAAImD,iBAAiByB,YAAY3E,QAC7B0E,YAAa,EACb7a,WAAW3hB,KAAK83B,YAEf,IAAIkD,iBAAiB0B,OAAO5E,QAC7B0E,YAAa,EACbP,MAAMj8B,KAAK83B,YAEV,IAAIkD,iBAAiB2B,WAAW7E,QAAS,CAC1C,GAAqBgE,UAAWd,iBAAiB4B,oBAAoB9E,QAAQ,EACzEgE,YACAU,YAAa,EACbX,UAAU77B,KAAK87B,eAGdd,kBAAiB6B,aAAa/E,UACnC0E,YAAa,EACbN,YAAYl8B,KAAK83B,QAGpB0E,cACDJ,sBACIA,uBAAyBU,8BAA8BhC,KAAMyB,iBAKzEzhB,SAAUA,SAAU6G,WAAYA,WAAYsa,MAAOA,MAAOJ,UAAWA,UAAWK,YAAaA,YAAaE,sBAAuBA,uBAQzI,QAASU,+BAA8BhC,KAAMlD,UACzC,GAAqBwE,wBAAwB,CA6D7C,OADA9/B,YAAWs7B,SAAU,IA3DQ,WACzB,QAASmF,YAwDT,MAjDAA,SAAQvjC,UAAUoD,WAKlB,SAAUqL,IAAKxL,SACX,GAAIugC,OAAQ/jC,IACZgP,KAAInI,QAAQ,SAAUm9B,GAAK,MAAO3gC,YAAW2gC,EAAGD,MAAOvgC,YAO3DsgC,QAAQvjC,UAAUsD,eAKlB,SAAU+B,IAAKpC,SACX,GAAIugC,OAAQ/jC,IACZQ,QAAOy2B,KAAKrxB,KAAKiB,QAAQ,SAAUoN,KAAO,MAAO5Q,YAAWuC,IAAIqO,KAAM8vB,MAAOvgC,YAOjFsgC,QAAQvjC,UAAUuD,eAKlB,SAAUR,MAAOE,WAMjBsgC,QAAQvjC,UAAUwD,WAKlB,SAAUT,MAAOE,SACTF,gBAAiBkE,gBAAiBq6B,KAAKY,aAAan/B,MAAMsE,YAC1Du7B,uBAAwB,IAGzBW,YAEyB,MAC7BX,sBAMX,QAASnB,oBAAmBiC,eACxB,GAAqBC,iBACAC,0BAA4B,GAAItb,KAChCub,sBAAwB,GAAIlgB,IACjD+f,eAAcp9B,QAAQ,SAAUw9B,IAC5BA,GAAGzB,UAAU/7B,QAAQ,SAAUg8B,UAC3BqB,aAAan9B,KAAK87B,UAClBA,SAASyB,mBAAmBz9B,QAAQ,SAAU3G,GAAK,MAAOikC,2BAA0B3jB,IAAItgB,EAAEoH,UAAWu7B,YACrGA,SAAS0B,cAAc19B,QAAQ,SAAU4X,GAAK,MAAO0lB,2BAA0B3jB,IAAI/B,EAAEnX,UAAWu7B,cAEpGwB,GAAG3b,WAAW7hB,QAAQ,SAAU3G,GAAK,MAAOkkC,uBAAsB7H,IAAIr8B,KACtEmkC,GAAGrB,MAAMn8B,QAAQ,SAAU4X,GAAK,MAAO2lB,uBAAsB7H,IAAI9d,MAErE,IAAqB4jB,wBAMrB,OALA+B,uBAAsBv9B,QAAQ,SAAUU,KAC/B48B,0BAA0BnQ,IAAIzsB,MAC/B86B,qBAAqBt7B,KAAKQ,QAI9Bq7B,UAAWsB,aACXC,0BAA2BA,0BAC3B9B,qBAAsBA,qBACtBE,MAAO0B,eAOf,QAASO,yBAAwBjC,OAC7B,MAAOJ,yBAAwBH,mBAAmBO,QA2BtD,QAASkC,WAAUC,OACf,GAAIA,OAAS,EACT,MAAO,EACX,IAAIA,MAAQ,EACR,OAAQ,GAAI,IAAK,KAAM,MAAO,OAAQ,SAASA,MACnD,IAAqBC,MAAOF,UAAU7nB,KAAKgoB,MAAMF,MAAQ,GACzD,OAAOC,MAAOA,MAAQD,MAAQ,GAAM,EAAI,IAAM,IAOlD,QAASG,aAAYC,MAAOC,QAExB,OADe,KAAXA,SAAqBA,OAAS,IAC7BD,MACD,MAAO,EACX,IAAqBv6B,UAAWu6B,MAAMv6B,SAClCu6B,MAAMv6B,SAASsX,SAAW,KAAOijB,MAAMv6B,SAASy6B,KAAO,GAAK,KAAOF,MAAMv6B,SAAS06B,OAAS,GAAK,IAChG,GACiBn4B,OAASvC,UAAuB,IAAXw6B,OAAex6B,SAAW,KAAO,GACtD26B,QAAU36B,UAAuB,IAAXw6B,OAAe,OAASx6B,SAAW,GACzD2G,QAAU,GAAKpE,OAASg4B,MAAM5zB,QAAUg0B,OAC7D,OAAO,GAAKT,UAAUM,QAAU7zB,SAAY4zB,MAAMK,MAAS,KAAON,YAAYC,MAAMK,KAAMJ,OAAS,IAAQ,IAM/G,QAASK,gBAAeN,OACpB,GAAqB5zB,SAAU2zB,YAAYC,OAAS,IAC/BvgC,MAA0BH,YAAY8M,QAI3D,OAHA,OAA2Bm0B,oBAAqB,EAChD9gC,MAAMugC,MAAQA,MACdvgC,MAAMgG,SAAWu6B,MAAMv6B,SAChBhG,MAMX,QAAS+gC,kBAAiB/gC,OACtB,QAAS,MAA2B8gC,mBA6BxC,QAASE,cAAajiC,OAClB,MAAOA,QAA6B,UAApBA,MAAMs7B,WA87B1B,QAAS4G,eAAct0B,QAASuuB,QAASgG,OAAQl7B,SAAUs0B,OAAQr7B,QAASshC,OACxE,GAAqBvgC,OAA0BH,YAAY8M,QAc3D,OAbA,OAA2Bw0B,iBAAkB,EACzCD,SACAlhC,MAAMkhC,OAASA,QACfl7B,WACAhG,MAAMgG,SAAWA,UACjBk1B,UACAl7B,MAAMk7B,QAAUA,SAChBj8B,UACAe,MAAMf,QAAUA,SAChBshC,QACAvgC,MAAMugC,MAAQA,OACdjG,SACAt6B,MAAMs6B,OAASA,QACZt6B,MAMX,QAASohC,iBAAgBphC,OACrB,QAAS,MAA2BmhC,gBAcxC,QAASE,iBAAgB10B,QAAS1N,SAC9B,OAAQ0N,SACJ,IAAK20B,gCACD,GAAIriC,SAAWA,QAAQ8xB,UACnB,MAAO,0EAA4E9xB,QAAQ8xB,UAAY,kBAE3G,MACJ,KAAKwQ,0BACD,MAAO,gJACX,KAAKC,2BACD,MAAO,4IACX,KAAKC,wBACD,GAAIxiC,SAAWA,QAAQyiC,SACnB,MAAO,0BAA4BziC,QAAQyiC,QAE/C,MACJ,KAAKC,6BACD,MAAI1iC,UAAWA,QAAQ/B,KACZ,uDAAyD+B,QAAQ/B,KAAO,eAE5E,gDACX,KAAK0kC,2BACD,GAAI3iC,SAAWA,QAAQ/B,KACnB,MAAO,oFAAsF+B,QAAQ/B,KAAO,kBAEhH,MACJ,KAAK2kC,sBACD,MAAO,uDAEf,MAAOl1B,SAOX,QAASm1B,eAAcn1B,QAAS1N,SAC5B,OAAQ0N,SACJ,IAAK20B,gCACD,GAAIriC,SAAWA,QAAQ8xB,UACnB,MAAO,uBAAyB9xB,QAAQ8xB,UAAY,GAExD,MACJ,KAAKyQ,2BACD,MAAO,6CACX,KAAKI,2BACD,GAAI3iC,SAAWA,QAAQ/B,KACnB,MAAO,uBAAyB+B,QAAQ/B,KAAO,GAEnD,MACJ,KAAK2kC,sBACD,MAAO,uEAQnB,QAASE,cAAa/hC,OAClB,GAAIA,MAAMk7B,QACN,MAAOl7B,OAAMk7B,OAEjB,QAAQl7B,MAAM2M,SACV,IAAK20B,gCACD,GAAIthC,MAAMf,SAAWe,MAAMf,QAAQ8xB,UAC/B,MAAO,iCAAmC/wB,MAAMf,QAAQ8xB,SAE5D,MACJ,KAAKwQ,0BACD,MAAO,oBACX,KAAKC,2BACD,MAAO,4BACX,KAAKC,wBACD,MAAO,uBACX,KAAKE,6BACD,MAAI3hC,OAAMf,SAAWe,MAAMf,QAAQ/B,KACxB,UAAY8C,MAAMf,QAAQ/B,KAAO,IAErC,kBACX,KAAK0kC,2BACD,MAAI5hC,OAAMf,SAAWe,MAAMf,QAAQ/B,KACxB,6BAA+B8C,MAAMf,QAAQ/B,KAEjD,8BAEf,MAAO,qBAOX,QAAS8kC,cAAahkC,MAAOikC,WACzB,IAAKjkC,MACD,QACJ,IAAqBmE,UAYrB,OAXAlG,QAAOy2B,KAAK10B,OAAOsE,QAAQ,SAAUoN,KACjC,GAAqB3Q,OAAQkjC,UAAUjkC,MAAM0R,KAAMA,IAC9CsxB,cAAajiC,SACVmjC,WAAWp7B,KAAK4I,KAChBzT,OAAO4f,eAAe1Z,OAAQuN,KAAOqM,YAAY,EAAOD,cAAc,EAAM/c,MAAOA,QAGnFoD,OAAOuN,KAAO3Q,SAInBoD,OAMX,QAASggC,aAAYC,GACjB,MAAa,QAANA,GAA4B,kBAANA,IAAiC,gBAANA,GAuD5D,QAASC,4BAA2B9B,MAAOW,QAQvC,OAASv0B,QAPuB00B,gBAAgBd,MAAM5zB,QAAS4zB,MAAMthC,UACtCshC,MAAMjG,OAAS,QAAUiG,MAAMjG,OAAOp9B,KAAO,IAAM,IAMvD8I,SAJKu6B,MAAMv6B,SAIS46B,KAHnBL,MAAMK,KAC9ByB,2BAA2B9B,MAAMK,KAAMM,QACvCA,QAAWv0B,QAASu0B,YAAWvhC,IAQvC,QAAS2iC,qBAAoBvtB,EAAG9V,SAC5B,GAAImiC,gBAAgBrsB,GAAI,CAGpB,GAAqB/O,UAAW+O,EAAE/O,QAOlC,OAAO66B,gBAAewB,4BALlB11B,QAAS,qCAAuC1N,QAAQ/B,KAAO,IAC/D8I,SAAUA,SACV46B,MAAQj0B,QAASoI,EAAEpI,QAASi0B,KAAM7rB,EAAEwrB,MAAOthC,QAAS8V,EAAE9V,QAASq7B,OAAQvlB,EAAEulB,SAE/CvlB,EAAEmsB,QAAUY,cAAc/sB,EAAEpI,QAASoI,EAAE9V,WAGzE,MAAO8V;;;;;;;AAgMX,QAASwtB,sBAAqBjF,MAC1B,OACI31B,QAAS,SAAU66B,SAAUj+B,KACzB,GAAqBlB,UAAWi6B,KAAKmF,uBAAuBl+B,IAAKi+B,SACjE,KAAKn/B,SACD,KAAMxD,aAAY,6BAA+B0E,IAAM,SAAWi+B,SAEtE,OAAOn/B,YAWnB,QAASq/B,mBAAkBC,aAAcC,QAASC,gBAC9C,GAAqBlpB,cAAeipB,QAAQjpB,cAAgB,GACvCmpB,YAAcP,qBAAqBI,cACnChH,YAAc,GAAIoH,mBAClBrI,gBAAkB,GAAIsI,oBAAmBL,aAAchH,aACvDhB,eAAiB,GAAIsI,sBAAqBN,aAAchH,YAAajB,iBACrEwI,gBAAkB,GAAIC,iBAAgBzI,gBAAiBC,qBAAwBkI,gBAC/EO,WAAa,GAAIC,gBAAe,GAAIC,YAAc3pB,aAAcipB,QAAQW,WAAYX,QAAQY,mBAAoBC,SAChH7yB,OAAS,GAAI8yB,iBAC9BC,qBAAsBC,kBAAkBC,SACxCC,QAAQ,EACRpS,sBAAuD,IAAjCkR,QAAQlR,qBAC9B8R,mBAAoBZ,QAAQY,mBAC5BO,oBAAqBnB,QAAQmB,oBAC7BC,0BAA2BpB,QAAQoB,4BAElBC,WAAa,GAAIC,sBAAsBloB,IAAK,SAAUzX,KAAO,MAAOo+B,cAAawB,aAAa5/B,OAAWu+B,YAAaM,WAAYxyB,QAClIwzB,iBAAmB,GAAIC,QAAO,GAAIC,QAClCC,sBAAwB,GAAIC,0BAC5BC,WAAa,GAAIC,gBAAe9zB,OAAQsyB,gBAAiBkB,iBAAkBG,sBAAuBnB,WAAYK,YAC9Gr8B,SAAW,GAAIu9B,yBAAwB/zB,OAAQwyB,WAAY,GAAIwB,kBAAiB1B,iBAAkB,GAAI2B,mBAAkB3B,iBAAkB,GAAI4B,cAAa5B,iBAAkBxI,gBAAiB6J,sBAAuBN,WAAYR,QAAS9H,YAAauH,gBAAiBL,gBAExQkC,aAAe,GAAIC,cAAa9B,iBAChC+B,kBAAoB,GAAIC,mBAAkBtC,QAASM,gBAExE,QAAS1nC,SADuB,GAAI2pC,aAAYv0B,OAAQgyB,QAASD,aAAcO,gBAAiB97B,SAAUq9B,WAAY,GAAIW,eAActC,aAAciC,aAAcE,kBAAmB,GAAII,kBAAiBnC,iBAAkB,GAAIlK,mBAAqB0B,gBAAiBC,gBAC3Ovc,UAAW8kB;;;;;;;AAkH5C,QAASoC,qBAAoBxQ,WAAY1W,WACrC,GAAqB8H,KAAM,GAAIqf,mBAAkB,KAAM,KAAM,KAAM,GAAIjhB,KACxC,IAAIkhB,sBAAqBpnB,WAChDyC,mBAAmBiU,WAAY5O,IACvC,IAAqB/jB,UAErB,OADA+jB,KAAI/qB,QAAQmH,QAAQ,SAAUmjC,YAActjC,OAAOsjC,YAAcvf,IAAIwf,KAAK1pB,IAAIypB,cACvEtjC,OAUX,QAASwjC,4BAA2B7kB,SAAU8kB,UAAW9Q,WAAY5O,IAAKlnB,SAEtE,IAAK,GADgB6mC,UAAW3f,IAAI4f,2BACVt/B,EAAI,EAAGA,EAAIsa,SAASvjB,OAAQiJ,IAClDq/B,SAASH,KAAKzpB,IAAI6E,SAASta,GAAIo/B,UAAUp/B,GAE7C,IAAqBrE,QAASnD,QAAQ6hB,mBAAmBiU,WAAY+Q,SACrE,OAAO1jC,QAASA,OAAOpD,MAAQ,KAiCnC,QAASgnC,oBAAmBC,WAAYC,KAAMjrB,UAC1C,GAAqBkrB,uBACrBF,YAAWG,QAAQ7jC,QAAQ,SAAU8jC,QAEjCF,oBAAoBE,OAAOlpC,OACvB4e,cAAc,EACdE,IAAK,WACD,GAAqBqqB,aAAc,GAAId,mBAAkBU,KAAMxqC,KAAMuqC,WAAW9oC,KAAM+oC,KAAKP,KAC3F,OAAOC,kCAAmCS,OAAOrjB,KAAMsjB,YAAarrB,cAIhFgrB,WAAWM,QAAQhkC,QAAQ,SAAUikC,QACjC,GAAqBC,YAAaD,OAAOzjB,OAAOzhB,IAAI,SAAUolC,OAAS,MAAOA,OAAMvpC,MAEpFgpC,qBAAuCK,OAAY,OAC/CG,UAAU,EACV5qB,cAAc,EACd/c,MAAO,WAEH,IAAK,GADD3B,SACKC,GAAK,EAAGA,GAAKC,UAAUC,OAAQF,KACpCD,KAAKC,IAAMC,UAAUD,GAEzB,IAAqBgpC,aAAc,GAAId,mBAAkBU,KAAMxqC,KAAMuqC,WAAW9oC,KAAM+oC,KAAKP,KAC3F,OAAOC,4BAA2Ba,WAAYppC,KAAMmpC,OAAOxjB,KAAMsjB,YAAarrB,aAI1F,IAAqB2rB,gBAAiBX,WAAWY,kBAAkB9jB,OAAOzhB,IAAI,SAAUolC,OAAS,MAAOA,OAAMvpC,OAEzF2pC,KAAO,WAGxB,IAAK,GAFDrH,OAAQ/jC,KACR2B,QACKC,GAAK,EAAGA,GAAKC,UAAUC,OAAQF,KACpCD,KAAKC,IAAMC,UAAUD,GAEzB,IAAqBgpC,aAAc,GAAId,mBAAkBU,KAAMxqC,KAAMuqC,WAAW9oC,KAAM+oC,KAAKP,KAC3FM,YAAWc,OAAOxkC,QAAQ,SAAUykC,OAASvH,MAAMuH,MAAM7pC,UAAQyC,KACjEgmC,2BAA2BgB,eAAgBvpC,KAAM4oC,WAAWY,kBAAkB7jB,KAAMsjB,YAAarrB,WAEhFgsB,WAAahB,WAAWiB,OAASjB,WAAWiB,OAAOxlB,gBAAgBzG,SAAUirB,MAAQhqC,MAE1G,OADA4qC,MAAK7qC,UAAYC,OAAOC,OAAO8qC,WAAWhrC,UAAWkqC,qBAC9CW,KAwkBX,QAASK,YAAWpmB,SAAUgU,WAAY5O,IAAKlnB,SAC3C,MAAO,YAEH,IAAK,GADD5B,SACKC,GAAK,EAAGA,GAAKC,UAAUC,OAAQF,KACpCD,KAAKC,IAAMC,UAAUD,GAEzB,OAAOsoC,4BAA2B7kB,SAAU1jB,KAAM03B,WAAY5O,IAAKlnB;;;;;;;AAmU3E,QAASmoC,gBAAeC,UAAWlhB,IAAKwf,KAAM2B,iBAC1C,GAAqBC,QAASphB,IAAIuE,WAAa,mBAAqB2c,UAC/CG,cACAC,cACrB,KAAK,GAAqBC,WAAW/B,MACjC6B,WAAW/kC,KAAKilC,SAChBD,YAAYhlC,KAAKkjC,KAAK+B,SAE1B,IAAIJ,gBAAiB,CAMjB,GAAqBK,UAAU,IAAKC,SAASC,KAAKnqC,MAAMkqC,cAAW,IAAQtjC,OAAOkjC,WAAWljC,OAAO,oBAAqB5C,WACpGomC,YAAcH,QAAQ9oC,MAAM,EAAG8oC,QAAQ/oC,QAAQ,iBAAiBsG,MAAM,MAAM1H,OAAS,CAC1G+pC,SAAU,KAAOphB,IAAI4hB,qBAAqBV,UAAWS,aAAaE,cAEtE,OAAO,IAAKJ,SAASC,KAAKnqC,MAAMkqC,cAAW,IAAQtjC,OAAOkjC,WAAWljC,OAAOijC,YAAa7pC,UAAM,GAAQ+pC,aAS3G,QAASQ,eAAcZ,UAAWtS,WAAY1W,UAAW6pB,kBACrD,GAAqBhe,WAAY,GAAIie,mBAAkB9pB,WAClC8H,IAAMiE,sBAAsBC,YAGjD,OAFAH,WAAUpJ,mBAAmBiU,WAAY5O,KACzC+D,UAAUke,iBAAiBjiB,KACpBihB,eAAeC,UAAWlhB,IAAK+D,UAAUme,UAAWH,kBA8mB/D,QAASI,iBAAgBvjC,MACrB,IAAKA,KAAK2f,YACN,KAAM,IAAIxkB,OAAM,sBAAwB4C,eAAeiC,KAAKjD,MAAQ,oCAM5E,QAASymC,uBAIL,OAASxT,cAAgByT,YAAa,GAAI3mB,WAHL,SAAU0Y,QAC3C,MAAO1Y,aAAa1kB,KAAM2F,eAAey3B,QAASN,WAAY,KAAMwO,QAASlO;;;;;;;AAyCrF,QAASmO,yCACL,MAAO,IAAIC,aAKf,QAASC,mCACL,MAAO,IAAID,aAAY,KAgE3B,QAASE,cAAarkC,KAClB,GAAqB0C,OAAQ4hC,OAAOtkC,IACpC,OAAQ0C,QAASA,MAAM6hC,gBAAgBC,SAAY,GAmBvD,QAASC,wBAAuBC,WAAYC,aAAcC,WAAYC,SAAUC,SAAUC,cAAeC,cACrG,GAAqBhqB,OAuBrB,OAtBkB,OAAd0pB,YACA1pB,IAAI/c,KAAKymC,WAAa,KAER,MAAdE,aACA5pB,IAAI/c,KAAK,MACW,MAAhB0mC,cACA3pB,IAAI/c,KAAK0mC,aAAe,KAE5B3pB,IAAI/c,KAAK2mC,YACO,MAAZC,UACA7pB,IAAI/c,KAAK,IAAM4mC,WAGP,MAAZC,UACA9pB,IAAI/c,KAAK6mC,UAEQ,MAAjBC,eACA/pB,IAAI/c,KAAK,IAAM8mC,eAEC,MAAhBC,cACAhqB,IAAI/c,KAAK,IAAM+mC,cAEZhqB,IAAIje,KAAK,IA4GpB,QAASunC,QAAOW,KACZ,MAA0BA,KAAIviC,MAAMwiC,UASxC,QAASC,oBAAmBzjC,MACxB,GAAY,KAARA,KACA,MAAO,GAMX,KAAK,GALgB0jC,cAA0B,KAAX1jC,KAAK,GAAY,IAAM,GACtC2jC,cAA0C,MAA1B3jC,KAAKA,KAAK1I,OAAS,GAAa,IAAM,GACtDssC,SAAW5jC,KAAKhB,MAAM,KACtBsa,OACAuqB,GAAK,EACAC,IAAM,EAAGA,IAAMF,SAAStsC,OAAQwsC,MAAO,CAC7D,GAAqBC,SAAUH,SAASE,IACxC,QAAQC,SACJ,IAAK,GACL,IAAK,IACD,KACJ,KAAK,KACGzqB,IAAIhiB,OAAS,EACbgiB,IAAI0qB,MAGJH,IAEJ,MACJ,SACIvqB,IAAI/c,KAAKwnC,UAGrB,GAAoB,IAAhBL,aAAoB,CACpB,KAAOG,MAAO,GACVvqB,IAAIwV,QAAQ,KAEG,KAAfxV,IAAIhiB,QACJgiB,IAAI/c,KAAK,KAEjB,MAAOmnC,cAAepqB,IAAIje,KAAK,KAAOsoC,cAQ1C,QAASM,0BAAyBz2B,OAC9B,GAAqBxN,MAAOwN,MAAMq1B,gBAAgBqB,KAGlD,OAFAlkC,MAAe,MAARA,KAAe,GAAKyjC,mBAAmBzjC,MAC9CwN,MAAMq1B,gBAAgBqB,MAAQlkC,KACvB+iC,uBAAuBv1B,MAAMq1B,gBAAgBC,QAASt1B,MAAMq1B,gBAAgBsB,UAAW32B,MAAMq1B,gBAAgBuB,QAAS52B,MAAMq1B,gBAAgBwB,MAAOrkC,KAAMwN,MAAMq1B,gBAAgByB,WAAY92B,MAAMq1B,gBAAgB0B,WAQ5N,QAASC,aAAYnqB,KAAM/b,KACvB,GAAqBkP,OAAQo1B,OAAO6B,UAAUnmC,MACzBomC,UAAY9B,OAAOvoB,KACxC,IAAqC,MAAjC7M,MAAMq1B,gBAAgBC,QACtB,MAAOmB,0BAAyBz2B,MAGhCA,OAAMq1B,gBAAgBC,QAAU4B,UAAU7B,gBAAgBC,OAE9D,KAAK,GAAqBviC,GAAIsiC,gBAAgBC,OAAQviC,GAAKsiC,gBAAgBwB,KAAM9jC,IAC7D,MAAZiN,MAAMjN,KACNiN,MAAMjN,GAAKmkC,UAAUnkC,GAG7B,IAAsC,KAAlCiN,MAAMq1B,gBAAgBqB,MAAM,GAC5B,MAAOD,0BAAyBz2B,MAEpC,IAAqBxN,MAAO0kC,UAAU7B,gBAAgBqB,KAC1C,OAARlkC,OACAA,KAAO,IACX,IAAqBpF,OAAQoF,KAAKkX,YAAY,IAG9C,OAFAlX,MAAOA,KAAKtE,UAAU,EAAGd,MAAQ,GAAK4S,MAAMq1B,gBAAgBqB,MAC5D12B,MAAMq1B,gBAAgBqB,MAAQlkC,KACvBikC,yBAAyBz2B,OArxkCpC,GAAI1X,eAAgBE,OAAO2uC,iBACpBC,uBAA2B3rC,QAAS,SAAUvD,EAAGC,GAAKD,EAAEkvC,UAAYjvC,IACvE,SAAUD,EAAGC,GAAK,IAAK,GAAIse,KAAKte,GAAOA,EAAEkG,eAAeoY,KAAIve,EAAEue,GAAKte,EAAEse,KAQrExc,SAAWzB,OAAO6uC,QAAU,SAAkBC,GAC9C,IAAK,GAAIxqC,GAAGiG,EAAI,EAAGgG,EAAIlP,UAAUC,OAAQiJ,EAAIgG,EAAGhG,IAAK,CACjDjG,EAAIjD,UAAUkJ,EACd,KAAK,GAAI0T,KAAK3Z,GAAOtE,OAAOD,UAAU8F,eAAekpC,KAAKzqC,EAAG2Z,KAAI6wB,EAAE7wB,GAAK3Z,EAAE2Z,IAE9E,MAAO6wB,IA4BPE,aAAehuC,oBAAoB,SAAU,SAAUmE,OAAS,OAAUA,MAAOA,SACjF8pC,qBAAuBjuC,oBAAoB,iBAAkB,SAAUkuC,MAAQ,OAAUC,MAAOD,QAKhGE,gBAAkBpuC,oBAAoB,YAAa,SAAUquC,eAAiB,OAAUA,cAAeA,iBAKvGC,sBAAwBtuC,oBAAoB,kBAAmB,SAAU2uB,SAAU4f,MAEnF,WADa,KAATA,OAAmBA,SACf9tC,UAAWkuB,SAAUA,SAAU6f,OAAO,EAAOC,aAAa,EAAOC,aAAa,GAASH,QAE/FI,mBAAqB3uC,oBAAoB,eAAgB,SAAU2uB,SAAU4f,MAE7E,WADa,KAATA,OAAmBA,SACf9tC,UAAWkuB,SAAUA,SAAU6f,OAAO,EAAMC,aAAa,EAAOC,aAAa,GAAQH,QAE7FK,mBAAqB5uC,oBAAoB,eAAgB,SAAU2uB,SAAU4f,MAE7E,WADa,KAATA,OAAmBA,SACf9tC,UAAWkuB,SAAUA,SAAU6f,OAAO,EAAOC,aAAa,EAAMC,aAAa,GAAQH,QAE7FM,gBAAkB7uC,oBAAoB,YAAa,SAAU2uB,SAAU4f,MACvE,MAAQ9tC,WAAWkuB,SAAUA,SAAU6f,OAAO,EAAMC,aAAa,EAAMC,aAAa,GAAQH,QAM5FlhC,gBAAkBrN,oBAAoB,YAAa,SAAU0nB,KAE7D,WADY,KAARA,MAAkBA,QACfA,MAOPif,mBACAC,SAAU,EACVkI,OAAQ,EACRC,KAAM,EAEVpI,mBAAkBA,kBAAkBC,UAAY,WAChDD,kBAAkBA,kBAAkBmI,QAAU,SAC9CnI,kBAAkBA,kBAAkBoI,MAAQ,MAE5C,IAAIC,0BACAC,OAAQ,EACRC,QAAS,EAEbF,yBAAwBA,wBAAwBC,QAAU,SAC1DD,wBAAwBA,wBAAwBE,SAAW,SAC3D,IAAI5hC,iBAAkBtN,oBAAoB,YAAa,SAAU6X,GAE7D,WADU,KAANA,IAAgBA,MACZpX,UAAW0uC,gBAAiBH,wBAAwBE,SAAWr3B,KAMvEu3B,WAAapvC,oBAAoB,OAAQ,SAAUid,GAAK,MAAQxc,WAAW4uC,MAAM,GAAQpyB,KAKzFqyB,YAActvC,oBAAoB,QAAS,SAAUuvC,qBAAuB,OAAUA,oBAAqBA,uBAK3GC,aAAexvC,oBAAoB,SAAU,SAAUuvC,qBAAuB,OAAUA,oBAAqBA,uBAK7GE,kBAAoBzvC,oBAAoB,cAAe,SAAU0vC,kBAAoB,OAAUA,iBAAkBA,oBAKjHC,mBAAqB3vC,oBAAoB,eAAgB,SAAU4vC,UAAWzvC,MAAQ,OAAUyvC,UAAWA,UAAWzvC,KAAMA,QAK5H0vC,eAAiB7vC,oBAAoB,WAAY,SAAUqhC,UAAY,MAAOA,YAS9EyO,wBACA7vC,KAAM,mBAEN8vC,kBACA9vC,KAAM,oBAEN+vC,eAAiBhwC,oBAAoB,YACrCiwC,iBAAmBjwC,oBAAoB,cACvCkwC,WAAalwC,oBAAoB,QACjCmwC,eAAiBnwC,oBAAoB,YACrCowC,WAAapwC,oBAAoB,QACjC6iB,KAAO6nB,SAEPhY,iBACAC,KAAM,EACN0d,KAAM,EACNxjC,MAAO,EACPE,OAAQ,EACRujC,IAAK,EACLC,aAAc,EAElB7d,iBAAgBA,gBAAgBC,MAAQ,OACxCD,gBAAgBA,gBAAgB2d,MAAQ,OACxC3d,gBAAgBA,gBAAgB7lB,OAAS,QACzC6lB,gBAAgBA,gBAAgB3lB,QAAU,SAC1C2lB,gBAAgBA,gBAAgB4d,KAAO,MACvC5d,gBAAgBA,gBAAgB6d,cAAgB,cAEhD,IAAIC,YACAzB,KAAM,EACN0B,YAAa,EACbC,SAAU,EACVC,kBAAmB,EACnBC,cAAe,EACfC,cAAe,EACfC,SAAU,GACVC,cAAe,GACfC,eAAgB,GAChBC,aAAc,IACdC,kBAAmB,IACnBC,kBAAmB,IACnBC,kBAAmB,IACnBC,oBAAqB,KACrBC,wBAAyB,KACzBC,aAAc,KACdC,gBAAiB,KACjBC,cAAe,MACfnyC,UAAW,MACXoyC,uBAAwB,KACxBC,YAAa,MACb/vB,OAAQ,MACRC,UAAW,OACXC,QAAS,OACTC,UAAW,OACXC,iBAAkB,QAClBC,oBAAqB,QACrBC,cAAe,QACfC,iBAAkB,QAClByvB,cAAe,SACfC,cAAe,SACfC,iBAAkB,SAClBC,cAAe,UACfC,YAAa,UACbC,aAAc,UACdC,SAAU,UAEVC,MAAO,WAGPC,UACArD,KAAM,EACNsD,SAAU,EACVC,SAAU,EACVC,MAAO,GAGPC,cAAiBC,OAAQ,EAAGC,QAAS,GAErCC,cACAC,qBAAsB,EACtBC,iBAAkB,EAClBC,iBAAkB,EAClBC,aAAc,EACdC,kBAAmB,GACnBC,sBAAuB,GACvBC,qBAAsB,GAEtBf,MAAO,IAGPgB,kBAAqBC,MAAO,EAAGC,IAAK,GAEpCC,gBACAC,WAAY,EACZC,cAAe,EACfC,YAAa,EACbC,iBAAkB,EAClBC,SAAU,GAGVC,WACA7E,KAAM,EACNE,OAAQ,GAGR4E,4BACA7wC,MAAO,EACP8wC,QAAS,EACTC,OAAQ,EAEZF,4BAA2BA,2BAA2B7wC,OAAS,QAC/D6wC,2BAA2BA,2BAA2BC,SAAW,UACjED,2BAA2BA,2BAA2BE,QAAU,QAgChE,IAAIC,MAAOh1C,OAAOi1C,QACjB/0C,OAAQA,OACR8uC,aAAcA,aACdC,qBAAsBA,qBACtB9uC,UAAWA,UACXivC,gBAAiBA,gBACjBhvC,MAAOA,MACPkvC,sBAAuBA,sBACvBK,mBAAoBA,mBACpBC,mBAAoBA,mBACpBC,gBAAiBA,gBACjBxvC,UAAWA,UACXgO,gBAAiBA,gBACjB/N,UAAWA,UACXqnC,kBAAmBA,kBACnBqI,wBAAyBA,wBACzB1hC,gBAAiBA,gBACjB/N,KAAMA,KACN6vC,WAAYA,WACZ5vC,MAAOA,MACP8vC,YAAaA,YACb7vC,OAAQA,OACR+vC,aAAcA,aACd9vC,YAAaA,YACb+vC,kBAAmBA,kBACnB9vC,aAAcA,aACdgwC,mBAAoBA,mBACpB/vC,SAAUA,SACViwC,eAAgBA,eAChBhwC,oBAAqBA,oBACrBC,eAAgBA,eAChBgwC,uBAAwBA,uBACxBC,iBAAkBA,iBAClBC,eAAgBA,eAChBC,iBAAkBA,iBAClBC,WAAYA,WACZC,eAAgBA,eAChBC,WAAYA,WACZvtB,KAAMA,KACN6P,gBAAiBA,gBACjB8d,UAAWA,UACX4B,SAAUA,SACVI,aAAcA,aACdG,aAAcA,aACdQ,iBAAkBA,iBAClBG,eAAgBA,eAChBM,UAAWA,UACXC,2BAA4BA,2BAC5B9zC,gBAAiBA,gBACjBc,MAAOA,QAcJI,iBAAmB,gBAgFnBizC,iBAAkC,WAClC,QAASA,qBAsDT,MA/CAA,kBAAiBn1C,UAAUoD,WAK3B,SAAUqL,IAAKxL,SACX,GAAIugC,OAAQ/jC,IACZ,OAAOgP,KAAIpJ,IAAI,SAAUtC,OAAS,MAAOD,YAAWC,MAAOygC,MAAOvgC,YAOtEkyC,iBAAiBn1C,UAAUsD,eAK3B,SAAU+B,IAAKpC,SACX,GAAIugC,OAAQ/jC,KACS0G,SAErB,OADAlG,QAAOy2B,KAAKrxB,KAAKiB,QAAQ,SAAUoN,KAAOvN,OAAOuN,KAAO5Q,WAAWuC,IAAIqO,KAAM8vB,MAAOvgC,WAC7EkD,QAOXgvC,iBAAiBn1C,UAAUuD,eAK3B,SAAUR,MAAOE,SAAW,MAAOF,QAMnCoyC,iBAAiBn1C,UAAUwD,WAK3B,SAAUT,MAAOE,SAAW,MAAOF,QAC5BoyC,oBAEPC,WACAC,WAAY,SAAUtyC,OAClB,GAAIgD,UAAUhD,OACV,KAAM,IAAIkB,OAAM,2CAEpB,OAAOlB,QAEXiD,KAAM,SAAUjD,MAAOuyC,IAAM,MAAOvvC,WAAUhD,OAASA,MAAMiD,KAAKsvC,IAAMA,GAAGvyC,QAC3EwyC,IAAK,SAAUC,iBACX,MAAOA,iBAAgBvkB,KAAKlrB,WAAa0vC,QAAQF,IAAIC,iBAAoC,kBAe7FtxC,mBAAqB,gBACrBC,mBAAqB,gBAsBrBM,iBAAmBxE,OAAOuE,mBA8F1BkxC,QAAyB,WACzB,QAASA,SAAQC,MACbl2C,KAAKk2C,KAAOA,IACZ,IAAqBC,QAASD,KAAK1sC,MAAM,IACzCxJ,MAAKo2C,MAAQD,OAAO,GACpBn2C,KAAKq2C,MAAQF,OAAO,GACpBn2C,KAAKs2C,MAAQH,OAAOhzC,MAAM,GAAG0C,KAAK,KAEtC,MAAOowC,YAoBPM,QAAU,GAAIN,SAAQ,qBAqBtBO,QAAyB,WACzB,QAASA,SAAQlzC,MAAOmzC,eAAgBzsC,YACpChK,KAAKsD,MAAQA,MACbtD,KAAKy2C,eAAiBA,eACtBz2C,KAAKgK,WAAaA,WAatB,MANAwsC,SAAQj2C,UAAUoG,MAKlB,SAAUpD,QAASC,SAAW,MAAOD,SAAQmzC,UAAU12C,KAAMwD,UACtDgzC,WAKPG,aAA8B,WAC9B,QAASA,cAAarzC,MAAOmzC,eAAgBzsC,YACzChK,KAAKsD,MAAQA,MACbtD,KAAKy2C,eAAiBA,eACtBz2C,KAAKgK,WAAaA,WAetB,MARA2sC,cAAap2C,UAAUoG,MAKvB,SAAUpD,QAASC,SACf,MAAOD,SAAQqzC,eAAe52C,KAAMwD,UAEjCmzC,gBAKPE,QAAyB,WACzB,QAASA,SAAQp1C,KAAM6B,MAAO0G,YAC1BhK,KAAKyB,KAAOA,KACZzB,KAAKsD,MAAQA,MACbtD,KAAKgK,WAAaA,WAatB,MANA6sC,SAAQt2C,UAAUoG,MAKlB,SAAUpD,QAASC,SAAW,MAAOD,SAAQuzC,UAAU92C,KAAMwD,UACtDqzC,WAMPE,wBAAyC,WACzC,QAASA,yBAAwBt1C,KAAM2E,KAAM6tB,gBAAiB3wB,MAAOw3B,KAAM9wB,YACvEhK,KAAKyB,KAAOA,KACZzB,KAAKoG,KAAOA,KACZpG,KAAKi0B,gBAAkBA,gBACvBj0B,KAAKsD,MAAQA,MACbtD,KAAK86B,KAAOA,KACZ96B,KAAKgK,WAAaA,WAClBhK,KAAK68B,YAAc78B,KAAKoG,OAASq0B,oBAAoBE,UAezD,MARAoc,yBAAwBx2C,UAAUoG,MAKlC,SAAUpD,QAASC,SACf,MAAOD,SAAQyzC,qBAAqBh3C,KAAMwD,UAEvCuzC,2BAMPE,cAA+B,WAC/B,QAASA,eAAcx1C,KAAMoS,OAAQipB,MAAOoa,QAASltC,YACjDhK,KAAKyB,KAAOA,KACZzB,KAAK6T,OAASA,OACd7T,KAAK88B,MAAQA,MACb98B,KAAKk3C,QAAUA,QACfl3C,KAAKgK,WAAaA,WAClBhK,KAAK4M,SAAWqqC,cAAcE,aAAan3C,KAAKyB,KAAMzB,KAAK6T,OAAQ7T,KAAK88B,OACxE98B,KAAK68B,cAAgB78B,KAAK88B,MAsC9B,MA9BAma,eAAcE,aAMd,SAAU11C,KAAMoS,OAAQipB,OACpB,MAAIjpB,QACOA,OAAS,IAAMpS,KAEjBq7B,MACE,IAAMr7B,KAAO,IAAMq7B,MAGnBr7B,MAQfw1C,cAAc12C,UAAUoG,MAKxB,SAAUpD,QAASC,SACf,MAAOD,SAAQ6zC,WAAWp3C,KAAMwD,UAE7ByzC,iBAKPI,aAA8B,WAC9B,QAASA,cAAa51C,KAAM6B,MAAO0G,YAC/BhK,KAAKyB,KAAOA,KACZzB,KAAKsD,MAAQA,MACbtD,KAAKgK,WAAaA,WAetB,MARAqtC,cAAa92C,UAAUoG,MAKvB,SAAUpD,QAASC,SACf,MAAOD,SAAQ+zC,eAAet3C,KAAMwD,UAEjC6zC,gBAKPE,YAA6B,WAC7B,QAASA,aAAY91C,KAAM6B,MAAO0G,YAC9BhK,KAAKyB,KAAOA,KACZzB,KAAKsD,MAAQA,MACbtD,KAAKgK,WAAaA,WAetB,MARAutC,aAAYh3C,UAAUoG,MAKtB,SAAUpD,QAASC,SACf,MAAOD,SAAQi0C,cAAcx3C,KAAMwD,UAEhC+zC,eAKPnd,WAA4B,WAC5B,QAASA,YAAW34B,KAAM6L,MAAOmqC,OAAQC,QAASC,WAAYjvB,WAAYN,UAAW+R,iBAAkBiC,aAAc/xB,SAAUosC,eAAgBzsC,WAAYI,eACvJpK,KAAKyB,KAAOA,KACZzB,KAAKsN,MAAQA,MACbtN,KAAKy3C,OAASA,OACdz3C,KAAK03C,QAAUA,QACf13C,KAAK23C,WAAaA,WAClB33C,KAAK0oB,WAAaA,WAClB1oB,KAAKooB,UAAYA,UACjBpoB,KAAKm6B,iBAAmBA,iBACxBn6B,KAAKo8B,aAAeA,aACpBp8B,KAAKqK,SAAWA,SAChBrK,KAAKy2C,eAAiBA,eACtBz2C,KAAKgK,WAAaA,WAClBhK,KAAKoK,cAAgBA,cAezB,MARAgwB,YAAW75B,UAAUoG,MAKrB,SAAUpD,QAASC,SACf,MAAOD,SAAQq0C,aAAa53C,KAAMwD,UAE/B42B,cAKPF,oBAAqC,WACrC,QAASA,qBAAoB5sB,MAAOoqC,QAASC,WAAYE,UAAWnvB,WAAYN,UAAW+R,iBAAkBiC,aAAc/xB,SAAUosC,eAAgBzsC,YACjJhK,KAAKsN,MAAQA,MACbtN,KAAK03C,QAAUA,QACf13C,KAAK23C,WAAaA,WAClB33C,KAAK63C,UAAYA,UACjB73C,KAAK0oB,WAAaA,WAClB1oB,KAAKooB,UAAYA,UACjBpoB,KAAKm6B,iBAAmBA,iBACxBn6B,KAAKo8B,aAAeA,aACpBp8B,KAAKqK,SAAWA,SAChBrK,KAAKy2C,eAAiBA,eACtBz2C,KAAKgK,WAAaA,WAetB,MARAkwB,qBAAoB35B,UAAUoG,MAK9B,SAAUpD,QAASC,SACf,MAAOD,SAAQu0C,sBAAsB93C,KAAMwD,UAExC02B,uBAKP6d,0BAA2C,WAC3C,QAASA,2BAA0BC,cAAeC,aAAc30C,MAAO0G,YACnEhK,KAAKg4C,cAAgBA,cACrBh4C,KAAKi4C,aAAeA,aACpBj4C,KAAKsD,MAAQA,MACbtD,KAAKgK,WAAaA,WAetB,MARA+tC,2BAA0Bx3C,UAAUoG,MAKpC,SAAUpD,QAASC,SACf,MAAOD,SAAQ20C,uBAAuBl4C,KAAMwD,UAEzCu0C,6BAKPI,aAA8B,WAC9B,QAASA,cAAarvB,UAAW2uB,OAAQW,eAAgBC,WAAYnuB,oBAAqBlgB,YACtFhK,KAAK8oB,UAAYA,UACjB9oB,KAAKy3C,OAASA,OACdz3C,KAAKo4C,eAAiBA,eACtBp4C,KAAKq4C,WAAaA,WAClBr4C,KAAKkqB,oBAAsBA,oBAC3BlqB,KAAKgK,WAAaA,WAetB,MARAmuC,cAAa53C,UAAUoG,MAKvB,SAAUpD,QAASC,SACf,MAAOD,SAAQ+0C,eAAet4C,KAAMwD,UAEjC20C,gBAKP9vB,YAA6B,WAC7B,QAASA,aAAY1iB,MAAO2iB,cAAeH,MAAOC,UAAWG,aAAcC,eAAgBxe,YACvFhK,KAAK2F,MAAQA,MACb3F,KAAKsoB,cAAgBA,cACrBtoB,KAAKmoB,MAAQA,MACbnoB,KAAKooB,UAAYA,UACjBpoB,KAAKuoB,aAAeA,aACpBvoB,KAAKwoB,eAAiBA,eACtBxoB,KAAKgK,WAAaA,WAgBtB,MATAqe,aAAY9nB,UAAUoG,MAKtB,SAAUpD,QAASC,SAEf,MAAO,OAEJ6kB,eAGPY,iBACAE,cAAe,EACfE,eAAgB,EAChBvoB,UAAW,EACXD,UAAW,EACX03C,QAAS,EAEbtvB,iBAAgBA,gBAAgBE,eAAiB,gBACjDF,gBAAgBA,gBAAgBI,gBAAkB,iBAClDJ,gBAAgBA,gBAAgBnoB,WAAa,YAC7CmoB,gBAAgBA,gBAAgBpoB,WAAa,YAC7CooB,gBAAgBA,gBAAgBsvB,SAAW,SAI3C,IAAIle,cAA8B,WAC9B,QAASA,cAAaj1B,MAAOqxC,eAAgBzsC,YACzChK,KAAKoF,MAAQA,MACbpF,KAAKy2C,eAAiBA,eACtBz2C,KAAKgK,WAAaA,WAetB,MARAqwB,cAAa95B,UAAUoG,MAKvB,SAAUpD,QAASC,SACf,MAAOD,SAAQi1C,eAAex4C,KAAMwD,UAEjC62B,gBAGPI,qBAIAC,SAAU,EAIV/5B,UAAW,EAIXi6B,MAAO,EAIPC,MAAO,EAIPF,UAAW,EAEfF,qBAAoBA,oBAAoBC,UAAY,WACpDD,oBAAoBA,oBAAoB95B,WAAa,YACrD85B,oBAAoBA,oBAAoBG,OAAS,QACjDH,oBAAoBA,oBAAoBI,OAAS,QACjDJ,oBAAoBA,oBAAoBE,WAAa,WAcrD,IAAI8d,qBAAqC,WACrC,QAASA,wBAsIT,MA/HAA,qBAAoBl4C,UAAUi4C,eAK9B,SAAU5xC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAUu3C,sBAK9B,SAAUlxC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAUq3C,aAK9B,SAAUhxC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAU+2C,eAK9B,SAAU1wC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAUi3C,cAK9B,SAAU5wC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAU62C,WAK9B,SAAUxwC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAUy2C,qBAK9B,SAAUpwC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAUu2C,UAK9B,SAAUlwC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAUq2C,eAK9B,SAAUhwC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAUm2C,UAK9B,SAAU9vC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAU+3C,eAK9B,SAAU1xC,IAAKpD,WAMfi1C,oBAAoBl4C,UAAU23C,uBAK9B,SAAUtxC,IAAKpD,WACRi1C,uBAMPC,4BAA6C,SAAUjuC,QAEvD,QAASiuC,+BACL,MAAOjuC,QAAO8kC,KAAKvvC,OAASA,KAwFhC,MA1FAC,WAAUy4C,4BAA6BjuC,QAUvCiuC,4BAA4Bn4C,UAAUu3C,sBAKtC,SAAUlxC,IAAKpD,SACX,MAAOxD,MAAK24C,cAAcn1C,QAAS,SAAUmD,OACzCA,MAAMC,IAAI0G,OACV3G,MAAMC,IAAI+wC,YACVhxC,MAAMC,IAAIixC,WACVlxC,MAAMC,IAAI8hB,YACV/hB,MAAMC,IAAIwhB,WACVzhB,MAAMC,IAAIyD,aAQlBquC,4BAA4Bn4C,UAAUq3C,aAKtC,SAAUhxC,IAAKpD,SACX,MAAOxD,MAAK24C,cAAcn1C,QAAS,SAAUmD,OACzCA,MAAMC,IAAI0G,OACV3G,MAAMC,IAAI6wC,QACV9wC,MAAMC,IAAI8wC,SACV/wC,MAAMC,IAAI+wC,YACVhxC,MAAMC,IAAI8hB,YACV/hB,MAAMC,IAAIwhB,WACVzhB,MAAMC,IAAIyD,aAQlBquC,4BAA4Bn4C,UAAU+3C,eAKtC,SAAU1xC,IAAKpD,SACX,MAAOxD,MAAK24C,cAAcn1C,QAAS,SAAUmD,OACzCA,MAAMC,IAAI6wC,QACV9wC,MAAMC,IAAIwxC,gBACVzxC,MAAMC,IAAIyxC,eASlBK,4BAA4Bn4C,UAAUo4C,cAMtC,SAAUn1C,QAASqyC,IAQf,QAASlvC,OAAM0D,UACPA,UAAYA,SAASvI,QACrB82C,QAAQ7xC,KAAKP,iBAAiB8oC,EAAGjlC,SAAU7G,UATnD,GAAqBo1C,YACAtJ,EAAItvC,IAWzB,OADA61C,IAAGlvC,UACOiC,OAAO5G,SAAU42C,UAExBF,6BACTD,qBAkCExQ,eAAgC,WAChC,QAASA,gBAAe7uB,IACpB,GAAIG,QAAY,KAAPH,MAAqBA,GAAIW,GAAKR,GAAG2uB,qBAAsBA,yBAA8B,KAAPnuB,GAAgBouB,kBAAkBC,SAAWruB,GAAIM,GAAKd,GAAG8uB,OAAQA,WAAgB,KAAPhuB,IAAuBA,GAAIC,GAAKf,GAAGs/B,WAAYA,eAAoB,KAAPv+B,IAAwBA,GAAIw+B,GAAKv/B,GAAGwuB,mBAAoBA,uBAA4B,KAAP+Q,GAAgB,KAAOA,GAAI7iB,qBAAuB1c,GAAG0c,qBAAsBqS,oBAAsB/uB,GAAG+uB,oBAAqBC,0BAA4BhvB,GAAGgvB,yBAClcvoC,MAAKkoC,qBAAuBA,qBAC5BloC,KAAKqoC,SAAWA,OAChBroC,KAAK64C,aAAeA,WACpB74C,KAAK+nC,mBAAqBA,mBAC1B/nC,KAAKi2B,sBAAgD,IAAzBA,qBAC5Bj2B,KAAKsoC,oBAAsBthC,2BAA2B7C,YAAYmkC,sBAClEtoC,KAAKuoC,2BAA0D,IAA9BA,0BAErC,MAAON,mBA4BPzgC,aAA8B,WAC9B,QAASA,cAAaI,SAAUnG,KAAMs3C,SAClC/4C,KAAK4H,SAAWA,SAChB5H,KAAKyB,KAAOA,KACZzB,KAAK+4C,QAAUA,QAanB,MARAvxC,cAAajH,UAAUy4C,gBAGvB,WACI,GAAIh5C,KAAK+4C,QAAQj3C,OACb,KAAM,IAAI0C,OAAM,2DAA6Dy0C,KAAKvzC,UAAU1F,MAAQ,MAGrGwH,gBAMP8/B,kBAAmC,WACnC,QAASA,qBACLtnC,KAAKk5C,MAAQ,GAAIrwB,KAyBrB,MAjBAye,mBAAkB/mC,UAAUggB,IAM5B,SAAU44B,gBAAiB13C,KAAMs3C,SAC7BA,QAAUA,WACV,IAAqBK,cAAeL,QAAQj3C,OAAS,IAAMi3C,QAAQlzC,KAAK,KAAO,GAC1DoO,IAAM,IAAOklC,gBAAkB,KAAQ13C,KAAO23C,aAC9C1yC,OAAS1G,KAAKk5C,MAAM34B,IAAItM,IAK7C,OAJKvN,UACDA,OAAS,GAAIc,cAAa2xC,gBAAiB13C,KAAMs3C,SACjD/4C,KAAKk5C,MAAM14B,IAAIvM,IAAKvN,SAEjBA,QAEJ4gC,qBAkBP+R,aAAe,qDAQf3xC,oBAAsB,EA6EtB4xC,oBACAv4C,KAAM,EACNF,UAAW,EACXO,SAAU,EACVm4C,WAAY,EAEhBD,oBAAmBA,mBAAmBv4C,MAAQ,OAC9Cu4C,mBAAmBA,mBAAmBz4C,WAAa,YACnDy4C,mBAAmBA,mBAAmBl4C,UAAY,WAClDk4C,mBAAmBA,mBAAmBC,YAAc,YAuDpD,IAAIC,2BAA2C,WAC3C,QAASA,2BAA0BpgC,IAC/B,GAAIG,QAAY,KAAPH,MAAqBA,GAAI5D,UAAY+D,GAAG/D,UAAWikC,OAASlgC,GAAGkgC,OAAQC,UAAYngC,GAAGmgC,SAC/F15C,MAAKwV,UAAYA,WAAa,KAC9BxV,KAAKy5C,OAASpxC,gBAAgBoxC,QAC9Bz5C,KAAK05C,UAAYrxC,gBAAgBqxC,WAErC,MAAOF,8BAUPG,wBAAyC,WACzC,QAASA,yBAAwBvgC,IAC7B,GAAIwgC,eAAgBxgC,GAAGwgC,cAAeC,SAAWzgC,GAAGygC,SAAUC,YAAc1gC,GAAG0gC,YAAaC,QAAU3gC,GAAG2gC,QAASN,OAASrgC,GAAGqgC,OAAQC,UAAYtgC,GAAGsgC,UAAWM,oBAAsB5gC,GAAG4gC,oBAAqBC,WAAa7gC,GAAG6gC,WAAYC,mBAAqB9gC,GAAG8gC,mBAAoBC,cAAgB/gC,GAAG+gC,cAAehxC,SAAWiQ,GAAGjQ,SAAUm/B,oBAAsBlvB,GAAGkvB,mBAUzW,IATAtoC,KAAK45C,cAAgBA,cACrB55C,KAAK65C,SAAWA,SAChB75C,KAAK85C,YAAcA,YACnB95C,KAAK+5C,QAAUA,QACf/5C,KAAKy5C,OAASpxC,gBAAgBoxC,QAC9Bz5C,KAAK05C,UAAYrxC,gBAAgBqxC,WACjC15C,KAAKg6C,oBAAsB3xC,gBAAgB2xC,qBAC3Ch6C,KAAKi6C,WAAaA,WAAa3xC,QAAQ2xC,eACvCj6C,KAAKk6C,mBAAqBA,uBACtBC,eAAyC,GAAxBA,cAAcr4C,OAC/B,KAAM,IAAI0C,OAAM,yDAEpBxE,MAAKm6C,cAAgBA,cACrBn6C,KAAKmJ,SAAWA,SAChBnJ,KAAKsoC,oBAAsBA,oBAc/B,MATAqR,yBAAwBp5C,UAAU65C,UAGlC,WACI,OACIF,mBAAoBl6C,KAAKk6C,mBACzBN,cAAe55C,KAAK45C,gBAGrBD,2BAaPU,yBAA0C,WAC1C,QAASA,0BAAyBjhC,IAC9B,GAAIkhC,QAASlhC,GAAGkhC,OAAQl0C,KAAOgT,GAAGhT,KAAM4iB,YAAc5P,GAAG4P,YAAamH,SAAW/W,GAAG+W,SAAUsE,SAAWrb,GAAGqb,SAAUkc,gBAAkBv3B,GAAGu3B,gBAAiB8G,OAASr+B,GAAGq+B,OAAQC,QAAUt+B,GAAGs+B,QAAS6C,cAAgBnhC,GAAGmhC,cAAenC,eAAiBh/B,GAAGg/B,eAAgBjd,eAAiB/hB,GAAG+hB,eAAgB/S,UAAYhP,GAAGgP,UAAWgB,cAAgBhQ,GAAGgQ,cAAekB,QAAUlR,GAAGkR,QAASkwB,OAASphC,GAAGohC,OAAQ3wB,YAAczQ,GAAGyQ,YAAaiD,gBAAkB1T,GAAG0T,gBAAiB+sB,SAAWzgC,GAAGygC,SAAUY,kBAAoBrhC,GAAGqhC,kBAAmBC,aAAethC,GAAGshC,aAAcztB,iBAAmB7T,GAAG6T,gBACllBjtB,MAAKs6C,SAAWA,OAChBt6C,KAAKoG,KAAOA,KACZpG,KAAKgpB,YAAcA,YACnBhpB,KAAKmwB,SAAWA,SAChBnwB,KAAKy0B,SAAWA,SAChBz0B,KAAK2wC,gBAAkBA,gBACvB3wC,KAAKy3C,OAASA,OACdz3C,KAAK03C,QAAUA,QACf13C,KAAKu6C,cAAgBA,cACrBv6C,KAAKo4C,eAAiBA,eACtBp4C,KAAKm7B,eAAiBA,eACtBn7B,KAAKooB,UAAY/f,gBAAgB+f,WACjCpoB,KAAKopB,cAAgB/gB,gBAAgB+gB,eACrCppB,KAAKsqB,QAAUjiB,gBAAgBiiB,SAC/BtqB,KAAKw6C,OAASA,OACdx6C,KAAK6pB,YAAcxhB,gBAAgBwhB,aACnC7pB,KAAK8sB,gBAAkBzkB,gBAAgBykB,iBACvC9sB,KAAK65C,SAAWA,SAChB75C,KAAKy6C,kBAAoBA,kBACzBz6C,KAAK06C,aAAeA,aACpB16C,KAAKitB,iBAAmBA,iBAoG5B,MA9FAotB,0BAAyB55C,OAIzB,SAAU2Y,IACN,GAAIkhC,QAASlhC,GAAGkhC,OAAQl0C,KAAOgT,GAAGhT,KAAM4iB,YAAc5P,GAAG4P,YAAamH,SAAW/W,GAAG+W,SAAUsE,SAAWrb,GAAGqb,SAAUkc,gBAAkBv3B,GAAGu3B,gBAAiB8G,OAASr+B,GAAGq+B,OAAQC,QAAUt+B,GAAGs+B,QAAS7V,KAAOzoB,GAAGyoB,KAAMzZ,UAAYhP,GAAGgP,UAAWgB,cAAgBhQ,GAAGgQ,cAAekB,QAAUlR,GAAGkR,QAASkwB,OAASphC,GAAGohC,OAAQ3wB,YAAczQ,GAAGyQ,YAAaiD,gBAAkB1T,GAAG0T,gBAAiB+sB,SAAWzgC,GAAGygC,SAAUY,kBAAoBrhC,GAAGqhC,kBAAmBC,aAAethC,GAAGshC,aAAcztB,iBAAmB7T,GAAG6T,iBACnestB,iBACAnC,kBACAjd,iBACT,OAAR0G,MACArhC,OAAOy2B,KAAK4K,MAAMh7B,QAAQ,SAAUoN,KAChC,GAAqB3Q,OAAQu+B,KAAK5tB,KACb0mC,QAAU1mC,IAAIzI,MAAM6tC,aACzB,QAAZsB,QACAxf,eAAelnB,KAAO3Q,MAEH,MAAdq3C,QAAQ,GACbvC,eAAeuC,QAAQ,IAAMr3C,MAEV,MAAdq3C,QAAQ,KACbJ,cAAcI,QAAQ,IAAMr3C,QAIxC,IAAqBs3C,aACP,OAAVnD,QACAA,OAAO5wC,QAAQ,SAAUg0C,YAGrB,GAAqB7iC,OAAQpV,aAAai4C,YAAaA,WAAYA,YACnED,WAAU5iC,MAAM,IAAMA,MAAM,IAGpC,IAAqB8iC,cASrB,OARe,OAAXpD,SACAA,QAAQ7wC,QAAQ,SAAUg0C,YAGtB,GAAqB7iC,OAAQpV,aAAai4C,YAAaA,WAAYA,YACnEC,YAAW9iC,MAAM,IAAMA,MAAM,KAG9B,GAAIqiC,2BACPC,OAAQA,OACRl0C,KAAMA,KACN4iB,cAAeA,YAAamH,SAAUA,SAAUsE,SAAUA,SAAUkc,gBAAiBA,gBACrF8G,OAAQmD,UACRlD,QAASoD,WACTP,cAAeA,cACfnC,eAAgBA,eAChBjd,eAAgBA,eAChB/S,UAAWA,UACXgB,cAAeA,cACfkB,QAASA,QACTkwB,OAAQA,OACR3wB,YAAaA,YACbiD,gBAAiBA,gBACjB+sB,SAAUA,SACVY,kBAAmBA,kBACnBC,aAAcA,aACdztB,iBAAkBA,oBAM1BotB,yBAAyB95C,UAAU65C,UAGnC,WACI,OACIW,YAAazB,mBAAmBz4C,UAChCuF,KAAMpG,KAAKoG,KACX4iB,YAAahpB,KAAKgpB,YAClBmH,SAAUnwB,KAAKmwB,SACfsE,SAAUz0B,KAAKy0B,SACfgjB,OAAQz3C,KAAKy3C,OACbC,QAAS13C,KAAK03C,QACd6C,cAAev6C,KAAKu6C,cACpBnC,eAAgBp4C,KAAKo4C,eACrBjd,eAAgBn7B,KAAKm7B,eACrB/S,UAAWpoB,KAAKooB,UAChBgB,cAAeppB,KAAKopB,cACpBkB,QAAStqB,KAAKsqB,QACdkwB,OAAQx6C,KAAKw6C,OACb3wB,YAAa7pB,KAAK6pB,YAClBiD,gBAAiB9sB,KAAK8sB,gBACtB6jB,gBAAiB3wC,KAAK2wC,gBACtBkJ,SAAU75C,KAAK65C,UAAY75C,KAAK65C,SAASO,YACzCK,kBAAmBz6C,KAAKy6C,kBACxBC,aAAc16C,KAAK06C,aACnBztB,iBAAkBjtB,KAAKitB,mBAGxBotB,4BAMPW,oBAAqC,WACrC,QAASA,qBAAoB5hC,IACzB,GAAIhT,MAAOgT,GAAGhT,KAAM3E,KAAO2X,GAAG3X,KAAMovC,KAAOz3B,GAAGy3B,IAC9C7wC,MAAKoG,KAAOA,KACZpG,KAAKyB,KAAOA,KACZzB,KAAK6wC,OAASA,KAgBlB,MAXAmK,qBAAoBz6C,UAAU65C,UAG9B,WACI,OACIW,YAAazB,mBAAmBv4C,KAChCqF,KAAMpG,KAAKoG,KACX3E,KAAMzB,KAAKyB,KACXovC,KAAM7wC,KAAK6wC,OAGZmK,uBASPC,wBAAyC,WACzC,QAASA,yBAAwB7hC,IAC7B,GAAIhT,MAAOgT,GAAGhT,KAAMgiB,UAAYhP,GAAGgP,UAAWkc,mBAAqBlrB,GAAGkrB,mBAAoB4W,mBAAqB9hC,GAAG8hC,mBAAoB3W,cAAgBnrB,GAAGmrB,cAAe4W,cAAgB/hC,GAAG+hC,cAAeruB,gBAAkB1T,GAAG0T,gBAAiBsuB,oBAAsBhiC,GAAGgiC,oBAAqBC,gBAAkBjiC,GAAGiiC,gBAAiBC,gBAAkBliC,GAAGkiC,gBAAiBC,QAAUniC,GAAGmiC,QAAS5d,iBAAmBvkB,GAAGukB,iBAAkBr0B,GAAK8P,GAAG9P,EAChbtJ,MAAKoG,KAAOA,MAAQ,KACpBpG,KAAKskC,mBAAqBj8B,gBAAgBi8B,oBAC1CtkC,KAAKk7C,mBAAqB7yC,gBAAgB6yC,oBAC1Cl7C,KAAKukC,cAAgBl8B,gBAAgBk8B,eACrCvkC,KAAKm7C,cAAgB9yC,gBAAgB8yC,eACrCn7C,KAAKooB,UAAY/f,gBAAgB+f,WACjCpoB,KAAK8sB,gBAAkBzkB,gBAAgBykB,iBACvC9sB,KAAKo7C,oBAAsB/yC,gBAAgB+yC,qBAC3Cp7C,KAAKq7C,gBAAkBhzC,gBAAgBgzC,iBACvCr7C,KAAKs7C,gBAAkBjzC,gBAAgBizC,iBACvCt7C,KAAKu7C,QAAUlzC,gBAAgBkzC,SAC/Bv7C,KAAKsJ,GAAKA,IAAM,KAChBtJ,KAAK29B,iBAAmBA,kBAAoB,KAoBhD,MAfAsd,yBAAwB16C,UAAU65C,UAGlC,WACI,GAAqBz6C,QAA4BK,KAAsB,gBACvE,QACI+6C,YAAazB,mBAAmBl4C,SAChCgF,KAAMpG,KAAKoG,KACX0mB,gBAAiBntB,OAAOmtB,gBACxB1E,UAAWzoB,OAAOyoB,UAClB0a,QAASnjC,OAAOmjC,QAChBoY,mBAAoBv7C,OAAOu7C,mBAC3BC,cAAex7C,OAAOw7C,gBAGvBF,2BAEPO,kCAAmD,WACnD,QAASA,qCACLx7C,KAAKy7C,cAAgB,GAAIv3B,KACzBlkB,KAAK0oB,cACL1oB,KAAK07C,sBAAwB,GAAIx3B,KACjClkB,KAAKk7C,sBACLl7C,KAAK27C,SAAW,GAAIz3B,KACpBlkB,KAAKgjC,SACLhjC,KAAK47C,iBAAmB,GAAI13B,KAC5BlkB,KAAKm7C,iBACLn7C,KAAK67C,WAAa,GAAI33B,KACtBlkB,KAAK8iC,WACL9iC,KAAK87C,mBAAqB,GAAI53B,KAC9BlkB,KAAK8sB,mBACL9sB,KAAKooB,aAmGT,MA5FAozB,mCAAkCj7C,UAAUw7C,YAK5C,SAAUp0B,SAAUhoB,QAChBK,KAAKooB,UAAUrhB,MAAO4gB,SAAUA,SAAUhoB,OAAQA,UAMtD67C,kCAAkCj7C,UAAUy7C,aAI5C,SAAU1yC,IACDtJ,KAAKy7C,cAAcznB,IAAI1qB,GAAGhC,aAC3BtH,KAAKy7C,cAAclf,IAAIjzB,GAAGhC,WAC1BtH,KAAK0oB,WAAW3hB,KAAKuC,MAO7BkyC,kCAAkCj7C,UAAU07C,qBAI5C,SAAU3yC,IACDtJ,KAAK07C,sBAAsB1nB,IAAI1qB,GAAGhC,aACnCtH,KAAK07C,sBAAsBnf,IAAIjzB,GAAGhC,WAClCtH,KAAKk7C,mBAAmBn0C,KAAKuC,MAOrCkyC,kCAAkCj7C,UAAU27C,QAI5C,SAAU5yC,IACDtJ,KAAK27C,SAAS3nB,IAAI1qB,GAAGhC,aACtBtH,KAAK27C,SAASpf,IAAIjzB,GAAGhC,WACrBtH,KAAKgjC,MAAMj8B,KAAKuC,MAOxBkyC,kCAAkCj7C,UAAU47C,gBAI5C,SAAU7yC,IACDtJ,KAAK47C,iBAAiB5nB,IAAI1qB,GAAGhC,aAC9BtH,KAAK47C,iBAAiBrf,IAAIjzB,GAAGhC,WAC7BtH,KAAKm7C,cAAcp0C,KAAKuC,MAOhCkyC,kCAAkCj7C,UAAU67C,UAI5C,SAAU9yC,IACDtJ,KAAK67C,WAAW7nB,IAAI1qB,GAAGhC,aACxBtH,KAAK67C,WAAWtf,IAAIjzB,GAAGhC,WACvBtH,KAAK8iC,QAAQ/7B,KAAKuC,MAO1BkyC,kCAAkCj7C,UAAU87C,kBAI5C,SAAUC,IACDt8C,KAAK87C,mBAAmB9nB,IAAIsoB,GAAGC,iBAChCv8C,KAAK87C,mBAAmBvf,IAAI+f,GAAGC,eAC/Bv8C,KAAK8sB,gBAAgB/lB,KAAKu1C,MAG3Bd,qCASPgB,aAA8B,WAC9B,QAASA,cAAa72C,MAAOyT,IACzB,GAAI2O,UAAW3O,GAAG2O,SAAUF,SAAWzO,GAAGyO,SAAUD,YAAcxO,GAAGwO,YAAaI,WAAa5O,GAAG4O,WAAYF,KAAO1O,GAAG0O,KAAMG,MAAQ7O,GAAG6O,KACzIjoB,MAAK2F,MAAQA,MACb3F,KAAK+nB,SAAWA,UAAY,KAC5B/nB,KAAK6nB,SAAWA,SAChB7nB,KAAK4nB,YAAcA,YACnB5nB,KAAKgoB,WAAaA,YAAc,KAChChoB,KAAKqhC,aAAevZ,MAAQ,KAC5B9nB,KAAKioB,QAAUA,MAEnB,MAAOu0B,iBAoGP3xC,QAAyB,WACzB,QAASA,SAAQL,KAAMD,cACF,KAAbA,WAAuBA,UAAY,GACvCvK,KAAKwK,KAAOA,KACZxK,KAAKuK,SAAWA,SA+EpB,MA7EA/J,QAAO4f,eAAevV,QAAQtK,UAAW,SACrCggB,IAGA,WAAc,OAAQvgB,KAAKwK,OAASxK,KAAKwK,KAAK1I,QAC9Cwe,YAAY,EACZD,cAAc,IAElB7f,OAAO4f,eAAevV,QAAQtK,UAAW,QACrCggB,IAGA,WAAc,MAAOvgB,MAAKwK,KAAK,IAC/B8V,YAAY,EACZD,cAAc,IAElB7f,OAAO4f,eAAevV,QAAQtK,UAAW,QACrCggB,IAGA,WAAc,MAAOvgB,MAAKwK,KAAKxK,KAAKwK,KAAK1I,OAAS,IAClDwe,YAAY,EACZD,cAAc,IAMlBxV,QAAQtK,UAAUk8C,SAIlB,SAAUn9B,MACN,MAAOA,OAAQtf,KAAKwK,KAAKxK,KAAKwK,KAAKtH,QAAQoc,MAAQ,IAMvDzU,QAAQtK,UAAUm8C,QAIlB,SAAUp9B,MAAQ,MAAOtf,MAAKwK,KAAKxK,KAAKwK,KAAKtH,QAAQoc,MAAQ,IAM7DzU,QAAQtK,UAAUyvC,MAKlB,SAAU5E,MACN,IAAK,GAAqBrgC,GAAI/K,KAAKwK,KAAK1I,OAAS,EAAGiJ,GAAK,EAAGA,IAAK,CAC7D,GAAqBrC,MAAO1I,KAAKwK,KAAKO,EACtC,IAAIrC,eAAgB0iC,MAChB,MAAwB,QAOpCvgC,QAAQtK,UAAUwG,KAIlB,SAAUuY,MAAQtf,KAAKwK,KAAKzD,KAAKuY,OAIjCzU,QAAQtK,UAAUiuC,IAGlB,WAAc,MAA0BxuC,MAAKwK,KAAKgkC,OAC3C3jC,WAkBP4qB,KAAsB,WACtB,QAASA,MAAKnyB,MAAO0G,YACjBhK,KAAKsD,MAAQA,MACbtD,KAAKgK,WAAaA,WAatB,MANAyrB,MAAKl1B,UAAUoG,MAKf,SAAUpD,QAASC,SAAW,MAAOD,SAAQmzC,UAAU12C,KAAMwD,UACtDiyB,QAEPknB,UAA2B,WAC3B,QAASA,WAAU5pB,YAAa3sB,KAAMosB,MAAOxoB,WAAYgpB,uBACrDhzB,KAAK+yB,YAAcA,YACnB/yB,KAAKoG,KAAOA,KACZpG,KAAKwyB,MAAQA,MACbxyB,KAAKgK,WAAaA,WAClBhK,KAAKgzB,sBAAwBA,sBAajC,MANA2pB,WAAUp8C,UAAUoG,MAKpB,SAAUpD,QAASC,SAAW,MAAOD,SAAQq5C,eAAe58C,KAAMwD,UAC3Dm5C,aAEPE,cAA+B,WAC/B,QAASA,eAAcv5C,MAAOqR,WAAY3K,WAAY2oB,gBAAiBmqB,eACnE98C,KAAKsD,MAAQA,MACbtD,KAAK2U,WAAaA,WAClB3U,KAAKgK,WAAaA,WAClBhK,KAAK2yB,gBAAkBA,gBACvB3yB,KAAK88C,cAAgBA,cAazB,MANAD,eAAct8C,UAAUoG,MAKxB,SAAUpD,QAASC,SAAW,MAAOD,SAAQw5C,mBAAmB/8C,KAAMwD,UAC/Dq5C,iBAEPhqB,YAA6B,WAC7B,QAASlyB,WAAUc,KAAM6B,MAAO0G,WAAYgzC,WACxCh9C,KAAKyB,KAAOA,KACZzB,KAAKsD,MAAQA,MACbtD,KAAKgK,WAAaA,WAClBhK,KAAKg9C,UAAYA,UAarB,MANAr8C,WAAUJ,UAAUoG,MAKpB,SAAUpD,QAASC,SAAW,MAAOD,SAAQ05C,eAAej9C,KAAMwD,UAC3D7C,aAEPwJ,QAAyB,WACzB,QAASA,SAAQ1I,KAAM6L,MAAOjD,SAAUL,WAAYkzC,gBAAiB9yC,mBACzC,KAApB8yC,kBAA8BA,gBAAkB,UAC9B,KAAlB9yC,gBAA4BA,cAAgB,MAChDpK,KAAKyB,KAAOA,KACZzB,KAAKsN,MAAQA,MACbtN,KAAKqK,SAAWA,SAChBrK,KAAKgK,WAAaA,WAClBhK,KAAKk9C,gBAAkBA,gBACvBl9C,KAAKoK,cAAgBA,cAazB,MANAD,SAAQ5J,UAAUoG,MAKlB,SAAUpD,QAASC,SAAW,MAAOD,SAAQq0C,aAAa53C,KAAMwD,UACzD2G,WAEPkU,QAAyB,WACzB,QAASA,SAAQ/a,MAAO0G,YACpBhK,KAAKsD,MAAQA,MACbtD,KAAKgK,WAAaA,WAatB,MANAqU,SAAQ9d,UAAUoG,MAKlB,SAAUpD,QAASC,SAAW,MAAOD,SAAQ45C,aAAan9C,KAAMwD,UACzD6a,WA0BPzT,iBAAkC,WAClC,QAASA,qBAsGT,MA/FAA,kBAAiBrK,UAAUq3C,aAK3B,SAAUhxC,IAAKpD,SACXxD,KAAK24C,cAAcn1C,QAAS,SAAUmD,OAClCA,MAAMC,IAAI0G,OACV3G,MAAMC,IAAIyD,aAQlBO,iBAAiBrK,UAAU08C,eAK3B,SAAUr2C,IAAKpD,WAMfoH,iBAAiBrK,UAAUm2C,UAK3B,SAAU9vC,IAAKpD,WAMfoH,iBAAiBrK,UAAU48C,aAK3B,SAAUv2C,IAAKpD,WAMfoH,iBAAiBrK,UAAUq8C,eAK3B,SAAUh2C,IAAKpD,SACX,MAAOxD,MAAK24C,cAAcn1C,QAAS,SAAUmD,OAASA,MAAMC,IAAI4rB,UAOpE5nB,iBAAiBrK,UAAUw8C,mBAK3B,SAAUn2C,IAAKpD,WAOfoH,iBAAiBrK,UAAUo4C,cAM3B,SAAUn1C,QAASqyC,IAQf,QAASlvC,OAAM0D,UACPA,UACAuuC,QAAQ7xC,KAAK6C,SAAS0lC,EAAGjlC,SAAU7G,UAT3C,GAAqBo1C,YACAtJ,EAAItvC,IAWzB,OADA61C,IAAGlvC,UACOiC,OAAO5G,SAAU42C;6BAExBhuC,oBAsFPO,iCACA,QACA,OACA,SACA,cACA,SAkCAiyC,oBAAqC,WACrC,QAASA,qBAAoBrzC,MAAOG,KAChClK,KAAK+J,MAAQA,MACb/J,KAAKkK,IAAMA,IAiBf,MAXAkzC,qBAAoBC,UAIpB,SAAUC,SACN,MAAKA,UAGLtyC,2BAA2B,gBAAiBsyC,SACrC,GAAIF,qBAAoBE,QAAQ,GAAIA,QAAQ,KAHxCnnC,8BAKRinC,uBAEPjnC,6BAA+B,GAAIinC,qBAAoB,KAAM,MAa7DjxC,iBAAkC,WAClC,QAASA,kBAAiBoxC,MAAO7D,WAC7B15C,KAAKu9C,MAAQA,MACbv9C,KAAK05C,UAAYA,UAErB,MAAOvtC,qBAuCPF,kBAAoB,kEACpBD,8BAAgC,2DAChCP,uBAAyB,gBAczB+xC,gBACAC,SAAU,EACVC,mBAAoB,EACpBC,cAAe,EAEnBH,gBAAeA,eAAeC,UAAY,WAC1CD,eAAeA,eAAeE,oBAAsB,qBACpDF,eAAeA,eAAeG,eAAiB,eA4D/C,IAAIC,iBACAC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,QAAW,IACXC,MAAS,IACTC,MAAS,IACTC,IAAO,IACPC,IAAO,IACPC,IAAO,IACPC,KAAQ,IACRC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,KAAQ,IACRC,KAAQ,IACRC,MAAS,IACTC,KAAQ,IACRC,KAAQ,IACRC,OAAU,IACVC,KAAQ,IACRC,IAAO,IACPC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,KAAQ,IACRC,IAAO,IACPC,IAAO,IACPC,KAAQ,IACRC,MAAS,IACTC,KAAQ,IACRC,KAAQ,IACRC,MAAS,IACTC,IAAO,IACPC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,KAAQ,IACRC,KAAQ,IACRC,IAAO,IACPC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,KAAQ,IACRC,KAAQ,IACRC,QAAW,IACXC,QAAW,IACXC,MAAS,IACTC,IAAO,IACPC,IAAO,IACPC,IAAO,IACPC,IAAO,IACPC,KAAQ,IACRC,KAAQ,IACRC,KAAQ,IACRC,MAAS,IACTC,KAAQ,IACRC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,GAAM,IACNC,GAAM,IACNC,KAAQ,IACRC,KAAQ,IACRC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,IAAO,IACPC,KAAQ,IACRC,KAAQ,IACRC,OAAU,IACVC,KAAQ,IACRC,KAAQ,IACRC,KAAQ,IACRC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,KAAQ,IACRC,MAAS,IACTC,KAAQ,IACRC,KAAQ,IACRC,MAAS,IACTC,MAAS,IACTC,GAAM,IACNC,OAAU,IACVC,OAAU,IACVC,IAAO,IACPC,IAAO,IACPC,OAAU,IACVC,MAAS,IACTC,GAAM,IACNC,KAAQ,IACRC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,MAAS,IACTC,GAAM,IACNC,GAAM,IACNC,MAAS,IACTC,KAAQ,IACRC,MAAS,IACTC,GAAM,IACNC,GAAM,IACN/+B,IAAO,IACPg/B,MAAS,IACTC,KAAQ,IACRC,OAAU,IACVC,OAAU,IACVC,GAAM,IACNC,GAAM,IACNC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,QAAW,IACXC,QAAW,IACXC,MAAS,IACTC,GAAM,IACNC,KAAQ,IACRC,KAAQ,IACRC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,OAAU,IACVC,KAAQ,IACRC,KAAQ,IACRC,KAAQ,IACRC,OAAU,IACVC,KAAQ,IACRC,IAAO,IACPC,IAAO,IACPC,GAAM,IACNC,GAAM,IACNC,IAAO,IACPC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,KAAQ,IACRn5B,KAAQ,IACRo5B,IAAO,IACPC,IAAO,IACPC,KAAQ,IACRC,MAAS,IACTC,KAAQ,IACRC,MAAS,IACTC,KAAQ,IACRC,KAAQ,IACRC,MAAS,IACTC,MAAS,IACTC,KAAQ,IACRC,IAAO,IACPC,OAAU,IACVC,IAAO,IACPC,IAAO,IACPC,IAAO,IACPC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,KAAQ,IACRC,KAAQ,IACRC,IAAO,IACPC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,IAAO,IACPC,OAAU,IACVC,IAAO,IACPC,KAAQ,IACR9tC,IAAO,IACP+tC,IAAO,IACPC,KAAQ,IACRC,KAAQ,IACRC,KAAQ,IACRC,KAAQ,IACRC,MAAS,IACTC,IAAO,IACPC,IAAO,IACPC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,SAAY,IACZC,OAAU,IACVC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,KAAQ,IACRC,KAAQ,IACRC,MAAS,IACTC,MAAS,IACTC,OAAU,IACVC,OAAU,IACVC,IAAO,IACPC,MAAS,IACTC,QAAW,IACXC,QAAW,IACXC,KAAQ,IACRC,KAAQ,IACRC,OAAU,IACVC,GAAM,IACNC,GAAM,IACNC,OAAU,IACVC,OAAU,IACVC,IAAO,IACPC,KAAQ,IACRC,KAAQ,IACRC,KAAQ,IACRC,KAAQ,IACRC,IAAO,IACPC,KAAQ,KAIR17B,aAAe,GACnBisB,gBAAqB,KAAIjsB;;;;;;;AAazB,GAAIjkB,wBAAyB,SACzBc,aAAe,OACfZ,oBAAsB,MACtBD,qBAAuB,OACvBc,qBAAuB,aACvBL,cAAgB,QAChBE,eAAiB,SACjBT,qBAAuB,gBACvBC,cAAgB,cAiDhBG,sBACAE,WAAY,EACZE,MAAO,EACPK,WAAY,EACZH,OAAQ,EACRL,MAAO,EAEXD,sBAAqBA,qBAAqBE,YAAc,aACxDF,qBAAqBA,qBAAqBI,OAAS,QACnDJ,qBAAqBA,qBAAqBS,YAAc,aACxDT,qBAAqBA,qBAAqBM,QAAU,SACpDN,qBAAqBA,qBAAqBC,OAAS,OACnD,IAAIS,kBAAkC,WAClC,QAASA,kBAAiBvI,KAAM6G,WAAYC,SAAUE,YAAaC,WAC/DrN,KAAKoG,KAAOA,KACZpG,KAAKiN,WAAaA,WAClBjN,KAAKkN,SAAWA,SAChBlN,KAAKoN,YAAcA,YACnBpN,KAAKqN,UAAYA,UAErB,MAAOsB,qBA4BP85B,oBAAqC,WACrC,QAASA,qBAAoB6kB,gBAAiBC,aAAcC,YAAaC,SACrEztD,KAAKstD,gBAAkBA,gBACvBttD,KAAKutD,aAAeA,aACpBvtD,KAAKwtD,YAAcA,YACnBxtD,KAAKytD,QAAUA,QACfztD,KAAK0tD,qBAAuB,GAAI7kC,KAoQpC,MA/PA4f,qBAAoBloC,UAAUotD,WAG9B,WAAc3tD,KAAK0tD,qBAAqBE,SAKxCnlB,oBAAoBloC,UAAUstD,cAI9B,SAAUC,qBACN,GAAI/pB,OAAQ/jC,IACZ,IAAK8tD,oBAAoB9kC,YAAzB,CAGA,GAAqB6wB,UAA8BiU,oBAA6B,QAChF9tD,MAAK0tD,qBAAqBlxB,OAA0Bqd,SAAqB,aACzEA,SAASG,oBAAoBnzC,QAAQ,SAAUknD,YAAchqB,MAAM2pB,qBAAqBlxB,OAA0BuxB,WAAqB,eAM3ItlB,oBAAoBloC,UAAUytD,OAI9B,SAAUllD,KACN,GAAqBpC,QAAS1G,KAAK0tD,qBAAqBntC,IAAIzX,IAK5D,OAJKpC,UACDA,OAAS1G,KAAKstD,gBAAgB/sC,IAAIzX,KAClC9I,KAAK0tD,qBAAqBltC,IAAI1X,IAAKpC,SAEhCA,QAMX+hC,oBAAoBloC,UAAU0tD,kBAI9B,SAAUC,aACN,GAAInqB,OAAQ/jC,IACZ,IAAIgE,UAAUkqD,YAAYrU,UAAW,CACjC,GAAI71C,UAAUkqD,YAAYpU,aACtB,KAAM11C,aAAY,IAAMsB,UAAUwoD,YAAY3R,eAAiB,0DAEnE,IAAoC,gBAAzB2R,aAAYrU,SACnB,KAAMz1C,aAAY,wCAA0CsB,UAAUwoD,YAAY3R,eAAiB,wBAGtG,CAAA,IAAIv4C,UAAUkqD,YAAYpU,aAM3B,KAAM11C,aAAY,uCAAyCsB,UAAUwoD,YAAY3R,eALjF,IAAuC,gBAA5B2R,aAAYpU,YACnB,KAAM11C,aAAY,2CAA6CsB,UAAUwoD,YAAY3R,eAAiB,oBAM9G,GAAIv4C,UAAUkqD,YAAY5lB,sBACqB,iBAApC4lB,aAAY5lB,oBACnB,KAAMlkC,aAAY,gDAAkDsB,UAAUwoD,YAAY3R,eAAiB,qBAE/G,OAAO5G,WAAUpvC,KAAKvG,KAAKmuD,kBAAkBD,aAAc,SAAUE,mBAAqB,MAAOrqB,OAAMsqB,2BAA2BH,YAAaE,sBAMnJ3lB,oBAAoBloC,UAAU4tD,kBAI9B,SAAUG,YACN,GACqBzU,UACAC,YAFjB/V,MAAQ/jC,IAWZ,OAR2B,OAAvBsuD,WAAWzU,UACXA,SAAWyU,WAAWzU,SACtBC,YAAcwU,WAAW94C,YAGzBskC,YAAc95C,KAAKutD,aAAarhD,QAAQoiD,WAAW94C,UAA8B84C,WAAuB,aACxGzU,SAAW75C,KAAKguD,OAAOlU,cAEpBnE,UAAUpvC,KAAKszC,SAAU,SAAUA,UAAY,MAAO9V,OAAMwqB,wBAAwBD,WAAYzU,SAAUC,gBAQrHrR,oBAAoBloC,UAAUguD,wBAM9B,SAAUL,YAAarU,SAAU2U,gBAC7B,GAAqBrlD,YAAa+kD,YAAYrU,SACzB3jC,oBAAsBknC,oBAAoBC,UAA6B6Q,YAA0B,eACjGO,mBAAqBzuD,KAAKwtD,YAAY/5B,MAAMomB,SAAU9wC,mBAAoBzB,UAAW4mD,YAAYllD,eAAkB5C,MAAQkB,UAAW4mD,YAAY3R,iBAAqBpzC,SAAUA,SAAU2wC,YAAa0U,kBAAmB,EAAMt4C,oBACtP,IAAIu4C,mBAAmBx8B,OAAOnwB,OAAS,EAAG,CAEtC,KAAMsC,aAAY,2BADiBqqD,mBAAmBx8B,OAAOpsB,KAAK,OAGtE,GAAqB6oD,wBAAyB1uD,KAAK2uD,qBAAqB,GAAInV,4BAA4BC,OAAQyU,YAAYzU,OAAQjkC,UAAW04C,YAAY14C,aACtIjS,QAAU,GAAIqrD,wBACnChlD,UAASrG,QAASkrD,mBAAmBz8B,UACrC,IAAqB68B,gBAAiB7uD,KAAK2uD,qBAAqB,GAAInV,4BAA4BC,OAAQl2C,QAAQk2C,OAAQC,UAAWn2C,QAAQm2C,UAAWlkC,UAAWg5C,iBAMjK,QACI3U,SAAUA,SACVC,YAAa0U,eAAgBrlD,SAAUA,SACvC4wC,QAAS0U,mBAAoBhV,OARHiV,uBAAuBjV,OAAO7wC,OAAOimD,eAAepV,QAQjCqV,gBAPVJ,uBAAuBhV,UAAU9wC,OAAOimD,eAAenV,WAOXA,UANlD15C,KAC5B2uD,qBAAqB,GAAInV,4BAA4BE,UAAWwU,YAAYxU,UAAWlkC,UAAW04C,YAAY14C,aAC9GkkC,UAKDQ,mBAAoB32C,QAAQ22C,qBAQpCzR,oBAAoBloC,UAAU8tD,2BAK9B,SAAUH,YAAaE,mBACnB,GAAIrqB,OAAQ/jC,IACZ,OAAO21C,WAAUpvC,KAAKvG,KAAK+uD,gCAAgCX,kBAAkB1U,UAAU9wC,OAAOwlD,kBAAkBU,kBAAmB,SAAU9U,qBACzI,MAAOjW,OAAMirB,iCAAiCd,YAAaE,kBAAmBpU,wBAStFvR,oBAAoBloC,UAAUyuD,iCAM9B,SAAUd,YAAaE,kBAAmBa,aACtC,GAAIlrB,OAAQ/jC,KAQSy5C,OAAS2U,kBAAkB3U,OAAOt2C,OACvDnD,MAAKkvD,cAAcd,kBAAkBU,gBAAiBG,YAAaxV,OACnE,IAAqBC,WAAY0U,kBAAkB1U,UAC9BM,oBAAsBN,UAAU9zC,IAAI,SAAUupD,UAC/D,GAAqBpB,YAAgCkB,YAAY1uC,IAAI4uC,UAChD1V,OAASsU,WAAWtU,OAAOt2C,OAEhD,OADA4gC,OAAMmrB,cAAcnB,WAAWrU,UAAWuV,YAAaxV,QAChD,GAAID,4BAA4BhkC,UAAW25C,SAAU1V,OAAQA,WAEnDG,cAAgBsU,YAAYtU,aAQjD,OAPqB,OAAjBA,gBACAA,cAAgB55C,KAAKytD,QAAQvlB,sBAE7B0R,gBAAkBzR,kBAAkBC,UAA8B,IAAlBqR,OAAO33C,QAClC,IAArB43C,UAAU53C,SACV83C,cAAgBzR,kBAAkBoI,MAE/B,GAAIoJ,0BACPC,cAAeA,cACfC,SAAUuU,kBAAkBvU,SAC5BC,YAAasU,kBAAkBtU,YAC/BC,QAASqU,kBAAkBrU,QAASN,OAAQA,OAAQC,UAAWA,UAC/DQ,mBAAoBkU,kBAAkBlU,mBACtCD,WAAYiU,YAAYjU,WACxBE,cAAe+T,YAAY/T,cAC3BhxC,SAAUilD,kBAAkBjlD,SAAU6wC,oBAAqBA,oBAC3D1R,oBAAqBthC,2BAA2BknD,YAAY5lB,oBAAqBtoC,KAAKytD,QAAQnlB,wBAStGG,oBAAoBloC,UAAU2uD,cAM9B,SAAUxV,UAAWuV,YAAaG,cAC9B,GAAIrrB,OAAQ/jC,IACZ05C,WAAU7yC,QAAQ,SAAUsoD,UACxB,GAAqBpB,YAAgCkB,YAAY1uC,IAAI4uC,SACrEpB,YAAWtU,OAAO5yC,QAAQ,SAAU02C,OAAS,MAAO6R,cAAaroD,KAAKw2C,SACtExZ,MAAMmrB,cAAcnB,WAAWrU,UAAWuV,YAAaG,iBAQ/D3mB,oBAAoBloC,UAAUwuD,gCAK9B,SAAUrV,UAAW2V,mBACjB,GAAItrB,OAAQ/jC,IAEZ,YAD0B,KAAtBqvD,oBAAgCA,kBAAoB,GAAIxmC,MACrD8sB,UAAUpvC,KAAKovC,UAAUG,IAAI4D,UAAUx2B,OAAO,SAAUisC,UAAY,OAAQE,kBAAkBr7B,IAAIm7B,YACpGvpD,IAAI,SAAUupD,UACf,MAAOxZ,WAAUpvC,KAAKw9B,MAAMiqB,OAAOmB,UAAW,SAAUG,aACpD,GAAqBvB,YAAahqB,MAAM4qB,qBAAqB,GAAInV,4BAA4BC,QAAS6V,aAAc95C,UAAW25C,WAE/H,OADAE,mBAAkB7uC,IAAI2uC,SAAUpB,YACzBhqB,MAAMgrB,gCAAgChB,WAAWrU,UAAW2V,wBAEtE,SAAU5uC,GAAK,MAAO4uC,sBAM/B5mB,oBAAoBloC,UAAUouD,qBAI9B,SAAUZ,YACN,GAAIhqB,OAAQ/jC,KACSwV,UAA+Bu4C,WAAqB,UACpDwB,aAAexB,WAAWrU,UAAUx2B,OAAO5X,sBAC3D1F,IAAI,SAAUkD,KAAO,MAAOi7B,OAAMwpB,aAAarhD,QAAQsJ,UAAW1M,OAClD0mD,UAAYzB,WAAWtU,OAAO7zC,IAAI,SAAU23C,OAC7D,GAAqBkS,kBAAmB/jD,iBAAiBq4B,MAAMwpB,aAAc/3C,UAAW+nC,MAExF,OADAgS,cAAaxoD,KAAK/E,MAAMutD,aAAcE,iBAAiB/V,WAChD+V,iBAAiBlS,OAE5B,OAAO,IAAI/D,4BAA4BC,OAAQ+V,UAAW9V,UAAW6V,aAAc/5C,UAAWA,aAE3FizB,uBAEPmmB,wBAAyC,WACzC,QAASA,2BACL5uD,KAAKk6C,sBACLl6C,KAAKy5C,UACLz5C,KAAK05C,aACL15C,KAAK0vD,wBAA0B,EAqGnC,MA9FAd,yBAAwBruD,UAAUq3C,aAKlC,SAAUhxC,IAAKpD,SACX,GAAqBmsD,kBAAmB3iD,gBAAgBpG,IACxD,QAAQ+oD,iBAAiBvpD,MACrB,IAAK6H,sBAAqBE,WACe,IAAjCnO,KAAK0vD,yBACL1vD,KAAKk6C,mBAAmBnzC,KAAK4oD,iBAAiB1iD,WAElD,MACJ,KAAKgB,sBAAqBI,MACtB,GAAqBuhD,eAAgB,EACrChpD,KAAIyD,SAASxD,QAAQ,SAAUw1B,OACvBA,gBAAiB5G,QACjBm6B,eAAiBvzB,MAAM/4B,SAG/BtD,KAAKy5C,OAAO1yC,KAAK6oD,cACjB,MACJ,KAAK3hD,sBAAqBS,WACtB1O,KAAK05C,UAAU3yC,KAAK4oD,iBAAiBziD,UAY7C,MAPIyiD,kBAAiBviD,aACjBpN,KAAK0vD,0BAET9lD,SAAS5J,KAAM4G,IAAIyD,UACfslD,iBAAiBviD,aACjBpN,KAAK0vD,0BAEF,MAOXd,wBAAwBruD,UAAUq8C,eAKlC,SAAUh2C,IAAKpD,SAAWoG,SAAS5J,KAAM4G,IAAI4rB,QAM7Co8B,wBAAwBruD,UAAUw8C,mBAKlC,SAAUn2C,IAAKpD,SACXoG,SAAS5J,KAAM4G,IAAI+N,aAOvBi6C,wBAAwBruD,UAAU48C,aAKlC,SAAUv2C,IAAKpD,SAAW,MAAO,OAMjCorD,wBAAwBruD,UAAU08C,eAKlC,SAAUr2C,IAAKpD,SAAW,MAAO,OAMjCorD,wBAAwBruD,UAAUm2C,UAKlC,SAAU9vC,IAAKpD,SAAW,MAAO,OAC1BorD,2BAcPiB,4BACAxf,gBACAD,mBACAD,mBACAL,uBAEA1G,kBAAmC,WACnC,QAASA,mBAAkB0mB,YACvB9vD,KAAK8vD,WAAaA,WAwMtB,MAlMA1mB,mBAAkB7oC,UAAUijC,YAI5B,SAAUp9B,MACN,GAAqB2pD,cAAe/vD,KAAK8vD,WAAWE,YAAY7pD,kBAAkBC,MAClF,OAAO2pD,eAAgBA,aAAav+B,KAAK5iB,sBAO7Cw6B,kBAAkB7oC,UAAU2L,QAK5B,SAAU9F,KAAM6pD,qBACY,KAApBA,kBAA8BA,iBAAkB,EACpD,IAAqBF,cAAe/vD,KAAK8vD,WAAWE,YAAY7pD,kBAAkBC,MAClF,IAAI2pD,aAAc,CACd,GAAqBpxB,UAAW5vB,SAASghD,aAAcnhD,oBACvD,IAAI+vB,SAAU,CACV,GAAqBuxB,kBAAmBlwD,KAAK8vD,WAAWK,aAAa/pD,MAChDo0C,OAASx6C,KAAK8vD,WAAWtV,OAAOp0C,KACrD,OAAOpG,MAAKowD,2BAA2BzxB,SAAUuxB,iBAAkB1V,OAAQp0C,OAGnF,GAAI6pD,gBACA,KAAM,IAAIzrD,OAAM,oCAAsCkB,UAAUU,MAEpE,OAAO,OASXgjC,kBAAkB7oC,UAAU6vD,2BAO5B,SAAUC,GAAIH,iBAAkB1V,OAAQ8V,eACpC,GAAqB7Y,WACAC,WACA7V,QACAvX,UA8CrB,OA7CA9pB,QAAOy2B,KAAKi5B,kBAAkBrpD,QAAQ,SAAUwsB,UAC5C,GAAqB9wB,OAAQwM,SAASmhD,iBAAiB78B,UAAW,SAAU1a,GAAK,MAAOm4B,aAAY3uC,SAASwW,IACzGpW,SACIA,MAAMwuC,oBACN0G,OAAO1wC,KAAKssB,SAAW,KAAO9wB,MAAMwuC,qBAGpC0G,OAAO1wC,KAAKssB,UAGpB,IAAqBwG,QAAS9qB,SAASmhD,iBAAiB78B,UAAW,SAAU1a,GAAK,MAAOq4B,cAAa7uC,SAASwW,IAC3GkhB,UACIA,OAAOkX,oBACP2G,QAAQ3wC,KAAKssB,SAAW,KAAOwG,OAAOkX,qBAGtC2G,QAAQ3wC,KAAKssB,WAGe68B,iBAAiB78B,UAAUnQ,OAAO,SAAUvK,GAAK,MAAOs4B,mBAAkB9uC,SAASwW,KAC1G9R,QAAQ,SAAU0pD,aAC3B,GAAIA,YAAYrf,iBAAkB,CAC9B,GAAqBsf,WAAYD,YAAYrf,iBAAiB,EAC9D,IAAkB,MAAdsf,UACA,KAAM,IAAIhsD,OAAM,kEAEf,IAAkB,MAAdgsD,UACL,KAAM,IAAIhsD,OAAM,sFAEpBq9B,MAAK,IAAM0uB,YAAYrf,iBAAmB,KAAO7d,aAGjDwO,MAAK,IAAMxO,SAAW,KAAOA,WAGA68B,iBAAiB78B,UAAUnQ,OAAO,SAAUvK,GAAK,MAAOw4B,oBAAmBhvC,SAASwW,KAC3G9R,QAAQ,SAAU4pD,cAC5B,GAAqB9uD,MAAO8uD,aAAa9uD,QACzCkgC,MAAK,IAAM4uB,aAAarf,UAAY,KAAO/d,SAAW,IAAM1xB,KAAKkE,KAAK,KAAO,KAEjF,IAAqBikB,OAAQ/a,SAASmhD,iBAAiB78B,UAAW,SAAU1a,GAAK,MAAOk3C,4BAA2Br+B,KAAK,SAAUzmB,GAAK,MAAOA,GAAE5I,SAASwW,MACrJmR,SACAQ,QAAQ+I,UAAYvJ,SAGrB9pB,KAAK0wD,OAAOL,GAAI5Y,OAAQC,QAAS7V,KAAMvX,QAASkwB,OAAQ8V,gBAMnElnB,kBAAkB7oC,UAAUowD,mBAI5B,SAAUC,KAAO,MAAOhuD,cAAaguD,KAAuB,KAAUA,MAAM,GAAGxtD,QAK/EgmC,kBAAkB7oC,UAAUswD,gBAI5B,SAAUC,UAKN,IAAK,GAJgBC,OAAQ,GAAI7sC,KACZ8sC,YAAc,GAAI9sC,KAClB+sC,kBAEKlmD,EAAI+lD,SAAShvD,OAAS,EAAGiJ,GAAK,EAAGA,IAAK,CAC5D,GAAqBmmD,SAAUJ,SAAS/lD,GACnBomD,OAASnxD,KAAK2wD,mBAAmBO,QACtDF,aAAYz0B,IAAI40B,QACXJ,MAAM/8B,IAAIm9B,UACXJ,MAAMx0B,IAAI40B,QACVF,eAAelqD,KAAKmqD,UAG5B,MAAOD,gBAAez0C,WAY1B4sB,kBAAkB7oC,UAAUmwD,OAU5B,SAAU5nC,UAAW2uB,OAAQC,QAAS7V,KAAMvX,QAASkwB,OAAQ8V,eACzD,GAAqBc,cAAepxD,KAAK6wD,gBAAgB/nC,UAAU2uB,OAAS3uB,UAAU2uB,OAAO7uC,OAAO6uC,QAAUA,QACzF4Z,cAAgBrxD,KAAK6wD,gBAAgB/nC,UAAU4uB,QAAU5uB,UAAU4uB,QAAQ9uC,OAAO8uC,SAAWA,SAC7F4Z,WAAaxoC,UAAU+Y,KAAO5/B,YAAa6mB,UAAU+Y,KAAMA,MAAQA,KACnE0vB,cAAgBzoC,UAAUwB,QAAUroB,YAAa6mB,UAAUwB,QAASA,SAAWA,OACpG,IAAIxb,gBAAgB3M,SAAS2mB,WAAY,CACrC,GAAqB0oC,MAAwB,SAC7C,OAAO1iD,kBACHqhB,SAAUqhC,KAAKrhC,SACfsnB,OAAQ2Z,aACR1Z,QAAS2Z,cACTxvB,KAAMyvB,WACN78B,SAAU+8B,KAAK/8B,SACfg9B,SAAUD,KAAKC,SACfnnC,QAASinC,cACT5gB,gBAAiB6gB,KAAK7gB,gBACtBvoB,UAAWopC,KAAKppC,UAChBgB,cAAeooC,KAAKpoC,cACpB0D,gBAAiB0kC,KAAK1kC,gBACtB+sB,SAAU2X,KAAK3X,SACfC,YAAa0X,KAAK1X,YAClBL,OAAQ+X,KAAK/X,OACbC,UAAW8X,KAAK9X,UAChBE,cAAe4X,KAAK5X,cACpBK,WAAYuX,KAAKvX,WACjBE,cAAeqX,KAAKrX,cACpB7R,oBAAqBxf,UAAUwf,sBAInC,MAAOz5B,kBACHshB,SAAUrH,UAAUqH,SACpBsnB,OAAQ2Z,aACR1Z,QAAS2Z,cACTxvB,KAAMyvB,WACN78B,SAAU3L,UAAU2L,SACpBnK,QAASinC,cACTnpC,UAAWU,UAAUV,UAAWoyB,OAAQA,UAI7CpR,qBAmCPz3B,KAAO,EACPvC,KAAO,EACPqD,IAAM,GACNM,MAAQ,GACRL,IAAM,GACNE,IAAM,GACNvD,OAAS,GAETgD,IAAM,GAENhB,GAAK,GAGLe,IAAM,GAINF,MAAQ,GAERD,OAAS,GAET2E,OAAS,GAETI,WAAa,GAEbH,IAAM,GACNF,IAAM,GAENnH,GAAK,GACLC,GAAK,GACLI,GAAK,GACLkC,GAAK,GACL9B,GAAK,GAELH,GAAK,GAKLsB,GAAK,GACLzB,GAAK,GACLmC,GAAK,IACL9B,GAAK,IACLwC,GAAK,IACLG,GAAK,IACLE,GAAK,IAELC,GAAK,IAELlD,GAAK,IACLwH,QAAU,IAGV9H,MAAQ,IAIRgD,IAAM,GA0CNlC,WACAC,UAAW,EACXG,WAAY,EACZE,QAAS,EACTlL,OAAQ,EACRoL,SAAU,EACVI,OAAQ,EACRxM,MAAO,EAEX4L,WAAUA,UAAUC,WAAa,YACjCD,UAAUA,UAAUI,YAAc,aAClCJ,UAAUA,UAAUM,SAAW,UAC/BN,UAAUA,UAAU5K,QAAU,SAC9B4K,UAAUA,UAAUQ,UAAY,WAChCR,UAAUA,UAAUY,QAAU,SAC9BZ,UAAUA,UAAU5L,OAAS,OAC7B,IAAIktD,WAAY,MAAO,MAAO,KAAM,OAAQ,YAAa,OAAQ,QAAS,KAAM,OAAQ,QACpF7oB,MAAuB,WACvB,QAASA,UAoBT,MAdAA,OAAMtoC,UAAUuV,SAIhB,SAAUvF,MAIN,IAHA,GAAqBgB,SAAU,GAAIC,UAASjB,MACvBohD,UACAhsD,MAAQ4L,QAAQqgD,YACrB,MAATjsD,OACHgsD,OAAO5qD,KAAKpB,OACZA,MAAQ4L,QAAQqgD,WAEpB,OAAOD,SAEJ9oB,SAEP14B,MAAuB,WACvB,QAASA,OAAM/K,MAAOgB,KAAMyrD,SAAUC,UAClC9xD,KAAKoF,MAAQA,MACbpF,KAAKoG,KAAOA,KACZpG,KAAK6xD,SAAWA,SAChB7xD,KAAK8xD,SAAWA,SA0IpB,MApIA3hD,OAAM5P,UAAUwxD,YAIhB,SAAU5iD,MACN,MAAOnP,MAAKoG,MAAQgK,UAAUC,WAAarQ,KAAK6xD,UAAY1iD,MAKhEgB,MAAM5P,UAAUyxD,SAGhB,WAAc,MAAOhyD,MAAKoG,MAAQgK,UAAUY,QAI5Cb,MAAM5P,UAAU0xD,SAGhB,WAAc,MAAOjyD,MAAKoG,MAAQgK,UAAU5K,QAK5C2K,MAAM5P,UAAU2xD,WAIhB,SAAUC,UACN,MAAOnyD,MAAKoG,MAAQgK,UAAUQ,UAAY5Q,KAAK8xD,UAAYK,UAK/DhiD,MAAM5P,UAAU+Q,aAGhB,WAAc,MAAOtR,MAAKoG,MAAQgK,UAAUI,YAI5CL,MAAM5P,UAAU6xD,UAGhB,WAAc,MAAOpyD,MAAKoG,MAAQgK,UAAUM,SAI5CP,MAAM5P,UAAU8xD,aAGhB,WAAc,MAAOryD,MAAKoG,MAAQgK,UAAUM,SAA4B,OAAjB1Q,KAAK8xD,UAI5D3hD,MAAM5P,UAAU+xD,YAGhB,WAAc,MAAOtyD,MAAKoG,MAAQgK,UAAUM,SAA4B,MAAjB1Q,KAAK8xD,UAI5D3hD,MAAM5P,UAAUgyD,cAGhB,WAAc,MAAOvyD,MAAKoG,MAAQgK,UAAUM,SAA4B,QAAjB1Q,KAAK8xD,UAI5D3hD,MAAM5P,UAAUiyD,mBAGhB,WACI,MAAOxyD,MAAKoG,MAAQgK,UAAUM,SAA4B,aAAjB1Q,KAAK8xD,UAKlD3hD,MAAM5P,UAAUkyD,cAGhB,WAAc,MAAOzyD,MAAKoG,MAAQgK,UAAUM,SAA4B,QAAjB1Q,KAAK8xD,UAI5D3hD,MAAM5P,UAAUmyD,eAGhB,WAAc,MAAO1yD,MAAKoG,MAAQgK,UAAUM,SAA4B,SAAjB1Q,KAAK8xD,UAI5D3hD,MAAM5P,UAAUoyD,cAGhB,WAAc,MAAO3yD,MAAKoG,MAAQgK,UAAUM,SAA4B,QAAjB1Q,KAAK8xD,UAI5D3hD,MAAM5P,UAAUqyD,QAGhB,WAAc,MAAO5yD,MAAKoG,MAAQgK,UAAU5L,OAI5C2L,MAAM5P,UAAUsyD,SAGhB,WAAc,MAAO7yD,MAAKoG,MAAQgK,UAAUY,OAAShR,KAAK6xD,UAAY,GAItE1hD,MAAM5P,UAAUyF,SAGhB,WACI,OAAQhG,KAAKoG,MACT,IAAKgK,WAAUC,UACf,IAAKD,WAAUI,WACf,IAAKJ,WAAUM,QACf,IAAKN,WAAUQ,SACf,IAAKR,WAAU5K,OACf,IAAK4K,WAAU5L,MACX,MAAOxE,MAAK8xD,QAChB,KAAK1hD,WAAUY,OACX,MAAOhR,MAAK6xD,SAAS7rD,UACzB,SACI,MAAO,QAGZmK,SA0DP2iD,IAAM,GAAI3iD,QAAO,EAAGC,UAAUC,UAAW,EAAG,IAC5CmB,SAA0B,WAC1B,QAASA,UAASjP,OACdvC,KAAKuC,MAAQA,MACbvC,KAAKyR,KAAO,EACZzR,KAAKoF,OAAS,EACdpF,KAAK8B,OAASS,MAAMT,OACpB9B,KAAK0R,UAmRT,MA9QAF,UAASjR,UAAUmR,QAGnB,WACI1R,KAAKyR,OAASzR,KAAKoF,OAASpF,KAAK8B,OAAS6P,KAAO3R,KAAKuC,MAAM+C,WAAWtF,KAAKoF,QAKhFoM,SAASjR,UAAUqxD,UAGnB,WAII,IAHA,GAAqBrvD,OAAQvC,KAAKuC,MAAwBT,OAAS9B,KAAK8B,OACnD2P,KAAOzR,KAAKyR,KAAuBrM,MAAQpF,KAAKoF,MAE9DqM,MAAQpC,QAAQ,CACnB,KAAMjK,OAAStD,OAAQ,CACnB2P,KAAOE,IACP,OAGAF,KAAOlP,MAAM+C,WAAWF,OAKhC,GAFApF,KAAKyR,KAAOA,KACZzR,KAAKoF,MAAQA,MACTA,OAAStD,OACT,MAAO,KAGX,IAAIqP,kBAAkBM,MAClB,MAAOzR,MAAK+yD,gBAChB,IAAIxjD,QAAQkC,MACR,MAAOzR,MAAKgzD,WAAW5tD,MAC3B,IAAqB2E,OAAQ3E,KAC7B,QAAQqM,MACJ,IAjXE,IAmXE,MADAzR,MAAK0R,UACEnC,QAAQvP,KAAKyR,MAAQzR,KAAKgzD,WAAWjpD,OACxCmG,kBAAkBnG,MApXxB,GAqXF,KA3XE,IA4XF,IA3XE,IA4XF,IAAKqN,SACL,IAxVE,KAyVF,IA1WI,IA2WJ,IAzWI,IA0WJ,IA7XC,IA8XD,IA1XC,IA2XD,IAAKJ,YACD,MAAOhX,MAAKizD,cAAclpD,MAAO0H,KACrC,KAAKW,KACL,IAAKC,KACD,MAAOrS,MAAKkzD,YAChB,KA7YA,IA8YA,IAAKhhD,OACL,IAAKD,QACL,IAzYA,IA0YA,IAAK2E,QACL,IAhZG,IAiZH,IAtXC,IAuXG,MAAO5W,MAAKmzD,aAAappD,MAAOvE,OAAOC,aAAagM,MACxD,KAnYI,IAoYA,MAAOzR,MAAKozD,oBAAoBrpD,MAAO,IA3YzC,GA2YuD,IACzD,KAxYF,IAyYE,IAAK4M,KACD,MAAO3W,MAAKozD,oBAAoBrpD,MAAOvE,OAAOC,aAAagM,MAAOoF,IAAK,IAC3E,KA5ZA,IA6ZA,IAAKA,KACD,MAAO7W,MAAKozD,oBAAoBrpD,MAAOvE,OAAOC,aAAagM,MAAOoF,IAAK,IAAKA,IAAK,IACrF,KA1ZK,IA2ZD,MAAO7W,MAAKozD,oBAAoBrpD,MAAO,IA3ZtC,GA2ZuD,IAC5D,KArXD,KAsXK,MAAO/J,MAAKozD,oBAAoBrpD,MAAO,IAtX5C,IAsXuD,IACtD,KAAKuF,OACD,KAAOJ,aAAalP,KAAKyR,OACrBzR,KAAK0R,SACT,OAAO1R,MAAK4xD,YAGpB,MADA5xD,MAAK0R,UACE1R,KAAKuE,MAAM,yBAA2BiB,OAAOC,aAAagM,MAAQ,IAAK,IAOlFD,SAASjR,UAAU0yD,cAKnB,SAAUlpD,MAAOoF,MAEb,MADAnP,MAAK0R,UACExB,kBAAkBnG,MAAOoF,OAOpCqC,SAASjR,UAAU4yD,aAKnB,SAAUppD,MAAO7E,KAEb,MADAlF,MAAK0R,UACEf,iBAAiB5G,MAAO7E,MAuBnCsM,SAASjR,UAAU6yD,oBAWnB,SAAUrpD,MAAOspD,IAAKC,QAASC,IAAKC,UAAWC,OAC3CzzD,KAAK0R,SACL,IAAqBxM,KAAMmuD,GAS3B,OARIrzD,MAAKyR,MAAQ6hD,UACbtzD,KAAK0R,UACLxM,KAAOquD,KAEM,MAAbC,WAAqBxzD,KAAKyR,MAAQ+hD,YAClCxzD,KAAK0R,UACLxM,KAAOuuD,OAEJ9iD,iBAAiB5G,MAAO7E,MAKnCsM,SAASjR,UAAUwyD,eAGnB,WACI,GAAqBhpD,OAAQ/J,KAAKoF,KAElC,KADApF,KAAK0R,UACEE,iBAAiB5R,KAAKyR,OACzBzR,KAAK0R,SACT,IAAqBxM,KAAMlF,KAAKuC,MAAM2D,UAAU6D,MAAO/J,KAAKoF,MAC5D,OAAOssD,UAASxuD,QAAQgC,MAAQ,EAAIuL,gBAAgB1G,MAAO7E,KACvDoL,mBAAmBvG,MAAO7E,MAMlCsM,SAASjR,UAAUyyD,WAInB,SAAUjpD,OACN,GAAqB2pD,QAAU1zD,KAAKoF,QAAU2E,KAE9C,KADA/J,KAAK0R,YACQ,CACT,GAAInC,QAAQvP,KAAKyR,WAGZ,IArgBH,IAqgBOzR,KAAKyR,KACViiD,QAAS,MAER,CAAA,IAAI7hD,gBAAgB7R,KAAKyR,MAS1B,KALA,IAHAzR,KAAK0R,UACDM,eAAehS,KAAKyR,OACpBzR,KAAK0R,WACJnC,QAAQvP,KAAKyR,MACd,MAAOzR,MAAKuE,MAAM,oBAAqB,EAC3CmvD,SAAS,EAKb1zD,KAAK0R,UAET,GAAqBxM,KAAMlF,KAAKuC,MAAM2D,UAAU6D,MAAO/J,KAAKoF,MAE5D,OAAO0L,gBAAe/G,MADO2pD,OAAS1gD,kBAAkB9N,KAAOyuD,WAAWzuD,OAM9EsM,SAASjR,UAAU2yD,WAGnB,WACI,GAAqBnpD,OAAQ/J,KAAKoF,MACbwuD,MAAQ5zD,KAAKyR,IAClCzR,MAAK0R,SAIL,KAHA,GAAqBmiD,QAAS,GACTC,OAAS9zD,KAAKoF,MACd7C,MAAQvC,KAAKuC,MAC3BvC,KAAKyR,MAAQmiD,OAChB,GAvhBK,IAuhBD5zD,KAAKyR,KAAoB,CACzBoiD,QAAUtxD,MAAM2D,UAAU4tD,OAAQ9zD,KAAKoF,OACvCpF,KAAK0R,SACL,IAAqBqiD,mBAAgB,EAGrC,IADA/zD,KAAKyR,KAAOzR,KAAKyR,KAlhBxB,KAmhBWzR,KAAKyR,KAAY,CAEjB,GAAqB0K,KAAM5Z,MAAM2D,UAAUlG,KAAKoF,MAAQ,EAAGpF,KAAKoF,MAAQ,EACxE,KAAI,eAAeiG,KAAK8Q,KAIpB,MAAOnc,MAAKuE,MAAM,8BAAgC4X,IAAM,IAAK,EAH7D43C,eAAgB9gD,SAASkJ,IAAK,GAKlC,KAAK,GAAqBpR,GAAI,EAAGA,EAAI,EAAGA,IACpC/K,KAAK0R,cAITqiD,eAAgBxhD,SAASvS,KAAKyR,MAC9BzR,KAAK0R,SAETmiD,SAAUruD,OAAOC,aAAasuD,eAC9BD,OAAS9zD,KAAKoF,UAEb,CAAA,GAAIpF,KAAKyR,MAAQE,KAClB,MAAO3R,MAAKuE,MAAM,qBAAsB,EAGxCvE,MAAK0R,UAGb,GAAqBsiD,MAAOzxD,MAAM2D,UAAU4tD,OAAQ9zD,KAAKoF,MAEzD,OADApF,MAAK0R,UACEb,eAAe9G,MAAO8pD,OAASG,OAO1CxiD,SAASjR,UAAUgE,MAKnB,SAAU2M,QAASjH,QACf,GAAqBM,UAAWvK,KAAKoF,MAAQ6E,MAC7C,OAAOgH,eAAc1G,SAAU,gBAAkB2G,QAAU,cAAgB3G,SAAW,mBAAqBvK,KAAKuC,MAAQ,MAErHiP,YAoGPyiD,YAA6B,WAC7B,QAASA,aAAY/iD,QAAS3O,MAAO2xD,YAAaC,aAC9Cn0D,KAAKuC,MAAQA,MACbvC,KAAKk0D,YAAcA,YACnBl0D,KAAKm0D,YAAcA,YACnBn0D,KAAKkR,QAAU,iBAAmBA,QAAU,IAAMgjD,YAAc,KAAO3xD,MAAQ,QAAU4xD,YAE7F,MAAOF,gBAEPG,UAA2B,WAC3B,QAASA,WAAUrqD,MAAOG,KACtBlK,KAAK+J,MAAQA,MACb/J,KAAKkK,IAAMA,IAEf,MAAOkqD,cAEPC,IAAqB,WACrB,QAASA,KAAI1pD,MACT3K,KAAK2K,KAAOA,KAuBhB,MAhBA0pD,KAAI9zD,UAAUoG,MAKd,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7B,MAKX6wD,IAAI9zD,UAAUyF,SAGd,WAAc,MAAO,OACdquD,OAePC,MAAuB,SAAU7pD,QAEjC,QAAS6pD,OAAM3pD,KAAMmC,OAAQynD,wBAAyBC,UAClD,GAAIzwB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAIvC,OAHA+jC,OAAMj3B,OAASA,OACfi3B,MAAMwwB,wBAA0BA,wBAChCxwB,MAAMywB,SAAWA,SACVzwB,MAuBX,MA7BA9jC,WAAUq0D,MAAO7pD,QAajB6pD,MAAM/zD,UAAUoG,MAKhB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQwR,WAAW/U,KAAMwD,UAKpC8wD,MAAM/zD,UAAUyF,SAGhB,WAAc,MAAO,SACdsuD,OACTD,KACEv+B,UAA2B,SAAUrrB,QAErC,QAASqrB,aACL,MAAkB,QAAXrrB,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KAgB/D,MAlBAC,WAAU61B,UAAWrrB,QASrBqrB,UAAUv1B,UAAUoG,MAKpB,SAAUpD,QAASC,aACC,KAAZA,UAAsBA,QAAU,OAGjCsyB,WACTu+B,KACEI,iBAAkC,SAAUhqD,QAE5C,QAASgqD,oBACL,MAAkB,QAAXhqD,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KAgB/D,MAlBAC,WAAUw0D,iBAAkBhqD,QAS5BgqD,iBAAiBl0D,UAAUoG,MAK3B,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQuQ,sBAAsB9T,KAAMwD,UAExCixD,kBACTJ,KAIEK,MAAuB,SAAUjqD,QAEjC,QAASiqD,OAAM/pD,KAAM6I,aACjB,GAAIuwB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAEvC,OADA+jC,OAAMvwB,YAAcA,YACbuwB,MAgBX,MApBA9jC,WAAUy0D,MAAOjqD,QAWjBiqD,MAAMn0D,UAAUoG,MAKhB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQgQ,WAAWvT,KAAMwD,UAE7BkxD,OACTL,KACEM,YAA6B,SAAUlqD,QAEvC,QAASkqD,aAAYhqD,KAAMsE,UAAWyE,QAASC,UAC3C,GAAIowB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAIvC,OAHA+jC,OAAM90B,UAAYA,UAClB80B,MAAMrwB,QAAUA,QAChBqwB,MAAMpwB,SAAWA,SACVowB,MAgBX,MAtBA9jC,WAAU00D,YAAalqD,QAavBkqD,YAAYp0D,UAAUoG,MAKtB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQkQ,iBAAiBzT,KAAMwD,UAEnCmxD,aACTN,KACEO,aAA8B,SAAUnqD,QAExC,QAASmqD,cAAajqD,KAAM4J,SAAU9S,MAClC,GAAIsiC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAGvC,OAFA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAMtiC,KAAOA,KACNsiC,MAgBX,MArBA9jC,WAAU20D,aAAcnqD,QAYxBmqD,aAAar0D,UAAUoG,MAKvB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQsR,kBAAkB7U,KAAMwD,UAEpCoxD,cACTP,KACEQ,cAA+B,SAAUpqD,QAEzC,QAASoqD,eAAclqD,KAAM4J,SAAU9S,KAAM6B,OACzC,GAAIygC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAIvC,OAHA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAMtiC,KAAOA,KACbsiC,MAAMzgC,MAAQA,MACPygC,MAgBX,MAtBA9jC,WAAU40D,cAAepqD,QAazBoqD,cAAct0D,UAAUoG,MAKxB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQuR,mBAAmB9U,KAAMwD,UAErCqxD,eACTR,KACES,iBAAkC,SAAUrqD,QAE5C,QAASqqD,kBAAiBnqD,KAAM4J,SAAU9S,MACtC,GAAIsiC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAGvC,OAFA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAMtiC,KAAOA,KACNsiC,MAgBX,MArBA9jC,WAAU60D,iBAAkBrqD,QAY5BqqD,iBAAiBv0D,UAAUoG,MAK3B,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQ0R,sBAAsBjV,KAAMwD,UAExCsxD,kBACTT,KACEU,UAA2B,SAAUtqD,QAErC,QAASsqD,WAAUpqD,KAAMvI,IAAK6R,KAC1B,GAAI8vB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAGvC,OAFA+jC,OAAM3hC,IAAMA,IACZ2hC,MAAM9vB,IAAMA,IACL8vB,MAgBX,MArBA9jC,WAAU80D,UAAWtqD,QAYrBsqD,UAAUx0D,UAAUoG,MAKpB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQyQ,eAAehU,KAAMwD,UAEjCuxD,WACTV,KACEW,WAA4B,SAAUvqD,QAEtC,QAASuqD,YAAWrqD,KAAMvI,IAAK6R,IAAK3Q,OAChC,GAAIygC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAIvC,OAHA+jC,OAAM3hC,IAAMA,IACZ2hC,MAAM9vB,IAAMA,IACZ8vB,MAAMzgC,MAAQA,MACPygC,MAgBX,MAtBA9jC,WAAU+0D,WAAYvqD,QAatBuqD,WAAWz0D,UAAUoG,MAKrB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQ2Q,gBAAgBlU,KAAMwD,UAElCwxD,YACTX,KACEY,YAA6B,SAAUxqD,QAEvC,QAASwqD,aAAYtqD,KAAM8J,IAAKhT,KAAME,MAClC,GAAIoiC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAIvC,OAHA+jC,OAAMtvB,IAAMA,IACZsvB,MAAMtiC,KAAOA,KACbsiC,MAAMpiC,KAAOA,KACNoiC,MAgBX,MAtBA9jC,WAAUg1D,YAAaxqD,QAavBwqD,YAAY10D,UAAUoG,MAKtB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQiR,UAAUxU,KAAMwD,UAE5ByxD,aACTZ,KACEa,iBAAkC,SAAUzqD,QAE5C,QAASyqD,kBAAiBvqD,KAAMrH,OAC5B,GAAIygC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAEvC,OADA+jC,OAAMzgC,MAAQA,MACPygC,MAgBX,MApBA9jC,WAAUi1D,iBAAkBzqD,QAW5ByqD,iBAAiB30D,UAAUoG,MAK3B,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQ8Q,sBAAsBrU,KAAMwD,UAExC0xD,kBACTb,KACEc,aAA8B,SAAU1qD,QAExC,QAAS0qD,cAAaxqD,KAAM6I,aACxB,GAAIuwB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAEvC,OADA+jC,OAAMvwB,YAAcA,YACbuwB,MAgBX,MApBA9jC,WAAUk1D,aAAc1qD,QAWxB0qD,aAAa50D,UAAUoG,MAKvB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQ4Q,kBAAkBnU,KAAMwD,UAEpC2xD,cACTd,KACEe,WAA4B,SAAU3qD,QAEtC,QAAS2qD,YAAWzqD,KAAMssB,KAAMl1B,QAC5B,GAAIgiC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAGvC,OAFA+jC,OAAM9M,KAAOA,KACb8M,MAAMhiC,OAASA,OACRgiC,MAgBX,MArBA9jC,WAAUm1D,WAAY3qD,QAYtB2qD,WAAW70D,UAAUoG,MAKrB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQ6Q,gBAAgBpU,KAAMwD,UAElC4xD,YACTf,KACEgB,cAA+B,SAAU5qD,QAEzC,QAAS4qD,eAAc1qD,KAAM2qD,QAAS9hD,aAClC,GAAIuwB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAGvC,OAFA+jC,OAAMuxB,QAAUA,QAChBvxB,MAAMvwB,YAAcA,YACbuwB,MAgBX,MArBA9jC,WAAUo1D,cAAe5qD,QAYzB4qD,cAAc90D,UAAUoG,MAKxB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQwQ,mBAAmB/T,KAAMwD,UAErC6xD,eACThB,KACEkB,OAAwB,SAAU9qD,QAElC,QAAS8qD,QAAO5qD,KAAM6qD,UAAWniD,KAAMC,OACnC,GAAIywB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAIvC,OAHA+jC,OAAMyxB,UAAYA,UAClBzxB,MAAM1wB,KAAOA,KACb0wB,MAAMzwB,MAAQA,MACPywB,MAgBX,MAtBA9jC,WAAUs1D,OAAQ9qD,QAalB8qD,OAAOh1D,UAAUoG,MAKjB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQ6P,YAAYpT,KAAMwD,UAE9B+xD,QACTlB,KACEoB,UAA2B,SAAUhrD,QAErC,QAASgrD,WAAU9qD,KAAMgK,YACrB,GAAIovB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAEvC,OADA+jC,OAAMpvB,WAAaA,WACZovB,MAgBX,MApBA9jC,WAAUw1D,UAAWhrD,QAWrBgrD,UAAUl1D,UAAUoG,MAKpB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQmR,eAAe1U,KAAMwD,UAEjCiyD,WACTpB,KACEqB,cAA+B,SAAUjrD,QAEzC,QAASirD,eAAc/qD,KAAMgK,YACzB,GAAIovB,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAEvC,OADA+jC,OAAMpvB,WAAaA,WACZovB,MAgBX,MApBA9jC,WAAUy1D,cAAejrD,QAWzBirD,cAAcn1D,UAAUoG,MAKxB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQqR,mBAAmB5U,KAAMwD,UAErCkyD,eACTrB,KACEsB,WAA4B,SAAUlrD,QAEtC,QAASkrD,YAAWhrD,KAAM4J,SAAU9S,KAAME,MACtC,GAAIoiC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAIvC,OAHA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAMtiC,KAAOA,KACbsiC,MAAMpiC,KAAOA,KACNoiC,MAgBX,MAtBA9jC,WAAU01D,WAAYlrD,QAatBkrD,WAAWp1D,UAAUoG,MAKrB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQ+Q,gBAAgBtU,KAAMwD,UAElCmyD,YACTtB,KACEuB,eAAgC,SAAUnrD,QAE1C,QAASmrD,gBAAejrD,KAAM4J,SAAU9S,KAAME,MAC1C,GAAIoiC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAIvC,OAHA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAMtiC,KAAOA,KACbsiC,MAAMpiC,KAAOA,KACNoiC,MAgBX,MAtBA9jC,WAAU21D,eAAgBnrD,QAa1BmrD,eAAer1D,UAAUoG,MAKzB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQyR,oBAAoBhV,KAAMwD,UAEtCoyD,gBACTvB,KACEwB,aAA8B,SAAUprD,QAExC,QAASorD,cAAalrD,KAAMkJ,OAAQlS,MAChC,GAAIoiC,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,OAAS3K,IAGvC,OAFA+jC,OAAMlwB,OAASA,OACfkwB,MAAMpiC,KAAOA,KACNoiC,MAgBX,MArBA9jC,WAAU41D,aAAcprD,QAYxBorD,aAAat1D,UAAUoG,MAKvB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BD,QAAQqQ,kBAAkB5T,KAAMwD,UAEpCqyD,cACTxB,KACEx+B,cAA+B,SAAUprB,QAEzC,QAASorB,eAAcjvB,IAAKmP,OAAQy+C,SAAUviC,QAC1C,GAAI8R,OAAQt5B,OAAO8kC,KAAKvvC,KAAM,GAAIo0D,WAAU,EAAa,MAAVr+C,OAAiB,EAAIA,OAAOjU,UAAY9B,IAKvF,OAJA+jC,OAAMn9B,IAAMA,IACZm9B,MAAMhuB,OAASA,OACfguB,MAAMywB,SAAWA,SACjBzwB,MAAM9R,OAASA,OACR8R,MAuBX,MA9BA9jC,WAAU41B,cAAeprB,QAczBorB,cAAct1B,UAAUoG,MAKxB,SAAUpD,QAASC,SAEf,WADgB,KAAZA,UAAsBA,QAAU,MAC7BxD,KAAK4G,IAAID,MAAMpD,QAASC,UAKnCqyB,cAAct1B,UAAUyF,SAGxB,WAAc,MAAOhG,MAAK+V,OAAS,OAAS/V,KAAKw0D,UAC1C3+B,eACTw+B,KACEyB,gBAAiC,WACjC,QAASA,iBAAgBnrD,KAAMsJ,IAAK8hD,SAAUt0D,KAAMkT,YAChD3U,KAAK2K,KAAOA,KACZ3K,KAAKiU,IAAMA,IACXjU,KAAK+1D,SAAWA,SAChB/1D,KAAKyB,KAAOA,KACZzB,KAAK2U,WAAaA,WAEtB,MAAOmhD,oBAMPE,eAAgC,WAChC,QAASA,mBA8NT,MAvNAA,gBAAez1D,UAAU6S,YAKzB,SAAUxM,IAAKpD,WAMfwyD,eAAez1D,UAAUgT,WAKzB,SAAU3M,IAAKpD,WAMfwyD,eAAez1D,UAAUkT,iBAKzB,SAAU7M,IAAKpD,WAMfwyD,eAAez1D,UAAUqT,kBAKzB,SAAUhN,IAAKpD,WAMfwyD,eAAez1D,UAAUuT,sBAKzB,SAAUlN,IAAKpD,WAMfwyD,eAAez1D,UAAUwT,mBAKzB,SAAUnN,IAAKpD,WAMfwyD,eAAez1D,UAAUyT,eAKzB,SAAUpN,IAAKpD,WAMfwyD,eAAez1D,UAAU2T,gBAKzB,SAAUtN,IAAKpD,WAMfwyD,eAAez1D,UAAU4T,kBAKzB,SAAUvN,IAAKpD,WAMfwyD,eAAez1D,UAAU6T,gBAKzB,SAAUxN,IAAKpD,WAMfwyD,eAAez1D,UAAU8T,sBAKzB,SAAUzN,IAAKpD,WAMfwyD,eAAez1D,UAAU+T,gBAKzB,SAAU1N,IAAKpD,WAMfwyD,eAAez1D,UAAUiU,UAKzB,SAAU5N,IAAKpD,WAMfwyD,eAAez1D,UAAUmU,eAKzB,SAAU9N,IAAKpD,WAMfwyD,eAAez1D,UAAUqU,mBAKzB,SAAUhO,IAAKpD,WAMfwyD,eAAez1D,UAAUsU,kBAKzB,SAAUjO,IAAKpD,WAMfwyD,eAAez1D,UAAUuU,mBAKzB,SAAUlO,IAAKpD,WAMfwyD,eAAez1D,UAAUwU,WAKzB,SAAUnO,IAAKpD,WAMfwyD,eAAez1D,UAAUyU,oBAKzB,SAAUpO,IAAKpD,WAMfwyD,eAAez1D,UAAU0U,sBAKzB,SAAUrO,IAAKpD,WACRwyD,kBAEPC,oBAAqC,WACrC,QAASA,wBAiST,MA1RAA,qBAAoB11D,UAAU6S,YAK9B,SAAUxM,IAAKpD,SAGX,MAFAoD,KAAIyM,KAAK1M,MAAM3G,MACf4G,IAAI0M,MAAM3M,MAAM3G,MACT,MAOXi2D,oBAAoB11D,UAAUgT,WAK9B,SAAU3M,IAAKpD,SAAW,MAAOxD,MAAK4J,SAAShD,IAAI4M,YAAahQ,UAMhEyyD,oBAAoB11D,UAAUkT,iBAK9B,SAAU7M,IAAKpD,SAIX,MAHAoD,KAAIqI,UAAUtI,MAAM3G,MACpB4G,IAAI8M,QAAQ/M,MAAM3G,MAClB4G,IAAI+M,SAAShN,MAAM3G,MACZ,MAOXi2D,oBAAoB11D,UAAUiU,UAK9B,SAAU5N,IAAKpD,SAGX,MAFAoD,KAAI6N,IAAI9N,MAAM3G,MACdA,KAAK4J,SAAShD,IAAIjF,KAAM6B,SACjB,MAOXyyD,oBAAoB11D,UAAUqT,kBAK9B,SAAUhN,IAAKpD,SAGX,MAFmBoD,KAAW,OAAED,MAAM3G,MACtCA,KAAK4J,SAAShD,IAAIjF,KAAM6B,SACjB,MAOXyyD,oBAAoB11D,UAAUuT,sBAK9B,SAAUlN,IAAKpD,SAAW,MAAO,OAMjCyyD,oBAAoB11D,UAAUwT,mBAK9B,SAAUnN,IAAKpD,SACX,MAAOxD,MAAK4J,SAAShD,IAAI4M,YAAahQ,UAO1CyyD,oBAAoB11D,UAAUyT,eAK9B,SAAUpN,IAAKpD,SAGX,MAFAoD,KAAIxE,IAAIuE,MAAM3G,MACd4G,IAAIqN,IAAItN,MAAM3G,MACP,MAOXi2D,oBAAoB11D,UAAU2T,gBAK9B,SAAUtN,IAAKpD,SAIX,MAHAoD,KAAIxE,IAAIuE,MAAM3G,MACd4G,IAAIqN,IAAItN,MAAM3G,MACd4G,IAAItD,MAAMqD,MAAM3G,MACT,MAOXi2D,oBAAoB11D,UAAU4T,kBAK9B,SAAUvN,IAAKpD,SACX,MAAOxD,MAAK4J,SAAShD,IAAI4M,YAAahQ,UAO1CyyD,oBAAoB11D,UAAU6T,gBAK9B,SAAUxN,IAAKpD,SAAW,MAAOxD,MAAK4J,SAAShD,IAAI7E,OAAQyB,UAM3DyyD,oBAAoB11D,UAAU8T,sBAK9B,SAAUzN,IAAKpD,SAAW,MAAO,OAMjCyyD,oBAAoB11D,UAAU+T,gBAK9B,SAAU1N,IAAKpD,SAEX,MADAoD,KAAI2N,SAAS5N,MAAM3G,MACZA,KAAK4J,SAAShD,IAAIjF,KAAM6B,UAOnCyyD,oBAAoB11D,UAAUmU,eAK9B,SAAU9N,IAAKpD,SAEX,MADAoD,KAAI+N,WAAWhO,MAAM3G;kCACd,MAOXi2D,oBAAoB11D,UAAUqU,mBAK9B,SAAUhO,IAAKpD,SAEX,MADAoD,KAAI+N,WAAWhO,MAAM3G,MACd,MAOXi2D,oBAAoB11D,UAAUsU,kBAK9B,SAAUjO,IAAKpD,SAEX,MADAoD,KAAI2N,SAAS5N,MAAM3G,MACZ,MAOXi2D,oBAAoB11D,UAAUuU,mBAK9B,SAAUlO,IAAKpD,SAGX,MAFAoD,KAAI2N,SAAS5N,MAAM3G,MACnB4G,IAAItD,MAAMqD,MAAM3G,MACT,MAOXi2D,oBAAoB11D,UAAU0U,sBAK9B,SAAUrO,IAAKpD,SAEX,MADAoD,KAAI2N,SAAS5N,MAAM3G,MACZ,MAOXi2D,oBAAoB11D,UAAUyU,oBAK9B,SAAUpO,IAAKpD,SAEX,MADAoD,KAAI2N,SAAS5N,MAAM3G,MACZA,KAAK4J,SAAShD,IAAIjF,KAAM6B,UAOnCyyD,oBAAoB11D,UAAUqJ,SAK9B,SAAUnD,KAAMjD,SACZ,GAAIugC,OAAQ/jC,IAEZ,OADAyG,MAAKI,QAAQ,SAAUD,KAAO,MAAOA,KAAID,MAAMo9B,MAAOvgC,WAC/C,MAOXyyD,oBAAoB11D,UAAUwU,WAK9B,SAAUnO,IAAKpD,SAAW,MAAO,OAC1ByyD,uBAEPC,eAAgC,WAChC,QAASA,mBAmRT,MA5QAA,gBAAe31D,UAAUuT,sBAKzB,SAAUlN,IAAKpD,SAAW,MAAOoD,MAMjCsvD,eAAe31D,UAAUwT,mBAKzB,SAAUnN,IAAKpD,SACX,MAAO,IAAI6xD,eAAczuD,IAAI+D,KAAM/D,IAAI0uD,QAASt1D,KAAK4J,SAAShD,IAAI4M,eAOtE0iD,eAAe31D,UAAU8T,sBAKzB,SAAUzN,IAAKpD,SACX,MAAO,IAAI0xD,kBAAiBtuD,IAAI+D,KAAM/D,IAAItD,QAO9C4yD,eAAe31D,UAAUsU,kBAKzB,SAAUjO,IAAKpD,SACX,MAAO,IAAIoxD,cAAahuD,IAAI+D,KAAM/D,IAAI2N,SAAS5N,MAAM3G,MAAO4G,IAAInF,OAOpEy0D,eAAe31D,UAAUuU,mBAKzB,SAAUlO,IAAKpD,SACX,MAAO,IAAIqxD,eAAcjuD,IAAI+D,KAAM/D,IAAI2N,SAAS5N,MAAM3G,MAAO4G,IAAInF,KAAMmF,IAAItD,MAAMqD,MAAM3G,QAO3Fk2D,eAAe31D,UAAU0U,sBAKzB,SAAUrO,IAAKpD,SACX,MAAO,IAAIsxD,kBAAiBluD,IAAI+D,KAAM/D,IAAI2N,SAAS5N,MAAM3G,MAAO4G,IAAInF,OAOxEy0D,eAAe31D,UAAU+T,gBAKzB,SAAU1N,IAAKpD,SACX,MAAO,IAAImyD,YAAW/uD,IAAI+D,KAAM/D,IAAI2N,SAAS5N,MAAM3G,MAAO4G,IAAInF,KAAMzB,KAAK4J,SAAShD,IAAIjF,QAO1Fu0D,eAAe31D,UAAUyU,oBAKzB,SAAUpO,IAAKpD,SACX,MAAO,IAAIoyD,gBAAehvD,IAAI+D,KAAM/D,IAAI2N,SAAS5N,MAAM3G,MAAO4G,IAAInF,KAAMzB,KAAK4J,SAAShD,IAAIjF,QAO9Fu0D,eAAe31D,UAAUqT,kBAKzB,SAAUhN,IAAKpD,SACX,MAAO,IAAIqyD,cAAajvD,IAAI+D,KAAyB/D,IAAW,OAAED,MAAM3G,MAAOA,KAAK4J,SAAShD,IAAIjF,QAOrGu0D,eAAe31D,UAAU4T,kBAKzB,SAAUvN,IAAKpD,SACX,MAAO,IAAI2xD,cAAavuD,IAAI+D,KAAM3K,KAAK4J,SAAShD,IAAI4M,eAOxD0iD,eAAe31D,UAAU6T,gBAKzB,SAAUxN,IAAKpD,SACX,MAAO,IAAI4xD,YAAWxuD,IAAI+D,KAAM/D,IAAIqwB,KAAMj3B,KAAK4J,SAAShD,IAAI7E,UAOhEm0D,eAAe31D,UAAU6S,YAKzB,SAAUxM,IAAKpD,SACX,MAAO,IAAI+xD,QAAO3uD,IAAI+D,KAAM/D,IAAI4uD,UAAW5uD,IAAIyM,KAAK1M,MAAM3G,MAAO4G,IAAI0M,MAAM3M,MAAM3G,QAOrFk2D,eAAe31D,UAAUmU,eAKzB,SAAU9N,IAAKpD,SACX,MAAO,IAAIiyD,WAAU7uD,IAAI+D,KAAM/D,IAAI+N,WAAWhO,MAAM3G,QAOxDk2D,eAAe31D,UAAUqU,mBAKzB,SAAUhO,IAAKpD,SACX,MAAO,IAAIkyD,eAAc9uD,IAAI+D,KAAM/D,IAAI+N,WAAWhO,MAAM3G,QAO5Dk2D,eAAe31D,UAAUkT,iBAKzB,SAAU7M,IAAKpD,SACX,MAAO,IAAImxD,aAAY/tD,IAAI+D,KAAM/D,IAAIqI,UAAUtI,MAAM3G,MAAO4G,IAAI8M,QAAQ/M,MAAM3G,MAAO4G,IAAI+M,SAAShN,MAAM3G,QAO5Gk2D,eAAe31D,UAAUiU,UAKzB,SAAU5N,IAAKpD,SACX,MAAO,IAAIyxD,aAAYruD,IAAI+D,KAAM/D,IAAI6N,IAAI9N,MAAM3G,MAAO4G,IAAInF,KAAMzB,KAAK4J,SAAShD,IAAIjF,QAOtFu0D,eAAe31D,UAAUyT,eAKzB,SAAUpN,IAAKpD,SACX,MAAO,IAAIuxD,WAAUnuD,IAAI+D,KAAM/D,IAAIxE,IAAIuE,MAAM3G,MAAO4G,IAAIqN,IAAItN,MAAM3G,QAOtEk2D,eAAe31D,UAAU2T,gBAKzB,SAAUtN,IAAKpD,SACX,MAAO,IAAIwxD,YAAWpuD,IAAI+D,KAAM/D,IAAIxE,IAAIuE,MAAM3G,MAAO4G,IAAIqN,IAAItN,MAAM3G,MAAO4G,IAAItD,MAAMqD,MAAM3G,QAM9Fk2D,eAAe31D,UAAUqJ,SAIzB,SAAUnD,MAEN,IAAK,GADgBV,KAAM,GAAItC,OAAMgD,KAAK3E,QAChBiJ,EAAI,EAAGA,EAAItE,KAAK3E,SAAUiJ,EAChDhF,IAAIgF,GAAKtE,KAAKsE,GAAGpE,MAAM3G,KAE3B,OAAO+F,MAOXmwD,eAAe31D,UAAUgT,WAKzB,SAAU3M,IAAKpD,SACX,MAAO,IAAIkxD,OAAM9tD,IAAI+D,KAAM3K,KAAK4J,SAAShD,IAAI4M,eAOjD0iD,eAAe31D,UAAUwU,WAKzB,SAAUnO,IAAKpD,SACX,MAAO,IAAI8wD,OAAM1tD,IAAI+D,KAAM/D,IAAIkG,OAAQlG,IAAI2tD,wBAAyB3tD,IAAI4tD,WAErE0B,kBAwKPC,mBAAoC,WACpC,QAASA,oBAAmBb,QAAS9hD,YAAa4iD,SAC9Cp2D,KAAKs1D,QAAUA,QACft1D,KAAKwT,YAAcA,YACnBxT,KAAKo2D,QAAUA,QAEnB,MAAOD,uBAEPE,2BAA4C,WAC5C,QAASA,4BAA2BC,iBAAkBhiC,SAAUrC,QAC5DjyB,KAAKs2D,iBAAmBA,iBACxBt2D,KAAKs0B,SAAWA,SAChBt0B,KAAKiyB,OAASA,OAElB,MAAOokC,+BAUPztB,OAAwB,WACxB,QAASA,QAAO2tB,QACZv2D,KAAKu2D,OAASA,OACdv2D,KAAKiyB,UAuTT,MA/SA2W,QAAOroC,UAAUi2D,YAMjB,SAAUj0D,MAAOiyD,SAAUt+C,yBACK,KAAxBA,sBAAkCA,oBAAsBC,8BAC5DnW,KAAKy2D,sBAAsBl0D,MAAOiyD,SAAUt+C,oBAC5C,IAAqBwgD,aAAc12D,KAAK22D,eAAep0D,OAClCovD,OAAS3xD,KAAKu2D,OAAOzgD,SAAS9V,KAAK22D,eAAep0D,QAClDqE,IAAM,GAAIgwD,WAAUr0D,MAAOiyD,SAAU7C,OAAQ+E,YAAY50D,QAAQ,EAAM9B,KAAKiyB,OAAQ1vB,MAAMT,OAAS40D,YAAY50D,QAC/H+0D,YACL,OAAO,IAAIhhC,eAAcjvB,IAAKrE,MAAOiyD,SAAUx0D,KAAKiyB,SAQxD2W,OAAOroC,UAAUu2D,aAMjB,SAAUv0D,MAAOiyD,SAAUt+C,yBACK,KAAxBA,sBAAkCA,oBAAsBC,6BAC5D,IAAqBvP,KAAM5G,KAAK+2D,iBAAiBx0D,MAAOiyD,SAAUt+C,oBAClE,OAAO,IAAI2f,eAAcjvB,IAAKrE,MAAOiyD,SAAUx0D,KAAKiyB,SAQxD2W,OAAOroC,UAAUy2D,mBAMjB,SAAUz0D,MAAOiyD,SAAUt+C,yBACK,KAAxBA,sBAAkCA,oBAAsBC,6BAC5D,IAAqBvP,KAAM5G,KAAK+2D,iBAAiBx0D,MAAOiyD,SAAUt+C,qBAC7C+b,OAASglC,wBAAwBC,MAAMtwD,IAI5D,OAHIqrB,QAAOnwB,OAAS,GAChB9B,KAAKm3D,aAAa,0CAA4CllC,OAAOpsB,KAAK,KAAMtD,MAAOiyD,UAEpF,GAAI3+B,eAAcjvB,IAAKrE,MAAOiyD,SAAUx0D,KAAKiyB,SASxD2W,OAAOroC,UAAU42D,aAOjB,SAAUjmD,QAAS3O,MAAO2xD,YAAaC,aACnCn0D,KAAKiyB,OAAOlrB,KAAK,GAAIktD,aAAY/iD,QAAS3O,MAAO2xD,YAAaC,eAQlEvrB,OAAOroC,UAAUw2D,iBAMjB,SAAUx0D,MAAOiyD,SAAUt+C,qBAGvB,GAAqB09C,OAAQ5zD,KAAKo3D,YAAY70D,MAAOiyD,SACrD,IAAa,MAATZ,MACA,MAAOA,MAEX5zD,MAAKy2D,sBAAsBl0D,MAAOiyD,SAAUt+C,oBAC5C,IAAqBwgD,aAAc12D,KAAK22D,eAAep0D,OAClCovD,OAAS3xD,KAAKu2D,OAAOzgD,SAAS4gD,YACnD,OAAO,IAAIE,WAAUr0D,MAAOiyD,SAAU7C,OAAQ+E,YAAY50D,QAAQ,EAAO9B,KAAKiyB,OAAQ1vB,MAAMT,OAAS40D,YAAY50D,QAC5G+0D,cAOTjuB,OAAOroC,UAAU62D,YAKjB,SAAU70D,MAAOiyD,UACb,GAAa,MAATjyD,MACA,MAAO,KACX,IAAqB80D,sBAAuB90D,MAAMW,QAAQ,IAC1D,KAA6B,GAAzBm0D,qBACA,MAAO,KACX,IAAqBvqD,QAASvK,MAAM2D,UAAU,EAAGmxD,sBAAsBj0D,MACvE,KAAKkO,aAAaxE,QACd,MAAO,KACX,IAAqBynD,yBAA0BhyD,MAAM2D,UAAUmxD,qBAAuB,EACtF,OAAO,IAAI/C,OAAM,GAAIF,WAAU,EAAG7xD,MAAMT,QAASgL,OAAQynD,wBAAyBC,WAQtF5rB,OAAOroC,UAAU+2D,sBAMjB,SAAUC,YAAah1D,MAAOiyD,UAC1B,GAAqB7C,QAAS3xD,KAAKu2D,OAAOzgD,SAASvT,MACnD,IAAIg1D,YAAa,CAEb,GAAqBC,cAAex3D,KAAKu2D,OAAOzgD,SAASyhD,aAAa3xD,IAAI,SAAU0pC,GAEhF,MADAA,GAAElqC,MAAQ,EACHkqC,GAEXqiB,QAAOr4B,QAAQt3B,MAAM2vD,OAAQ6F,cAEjC,MAAO,IAAIZ,WAAUr0D,MAAOiyD,SAAU7C,OAAQpvD,MAAMT,QAAQ,EAAO9B,KAAKiyB,OAAQ,GAC3EqlC,yBAQT1uB,OAAOroC,UAAUk3D,mBAMjB,SAAUl1D,MAAOiyD,SAAUt+C,yBACK,KAAxBA,sBAAkCA,oBAAsBC,6BAC5D,IAAqB3M,OAAQxJ,KAAK03D,mBAAmBn1D,MAAOiyD,SAAUt+C,oBACtE,IAAa,MAAT1M,MACA,MAAO,KAEX,KAAK,GADgBgK,gBACKzI,EAAI,EAAGA,EAAIvB,MAAMgK,YAAY1R,SAAUiJ,EAAG,CAChE,GAAqB4sD,gBAAiBnuD,MAAMgK,YAAYzI,GACnC2rD,YAAc12D,KAAK22D,eAAegB,gBAClChG,OAAS3xD,KAAKu2D,OAAOzgD,SAAS4gD,aAC9B9vD,IAAM,GAAIgwD,WAAUr0D,MAAOiyD,SAAU7C,OAAQ+E,YAAY50D,QAAQ,EAAO9B,KAAKiyB,OAAQzoB,MAAM4sD,QAAQrrD,IAAM4sD,eAAe71D,OAAS40D,YAAY50D,SAC7J+0D,YACLrjD,aAAYzM,KAAKH,KAErB,MAAO,IAAIivB,eAAc,GAAIw/B,eAAc,GAAIjB,WAAU,EAAY,MAAT7xD,MAAgB,EAAIA,MAAMT,QAAS0H,MAAM8rD,QAAS9hD,aAAcjR,MAAOiyD,SAAUx0D,KAAKiyB,SAQtJ2W,OAAOroC,UAAUm3D,mBAMjB,SAAUn1D,MAAOiyD,SAAUt+C,yBACK,KAAxBA,sBAAkCA,oBAAsBC,6BAC5D,IAAqB/K,QAAS8J,yBAAyBgB,qBAClC8B,MAAQzV,MAAMiH,MAAM4B,OACzC,IAAI4M,MAAMlW,QAAU,EAChB,MAAO,KAMX,KAAK,GAJgBwzD,YACA9hD,eACA4iD,WACAnsD,OAAS,EACJc,EAAI,EAAGA,EAAIiN,MAAMlW,OAAQiJ,IAAK,CACpD,GAAqBmmB,MAAOlZ,MAAMjN,EAC9BA,GAAI,GAAM,GAEVuqD,QAAQvuD,KAAKmqB,MACbjnB,QAAUinB,KAAKpvB,QAEVovB,KAAK9tB,OAAOtB,OAAS,GAC1BmI,QAAUiM,oBAAoBnM,MAAMjI,OACpC0R,YAAYzM,KAAKmqB,MACjBklC,QAAQrvD,KAAKkD,QACbA,QAAUinB,KAAKpvB,OAASoU,oBAAoBhM,IAAIpI,SAGhD9B,KAAKm3D,aAAa,4DAA6D50D,MAAO,aAAevC,KAAK43D,8BAA8B5/C,MAAOjN,EAAGmL,qBAAuB,MAAOs+C,UAChLhhD,YAAYzM,KAAK,YACjBqvD,QAAQrvD,KAAKkD,SAGrB,MAAO,IAAIksD,oBAAmBb,QAAS9hD,YAAa4iD,UAOxDxtB,OAAOroC,UAAUs3D,qBAKjB,SAAUt1D,MAAOiyD,UACb,MAAO,IAAI3+B,eAAc,GAAIq/B,kBAAiB,GAAId,WAAU,EAAY,MAAT7xD,MAAgB,EAAIA,MAAMT,QAASS,OAAQA,MAAOiyD,SAAUx0D,KAAKiyB,SAMpI2W,OAAOroC,UAAUo2D,eAIjB,SAAUp0D,OACN,GAAqBwI,GAAI/K,KAAK83D,cAAcv1D,MAC5C,OAAY,OAALwI,EAAYxI,MAAM2D,UAAU,EAAG6E,GAAG3H,OAASb,OAMtDqmC,OAAOroC,UAAUu3D,cAIjB,SAAUv1D,OAEN,IAAK,GADgBw1D,YAAa,KACRhtD,EAAI,EAAGA,EAAIxI,MAAMT,OAAS,EAAGiJ,IAAK,CACxD,GAAqBitD,MAAOz1D,MAAM+C,WAAWyF,GACxBktD,SAAW11D,MAAM+C,WAAWyF,EAAI,EACrD,IAAIitD,OAASphD,QAAUqhD,UAAYrhD,QAAwB,MAAdmhD,WACzC,MAAOhtD,EACPgtD,cAAeC,KACfD,WAAa,KAEM,MAAdA,YAAsB5lD,QAAQ6lD,QACnCD,WAAaC,MAGrB,MAAO,OAQXpvB,OAAOroC,UAAUk2D,sBAMjB,SAAUl0D,MAAOiyD,SAAUt+C,qBACvB,GAAqB9K,QAAS8J,yBAAyBgB,qBAClC8B,MAAQzV,MAAMiH,MAAM4B,OACrC4M,OAAMlW,OAAS,GACf9B,KAAKm3D,aAAa,sBAAwBjhD,oBAAoBnM,MAAQmM,oBAAoBhM,IAAM,kCAAmC3H,MAAO,aAAevC,KAAK43D,8BAA8B5/C,MAAO,EAAG9B,qBAAuB,MAAOs+C,WAS5O5rB,OAAOroC,UAAUq3D,8BAMjB,SAAU5/C,MAAOkgD,aAAchiD,qBAE3B,IAAK,GADgBg+C,aAAc,GACTr6C,EAAI,EAAGA,EAAIq+C,aAAcr+C,IAC/Cq6C,aAAer6C,EAAI,GAAM,EACrB7B,MAAM6B,GACN,GAAK3D,oBAAoBnM,MAAQiO,MAAM6B,GAAK3D,oBAAoBhM,GAExE,OAAOgqD,aAAYpyD,QAEhB8mC,UAEPguB,UAA2B,WAC3B,QAASA,WAAUr0D,MAAOiyD,SAAU7C,OAAQwG,YAAa3B,YAAavkC,OAAQhoB,QAC1EjK,KAAKuC,MAAQA,MACbvC,KAAKw0D,SAAWA,SAChBx0D,KAAK2xD,OAASA,OACd3xD,KAAKm4D,YAAcA,YACnBn4D,KAAKw2D,YAAcA,YACnBx2D,KAAKiyB,OAASA,OACdjyB,KAAKiK,OAASA,OACdjK,KAAKo4D,gBAAkB,EACvBp4D,KAAKq4D,kBAAoB,EACzBr4D,KAAKs4D,gBAAkB,EACvBt4D,KAAKoF,MAAQ,EAwuBjB,MAluBAwxD,WAAUr2D,UAAUkR,KAIpB,SAAUxH,QACN,GAAqBc,GAAI/K,KAAKoF,MAAQ6E,MACtC,OAAOc,GAAI/K,KAAK2xD,OAAO7vD,OAAS9B,KAAK2xD,OAAO5mD,GAAK+nD,KAErDtyD,OAAO4f,eAAew2C,UAAUr2D,UAAW,QACvCggB,IAGA,WAAc,MAAOvgB,MAAKyR,KAAK,IAC/B6O,YAAY,EACZD,cAAc,IAElB7f,OAAO4f,eAAew2C,UAAUr2D,UAAW,cACvCggB,IAGA,WACI,MAAQvgB,MAAKoF,MAAQpF,KAAK2xD,OAAO7vD,OAAU9B,KAAKmlC,KAAK//B,MAAQpF,KAAKiK,OAC9DjK,KAAKm4D,YAAcn4D,KAAKiK,QAEhCqW,YAAY,EACZD,cAAc,IAMlBu2C,UAAUr2D,UAAUoK,KAIpB,SAAUZ,OAAS,MAAO,IAAIqqD,WAAUrqD,MAAO/J,KAAKu4D,aAIpD3B,UAAUr2D,UAAUmR,QAGpB,WAAc1R,KAAKoF,SAKnBwxD,UAAUr2D,UAAUi4D,kBAIpB,SAAUrpD,MACN,QAAInP,KAAKmlC,KAAK4sB,YAAY5iD,QACtBnP,KAAK0R,WACE,IASfklD,UAAUr2D,UAAUk4D,eAGpB,WAAc,MAAOz4D,MAAKmlC,KAAKktB,gBAI/BuE,UAAUr2D,UAAUm4D,cAGpB,WAAc,MAAO14D,MAAKmlC,KAAKmtB,eAK/BsE,UAAUr2D,UAAUo4D,gBAIpB,SAAUxpD,MACFnP,KAAKw4D,kBAAkBrpD,OAE3BnP,KAAKuE,MAAM,oBAAsBiB,OAAOC,aAAa0J,QAMzDynD,UAAUr2D,UAAUq4D,iBAIpB,SAAUC,IACN,QAAI74D,KAAKmlC,KAAK+sB,WAAW2G,MACrB74D,KAAK0R,WACE,IAUfklD,UAAUr2D,UAAUu4D,eAIpB,SAAUC,UACF/4D,KAAK44D,iBAAiBG,WAE1B/4D,KAAKuE,MAAM,6BAA+Bw0D,WAK9CnC,UAAUr2D,UAAUy4D,0BAGpB,WACI,GAAqBjoD,GAAI/Q,KAAKmlC,IAC9B,OAAKp0B,GAAEO,gBAAmBP,EAAEqhD,aAI5BpyD,KAAK0R,UACoBX,EAAE/K,aAJvBhG,KAAKuE,MAAM,oBAAsBwM,EAAI,oCAC9B,KAQf6lD,UAAUr2D,UAAU04D,kCAGpB,WACI,GAAqBloD,GAAI/Q,KAAKmlC,IAC9B,OAAKp0B,GAAEO,gBAAmBP,EAAEqhD,aAAgBrhD,EAAEkhD,YAI9CjyD,KAAK0R,UACoBX,EAAE/K,aAJvBhG,KAAKuE,MAAM,oBAAsBwM,EAAI,6CAC9B,KAQf6lD,UAAUr2D,UAAUs2D,WAGpB,WAGI,IAFA,GAAqB9qC,UACAhiB,MAAQ/J,KAAKu4D,WAC3Bv4D,KAAKoF,MAAQpF,KAAK2xD,OAAO7vD,QAAQ,CACpC,GAAqBikB,MAAO/lB,KAAKk5D,WAEjC,IADAntC,MAAMhlB,KAAKgf,MACP/lB,KAAKw4D,kBAAkBxhD,YAIvB,IAHKhX,KAAKw2D,aACNx2D,KAAKuE,MAAM,wDAERvE,KAAKw4D,kBAAkBxhD,kBAGzBhX,MAAKoF,MAAQpF,KAAK2xD,OAAO7vD,QAC9B9B,KAAKuE,MAAM,qBAAuBvE,KAAKmlC,KAAO,KAGtD,MAAoB,IAAhBpZ,MAAMjqB,OACC,GAAIg0B,WAAU91B,KAAK2K,KAAKZ,QACf,GAAhBgiB,MAAMjqB,OACCiqB,MAAM,GACV,GAAI2oC,OAAM10D,KAAK2K,KAAKZ,OAAQgiB,QAKvC6qC,UAAUr2D,UAAU24D,UAGpB,WACI,GAAqBxyD,QAAS1G,KAAKm5D,iBACnC,IAAIn5D,KAAK44D,iBAAiB,KAAM,CACxB54D,KAAKw2D,aACLx2D,KAAKuE,MAAM,6CAEf,GAAG,CAGC,IAFA,GAAqB4sD,QAASnxD,KAAKg5D,4BACdr3D,QACd3B,KAAKw4D,kBAxwFf,KAywFO72D,KAAKoF,KAAK/G,KAAKm5D,kBAEnBzyD,QAAS,GAAIuuD,aAAYj1D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQrD,OAAQyqD,OAAQxvD,YAClE3B,KAAK44D,iBAAiB,MAEnC,MAAOlyD,SAKXkwD,UAAUr2D,UAAU44D,gBAGpB,WAAc,MAAOn5D,MAAKo5D,oBAI1BxC,UAAUr2D,UAAU64D,iBAGpB,WACI,GAAqBrvD,OAAQ/J,KAAKu4D,WACb7xD,OAAS1G,KAAKq5D,gBACnC,IAAIr5D,KAAK44D,iBAAiB,KAAM,CAC5B,GAAqBU,KAAMt5D,KAAKk5D,YACXK,OAAK,EAC1B,IAAKv5D,KAAKw4D,kBAnyFT,IA0yFGe,GAAKv5D,KAAKk5D,gBAPuB,CACjC,GAAqBhvD,KAAMlK,KAAKu4D,WACX5jD,WAAa3U,KAAKuC,MAAM2D,UAAU6D,MAAOG,IAC9DlK,MAAKuE,MAAM,0BAA4BoQ,WAAa,+BACpD4kD,GAAK,GAAIzjC,WAAU91B,KAAK2K,KAAKZ,QAKjC,MAAO,IAAI4qD,aAAY30D,KAAK2K,KAAKZ,OAAQrD,OAAQ4yD,IAAKC,IAGtD,MAAO7yD,SAMfkwD,UAAUr2D,UAAU84D,eAGpB,WAGI,IADA,GAAqB3yD,QAAS1G,KAAKw5D,kBAC5Bx5D,KAAK44D,iBAAiB,OAAO,CAChC,GAAqBtlD,OAAQtT,KAAKw5D,iBAClC9yD,QAAS,GAAI6uD,QAAOv1D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQ,KAAMrD,OAAQ4M,OAEpE,MAAO5M,SAKXkwD,UAAUr2D,UAAUi5D,gBAGpB,WAGI,IADA,GAAqB9yD,QAAS1G,KAAKy5D,gBAC5Bz5D,KAAK44D,iBAAiB,OAAO,CAChC,GAAqBtlD,OAAQtT,KAAKy5D,eAClC/yD,QAAS,GAAI6uD,QAAOv1D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQ,KAAMrD,OAAQ4M,OAEpE,MAAO5M,SAKXkwD,UAAUr2D,UAAUk5D,cAGpB,WAGI,IADA,GAAqB/yD,QAAS1G,KAAK05D,kBAC5B15D,KAAKmlC,KAAK/+B,MAAQgK,UAAUQ,UAAU,CACzC,GAAqBmoD,UAAW/4D,KAAKmlC,KAAK2sB,QAC1C,QAAQiH,UACJ,IAAK,KACL,IAAK,MACL,IAAK,KACL,IAAK,MACD/4D,KAAK0R,SACL,IAAqB4B,OAAQtT,KAAK05D,iBAClChzD,QAAS,GAAI6uD,QAAOv1D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQgvD,SAAUryD,OAAQ4M,MACpE,UAER,MAEJ,MAAO5M,SAKXkwD,UAAUr2D,UAAUm5D,gBAGpB,WAGI,IADA,GAAqBhzD,QAAS1G,KAAK25D,gBAC5B35D,KAAKmlC,KAAK/+B,MAAQgK,UAAUQ,UAAU,CACzC,GAAqBmoD,UAAW/4D,KAAKmlC,KAAK2sB,QAC1C,QAAQiH,UACJ,IAAK,IACL,IAAK,IACL,IAAK,KACL,IAAK,KACD/4D,KAAK0R,SACL,IAAqB4B,OAAQtT,KAAK25D,eAClCjzD,QAAS,GAAI6uD,QAAOv1D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQgvD,SAAUryD,OAAQ4M,MACpE,UAER,MAEJ,MAAO5M,SAKXkwD,UAAUr2D,UAAUo5D,cAGpB,WAGI,IADA,GAAqBjzD,QAAS1G,KAAK45D,sBAC5B55D,KAAKmlC,KAAK/+B,MAAQgK,UAAUQ,UAAU,CACzC,GAAqBmoD,UAAW/4D,KAAKmlC,KAAK2sB,QAC1C,QAAQiH,UACJ,IAAK,IACL,IAAK,IACD/4D,KAAK0R,SACL,IAAqB4B,OAAQtT,KAAK45D,qBAClClzD,QAAS,GAAI6uD,QAAOv1D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQgvD,SAAUryD,OAAQ4M,MACpE,UAER,MAEJ,MAAO5M,SAKXkwD,UAAUr2D,UAAUq5D,oBAGpB,WAGI,IADA,GAAqBlzD,QAAS1G,KAAK65D,cAC5B75D,KAAKmlC,KAAK/+B,MAAQgK,UAAUQ,UAAU,CACzC,GAAqBmoD,UAAW/4D,KAAKmlC,KAAK2sB,QAC1C,QAAQiH,UACJ,IAAK,IACL,IAAK,IACL,IAAK,IACD/4D,KAAK0R,SACL,IAAqB4B,OAAQtT,KAAK65D,aAClCnzD,QAAS,GAAI6uD,QAAOv1D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQgvD,SAAUryD,OAAQ4M,MACpE,UAER,MAEJ,MAAO5M,SAKXkwD,UAAUr2D,UAAUs5D,YAGpB,WACI,GAAI75D,KAAKmlC,KAAK/+B,MAAQgK,UAAUQ,SAAU,CACtC,GAAqB7G,OAAQ/J,KAAKu4D,WACbQ,SAAW/4D,KAAKmlC,KAAK2sB,SACrBprD,WAAS,EAC9B,QAAQqyD,UACJ,IAAK,IAGD,MAFA/4D,MAAK0R,UACLhL,OAAS1G,KAAK65D,cACP,GAAItE,QAAOv1D,KAAK2K,KAAKZ,OAAQ,IAAKrD,OAAQ,GAAIwuD,kBAAiB,GAAId,WAAUrqD,MAAOA,OAAQ,GACvG,KAAK,IAGD,MAFA/J,MAAK0R,UACLhL,OAAS1G,KAAK65D,cACP,GAAItE,QAAOv1D,KAAK2K,KAAKZ,OAAQgvD,SAAU,GAAI7D,kBAAiB,GAAId,WAAUrqD,MAAOA,OAAQ,GAAIrD,OACxG,KAAK,IAGD,MAFA1G,MAAK0R,UACLhL,OAAS1G,KAAK65D,cACP,GAAIpE,WAAUz1D,KAAK2K,KAAKZ,OAAQrD,SAGnD,MAAO1G,MAAK85D,kBAKhBlD,UAAUr2D,UAAUu5D,eAGpB,WAEI,IADA,GAAqBpzD,QAAS1G,KAAK+5D,iBAE/B,GAAI/5D,KAAKw4D,kBAx9FP,IAy9FE9xD,OAAS1G,KAAKg6D,8BAA8BtzD,QAAQ,OAEnD,IAAI1G,KAAK44D,iBAAiB,MAC3BlyD,OAAS1G,KAAKg6D,8BAA8BtzD,QAAQ,OAEnD,IAAI1G,KAAKw4D,kBA/8FV,IA+8FwC,CACxCx4D,KAAKq4D,mBACL,IAAqBpkD,KAAMjU,KAAKk5D,WAGhC,IAFAl5D,KAAKq4D,oBACLr4D,KAAK24D,gBAj9FL,IAk9FI34D,KAAK44D,iBAAiB,KAAM,CAC5B,GAAqBt1D,OAAQtD,KAAKo5D,kBAClC1yD,QAAS,GAAIsuD,YAAWh1D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQrD,OAAQuN,IAAK3Q,WAGnEoD,QAAS,GAAIquD,WAAU/0D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQrD,OAAQuN,SAGhE,IAAIjU,KAAKw4D,kBAj/FZ,IAi/FwC,CACtCx4D,KAAKo4D,iBACL,IAAqBz2D,MAAO3B,KAAKi6D,oBACjCj6D,MAAKo4D,kBACLp4D,KAAK24D,gBAp/FP,IAq/FEjyD,OAAS,GAAImvD,cAAa71D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQrD,OAAQ/E,UAE/D,CAAA,IAAI3B,KAAK44D,iBAAiB,KAI3B,MAAOlyD,OAHPA,QAAS,GAAIgvD,eAAc11D,KAAK2K,KAAKjE,OAAOiE,KAAKZ,OAAQrD,UAUrEkwD,UAAUr2D,UAAUw5D,aAGpB,WACI,GAAqBhwD,OAAQ/J,KAAKu4D,UAClC,IAAIv4D,KAAKw4D,kBAxgGH,IAwgG+B,CACjCx4D,KAAKo4D,iBACL,IAAqB1xD,QAAS1G,KAAKk5D,WAGnC,OAFAl5D,MAAKo4D,kBACLp4D,KAAK24D,gBA3gGH,IA4gGKjyD,OAEN,GAAI1G,KAAKmlC,KAAKotB,gBAEf,MADAvyD,MAAK0R,UACE,GAAIwjD,kBAAiBl1D,KAAK2K,KAAKZ,OAAQ,KAE7C,IAAI/J,KAAKmlC,KAAKqtB,qBAEf,MADAxyD,MAAK0R,UACE,GAAIwjD,kBAAiBl1D,KAAK2K,KAAKZ,WAAQ,GAE7C,IAAI/J,KAAKmlC,KAAKstB,gBAEf,MADAzyD,MAAK0R,UACE,GAAIwjD,kBAAiBl1D,KAAK2K,KAAKZ,QAAQ,EAE7C,IAAI/J,KAAKmlC,KAAKutB,iBAEf,MADA1yD,MAAK0R,UACE,GAAIwjD,kBAAiBl1D,KAAK2K,KAAKZ,QAAQ,EAE7C,IAAI/J,KAAKmlC,KAAKwtB,gBAEf,MADA3yD,MAAK0R,UACE,GAAI+iD,kBAAiBz0D,KAAK2K,KAAKZ,OAErC,IAAI/J,KAAKw4D,kBA9gGN,IA8gGoC,CACxCx4D,KAAKq4D,mBACL,IAAqB6B,UAAWl6D,KAAKm6D,oBA9gGjC,GAihGJ,OAFAn6D,MAAKq4D,oBACLr4D,KAAK24D,gBAhhGD,IAihGG,GAAIxD,cAAan1D,KAAK2K,KAAKZ,OAAQmwD,UAEzC,GAAIl6D,KAAKmlC,KAAK4sB,YAAY36C,SAC3B,MAAOpX,MAAKo6D,iBAEX,IAAIp6D,KAAKmlC,KAAK7zB,eACf,MAAOtR,MAAKg6D,8BAA8B,GAAIvF,kBAAiBz0D,KAAK2K,KAAKZ,SAAS,EAEjF,IAAI/J,KAAKmlC,KAAK6sB,WAAY,CAC3B,GAAqB1uD,OAAQtD,KAAKmlC,KAAK0tB,UAEvC,OADA7yD,MAAK0R,UACE,GAAIwjD,kBAAiBl1D,KAAK2K,KAAKZ,OAAQzG,OAE7C,GAAItD,KAAKmlC,KAAK8sB,WAAY,CAC3B,GAAqBoI,cAAer6D,KAAKmlC,KAAKn/B,UAE9C,OADAhG,MAAK0R,UACE,GAAIwjD,kBAAiBl1D,KAAK2K,KAAKZ,OAAQswD,cAE7C,MAAIr6D,MAAKoF,OAASpF,KAAK2xD,OAAO7vD,QAC/B9B,KAAKuE,MAAM,iCAAmCvE,KAAKuC,OAC5C,GAAIuzB,WAAU91B,KAAK2K,KAAKZ,UAG/B/J,KAAKuE,MAAM,oBAAsBvE,KAAKmlC,MAC/B,GAAIrP,WAAU91B,KAAK2K,KAAKZ,UAOvC6sD,UAAUr2D,UAAU45D,oBAIpB,SAAUG,YACN,GAAqB5zD,UACrB,KAAK1G,KAAKmlC,KAAK4sB,YAAYuI,YACvB,GACI5zD,OAAOK,KAAK/G,KAAKk5D,mBACZl5D,KAAKw4D,kBA5kGb,IA8kGL,OAAO9xD,SAKXkwD,UAAUr2D,UAAU65D,gBAGpB,WACI,GAAqBnjC,SACAl1B,UACAgI,MAAQ/J,KAAKu4D,UAElC,IADAv4D,KAAK24D,gBAAgBvhD,UAChBpX,KAAKw4D,kBAzjGJ,KAyjGgC,CAClCx4D,KAAKs4D,iBACL,GAAG,CACC,GAAqBvxC,QAAS/mB,KAAKmlC,KAAK8sB,WACnBh+C,IAAMjU,KAAKi5D,mCAChChiC,MAAKlwB,MAAOkN,IAAKA,IAAK8S,OAAQA,SAC9B/mB,KAAK24D,gBA7lGR,IA8lGG52D,OAAOgF,KAAK/G,KAAKk5D,mBACZl5D,KAAKw4D,kBAnmGb,IAomGDx4D,MAAKs4D,kBACLt4D,KAAK24D,gBAnkGH,KAqkGN,MAAO,IAAIvD,YAAWp1D,KAAK2K,KAAKZ,OAAQktB,KAAMl1B,SAOlD60D,UAAUr2D,UAAUy5D,8BAKpB,SAAUzlD,SAAUgmD,YACD,KAAXA,SAAqBA,QAAS,EAClC,IAAqBxwD,OAAQwK,SAAS5J,KAAKZ,MACtBT,GAAKtJ,KAAKg5D,2BAC/B,IAAIh5D,KAAKw4D,kBA3nGH,IA2nG+B,CACjCx4D,KAAKo4D,iBACL,IAAqBz2D,MAAO3B,KAAKi6D,oBACjCj6D,MAAK24D,gBA7nGH,IA8nGF34D,KAAKo4D,iBACL,IAAqBztD,MAAO3K,KAAK2K,KAAKZ,MACtC,OAAOwwD,QAAS,GAAI3E,gBAAejrD,KAAM4J,SAAUjL,GAAI3H,MACnD,GAAIg0D,YAAWhrD,KAAM4J,SAAUjL,GAAI3H,MAGvC,GAAI44D,OACA,MAAIv6D,MAAK44D,iBAAiB,MACtB54D,KAAKuE,MAAM,sDACJ,GAAIuxB,WAAU91B,KAAK2K,KAAKZ,SAGxB,GAAI+qD,kBAAiB90D,KAAK2K,KAAKZ,OAAQwK,SAAUjL,GAI5D,IAAItJ,KAAK44D,iBAAiB,KAAM,CAC5B,IAAK54D,KAAKw2D,YAEN,MADAx2D,MAAKuE,MAAM,uCACJ,GAAIuxB,WAAU91B,KAAK2K,KAAKZ,OAEnC,IAAqBzG,OAAQtD,KAAKo5D,kBAClC,OAAO,IAAIvE,eAAc70D,KAAK2K,KAAKZ,OAAQwK,SAAUjL,GAAIhG,OAGzD,MAAO,IAAIsxD,cAAa50D,KAAK2K,KAAKZ,OAAQwK,SAAUjL,KAQpEstD,UAAUr2D,UAAU05D,mBAGpB,WACI,GAAIj6D,KAAKmlC,KAAK4sB,YAnqGR,IAoqGF,QACJ,IAAqByI,eACrB,IACIA,YAAYzzD,KAAK/G,KAAKk5D,mBACjBl5D,KAAKw4D,kBArqGT,IAsqGL,OAAwB,cAS5B5B,UAAUr2D,UAAUk6D,yBAIpB,WACI,GAAqB/zD,QAAS,GACTg0D,eAAgB,CACrC,IACIh0D,QAAU1G,KAAKi5D,qCACfyB,cAAgB16D,KAAK44D,iBAAiB,QAElClyD,QAAU,WAETg0D,cACT,OAAOh0D,QAAOV,YAKlB4wD,UAAUr2D,UAAU+2D,sBAGpB,WAII,IAHA,GAAqBxG,aACAhkD,OAA0B,KAC1BwnB,YACdt0B,KAAKoF,MAAQpF,KAAK2xD,OAAO7vD,QAAQ,CACpC,GAAqBiI,OAAQ/J,KAAKu4D,WACbxC,SAAW/1D,KAAKy4D,gBACjC1C,WACA/1D,KAAK0R,SAET,IAAqBipD,QAAS36D,KAAKy6D,2BACdxmD,IAAM0mD,MACtB5E,YACa,MAAVjpD,OACAA,OAASmH,IAGTA,IAAMnH,OAASmH,IAAI,GAAGtR,cAAgBsR,IAAI/N,UAAU,IAG5DlG,KAAKw4D,kBArtGJ,GAstGD,IAAqBoC,QAA0B,KAC1BjmD,WAA8B,IACnD,IAAIohD,SAEI6E,OADA56D,KAAK44D,iBAAiB,KACb54D,KAAKy6D,2BAGL,gBAGZ,IAAIz6D,KAAK04D,gBAAiB,CAC3B,GAAqBmC,UAAW76D,KAAKu4D,UACrCv4D,MAAK0R,UACLkpD,OAASD,OACT1mD,IAAMjU,KAAKy6D,2BACX1E,UAAW,MAEV,IAAI/1D,KAAKmlC,OAAS2tB,MAAQ9yD,KAAKy4D,iBAAkB,CAClD,GAAqBxtD,SAAUjL,KAAKu4D,WACf3xD,IAAM5G,KAAKk5D,YACXnjD,OAAS/V,KAAKuC,MAAM2D,UAAU+E,QAAUjL,KAAKiK,OAAQjK,KAAKu4D,WAAav4D,KAAKiK,OACjG0K,YAAa,GAAIkhB,eAAcjvB,IAAKmP,OAAQ/V,KAAKw0D,SAAUx0D,KAAKiyB,QAGpE,GADA6+B,SAAS/pD,KAAK,GAAI+uD,iBAAgB91D,KAAK2K,KAAKZ,OAAQkK,IAAK8hD,SAAU6E,OAAQjmD,aACvE3U,KAAK04D,kBAAoB3C,SAAU,CACnC,GAAqB8E,UAAW76D,KAAKu4D,UACrCv4D,MAAK0R,SACL,IAAqBopD,SAAU96D,KAAKy6D,0BACpC3J,UAAS/pD,KAAK,GAAI+uD,iBAAgB91D,KAAK2K,KAAKkwD,UAAWC,SAAS,EAAM7mD,IAAsB,OAE3FjU,KAAKw4D,kBAAkBxhD,aACxBhX,KAAKw4D,kBAzvGR,IA4vGL,MAAO,IAAInC,4BAA2BvF,SAAUx8B,SAAUt0B,KAAKiyB,SAOnE2kC,UAAUr2D,UAAUgE,MAKpB,SAAU2M,QAAS9L,WACD,KAAVA,QAAoBA,MAAQ,MAChCpF,KAAKiyB,OAAOlrB,KAAK,GAAIktD,aAAY/iD,QAASlR,KAAKuC,MAAOvC,KAAK+6D,aAAa31D,OAAQpF,KAAKw0D,WACrFx0D,KAAKg7D,QAMTpE,UAAUr2D,UAAUw6D,aAIpB,SAAU31D,OAIN,WAHc,KAAVA,QAAoBA,MAAQ,MACnB,MAATA,QACAA,MAAQpF,KAAKoF,OACTA,MAAQpF,KAAK2xD,OAAO7vD,OAAU,cAAgB9B,KAAK2xD,OAAOvsD,OAAOA,MAAQ,GAAK,MAClF,gCAKRwxD,UAAUr2D,UAAUy6D,KAGpB,WAEI,IADA,GAAqBjqD,GAAI/Q,KAAKmlC,KACvBnlC,KAAKoF,MAAQpF,KAAK2xD,OAAO7vD,SAAWiP,EAAEghD,YAAY/6C,cACpDhX,KAAKo4D,iBAAmB,IAAMrnD,EAAEghD,YAxyG/B,OAyyGD/xD,KAAKs4D,iBAAmB,IAAMvnD,EAAEghD,YApwG/B,QAqwGD/xD,KAAKq4D,mBAAqB,IAAMtnD,EAAEghD,YApxG/B,MAqxGA/xD,KAAKmlC,KAAKytB,WACV5yD,KAAKiyB,OAAOlrB,KAAK,GAAIktD,aAA+Bj0D,KAAKmlC,KAAKn/B,WAAchG,KAAKuC,MAAOvC,KAAK+6D,eAAgB/6D,KAAKw0D,WAEtHx0D,KAAK0R,UACLX,EAAI/Q,KAAKmlC,MAGVyxB,aAEPK,wBAAyC,WACzC,QAASA,2BACLj3D,KAAKiyB,UAuPT,MAjPAglC,yBAAwBC,MAIxB,SAAUtwD,KACN,GAAqB9B,GAAI,GAAImyD,wBAE7B,OADArwD,KAAID,MAAM7B,GACHA,EAAEmtB,QAObglC,wBAAwB12D,UAAUuT,sBAKlC,SAAUlN,IAAKpD,WAMfyzD,wBAAwB12D,UAAUwT,mBAKlC,SAAUnN,IAAKpD,WAMfyzD,wBAAwB12D,UAAU8T,sBAKlC,SAAUzN,IAAKpD,WAMfyzD,wBAAwB12D,UAAUsU,kBAKlC,SAAUjO,IAAKpD,WAMfyzD,wBAAwB12D,UAAUuU,mBAKlC,SAAUlO,IAAKpD,WAMfyzD,wBAAwB12D,UAAU0U,sBAKlC,SAAUrO,IAAKpD,WAMfyzD,wBAAwB12D,UAAU+T,gBAKlC,SAAU1N,IAAKpD,WAMfyzD,wBAAwB12D,UAAUyU,oBAKlC,SAAUpO,IAAKpD,WAMfyzD,wBAAwB12D,UAAUqT,kBAKlC,SAAUhN,IAAKpD,WAMfyzD,wBAAwB12D,UAAU4T,kBAKlC,SAAUvN,IAAKpD,SAAWxD,KAAK4J,SAAShD,IAAI4M,cAM5CyjD,wBAAwB12D,UAAU6T,gBAKlC,SAAUxN,IAAKpD,SAAWxD,KAAK4J,SAAShD,IAAI7E,SAM5Ck1D,wBAAwB12D,UAAU6S,YAKlC,SAAUxM,IAAKpD,WAMfyzD,wBAAwB12D,UAAUmU,eAKlC,SAAU9N,IAAKpD,WAMfyzD,wBAAwB12D,UAAUqU,mBAKlC,SAAUhO,IAAKpD,WAMfyzD,wBAAwB12D,UAAUkT,iBAKlC,SAAU7M,IAAKpD,WAMfyzD,wBAAwB12D,UAAUiU,UAKlC,SAAU5N,IAAKpD,SAAWxD,KAAKiyB,OAAOlrB,KAAK,UAM3CkwD,wBAAwB12D,UAAUyT,eAKlC,SAAUpN,IAAKpD,WAMfyzD,wBAAwB12D,UAAU2T,gBAKlC,SAAUtN,IAAKpD,WAKfyzD,wBAAwB12D,UAAUqJ,SAIlC,SAAUnD,MACN,GAAIs9B,OAAQ/jC,IACZ,OAAOyG,MAAKb,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAMo9B,UAOxDkzB,wBAAwB12D,UAAUgT,WAKlC,SAAU3M,IAAKpD,WAMfyzD,wBAAwB12D,UAAUwU,WAKlC,SAAUnO,IAAKpD,WACRyzD,2BAOPphD,cAA+B,WAC/B,QAASA,eAAcunB,KAAMnzB,OAAQ+6B,KAAMi2B,KACvCj7D,KAAKo9B,KAAOA,KACZp9B,KAAKiK,OAASA,OACdjK,KAAKglC,KAAOA,KACZhlC,KAAKi7D,IAAMA,IAqGf,MAhGAplD,eAActV,UAAUyF,SAGxB,WACI,MAAsB,OAAfhG,KAAKiK,OAAiBjK,KAAKo9B,KAAKt0B,IAAM,IAAM9I,KAAKglC,KAAO,IAAMhlC,KAAKi7D,IAAMj7D,KAAKo9B,KAAKt0B,KAM9F+M,cAActV,UAAU26D,OAIxB,SAAUra,OAMN,IALA,GAAqB9qC,QAAS/V,KAAKo9B,KAAKhN,QACnBlX,IAAMnD,OAAOjU,OACbmI,OAASjK,KAAKiK,OACd+6B,KAAOhlC,KAAKglC,KACZi2B,IAAMj7D,KAAKi7D,IACzBhxD,OAAS,GAAK42C,MAAQ,GAAG,CAC5B52C,SACA42C,OACA,IAAqBsa,IAAKplD,OAAOzQ,WAAW2E,OAC5C,IAAIkxD,IAAM1oD,IAAK,CACXuyB,MACA,IAAqBo2B,WAAYrlD,OAAO0oB,OAAO,EAAGx0B,OAAS,GAAGyX,YAAYlc,OAAOC,aAAagN,KAC9FwoD,KAAMG,UAAY,EAAInxD,OAASmxD,UAAYnxD,WAG3CgxD,OAGR,KAAOhxD,OAASiP,KAAO2nC,MAAQ,GAAG,CAC9B,GAAqBsa,IAAKplD,OAAOzQ,WAAW2E,OAC5CA,UACA42C,QACIsa,IAAM1oD,KACNuyB,OACAi2B,IAAM,GAGNA,MAGR,MAAO,IAAIplD,eAAc7V,KAAKo9B,KAAMnzB,OAAQ+6B,KAAMi2B,MAStDplD,cAActV,UAAU86D,WAKxB,SAAUC,SAAUC,UAChB,GAAqBnrC,SAAUpwB,KAAKo9B,KAAKhN,QACpBorC,YAAcx7D,KAAKiK,MACxC,IAAmB,MAAfuxD,YAAqB,CACjBA,YAAcprC,QAAQtuB,OAAS,IAC/B05D,YAAcprC,QAAQtuB,OAAS,EAKnC,KAHA,GAAqB25D,WAAYD,YACZE,SAAW,EACXC,SAAW,EACzBD,SAAWJ,UAAYE,YAAc,IACxCA,cACAE,WAC4B,MAAxBtrC,QAAQorC,gBACFG,UAAYJ,YAO1B,IAFAG,SAAW,EACXC,SAAW,EACJD,SAAWJ,UAAYG,UAAYrrC,QAAQtuB,OAAS,IACvD25D,YACAC,WAC0B,MAAtBtrC,QAAQqrC,cACFE,UAAYJ,YAK1B,OACIK,OAAQxrC,QAAQlqB,UAAUs1D,YAAax7D,KAAKiK,QAC5C4xD,MAAOzrC,QAAQlqB,UAAUlG,KAAKiK,OAAQwxD,UAAY,IAG1D,MAAO,OAEJ5lD,iBAEPF,gBAAiC,WACjC,QAASA,iBAAgBya,QAAStnB,KAC9B9I,KAAKowB,QAAUA,QACfpwB,KAAK8I,IAAMA,IAEf,MAAO6M,oBAEPC,gBAAiC,WACjC,QAASA,iBAAgB7L,MAAOG,IAAK4xD,aACjB,KAAZA,UAAsBA,QAAU,MACpC97D,KAAK+J,MAAQA,MACb/J,KAAKkK,IAAMA,IACXlK,KAAK87D,QAAUA,QAWnB,MANAlmD,iBAAgBrV,UAAUyF,SAG1B,WACI,MAAOhG,MAAK+J,MAAMqzB,KAAKhN,QAAQlqB,UAAUlG,KAAK+J,MAAME,OAAQjK,KAAKkK,IAAID,SAElE2L,mBAGPmmD,iBACAC,QAAS,EACTC,MAAO,EAEXF,iBAAgBA,gBAAgBC,SAAW,UAC3CD,gBAAgBA,gBAAgBE,OAAS,OACzC,IAAIC,YAA4B,WAC5B,QAASA,YAAWvxD,KAAMtG,IAAKqgC,WACb,KAAVA,QAAoBA,MAAQq3B,gBAAgBE,OAChDj8D,KAAK2K,KAAOA,KACZ3K,KAAKqE,IAAMA,IACXrE,KAAK0kC,MAAQA,MAuBjB,MAlBAw3B,YAAW37D,UAAU47D,kBAGrB,WACI,GAAqB1xC,KAAMzqB,KAAK2K,KAAKZ,MAAMsxD,WAAW,IAAK,EAC3D,OAAO5wC,KAAMzqB,KAAKqE,IAAM,MAASomB,IAAImxC,OAAS,IAAMG,gBAAgB/7D,KAAK0kC,OAAS,OAASja,IAAIoxC,MAAQ,KACnG77D,KAAKqE,KAKb63D,WAAW37D,UAAUyF,SAGrB,WACI,GAAqB81D,SAAU97D,KAAK2K,KAAKmxD,QAAU,KAAO97D,KAAK2K,KAAKmxD,QAAU,EAC9E,OAAO97D,MAAKm8D,oBAAsB,KAAOn8D,KAAK2K,KAAKZ,MAAQ+xD,SAExDI,cA2BPpkD,aACAskD,eAAgB,EAChBC,aAAc,EACdC,kBAAmB,EACnBC,UAAW,EACXxkD,KAAM,EACN2lC,mBAAoB,EACpBD,SAAU,EACV+e,cAAe,EACfC,YAAa,EACbC,YAAa,EACbC,UAAW,GACXC,UAAW,GACXC,WAAY,GACZC,SAAU,GACVC,qBAAsB,GACtBC,qBAAsB,GACtBC,yBAA0B,GAC1BC,uBAAwB,GACxBC,mBAAoB,GACpBrK,IAAK,GAETh7C,aAAYA,YAAYskD,gBAAkB,iBAC1CtkD,YAAYA,YAAYukD,cAAgB,eACxCvkD,YAAYA,YAAYwkD,mBAAqB,oBAC7CxkD,YAAYA,YAAYykD,WAAa,YACrCzkD,YAAYA,YAAYC,MAAQ,OAChCD,YAAYA,YAAY4lC,oBAAsB,qBAC9C5lC,YAAYA,YAAY2lC,UAAY,WACpC3lC,YAAYA,YAAY0kD,eAAiB,gBACzC1kD,YAAYA,YAAY2kD,aAAe,cACvC3kD,YAAYA,YAAY4kD,aAAe,cACvC5kD,YAAYA,YAAY6kD,WAAa,YACrC7kD,YAAYA,YAAY8kD,WAAa,YACrC9kD,YAAYA,YAAY+kD,YAAc,aACtC/kD,YAAYA,YAAYglD,UAAY,WACpChlD,YAAYA,YAAYilD,sBAAwB,uBAChDjlD,YAAYA,YAAYklD,sBAAwB,uBAChDllD,YAAYA,YAAYmlD,0BAA4B,2BACpDnlD,YAAYA,YAAYolD,wBAA0B,yBAClDplD,YAAYA,YAAYqlD,oBAAsB,qBAC9CrlD,YAAYA,YAAYg7C,KAAO,KAC/B,IAAIsK,SAAyB,WACzB,QAASjtD,OAAM/J,KAAM4R,MAAOhO,YACxBhK,KAAKoG,KAAOA,KACZpG,KAAKgY,MAAQA,MACbhY,KAAKgK,WAAaA,WAEtB,MAAOmG,UAEPktD,WAA4B,SAAU5yD,QAEtC,QAAS4yD,YAAWC,SAAUC,UAAW5yD,MACrC,GAAIo5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,KAAM2yD,WAAat9D,IAEjD,OADA+jC,OAAMw5B,UAAYA,UACXx5B,MAEX,MANA9jC,WAAUo9D,WAAY5yD,QAMf4yD,YACTnB,YACEsB,eAAgC,WAChC,QAASA,gBAAe7L,OAAQ1/B,QAC5BjyB,KAAK2xD,OAASA,OACd3xD,KAAKiyB,OAASA,OAElB,MAAOurC,mBAgBPC,mBAAqB,SAgBrBC,kBAAmC,WACnC,QAASA,mBAAkBn5D,OACvBvE,KAAKuE,MAAQA,MAEjB,MAAOm5D,sBAEPtnD,WAA4B,WAO5B,QAASA,YAAWunD,MAAOC,kBAAmBC,aAAcC,0BAC3B,KAAzBA,uBAAmCA,qBAAuB3nD,8BAC9DnW,KAAK29D,MAAQA,MACb39D,KAAK49D,kBAAoBA,kBACzB59D,KAAK69D,aAAeA,aACpB79D,KAAK89D,qBAAuBA,qBAC5B99D,KAAK+9D,OAAS,EACd/9D,KAAKg+D,WAAa,EAClBh+D,KAAKi+D,QAAU,EACfj+D,KAAKk+D,MAAQ,EACbl+D,KAAKm+D,SAAW,EAChBn+D,KAAKo+D,uBACLp+D,KAAKq+D,kBAAmB,EACxBr+D,KAAK2xD,UACL3xD,KAAKiyB,UACLjyB,KAAKs+D,OAASX,MAAMvtC,QACpBpwB,KAAKu+D,QAAUZ,MAAMvtC,QAAQtuB,OAC7B9B,KAAKw+D,WAyzBT,MAnzBApoD,YAAW7V,UAAUk+D,wBAIrB,SAAUruC,SAKN,MAAOA,SAAQ5tB,QAAQi7D,mBAAoB,OAK/CrnD,WAAW7V,UAAUuV,SAGrB,WACI,KAAO9V,KAAK+9D,QAAUpsD,MAAM,CACxB,GAAqB5H,OAAQ/J,KAAK0+D,cAClC,KACQ1+D,KAAK2+D,iBAv4Hf,IAw4Hc3+D,KAAK2+D,iBAz5HjB,IA05HgB3+D,KAAK2+D,iBA93HjB,IA+3HY3+D,KAAK4+D,cAAc70D,OAEd/J,KAAK2+D,iBAAiB1sD,QAC3BjS,KAAK6+D,gBAAgB90D,OAGrB/J,KAAK8+D,gBAAgB/0D,OAGpB/J,KAAK2+D,iBAAiB/nD,QAC3B5W,KAAK++D,iBAAiBh1D,OAGtB/J,KAAKg/D,gBAAgBj1D,OAGlB/J,KAAK69D,cAAgB79D,KAAKi/D,0BACjCj/D,KAAKk/D,eAGb,MAAwB5lD,GACpB,KAAIA,YAAaokD,oBAIb,KAAMpkD,EAHNtZ,MAAKiyB,OAAOlrB,KAAKuS,EAAE/U,QAS/B,MAFAvE,MAAKm/D,YAAYrnD,YAAYg7C,KAC7B9yD,KAAKo/D,cACE,GAAI5B,gBAAe9lD,gBAAgB1X,KAAK2xD,QAAS3xD,KAAKiyB,SAMjE7b,WAAW7V,UAAU0+D,uBAIrB,WACI,GAAI/nD,qBAAqBlX,KAAKs+D,OAAQt+D,KAAKi+D,OAAQj+D,KAAK89D,sBAEpD,MADA99D,MAAKq/D,8BACE,CAEX,IAAIhoD,qBAAqBrX,KAAK+9D,QAAU/9D,KAAKs/D,qBAEzC,MADAt/D,MAAKu/D,8BACE,CAEX,IAh6HM,MAg6HFv/D,KAAK+9D,MAAmB,CACxB,GAAI/9D,KAAKw/D,qBAEL,MADAx/D,MAAKy/D,4BACE,CAEX,IAAIz/D,KAAKs/D,qBAEL,MADAt/D,MAAK0/D,4BACE,EAGf,OAAO,GAKXtpD,WAAW7V,UAAUm+D,aAGrB,WACI,MAAO,IAAI7oD,eAAc7V,KAAK29D,MAAO39D,KAAKi+D,OAAQj+D,KAAKk+D,MAAOl+D,KAAKm+D,UAOvE/nD,WAAW7V,UAAUo/D,SAKrB,SAAU51D,MAAOG,KAGb,WAFc,KAAVH,QAAoBA,MAAQ/J,KAAK0+D,oBACzB,KAARx0D,MAAkBA,IAAMlK,KAAK0+D,gBAC1B,GAAI9oD,iBAAgB7L,MAAOG,MAOtCkM,WAAW7V,UAAU4+D,YAKrB,SAAU/4D,KAAM2D,WACE,KAAVA,QAAoBA,MAAQ/J,KAAK0+D,gBACrC1+D,KAAK4/D,mBAAqB71D,MAC1B/J,KAAK6/D,kBAAoBz5D,MAO7BgQ,WAAW7V,UAAU6+D,UAKrB,SAAUpnD,MAAO9N,SACD,KAARA,MAAkBA,IAAMlK,KAAK0+D,eACjC,IAAqB/4D,OAAQ,GAAIy3D,SAAQp9D,KAAK6/D,kBAAmB7nD,MAAO,GAAIpC,iBAAgB5V,KAAK4/D,mBAAoB11D,KAIrH,OAHAlK,MAAK2xD,OAAO5qD,KAAKpB,OACjB3F,KAAK4/D,mBAAsC,KAC3C5/D,KAAK6/D,kBAAqC,KACnCl6D,OAOXyQ,WAAW7V,UAAUu/D,aAKrB,SAAUz7D,IAAKsG,MACP3K,KAAKs/D,uBACLj7D,KAAO,qFAEX,IAAqBE,OAAQ,GAAI84D,YAAWh5D,IAAKrE,KAAK6/D,kBAAmBl1D,KAGzE,OAFA3K,MAAK4/D,mBAAsC,KAC3C5/D,KAAK6/D,kBAAqC,KACnC,GAAInC,mBAAkBn5D,QAKjC6R,WAAW7V,UAAUi+D,SAGrB,WACI,GAAIx+D,KAAKi+D,QAAUj+D,KAAKu+D,QACpB,KAAMv+D,MAAK8/D,aAAazpD,6BAA6B1E,MAAO3R,KAAK2/D,WAEjE3/D,MAAK+9D,QAAUtrD,KACfzS,KAAKk+D,QACLl+D,KAAKm+D,QAAU,GAEVn+D,KAAK+9D,QAAUtrD,KAAOzS,KAAK+9D,QAAUnrD,KAC1C5S,KAAKm+D;mEAETn+D,KAAKi+D,SACLj+D,KAAK+9D,MAAQ/9D,KAAKi+D,QAAUj+D,KAAKu+D,QAAU5sD,KAAO3R,KAAKs+D,OAAOh5D,WAAWtF,KAAKi+D,QAC9Ej+D,KAAKg+D,UACDh+D,KAAKi+D,OAAS,GAAKj+D,KAAKu+D,QAAU5sD,KAAO3R,KAAKs+D,OAAOh5D,WAAWtF,KAAKi+D,OAAS,IAMtF7nD,WAAW7V,UAAUo+D,iBAIrB,SAAUroD,UACN,MAAItW,MAAK+9D,QAAUznD,WACftW,KAAKw+D,YACE,IAQfpoD,WAAW7V,UAAUw/D,gCAIrB,SAAUzpD,UACN,QAAIgB,+BAA+BtX,KAAK+9D,MAAOznD,YAC3CtW,KAAKw+D,YACE,IAQfpoD,WAAW7V,UAAUy/D,iBAIrB,SAAU1pD,UACN,GAAqBk+C,UAAWx0D,KAAK0+D,cACrC,KAAK1+D,KAAK2+D,iBAAiBroD,UACvB,KAAMtW,MAAK8/D,aAAazpD,6BAA6BrW,KAAK+9D,OAAQ/9D,KAAK2/D,SAASnL,SAAUA,YAOlGp+C,WAAW7V,UAAU0/D,YAIrB,SAAUC,OACN,GAAqBhnD,KAAMgnD,MAAMp+D,MACjC,IAAI9B,KAAKi+D,OAAS/kD,IAAMlZ,KAAKu+D,QACzB,OAAO,CAGX,KAAK,GADgB4B,iBAAkBngE,KAAKogE,gBAClBr1D,EAAI,EAAGA,EAAImO,IAAKnO,IACtC,IAAK/K,KAAK2+D,iBAAiBuB,MAAM56D,WAAWyF,IAIxC,MADA/K,MAAKqgE,iBAAiBF,kBACf,CAGf,QAAO,GAMX/pD,WAAW7V,UAAU+/D,2BAIrB,SAAUJ,OACN,IAAK,GAAqBn1D,GAAI,EAAGA,EAAIm1D,MAAMp+D,OAAQiJ,IAC/C,IAAK/K,KAAK+/D,gCAAgCG,MAAM56D,WAAWyF,IACvD,OAAO,CAGf,QAAO,GAMXqL,WAAW7V,UAAUggE,YAIrB,SAAUL,OACN,GAAqB1L,UAAWx0D,KAAK0+D,cACrC,KAAK1+D,KAAKigE,YAAYC,OAClB,KAAMlgE,MAAK8/D,aAAazpD,6BAA6BrW,KAAK+9D,OAAQ/9D,KAAK2/D,SAASnL,YAOxFp+C,WAAW7V,UAAUigE,wBAIrB,SAAUC,WACN,MAAQA,UAAUzgE,KAAK+9D,QACnB/9D,KAAKw+D,YAQbpoD,WAAW7V,UAAUmgE,wBAKrB,SAAUD,UAAWvnD,KACjB,GAAqBnP,OAAQ/J,KAAK0+D,cAElC,IADA1+D,KAAKwgE,wBAAwBC,WACzBzgE,KAAKi+D,OAASl0D,MAAME,OAASiP,IAC7B,KAAMlZ,MAAK8/D,aAAazpD,6BAA6BrW,KAAK+9D,OAAQ/9D,KAAK2/D,SAAS51D,MAAOA,SAO/FqM,WAAW7V,UAAUogE,kBAIrB,SAAU3I,MACN,KAAOh4D,KAAK+9D,QAAU/F,MAClBh4D,KAAKw+D,YAObpoD,WAAW7V,UAAUqgE,UAIrB,SAAUC,gBACN,GAAIA,gBA5sIK,KA4sIa7gE,KAAK+9D,MACvB,MAAO/9D,MAAK8gE,eAGZ,IAAqB17D,OAAQpF,KAAKi+D,MAElC,OADAj+D,MAAKw+D,WACEx+D,KAAKs+D,OAAOl5D,QAM3BgR,WAAW7V,UAAUugE,cAGrB,WACI,GAAqB/2D,OAAQ/J,KAAK0+D,cAElC,IADA1+D,KAAKw+D,YACDx+D,KAAK2+D,iBAjuIL,IAmvIC,CACD,GAAqBoC,eAAgB/gE,KAAKogE,eAE1C,IADApgE,KAAKwgE,wBAAwBvpD,kBACzBjX,KAAK+9D,OAAS/mD,WAEd,MADAhX,MAAKqgE,iBAAiBU,eACf,GAEX/gE,MAAKw+D,UACL,IAAqBrN,QAASnxD,KAAKs+D,OAAOp4D,UAAU6D,MAAME,OAAS,EAAGjK,KAAKi+D,OAAS,GAC/DjG,KAAOpa,eAAeuT,OAC3C,KAAK6G,KACD,KAAMh4D,MAAK8/D,aAAavpD,uBAAuB46C,QAASnxD,KAAK2/D,SAAS51D,OAE1E,OAAOiuD,MA9BP,GAAqBgJ,OAAQhhE,KAAK2+D,iBA3rIrC,MA2rI6D3+D,KAAK2+D,iBA1sIlE,IA2sIwBsC,YAAcjhE,KAAK0+D,eAAez0D,MAEvD,IADAjK,KAAKwgE,wBAAwBzpD,kBACzB/W,KAAK+9D,OAAS/mD,WACd,KAAMhX,MAAK8/D,aAAazpD,6BAA6BrW,KAAK+9D,OAAQ/9D,KAAK2/D,WAE3E3/D,MAAKw+D,UACL,IAAqB0C,QAASlhE,KAAKs+D,OAAOp4D,UAAU+6D,YAAajhE,KAAKi+D,OAAS,EAC/E,KACI,GAAqB3nD,UAAWrD,SAASiuD,OAAQF,MAAQ,GAAK,GAC9D,OAAOx7D,QAAOC,aAAa6Q,UAE/B,MAAwBgD,GACpB,GAAqB6nD,QAASnhE,KAAKs+D,OAAOp4D,UAAU6D,MAAME,OAAS,EAAGjK,KAAKi+D,OAAS,EACpF,MAAMj+D,MAAK8/D,aAAavpD,uBAAuB4qD,QAASnhE,KAAK2/D,SAAS51D,UAyBlFqM,WAAW7V,UAAU6gE,gBAMrB,SAAUP,eAAgBQ,eAAgBC,gBACtC,GAAqBC,eACAC,UAAYxhE,KAAK0+D,cACtC1+D,MAAKm/D,YAAY0B,eAAiB/oD,YAAY4lC,mBAAqB5lC,YAAY2lC,SAAU+jB,UAEzF,KADA,GAAqBxpD,YACR,CAET,GADAupD,cAAgBvhE,KAAK0+D,eACjB1+D,KAAK2+D,iBAAiB0C,iBAAmBC,iBACzC,KAMJ,KAJIthE,KAAKi+D,OAASsD,cAAct3D,QAE5B+N,MAAMjR,KAAK/G,KAAKs+D,OAAOp4D,UAAUq7D,cAAct3D,OAAQjK,KAAKi+D,SAEzDj+D,KAAK+9D,QAAUsD,gBAClBrpD,MAAMjR,KAAK/G,KAAK4gE,UAAUC,iBAGlC,MAAO7gE,MAAKo/D,WAAWp/D,KAAKy+D,wBAAwBzmD,MAAMnS,KAAK,MAAO07D,gBAM1EnrD,WAAW7V,UAAUs+D,gBAIrB,SAAU90D,OACN,GAAIg6B,OAAQ/jC,IACZA,MAAKm/D,YAAYrnD,YAAY0kD,cAAezyD,OAC5C/J,KAAKggE,iBAAiB/tD,QACtBjS,KAAKo/D,aACL,IAAqBqC,WAAYzhE,KAAKohE,iBAAgB,EAAOnvD,OAAQ,WAAc,MAAO8xB,OAAMk8B,YAAY,OAC5GjgE,MAAKm/D,YAAYrnD,YAAY2kD,YAAagF,UAAUz3D,WAAWE,KAC/DlK,KAAKo/D,eAMThpD,WAAW7V,UAAUq+D,cAIrB,SAAU70D,OACN,GAAIg6B,OAAQ/jC,IACZA,MAAKm/D,YAAYrnD,YAAY4kD,YAAa3yD,OAC1C/J,KAAKugE,YAAY,UACjBvgE,KAAKo/D,aACL,IAAqBqC,WAAYzhE,KAAKohE,iBAAgB,EAryI9C,GAqyIgE,WAAc,MAAOr9B,OAAMk8B,YAAY,OAC/GjgE,MAAKm/D,YAAYrnD,YAAY6kD,UAAW8E,UAAUz3D,WAAWE,KAC7DlK,KAAKo/D,eAMThpD,WAAW7V,UAAUu+D,gBAIrB,SAAU/0D,OACN/J,KAAKm/D,YAAYrnD,YAAYglD,SAAU/yD,OACvC/J,KAAK2gE,kBAAkBhqD,KACvB3W,KAAKw+D,WACLx+D,KAAKo/D,WAAWp/D,KAAKs+D,OAAOp4D,UAAU6D,MAAME,OAAS,EAAGjK,KAAKi+D,OAAS,MAK1E7nD,WAAW7V,UAAUmhE,sBAGrB,WAGI,IAFA,GAAqBC,mBAAoB3hE,KAAKi+D,OACzBnxD,OAA0B,KA90I1C,KA+0IE9M,KAAK+9D,QAAqBjnD,YAAY9W,KAAK+9D,QAC9C/9D,KAAKw+D,UAET,IAAqBoD,UAWrB,OA71IK,MAm1ID5hE,KAAK+9D,OACL/9D,KAAKw+D,WACL1xD,OAAS9M,KAAKs+D,OAAOp4D,UAAUy7D,kBAAmB3hE,KAAKi+D,OAAS,GAChE2D,UAAY5hE,KAAKi+D,QAGjB2D,UAAYD,kBAEhB3hE,KAAK0gE,wBAAwBhqD,UAAW1W,KAAKi+D,SAAW2D,UAAY,EAAI,IAEhE90D,OADoB9M,KAAKs+D,OAAOp4D,UAAU07D,UAAW5hE,KAAKi+D,UAOtE7nD,WAAW7V,UAAUy+D,gBAIrB,SAAUj1D,OACN,GACqByC,SACAq1D,iBAFAC,SAAW9hE,KAAKogE,eAGrC,KACI,IAAK1wD,cAAc1P,KAAK+9D,OACpB,KAAM/9D,MAAK8/D,aAAazpD,6BAA6BrW,KAAK+9D,OAAQ/9D,KAAK2/D,WAE3E,IAAqBiC,WAAY5hE,KAAKi+D,MAKtC,KAJAj+D,KAAK+hE,qBAAqBh4D,OAC1ByC,QAAUxM,KAAKs+D,OAAOp4D,UAAU07D,UAAW5hE,KAAKi+D,QAChD4D,iBAAmBr1D,QAAQiB,cAC3BzN,KAAKwgE,wBAAwB/pD,iBACtBzW,KAAK+9D,QAAUnnD,QAAU5W,KAAK+9D,QAAUpnD,KAC3C3W,KAAKgiE,wBACLhiE,KAAKwgE,wBAAwB/pD,iBACzBzW,KAAK2+D,iBAAiB9nD,OACtB7W,KAAKwgE,wBAAwB/pD,iBAC7BzW,KAAKiiE,0BAETjiE,KAAKwgE,wBAAwB/pD,gBAEjCzW,MAAKkiE,qBAET,MAAwB5oD,GACpB,GAAIA,YAAaokD,mBAMb,MAJA19D,MAAKqgE,iBAAiByB,UAEtB9hE,KAAKm/D,YAAYrnD,YAAYC,KAAMhO,WACnC/J,MAAKo/D,WAAW,KAGpB,MAAM9lD,GAEV,GAAqB6oD,kBAAmBniE,KAAK49D,kBAAkBpxD,SAAS41D,WACpED,oBAAqB3kB,eAAeC,SACpCz9C,KAAKqiE,4BAA4BR,kBAAkB,GAE9CM,mBAAqB3kB,eAAeE,oBACzC19C,KAAKqiE,4BAA4BR,kBAAkB,IAQ3DzrD,WAAW7V,UAAU8hE,4BAKrB,SAAUR,iBAAkBhB,gBACxB,GAAI98B,OAAQ/jC,KACSyhE,UAAYzhE,KAAKohE,gBAAgBP,eA55IpD,GA45IyE,WACvE,QAAK98B,MAAM46B,iBAAiB/nD,UAE5BmtB,MAAMy8B,wBAAwB/pD,mBACzBstB,MAAMu8B,2BAA2BuB,oBAEtC99B,MAAMy8B,wBAAwB/pD,iBACvBstB,MAAM46B,iBAAiBhoD,QAElC3W,MAAKm/D,YAAYrnD,YAAYykD,UAAWkF,UAAUz3D,WAAWE,KAC7DlK,KAAKo/D,WAA4B,KAAUyC,oBAM/CzrD,WAAW7V,UAAUwhE,qBAIrB,SAAUh4D,OACN/J,KAAKm/D,YAAYrnD,YAAYskD,eAAgBryD,MAC7C,IAAqBiO,OAAQhY,KAAK0hE,uBAClC1hE,MAAKo/D,UAAUpnD,QAKnB5B,WAAW7V,UAAUyhE,sBAGrB,WACIhiE,KAAKm/D,YAAYrnD,YAAY8kD,UAC7B,IAAqB0F,eAAgBtiE,KAAK0hE,uBAC1C1hE,MAAKo/D,UAAUkD,gBAKnBlsD,WAAW7V,UAAU0hE,uBAGrB,WACIjiE,KAAKm/D,YAAYrnD,YAAY+kD,WAC7B,IAAqBv5D,MACrB,IAAItD,KAAK+9D,QAAU3rD,KAAOpS,KAAK+9D,QAAU1rD,IAAK,CAC1C,GAAqBkwD,WAAYviE,KAAK+9D,KACtC/9D,MAAKw+D,UAEL,KADA,GAAqBxmD,UACdhY,KAAK+9D,QAAUwE,WAClBvqD,MAAMjR,KAAK/G,KAAK4gE,WAAU,GAE9Bt9D,OAAQ0U,MAAMnS,KAAK,IACnB7F,KAAKw+D,eAEJ,CACD,GAAqBgE,YAAaxiE,KAAKi+D,MACvCj+D,MAAK0gE,wBAAwBhqD,UAAW,GACxCpT,MAAQtD,KAAKs+D,OAAOp4D,UAAUs8D,WAAYxiE,KAAKi+D,QAEnDj+D,KAAKo/D,WAAWp/D,KAAKy+D,wBAAwBn7D,UAKjD8S,WAAW7V,UAAU2hE,mBAGrB,WACI,GAAqB3E,WAAYv9D,KAAK2+D,iBAAiB/nD,QAAUkB,YAAYwkD,kBAAoBxkD,YAAYukD,YAC7Gr8D,MAAKm/D,YAAY5B,WACjBv9D,KAAKggE,iBAAiBrpD,KACtB3W,KAAKo/D,eAMThpD,WAAW7V,UAAUw+D,iBAIrB,SAAUh1D,OACN/J,KAAKm/D,YAAYrnD,YAAYykD,UAAWxyD,OACxC/J,KAAKwgE,wBAAwB/pD,gBAC7B,IAAqB6rD,eAAgBtiE,KAAK0hE,uBAC1C1hE,MAAKwgE,wBAAwB/pD,iBAC7BzW,KAAKggE,iBAAiBrpD,KACtB3W,KAAKo/D,UAAUkD,gBAKnBlsD,WAAW7V,UAAU8+D,2BAGrB,WACIr/D,KAAKm/D,YAAYrnD,YAAYilD,qBAAsB/8D,KAAK0+D,gBACxD1+D,KAAKggE,iBAAiB5oD,SACtBpX,KAAKo/D,cACLp/D,KAAKo+D,oBAAoBr3D,KAAK+Q,YAAYilD,sBAC1C/8D,KAAKm/D,YAAYrnD,YAAY2lC,SAAUz9C,KAAK0+D,eAC5C,IAAqBzvD,WAAYjP,KAAKyiE,WAxgJjC,GAygJLziE,MAAKo/D,WAAWnwD,WAAYjP,KAAK0+D,gBACjC1+D,KAAKggE,iBA1gJA,IA2gJLhgE,KAAKwgE,wBAAwB/pD,iBAC7BzW,KAAKm/D,YAAYrnD,YAAY2lC,SAAUz9C,KAAK0+D,eAC5C,IAAqBt4D,MAAOpG,KAAKyiE,WA7gJ5B,GA8gJLziE,MAAKo/D,WAAWh5D,MAAOpG,KAAK0+D,gBAC5B1+D,KAAKggE,iBA/gJA,IAghJLhgE,KAAKwgE,wBAAwB/pD,kBAKjCL,WAAW7V,UAAUg/D,2BAGrB,WACIv/D,KAAKm/D,YAAYrnD,YAAYklD,qBAAsBh9D,KAAK0+D,eACxD,IAAqBp7D,OAAQtD,KAAKyiE,WAAWrrD,SAAShU,MACtDpD,MAAKo/D,WAAW97D,OAAQtD,KAAK0+D,gBAC7B1+D,KAAKwgE,wBAAwB/pD,iBAC7BzW,KAAKm/D,YAAYrnD,YAAYmlD,yBAA0Bj9D,KAAK0+D,gBAC5D1+D,KAAKggE,iBAAiB5oD,SACtBpX,KAAKo/D,aAAcp/D,KAAK0+D,gBACxB1+D,KAAKwgE,wBAAwB/pD,iBAC7BzW,KAAKo+D,oBAAoBr3D,KAAK+Q,YAAYmlD,2BAK9C7mD,WAAW7V,UAAUk/D,yBAGrB,WACIz/D,KAAKm/D,YAAYrnD,YAAYolD,uBAAwBl9D,KAAK0+D,gBAC1D1+D,KAAKggE,iBAzgJC,KA0gJNhgE,KAAKo/D,aAAcp/D,KAAK0+D,gBACxB1+D,KAAKwgE,wBAAwB/pD,iBAC7BzW,KAAKo+D,oBAAoB5vB,OAK7Bp4B,WAAW7V,UAAUm/D,yBAGrB,WACI1/D,KAAKm/D,YAAYrnD,YAAYqlD,mBAAoBn9D,KAAK0+D,gBACtD1+D,KAAKggE,iBAthJC,KAuhJNhgE,KAAKo/D,cACLp/D,KAAKo+D,oBAAoB5vB,OAK7Bp4B,WAAW7V,UAAU2+D,aAGrB,WACI,GAAqBn1D,OAAQ/J,KAAK0+D,cAClC1+D,MAAKm/D,YAAYrnD,YAAYC,KAAMhO,MACnC,IAAqBiO,SACrB,IACQhY,KAAK89D,sBAAwB99D,KAAKigE,YAAYjgE,KAAK89D,qBAAqB/zD,QACxEiO,MAAMjR,KAAK/G,KAAK89D,qBAAqB/zD,OACrC/J,KAAKq+D,kBAAmB,GAEnBr+D,KAAK89D,sBAAwB99D,KAAKq+D,kBACvCr+D,KAAKigE,YAAYjgE,KAAK89D,qBAAqB5zD,MAC3C8N,MAAMjR,KAAK/G,KAAK89D,qBAAqB5zD,KACrClK,KAAKq+D,kBAAmB,GAGxBrmD,MAAMjR,KAAK/G,KAAK4gE,WAAU,WAExB5gE,KAAK0iE,aACf1iE,MAAKo/D,WAAWp/D,KAAKy+D,wBAAwBzmD,MAAMnS,KAAK,QAK5DuQ,WAAW7V,UAAUmiE,WAGrB,WACI,GAvlJE,KAulJE1iE,KAAK+9D,OAAiB/9D,KAAK+9D,QAAUpsD,KACrC,OAAO,CAEX,IAAI3R,KAAK69D,eAAiB79D,KAAKq+D,iBAAkB,CAC7C,GAAInnD,qBAAqBlX,KAAKs+D,OAAQt+D,KAAKi+D,OAAQj+D,KAAK89D,sBAEpD,OAAO,CAEX,IAnkJE,MAmkJE99D,KAAK+9D,OAAqB/9D,KAAKw/D,qBAE/B,OAAO,EAGf,OAAO,GAKXppD,WAAW7V,UAAU6/D,cAGrB,WACI,OAAQpgE,KAAK+9D,MAAO/9D,KAAKi+D,OAAQj+D,KAAKm+D,QAASn+D,KAAKk+D,MAAOl+D,KAAK2xD,OAAO7vD,SAM3EsU,WAAW7V,UAAUkiE,WAIrB,SAAUzK,MACN,GAAqBjuD,OAAQ/J,KAAKi+D,MAElC,OADAj+D,MAAK2gE,kBAAkB3I,MAChBh4D,KAAKs+D,OAAOp4D,UAAU6D,MAAO/J,KAAKi+D,SAM7C7nD,WAAW7V,UAAU8/D,iBAIrB,SAAU91D,UACNvK,KAAK+9D,MAAQxzD,SAAS,GACtBvK,KAAKi+D,OAAS1zD,SAAS,GACvBvK,KAAKm+D,QAAU5zD,SAAS,GACxBvK,KAAKk+D,MAAQ3zD,SAAS,EACtB,IAAqBo4D,UAAWp4D,SAAS,EACrCo4D,UAAW3iE,KAAK2xD,OAAO7vD,SAEvB9B,KAAK2xD,OAAS3xD,KAAK2xD,OAAOxuD,MAAM,EAAGw/D,YAM3CvsD,WAAW7V,UAAUi/D,mBAGrB,WACI,MAAOx/D,MAAKo+D,oBAAoBt8D,OAAS,GACrC9B,KAAKo+D,oBAAoBp+D,KAAKo+D,oBAAoBt8D,OAAS,KACvDgW,YAAYmlD,0BAKxB7mD,WAAW7V,UAAU++D,mBAGrB,WACI,MAAOt/D,MAAKo+D,oBAAoBt8D,OAAS,GACrC9B,KAAKo+D,oBAAoBp+D,KAAKo+D,oBAAoBt8D,OAAS,KACvDgW,YAAYilD,sBAEjB3mD,cAuGPwsD,UAA2B,SAAUn4D,QAErC,QAASm4D,WAAUv2D,YAAa1B,KAAMtG,KAClC,GAAI0/B,OAAQt5B,OAAO8kC,KAAKvvC,KAAM2K,KAAMtG,MAAQrE,IAE5C,OADA+jC,OAAM13B,YAAcA,YACb03B,MAiBX,MArBA9jC,WAAU2iE,UAAWn4D,QAYrBm4D,UAAUniE,OAMV,SAAU4L,YAAa1B,KAAMtG,KACzB,MAAO,IAAIu+D,WAAUv2D,YAAa1B,KAAMtG,MAErCu+D,WACT1G,YACEpqC,gBAAiC,WACjC,QAASA,iBAAgBE,UAAWC,QAChCjyB,KAAKgyB,UAAYA,UACjBhyB,KAAKiyB,OAASA,OAElB,MAAOH,oBAEP+wC,SAA0B,WAC1B,QAASj6B,QAAO5yB,kBACZhW,KAAKgW,iBAAmBA,iBAuB5B,MAdA4yB,QAAOroC,UAAUkzB,MAOjB,SAAU1d,OAAQjN,IAAKg6D,oBAAqB5sD,yBACZ,KAAxB4sD,sBAAkCA,qBAAsB,OAChC,KAAxB5sD,sBAAkCA,oBAAsBC,6BAC5D,IAAqB4sD,iBAAkBjtD,SAASC,OAAQjN,IAAK9I,KAAKgW,iBAAkB8sD,oBAAqB5sD,qBACpF8sD,cAAgB,GAAIC,cAAaF,gBAAgBpR,OAAQ3xD,KAAKgW,kBAAkBktD,OACrG,OAAO,IAAIpxC,iBAAgBkxC,cAAchxC,UAA8B+wC,gBAAuB,OAAEn6D,OAAOo6D,cAAc/wC,UAElH2W,UAEPq6B,aAA8B,WAC9B,QAASA,cAAatR,OAAQ37C,kBAC1BhW,KAAK2xD,OAASA,OACd3xD,KAAKgW,iBAAmBA,iBACxBhW,KAAKi+D,QAAU,EACfj+D,KAAKmjE,cACLnjE,KAAKojE,WACLpjE,KAAKqjE,iBACLrjE,KAAKw+D,WA8cT,MAzcAyE,cAAa1iE,UAAU2iE,MAGvB,WACI,KAAOljE,KAAK+9D,MAAM33D,OAAS0R,YAAYg7C,KAC/B9yD,KAAK+9D,MAAM33D,OAAS0R,YAAYskD,eAChCp8D,KAAKsjE,iBAAiBtjE,KAAKw+D,YAEtBx+D,KAAK+9D,MAAM33D,OAAS0R,YAAYykD,UACrCv8D,KAAKujE,eAAevjE,KAAKw+D,YAEpBx+D,KAAK+9D,MAAM33D,OAAS0R,YAAY4kD,aACrC18D,KAAKwjE,oBACLxjE,KAAK4+D,cAAc5+D,KAAKw+D,aAEnBx+D,KAAK+9D,MAAM33D,OAAS0R,YAAY0kD,eACrCx8D,KAAKwjE,oBACLxjE,KAAK6+D,gBAAgB7+D,KAAKw+D,aAErBx+D,KAAK+9D,MAAM33D,OAAS0R,YAAYC,MAAQ/X,KAAK+9D,MAAM33D,OAAS0R,YAAY2lC,UAC7Ez9C,KAAK+9D,MAAM33D,OAAS0R,YAAY4lC,oBAChC19C,KAAKwjE,oBACLxjE,KAAKk/D,aAAal/D,KAAKw+D,aAElBx+D,KAAK+9D,MAAM33D,OAAS0R,YAAYilD,qBACrC/8D,KAAKyjE,kBAAkBzjE,KAAKw+D,YAI5Bx+D,KAAKw+D,UAGb,OAAO,IAAI1sC,iBAAgB9xB,KAAKmjE,WAAYnjE,KAAKojE,UAKrDH,aAAa1iE,UAAUi+D,SAGvB,WACI,GAAqBkF,MAAO1jE,KAAK+9D,KAMjC,OALI/9D,MAAKi+D,OAASj+D,KAAK2xD,OAAO7vD,OAAS,GAEnC9B,KAAKi+D,SAETj+D,KAAK+9D,MAAQ/9D,KAAK2xD,OAAO3xD,KAAKi+D,QACvByF,MAMXT,aAAa1iE,UAAUojE,WAIvB,SAAUv9D,MACN,MAAIpG,MAAK+9D,MAAM33D,OAASA,KACbpG,KAAKw+D,WAET,MAMXyE,aAAa1iE,UAAUq+D,cAIvB,SAAUgF,YACN5jE,KAAKk/D,aAAal/D,KAAKw+D,YACvBx+D,KAAK2jE,WAAW7rD,YAAY6kD,YAMhCsG,aAAa1iE,UAAUs+D,gBAIvB,SAAUl5D,OACN,GAAqB4K,MAAOvQ,KAAK2jE,WAAW7rD,YAAY2lC,SACxDz9C,MAAK2jE,WAAW7rD,YAAY2kD,YAC5B,IAAqBn5D,OAAgB,MAARiN,KAAeA,KAAKyH,MAAM,GAAG5U,OAAS,IACnEpD,MAAK6jE,aAAa,GAAIxlD,SAAQ/a,MAAOqC,MAAMqE,cAM/Ci5D,aAAa1iE,UAAUkjE,kBAIvB,SAAU99D,OAKN,IAJA,GAAqBotB,aAAc/yB,KAAKw+D,WACnBp4D,KAAOpG,KAAKw+D,WACZhsC,SAEdxyB,KAAK+9D,MAAM33D,OAAS0R,YAAYklD,sBAAsB,CACzD,GAAqB8G,SAAU9jE,KAAK+jE,qBACpC,KAAKD,QACD,MACJtxC,OAAMzrB,KAAK+8D,SAGf,GAAI9jE,KAAK+9D,MAAM33D,OAAS0R,YAAYqlD,mBAEhC,WADAn9D,MAAKojE,QAAQr8D,KAAK67D,UAAUniE,OAAO,KAAMT,KAAK+9D,MAAM/zD,WAAY,qCAGpE,IAAqBA,YAAa,GAAI4L,iBAAgBjQ,MAAMqE,WAAWD,MAAO/J,KAAK+9D,MAAM/zD,WAAWE,IACpGlK,MAAK6jE,aAAa,GAAIlnB,WAAU5pB,YAAY/a,MAAM,GAAI5R,KAAK4R,MAAM,GAAIwa,MAAOxoB,WAAY+oB,YAAY/oB,aACpGhK,KAAKw+D,YAKTyE,aAAa1iE,UAAUwjE,oBAGvB,WACI,GAAqBzgE,OAAQtD,KAAKw+D,UAElC,IAAIx+D,KAAK+9D,MAAM33D,OAAS0R,YAAYmlD,yBAEhC,MADAj9D,MAAKojE,QAAQr8D,KAAK67D,UAAUniE,OAAO,KAAMT,KAAK+9D,MAAM/zD,WAAY,sCACzD,IAGX,IAAqBD,OAAQ/J,KAAKw+D,WACb/pD,IAAMzU,KAAKgkE,2BAA2Bj6D,MAC3D,KAAK0K,IACD,MAAO,KACX,IAAqBvK,KAAMlK,KAAKw+D,UAChC/pD,KAAI1N,KAAK,GAAIq2D,SAAQtlD,YAAYg7C,OAAS5oD,IAAIF,YAE9C,IAAqBi6D,WAAY,GAAIhB,cAAaxuD,IAAKzU,KAAKgW,kBAAkBktD,OAC9E,IAAIe,UAAUhyC,OAAOnwB,OAAS,EAE1B,MADA9B,MAAKojE,QAAUpjE,KAAKojE,QAAQx6D,OAAyBq7D,UAAgB,QAC9D,IAEX,IAAqBj6D,YAAa,GAAI4L,iBAAgBtS,MAAM0G,WAAWD,MAAOG,IAAIF,WAAWE,KACxE4yC,cAAgB,GAAIlnC,iBAAgB7L,MAAMC,WAAWD,MAAOG,IAAIF,WAAWE,IAChG,OAAO,IAAI2yC,eAAcv5C,MAAM0U,MAAM,GAAIisD,UAAUjyC,UAAWhoB,WAAY1G,MAAM0G,WAAY8yC,gBAMhGmmB,aAAa1iE,UAAUyjE,2BAIvB,SAAUj6D,OAGN,IAFA,GAAqB0K,QACAyvD,oBAAsBpsD,YAAYmlD,4BAC1C,CAKT,GAJIj9D,KAAK+9D,MAAM33D,OAAS0R,YAAYilD,sBAChC/8D,KAAK+9D,MAAM33D,OAAS0R,YAAYmlD,0BAChCiH,mBAAmBn9D,KAAK/G,KAAK+9D,MAAM33D,MAEnCpG,KAAK+9D,MAAM33D,OAAS0R,YAAYolD,uBAAwB,CACxD,IAAIjlD,YAAYisD,mBAAoBpsD,YAAYmlD,0BAO5C,MADAj9D,MAAKojE,QAAQr8D,KAAK67D,UAAUniE,OAAO,KAAMsJ,MAAMC,WAAY,sCACpD,IALP,IADAk6D,mBAAmB11B,MACc,GAA7B01B,mBAAmBpiE,OACnB,MAAO2S,KAOnB,GAAIzU,KAAK+9D,MAAM33D,OAAS0R,YAAYqlD,mBAAoB,CACpD,IAAIllD,YAAYisD,mBAAoBpsD,YAAYilD,sBAK5C,MADA/8D,MAAKojE,QAAQr8D,KAAK67D,UAAUniE,OAAO,KAAMsJ,MAAMC,WAAY,sCACpD,IAJPk6D,oBAAmB11B,MAO3B,GAAIxuC,KAAK+9D,MAAM33D,OAAS0R,YAAYg7C,IAEhC,MADA9yD,MAAKojE,QAAQr8D,KAAK67D,UAAUniE,OAAO,KAAMsJ,MAAMC,WAAY,sCACpD,IAEXyK,KAAI1N,KAAK/G,KAAKw+D,cAOtByE,aAAa1iE,UAAU2+D,aAIvB,SAAUv5D,OACN,GAAqB4K,MAAO5K,MAAMqS,MAAM,EACxC,IAAIzH,KAAKzO,OAAS,GAAgB,MAAXyO,KAAK,GAAY,CACpC,GAAqB4zD,UAAWnkE,KAAKokE,mBACrB,OAAZD,UAAgD,GAA5BA,SAAS95D,SAASvI,QACtC9B,KAAKgW,iBAAiBmuD,SAAS1iE,MAAM4iE,gBACrC9zD,KAAOA,KAAKrK,UAAU,IAG1BqK,KAAKzO,OAAS,GACd9B,KAAK6jE,aAAa,GAAIpuC,MAAKllB,KAAM5K,MAAMqE,cAM/Ci5D,aAAa1iE,UAAUijE,kBAGvB,WACI,GAAqBxtC,IAAKh2B,KAAKokE,mBAC3BpuC,KAAMh2B,KAAKgW,iBAAiBggB,GAAGv0B,MAAM6iE,QACrCtkE,KAAKqjE,cAAc70B,OAO3By0B,aAAa1iE,UAAU+iE,iBAIvB,SAAUiB,eAIN,IAHA,GAAqBz3D,QAASy3D,cAAcvsD,MAAM,GAC7BvW,KAAO8iE,cAAcvsD,MAAM,GAC3B1K,SACdtN,KAAK+9D,MAAM33D,OAAS0R,YAAY8kD,WACnCtvD,MAAMvG,KAAK/G,KAAKwkE,aAAaxkE,KAAKw+D,YAEtC,IAAqB5xD,UAAW5M,KAAKykE,oBAAoB33D,OAAQrL,KAAMzB,KAAKokE,qBACvDM,aAAc,CAGnC,IAAI1kE,KAAK+9D,MAAM33D,OAAS0R,YAAYwkD,kBAAmB,CACnDt8D,KAAKw+D,WACLkG,aAAc,CACd,IAAqBC,QAAS3kE,KAAKgW,iBAAiBpJ,SAC9C+3D,QAAOC,cAA0C,OAA1Bj4D,YAAYC,WAAsB+3D,OAAOL,QAClEtkE,KAAKojE,QAAQr8D,KAAK67D,UAAUniE,OAAOmM,SAAU23D,cAAcv6D,WAAY,sDAAyDu6D,cAAcvsD,MAAM,GAAK,UAGxJhY,MAAK+9D,MAAM33D,OAAS0R,YAAYukD,eACrCr8D,KAAKw+D,WACLkG,aAAc,EAElB,IAAqBx6D,KAAMlK,KAAK+9D,MAAM/zD,WAAWD,MAC5BY,KAAO,GAAIiL,iBAAgB2uD,cAAcv6D,WAAWD,MAAOG,KAC3D8rB,GAAK,GAAI7rB,SAAQyC,SAAUU,SAAW3C,KAAMA,SAAMzG,GACvElE,MAAK6kE,aAAa7uC,IACd0uC,cACA1kE,KAAK8kE,YAAYl4D,UACjBopB,GAAG5rB,cAAgBO,OAO3Bs4D,aAAa1iE,UAAUskE,aAIvB,SAAU7uC,IACN,GAAqB+uC,UAAW/kE,KAAKokE,mBACjCW,WAAY/kE,KAAKgW,iBAAiB+uD,SAAStjE,MAAMujE,gBAAgBhvC,GAAGv0B,OACpEzB,KAAKqjE,cAAc70B,KAEvB,IAAqBm2B,QAAS3kE,KAAKgW,iBAAiBggB,GAAGv0B,MACnD2X,GAAKpZ,KAAKilE,sCAAuCz5B,OAASpyB,GAAGoyB,OAAQ05B,UAAY9rD,GAAG8rD,SACxF,IAAI15B,QAAUm5B,OAAOQ,mBAAmB35B,OAAO/pC,MAAO,CAClD,GAAqB2jE,WAAY,GAAIj7D,SAAQw6D,OAAOU,kBAAqBrvC,GAAGhsB,WAAYgsB,GAAGknB,gBAAiBlnB,GAAG5rB,cAC/GpK,MAAKslE,uBAAuB95B,OAAQ05B,UAAWE,WAEnDplE,KAAK6jE,aAAa7tC,IAClBh2B,KAAKqjE,cAAct8D,KAAKivB,KAM5BitC,aAAa1iE,UAAUgjE,eAIvB,SAAUgC,aACN,GAAqB34D,UAAW5M,KAAKykE,oBAAoBc,YAAYvtD,MAAM,GAAIutD,YAAYvtD,MAAM,GAAIhY,KAAKokE,oBAI1G,IAHIpkE,KAAKokE,sBACcpkE,KAAKokE,oBAAsBh6D,cAAgBm7D,YAAYv7D,YAE1EhK,KAAKgW,iBAAiBpJ,UAAU03D,OAChCtkE,KAAKojE,QAAQr8D,KAAK67D,UAAUniE,OAAOmM,SAAU24D,YAAYv7D,WAAY,uCAA0Cu7D,YAAYvtD,MAAM,GAAK,UAErI,KAAKhY,KAAK8kE,YAAYl4D,UAAW,CAClC,GAAqB44D,QAAS,2BAA8B54D,SAAW,6KACvE5M,MAAKojE,QAAQr8D,KAAK67D,UAAUniE,OAAOmM,SAAU24D,YAAYv7D,WAAYw7D,WAO7EvC,aAAa1iE,UAAUukE,YAIvB,SAAUl4D,UACN,IAAK,GAAqB64D,YAAazlE,KAAKqjE,cAAcvhE,OAAS,EAAG2jE,YAAc,EAAGA,aAAc,CACjG,GAAqBzvC,IAAKh2B,KAAKqjE,cAAcoC,WAC7C,IAAIzvC,GAAGv0B,MAAQmL,SAEX,MADA5M,MAAKqjE,cAAcqC,OAAOD,WAAYzlE,KAAKqjE,cAAcvhE,OAAS2jE,aAC3D,CAEX,KAAKzlE,KAAKgW,iBAAiBggB,GAAGv0B,MAAMkkE,eAChC,OAAO,EAGf,OAAO,GAMX1C,aAAa1iE,UAAUikE,aAIvB,SAAUvvC,UACN,GAAqBroB,UAAWC,eAAeooB,SAASjd,MAAM,GAAIid,SAASjd,MAAM,IAC5D9N,IAAM+qB,SAASjrB,WAAWE,IAC1B5G,MAAQ,GACR05C,cAA6B,EAClD,IAAIh9C,KAAK+9D,MAAM33D,OAAS0R,YAAY+kD,WAAY,CAC5C,GAAqB+I,YAAa5lE,KAAKw+D,UACvCl7D,OAAQsiE,WAAW5tD,MAAM,GACzB9N,IAAM07D,WAAW57D,WAAWE,IAC5B8yC,UAAY4oB,WAAW57D,WAE3B,MAAO,IAAI6oB,aAAYjmB,SAAUtJ,MAAO,GAAIsS,iBAAgBqf,SAASjrB,WAAWD,MAAOG,KAAM8yC,YAKjGimB,aAAa1iE,UAAU6jE,kBAGvB,WACI,MAAOpkE,MAAKqjE,cAAcvhE,OAAS,EAAI9B,KAAKqjE,cAAcrjE,KAAKqjE,cAAcvhE,OAAS,GAAK,MAQ/FmhE,aAAa1iE,UAAU0kE,oCAMvB,WAEI,IAAK,GADgBC,WAAY,KACPn6D,EAAI/K,KAAKqjE,cAAcvhE,OAAS,EAAGiJ,GAAK,EAAGA,IAAK,CACtE,IAAKwB,cAAcvM,KAAKqjE,cAAct4D,GAAGtJ,MACrC,OAAS+pC,OAAQxrC,KAAKqjE,cAAct4D,GAAIm6D,UAAWA,UAEvDA,WAAYllE,KAAKqjE,cAAct4D,GAEnC,OAASygC,OAAQ,KAAM05B,UAAWA,YAMtCjC,aAAa1iE,UAAUsjE,aAIvB,SAAUvkD,MACN,GAAqBksB,QAASxrC,KAAKokE,mBACrB,OAAV54B,OACAA,OAAOnhC,SAAStD,KAAKuY,MAGrBtf,KAAKmjE,WAAWp8D,KAAKuY,OAc7B2jD,aAAa1iE,UAAU+kE,uBAWvB,SAAU95B,OAAQ05B,UAAW5lD,MACzB,GAAK4lD,UAIA,CACD,GAAI15B,OAAQ,CAER,GAAqBpmC,OAAQomC,OAAOnhC,SAASnH,QAAQgiE,UACrD15B,QAAOnhC,SAASjF,OAASka,SAGzBtf,MAAKmjE,WAAWp8D,KAAKuY,KAEzBA,MAAKjV,SAAStD,KAAKm+D,WACnBllE,KAAKqjE,cAAcqC,OAAO1lE,KAAKqjE,cAAcngE,QAAQgiE,WAAY,EAAG5lD,UAbpEtf,MAAK6jE,aAAavkD,MAClBtf,KAAKqjE,cAAct8D,KAAKuY,OAqBhC2jD,aAAa1iE,UAAUkkE,oBAMvB,SAAU33D,OAAQC,UAAW84D,eAOzB,MANc,OAAV/4D,QAEc,OADdA,OAA4B9M,KAAKgW,iBAAiBjJ,WAAmC,0BAC9C,MAAjB84D,gBAClB/4D,OAASH,YAAYk5D,cAAcpkE,OAGpCoL,eAAeC,OAAQC,YAE3Bk2D,gBAgDP6C,mBAAoC,WACpC,QAASA,uBAoFT,MA7EAA,oBAAmBvlE,UAAUm2C,UAK7B,SAAUnmC,KAAM/M,SAAW,MAAO+M,MAAKjN,OAMvCwiE,mBAAmBvlE,UAAUwlE,eAK7B,SAAUb,UAAW1hE,SACjB,GAAIugC,OAAQ/jC,IACZ,OAAO,IAAMklE,UAAU76D,SAASzE,IAAI,SAAUy2B,OAAS,MAAOA,OAAM11B,MAAMo9B,SAAWl+B,KAAK,MAAQ,KAOtGigE,mBAAmBvlE,UAAUylE,SAK7B,SAAUC,IAAKziE,SACX,GAAIugC,OAAQ/jC,KACSkmE,SAAW1lE,OAAOy2B,KAAKgvC,IAAIzzC,OAAO5sB,IAAI,SAAUsU,GAAK,MAAOA,GAAI,KAAO+rD,IAAIzzC,MAAMtY,GAAGvT,MAAMo9B,OAAS,KACxH,OAAO,IAAMkiC,IAAItxD,WAAa,KAAOsxD,IAAI7/D,KAAO,KAAO8/D,SAASrgE,KAAK,MAAQ,KAOjFigE,mBAAmBvlE,UAAU4lE,oBAK7B,SAAUC,GAAI5iE,SACV,GAAIugC,OAAQ/jC,IACZ,OAAOomE,IAAG9B,OACN,iBAAoB8B,GAAGC,UAAY,MACnC,iBAAoBD,GAAGC,UAAY,KAAQD,GAAG/7D,SAASzE,IAAI,SAAUy2B,OAAS,MAAOA,OAAM11B,MAAMo9B,SAAWl+B,KAAK,MAAQ,cAAiBugE,GAAGE,UAAY,MAOjKR,mBAAmBvlE,UAAUgmE,iBAK7B,SAAUH,GAAI5iE,SACV,MAAO4iE,IAAG9iE,MAAQ,aAAgB8iE,GAAG3kE,KAAO,KAAQ2kE,GAAG9iE,MAAQ,QAAU,aAAgB8iE,GAAG3kE,KAAO,OAOvGqkE,mBAAmBvlE,UAAUimE,oBAK7B,SAAUJ,GAAI5iE,SACV,MAAO,iBAAoB4iE,GAAG3kE,KAAO,KAAQ2kE,GAAG9iE,MAAMqD,MAAM3G,MAAQ,SAEjE8lE,sBAEPltD,kBAAoB,GAAIktD,oBAexBrtD,+BAAgD,SAAUhO,QAE1D,QAASgO,kCACL,MAAkB,QAAXhO,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KAkB/D,MApBAC,WAAUwY,+BAAgChO,QAS1CgO,+BAA+BlY,UAAUylE,SAKzC,SAAUC,IAAKziE,SACX,GAAIugC,OAAQ/jC,KACSkmE,SAAW1lE,OAAOy2B,KAAKgvC,IAAIzzC,OAAO5sB,IAAI,SAAUsU,GAAK,MAAOA,GAAI,KAAO+rD,IAAIzzC,MAAMtY,GAAGvT,MAAMo9B,OAAS,KAExH,OAAO,IAAMkiC,IAAI7/D,KAAO,KAAO8/D,SAASrgE,KAAK,MAAQ,KAElD4S,gCACTqtD,oBAoJE9sD,QACAmC,OAAQ,EACRlC,IAAK,EAETD,QAAOA,OAAOmC,QAAU,SACxBnC,OAAOA,OAAOC,KAAO;;;;;;;AA+LrB,GAAIwtD,SAAyB,WASzB,QAASA,SAAQ58D,MAAO68D,aAAcC,qBAAsBpuD,QAASiF,YAAalU,IAC9EtJ,KAAK6J,MAAQA,MACb7J,KAAK0mE,aAAeA,aACpB1mE,KAAK2mE,qBAAuBA,qBAC5B3mE,KAAKuY,QAAUA,QACfvY,KAAKwd,YAAcA,YACnBxd,KAAKsJ,GAAKA,GACNO,MAAM/H,OACN9B,KAAK4mE,UACGh/D,SAAUiC,MAAM,GAAGG,WAAWD,MAAMqzB,KAAKt0B,IACzC+9D,UAAWh9D,MAAM,GAAGG,WAAWD,MAAMi7B,KAAO,EAC5C8hC,SAAUj9D,MAAM,GAAGG,WAAWD,MAAMkxD,IAAM,EAC1C8L,QAASl9D,MAAMA,MAAM/H,OAAS,GAAGkI,WAAWE,IAAI86B,KAAO,EACvDgiC,OAAQn9D,MAAM,GAAGG,WAAWD,MAAMkxD,IAAM,IAIhDj7D,KAAK4mE,WAGb,MAAOH,YAUPQ,OAAwB,WACxB,QAASxxC,MAAKnyB,MAAO0G,YACjBhK,KAAKsD,MAAQA,MACbtD,KAAKgK,WAAaA,WAatB,MANAyrB,MAAKl1B,UAAUoG,MAKf,SAAUpD,QAASC,SAAW,MAAOD,SAAQmzC,UAAU12C,KAAMwD,UACtDiyB,QAEPyxC,UAA2B,WAC3B,QAASA,WAAU78D,SAAUL,YACzBhK,KAAKqK,SAAWA,SAChBrK,KAAKgK,WAAaA,WAatB,MANAk9D,WAAU3mE,UAAUoG,MAKpB,SAAUpD,QAASC,SAAW,MAAOD,SAAQwiE,eAAe/lE,KAAMwD,UAC3D0jE,aAEPC,IAAqB,WACrB,QAASA,KAAIxyD,WAAYvO,KAAMosB,MAAOxoB,YAClChK,KAAK2U,WAAaA,WAClB3U,KAAKoG,KAAOA,KACZpG,KAAKwyB,MAAQA,MACbxyB,KAAKgK,WAAaA,WAatB,MANAm9D,KAAI5mE,UAAUoG,MAKd,SAAUpD,QAASC,SAAW,MAAOD,SAAQyiE,SAAShmE,KAAMwD,UACrD2jE,OAEPC,eAAgC,WAChC,QAASA,gBAAexnD,IAAKtS,MAAO+4D,UAAWC,UAAWj8D,SAAUi6D,OAAQt6D,YACxEhK,KAAK4f,IAAMA,IACX5f,KAAKsN,MAAQA,MACbtN,KAAKqmE,UAAYA,UACjBrmE,KAAKsmE,UAAYA,UACjBtmE,KAAKqK,SAAWA,SAChBrK,KAAKskE,OAASA,OACdtkE,KAAKgK,WAAaA,WAatB,MANAo9D,gBAAe7mE,UAAUoG,MAKzB,SAAUpD,QAASC,SAAW,MAAOD,SAAQ4iE,oBAAoBnmE,KAAMwD,UAChE4jE,kBAEPC,YAA6B,WAC7B,QAASA,aAAY/jE,MAAO7B,KAAMuI,YAC9BhK,KAAKsD,MAAQA,MACbtD,KAAKyB,KAAOA,KACZzB,KAAKgK,WAAaA,WAatB,MANAq9D,aAAY9mE,UAAUoG,MAKtB,SAAUpD,QAASC,SAAW,MAAOD,SAAQgjE,iBAAiBvmE,KAAMwD,UAC7D6jE,eAEPC,eAAgC,WAChC,QAASA,gBAAehkE,MAAO7B,KAAMuI,YACjChK,KAAKsD,MAAQA,MACbtD,KAAKyB,KAAOA,KACZzB,KAAKgK,WAAaA,WAatB,MANAs9D,gBAAe/mE,UAAUoG,MAKzB,SAAUpD,QAASC,SAAW,MAAOD,SAAQijE,oBAAoBxmE,KAAMwD,UAChE8jE,kBAMPC,aAA8B,WAC9B,QAASA,iBAuFT,MAhFAA,cAAahnE,UAAUm2C,UAKvB,SAAUnmC,KAAM/M,SAAW,MAAO,IAAIyjE,QAAO12D,KAAKjN,MAAOiN,KAAKvG,aAM9Du9D,aAAahnE,UAAUwlE,eAKvB,SAAUb,UAAW1hE,SACjB,GAAIugC,OAAQ/jC,KACSqK,SAAW66D,UAAU76D,SAASzE,IAAI,SAAUmL,GAAK,MAAOA,GAAEpK,MAAMo9B,MAAOvgC,UAC5F,OAAO,IAAI0jE,WAAU78D,SAAU66D,UAAUl7D,aAO7Cu9D,aAAahnE,UAAUylE,SAKvB,SAAUC,IAAKziE,SACX,GAAIugC,OAAQ/jC,KACSwyB,QACrBhyB,QAAOy2B,KAAKgvC,IAAIzzC,OAAO3rB,QAAQ,SAAUoN,KAAO,MAAOue,OAAMve,KAAOgyD,IAAIzzC,MAAMve,KAAKtN,MAAMo9B,MAAOvgC,UAChG,IAAqBa,KAAM,GAAI8iE,KAAIlB,IAAItxD,WAAYsxD,IAAI7/D,KAAMosB,MAAOyzC,IAAIj8D,WAExE,OADA3F,KAAImjE,sBAAwBvB,IAAIuB,sBACzBnjE,KAOXkjE,aAAahnE,UAAU4lE,oBAKvB,SAAUC,GAAI5iE,SACV,GAAIugC,OAAQ/jC,KACSqK,SAAW+7D,GAAG/7D,SAASzE,IAAI,SAAUmL,GAAK,MAAOA,GAAEpK,MAAMo9B,MAAOvgC,UACrF,OAAO,IAAI4jE,gBAAehB,GAAGxmD,IAAKwmD,GAAG94D,MAAO84D,GAAGC,UAAWD,GAAGE,UAAWj8D,SAAU+7D,GAAG9B,OAAQ8B,GAAGp8D,aAOpGu9D,aAAahnE,UAAUgmE,iBAKvB,SAAUH,GAAI5iE,SACV,MAAO,IAAI6jE,aAAYjB,GAAG9iE,MAAO8iE,GAAG3kE,KAAM2kE,GAAGp8D,aAOjDu9D,aAAahnE,UAAUimE,oBAKvB,SAAUJ,GAAI5iE,SACV,MAAO,IAAI8jE,gBAAelB,GAAG9iE,MAAO8iE,GAAG3kE,KAAM2kE,GAAGp8D,aAE7Cu9D,gBAEPE,eAAgC,WAChC,QAASA,mBA6ET,MAtEAA,gBAAelnE,UAAUm2C,UAKzB,SAAUnmC,KAAM/M,WAMhBikE,eAAelnE,UAAUwlE,eAKzB,SAAUb,UAAW1hE,SACjB,GAAIugC,OAAQ/jC,IACZklE,WAAU76D,SAASxD,QAAQ,SAAUw1B,OAAS,MAAOA,OAAM11B,MAAMo9B,UAOrE0jC,eAAelnE,UAAUylE,SAKzB,SAAUC,IAAKziE,SACX,GAAIugC,OAAQ/jC,IACZQ,QAAOy2B,KAAKgvC,IAAIzzC,OAAO3rB,QAAQ,SAAUqT,GAAK+rD,IAAIzzC,MAAMtY,GAAGvT,MAAMo9B,UAOrE0jC,eAAelnE,UAAU4lE,oBAKzB,SAAUC,GAAI5iE,SACV,GAAIugC,OAAQ/jC,IACZomE,IAAG/7D,SAASxD,QAAQ,SAAUw1B,OAAS,MAAOA,OAAM11B,MAAMo9B,UAO9D0jC,eAAelnE,UAAUgmE,iBAKzB,SAAUH,GAAI5iE,WAMdikE,eAAelnE,UAAUimE,oBAKzB,SAAUJ,GAAI5iE,WACPikE,kBAcPC,kBAAmC,WACnC,QAASA,mBAAkBtuD,IACvB,GAAIG,QAAY,KAAPH,MAAqBA,GAAIuuD,iBAAmBpuD,GAAGouD,iBAAkBC,gBAAkBruD,GAAGquD,gBAAiBC,wBAA0BtuD,GAAGsuD,wBAAyB9tD,GAAKR,GAAG6oD,YAAaA,gBAAqB,KAAProD,GAAgByjC,eAAeG,cAAgB5jC,GAAIM,GAAKd,GAAGosD,eAAgBA,mBAAwB,KAAPtrD,IAAwBA,GAAIC,GAAKf,GAAG+qD,OAAQA,WAAgB,KAAPhqD,IAAwBA,GAAIw+B,GAAKv/B,GAAG8qD,cAAeA,kBAAuB,KAAPvrB,IAAwBA,GACjb/U,MAAQ/jC,IACZA,MAAK2nE,oBACL3nE,KAAK2lE,gBAAiB,EACtB3lE,KAAK4kE,cAAe,EAChB+C,kBAAoBA,iBAAiB7lE,OAAS,GAC9C6lE,iBAAiB9gE,QAAQ,SAAU2F,SAAW,MAAOu3B,OAAM4jC,iBAAiBn7D,UAAW,IAE3FxM,KAAKskE,OAASA,OACdtkE,KAAK2lE,eAAiBA,gBAAkBrB,OACpCsD,iBAAmBA,gBAAgB9lE,OAAS,IAC5C9B,KAAK4nE,mBAEL5nE,KAAKqlE,YAAcuC,gBAAgB,GACnCA,gBAAgB/gE,QAAQ,SAAU2F,SAAW,MAAOu3B,OAAM6jC,gBAAgBp7D,UAAW,KAEzFxM,KAAK6nE,wBAA0BA,yBAA2B,KAC1D7nE,KAAKoiE,YAAcA,YACnBpiE,KAAKqkE,cAAgBA,cAgCzB,MA1BAqD,mBAAkBnnE,UAAU4kE,mBAI5B,SAAU2C,eACN,IAAK9nE,KAAK4nE,gBACN,OAAO,CAEX,KAAKE,cACD,OAAO,CAEX,IAAqBC,UAAWD,cAAcr6D,aAE9C,SADqD,aAAbs6D,UAA6C,gBAAlBD,gBACL,GAAlC9nE,KAAK4nE,gBAAgBG,WAMrDL,kBAAkBnnE,UAAUykE,gBAI5B,SAAUvjE,MACN,MAAOzB,MAAKskE,QAAU7iE,KAAKgM,eAAiBzN,MAAK2nE,kBAE9CD,qBAIPvqD,iBACA0H,KAAQ,GAAI6iD,oBAAoBpD,QAAQ,IACxCj7D,KAAQ,GAAIq+D,oBAAoBpD,QAAQ,IACxC0D,KAAQ,GAAIN,oBAAoBpD,QAAQ,IACxC2D,MAAS,GAAIP,oBAAoBpD,QAAQ,IACzC4D,KAAQ,GAAIR,oBAAoBpD,QAAQ,IACxC6D,IAAO,GAAIT,oBAAoBpD,QAAQ,IACvC/hE,MAAS,GAAImlE,oBAAoBpD,QAAQ,IACzCt5B,MAAS,GAAI08B,oBAAoBpD,QAAQ,IACzC8D,GAAM,GAAIV,oBAAoBpD,QAAQ,IACtC+D,GAAM,GAAIX,oBAAoBpD,QAAQ,IACtCvuD,OAAU,GAAI2xD,oBAAoBpD,QAAQ,IAC1CgE,MAAS,GAAIZ,oBAAoBpD,QAAQ,IACzCiE,IAAO,GAAIb,oBAAoBpD,QAAQ,IACvC7lD,EAAK,GAAIipD,oBACLC,kBACI,UAAW,UAAW,QAAS,aAAc,MAAO,KAAM,WAAY,SAAU,OAChF,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,SAAU,SAAU,KACxD,OAAQ,MAAO,KAAM,IAAK,MAAO,UAAW,QAAS,MAEzDhC,gBAAgB,IAEpB6C,MAAS,GAAId,oBAAoBC,kBAAmB,QAAS,WAC7Dc,MAAS,GAAIf,oBAAoBC,kBAAmB,QAAS,SAAUhC,gBAAgB,IACvF+C,MAAS,GAAIhB,oBAAoBC,kBAAmB,SAAUhC,gBAAgB,IAC9EgD,GAAM,GAAIjB,oBACNC,kBAAmB,MACnBC,iBAAkB,QAAS,QAAS,SACpCjC,gBAAgB,IAEpBiD,GAAM,GAAIlB,oBAAoBC,kBAAmB,KAAM,MAAOhC,gBAAgB,IAC9EkD,GAAM,GAAInB,oBAAoBC,kBAAmB,KAAM,MAAOhC,gBAAgB,IAC9E1K,IAAO,GAAIyM,oBAAoBE,iBAAkB,YAAatD,QAAQ,IACtEwE,IAAO,GAAIpB,oBAAoBG,wBAAyB,QACxDkB,KAAQ,GAAIrB,oBAAoBG,wBAAyB,SACzDmB,GAAM,GAAItB,oBAAoBC,kBAAmB,MAAOhC,gBAAgB,IACxEsD,GAAM,GAAIvB,oBAAoBC,kBAAmB,KAAM,QACvDuB,GAAM,GAAIxB,oBAAoBC,kBAAmB,KAAM,MAAOhC,gBAAgB,IAC9EwD,GAAM,GAAIzB,oBAAoBC,kBAAmB,KAAM,KAAM,MAAO,MAAOhC,gBAAgB,IAC3FyD,GAAM,GAAI1B,oBAAoBC,kBAAmB,KAAM,KAAM,MAAO,MAAOhC,gBAAgB,IAC3F0D,IAAO,GAAI3B,oBAAoBC,kBAAmB,KAAM,MAAO,MAAOhC,gBAAgB,IACtF2D,GAAM,GAAI5B,oBAAoBC,kBAAmB,KAAM,KAAM,MAAO,MAAOhC,gBAAgB,IAC3F4D,SAAY,GAAI7B,oBAAoBC,kBAAmB,YAAahC,gBAAgB,IACpF6D,OAAU,GAAI9B,oBAAoBC,kBAAmB,SAAU,YAAahC,gBAAgB,IAC5F8D,IAAO,GAAI/B,oBAAoBrD,eAAe,IAC9CqF,QAAW,GAAIhC,oBAAoBrD,eAAe,IAClD9mB,MAAS,GAAImqB,oBAAoBtF,YAAa5kB,eAAeC,WAC7DksB,OAAU,GAAIjC,oBAAoBtF,YAAa5kB,eAAeC,WAC9DmsB,MAAS,GAAIlC,oBAAoBtF,YAAa5kB,eAAeE,qBAC7DmsB,SAAY,GAAInC,oBAAoBtF,YAAa5kB,eAAeE,mBAAoB2mB,eAAe,KAEnGjnD,wBAA0B,GAAIsqD,mBAoB9BoC,0BACAC,EAAK,OACLC,EAAK,YACLC,GAAM,aACNC,GAAM,kBACNC,GAAM,iBACNC,GAAM,iBACNC,GAAM,iBACNC,GAAM,iBACNC,GAAM,iBACNC,GAAM,iBACNC,GAAM,kBACNC,EAAK,cACLC,GAAM,YACNC,KAAQ,aACRC,GAAM,eACNC,EAAK,YACLC,EAAK,YACLC,EAAK,qBACLC,MAAS,aACTC,IAAO,YACPC,IAAO,cACPC,MAAS,aACTC,GAAM,aACNC,MAAS,eACTC,GAAM,oBACNC,MAAS,eACTC,GAAM,YACNC,GAAM,kBACNC,EAAK,kBACLC,GAAM,kBAONC,oBAAqC,WACrC,QAASA,uBACL7rE,KAAK8rE,0BACL9rE,KAAK+rE,oBAwHT,MAhHAF,qBAAoBtrE,UAAUyrE,2BAM9B,SAAUpsD,IAAKtS,MAAOg3D,QAClB,GAAqB2H,WAAYjsE,KAAKksE,SAAStsD,IAAKtS,MAAOg3D,OAC3D,IAAItkE,KAAK+rE,iBAAiBE,WACtB,MAAOjsE,MAAK+rE,iBAAiBE,UAEjC,IAAqBE,UAAWvsD,IAAIjd,cACfypE,SAAWtC,yBAAyBqC,WAAa,OAASA,SAC1D1qE,KAAOzB,KAAKqsE,oBAAoB/H,OAAS8H,SAAW,SAAWA,SAEpF,OADApsE,MAAK+rE,iBAAiBE,WAAaxqE,KAC5BA,MAMXoqE,oBAAoBtrE,UAAU+rE,2BAI9B,SAAU1sD,KACN,GAAqBqsD,WAAYjsE,KAAKusE,gBAAgB3sD,IACtD,IAAI5f,KAAK+rE,iBAAiBE,WACtB,MAAOjsE,MAAK+rE,iBAAiBE,UAEjC,IAAqBE,UAAWvsD,IAAIjd,cACfypE,SAAWtC,yBAAyBqC,WAAa,OAASA,SAC1D1qE,KAAOzB,KAAKqsE,oBAAoB,SAAWD,SAEhE,OADApsE,MAAK+rE,iBAAiBE,WAAaxqE,KAC5BA,MAOXoqE,oBAAoBtrE,UAAUisE,mBAK9B,SAAU/qE,KAAM2uB,SACZ,GAAqBq8C,WAAYhrE,KAAKkB,cACjBspE,UAAY,OAASQ,UAAY,IAAMr8C,OAC5D,IAAIpwB,KAAK+rE,iBAAiBE,WACtB,MAAOjsE,MAAK+rE,iBAAiBE,UAEjC,IAAqBS,YAAa1sE,KAAKqsE,oBAAoBI,UAE3D,OADAzsE,MAAK+rE,iBAAiBE,WAAaS,WAC5BA,YAMXb,oBAAoBtrE,UAAUosE,qBAI9B,SAAUlrE,MACN,MAAOzB,MAAKqsE,oBAAoB5qE,KAAKkB,gBAQzCkpE,oBAAoBtrE,UAAU2rE,SAM9B,SAAUtsD,IAAKtS,MAAOg3D,QAIlB,MAH6B,IAAM1kD,IACHpf,OAAOy2B,KAAK3pB,OAAO8mB,OAAOxuB,IAAI,SAAUnE,MAAQ,MAAO,IAAMA,KAAO,IAAM6L,MAAM7L,QAAUoE,KAAK,KACpGy+D,OAAS,KAAO,MAAQ1kD,IAAM,MAO7DisD,oBAAoBtrE,UAAUgsE,gBAI9B,SAAU3sD,KAAO,MAAO5f,MAAKksE,SAAS,IAAMtsD,QAAS,IAKrDisD,oBAAoBtrE,UAAU8rE,oBAI9B,SAAUxnD,MAEN,IAD4B7kB,KAAK8rE,uBAAuBzlE,eAAewe,MAGnE,MADA7kB,MAAK8rE,uBAAuBjnD,MAAQ,EAC7BA,IAEX,IAAqBvb,IAAKtJ,KAAK8rE,uBAAuBjnD,KAEtD,OADA7kB,MAAK8rE,uBAAuBjnD,MAAQvb,GAAK,EAClCub,KAAO,IAAMvb,IAEjBuiE,uBAcPtuD,WAAa,GAAIqrB,QAAO,GAAIC,QAY5BvrB,aAA8B,WAC9B,QAASA,cAAasvD,kBAAmB9O,sBACrC99D,KAAK4sE,kBAAoBA,kBACzB5sE,KAAK89D,qBAAuBA,qBAkLhC,MAzKAxgD,cAAa/c,UAAUkd,cAOvB,SAAU5T,MAAO0O,QAASiF,YAAalU,IACnCtJ,KAAK6sE,OAAyB,GAAhBhjE,MAAM/H,QAAe+H,MAAM,YAAc8yC,WACvD38C,KAAK8sE,UAAY,EACjB9sE,KAAK+sE,qBAAuB,GAAIlB,qBAChC7rE,KAAKgtE,yBACLhtE,KAAKitE,wBACL,IAAqBC,UAAWtjE,SAAS5J,KAAM6J,SAC/C,OAAO,IAAI48D,SAAQyG,SAAUltE,KAAKgtE,sBAAuBhtE,KAAKitE,sBAAuB10D,QAASiF,YAAalU,KAO/GgU,aAAa/c,UAAUq3C,aAKvB,SAAU5hB,GAAIxyB,SACV,GAAqB6G,UAAWT,SAAS5J,KAAMg2B,GAAG3rB,UAC7BiD,QACrB0oB,IAAG1oB,MAAMzG,QAAQ,SAAU0G,MAEvBD,MAAMC,KAAK9L,MAAQ8L,KAAKjK,OAE5B,IAAqBghE,QAASpnD,qBAAqB8Y,GAAGv0B,MAAM6iE,OACvC6I,YAAcntE,KAAK+sE,qBAAqBf,2BAA2Bh2C,GAAGv0B,KAAM6L,MAAOg3D,OACxGtkE,MAAKgtE,sBAAsBG,aAAkCn3C,GAAc,WAAEhwB,UAC7E,IAAqBonE,aAAc,EAKnC,OAJK9I,UACD8I,YAAcptE,KAAK+sE,qBAAqBT,2BAA2Bt2C,GAAGv0B,MACtEzB,KAAKgtE,sBAAsBI,aAAe,KAAOp3C,GAAGv0B,KAAO,KAExD,GAAI2lE,gBAAepxC,GAAGv0B,KAAM6L,MAAO6/D,YAAaC,YAAa/iE,SAAUi6D,OAA2BtuC,GAAc,aAO3H1Y,aAAa/c,UAAU08C,eAKvB,SAAUowB,UAAW7pE,SACjB,MAAOxD,MAAKstE,4BAA4BD,UAAU/pE,MAAO+pE,UAAUrjE,aAOvEsT,aAAa/c,UAAUm2C,UAKvB,SAAUnmC,KAAM/M,SACZ,MAAOxD,MAAKstE,4BAA4B/8D,KAAKjN,MAA0BiN,KAAgB,aAO3F+M,aAAa/c,UAAU48C,aAKvB,SAAUowB,QAAS/pE,SAAW,MAAO,OAMrC8Z,aAAa/c,UAAUq8C,eAKvB,SAAUqpB,IAAKziE,SACX,GAAIugC,OAAQ/jC,IACZA,MAAK8sE,WACL,IAAqBU,iBACAC,QAAU,GAAItG,KAAIlB,IAAIlzC,YAAakzC,IAAI7/D,KAAMonE,aAAcvH,IAAIj8D,WAKpF,IAJAi8D,IAAIzzC,MAAM3rB,QAAQ,SAAU6mE,MACxBF,aAAaE,KAAKpqE,OAAS,GAAI4jE,WAAUwG,KAAK/4D,WAAW/O,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAMo9B,YAAgB2pC,KAAK5wB,iBAE1H98C,KAAK8sE,YACD9sE,KAAK6sE,QAAU7sE,KAAK8sE,UAAY,EAAG,CAInC,GAAqBa,OAAQ3tE,KAAK+sE,qBAAqBJ,qBAAqB,OAAS1G,IAAI7/D,KAGzF,OAFAqnE,SAAQjG,sBAAwBmG,MAChC3tE,KAAKgtE,sBAAsBW,OAAS1H,IAAIlzC,YACjC06C,QAOX,GAAqBG,QAAS5tE,KAAK+sE,qBAAqBP,mBAAmB,MAAOvG,IAAIj8D,WAAWhE,YAC5EzC,QAAU,GAAI+Z,cAAatd,KAAK4sE,kBAAmB5sE,KAAK89D,qBAE7E,OADA99D,MAAKitE,sBAAsBW,QAAUrqE,QAAQka,eAAewoD,KAAM,GAAI,GAAI,IACnE,GAAIqB,gBAAemG,QAASG,OAAQ3H,IAAIj8D,aAOnDsT,aAAa/c,UAAUw8C,mBAKvB,SAAU8wB,QAASrqE,SACf,KAAM,IAAIgB,OAAM,qBAOpB8Y,aAAa/c,UAAU+sE,4BAKvB,SAAU/8D,KAAMvG,YACZ,GAAqB0tD,oBAAqB13D,KAAK4sE,kBAAkBlV,mBAAmBnnD,KAAMvG,WAAWD,MAAM/D,WAAYhG,KAAK89D,qBAC5H,KAAKpG,mBAED,MAAO,IAAIuP,QAAO12D,KAAMvG,WAM5B,KAAK,GAHgBH,UACAq7D,UAAY,GAAIgC,WAAUr9D,MAAOG,YAClDoP,GAAKpZ,KAAK89D,qBAAsBgQ,WAAa10D,GAAGrP,MAAOgkE,WAAa30D,GAAGlP,IACjDa,EAAI,EAAGA,EAAI2sD,mBAAmBpC,QAAQxzD,OAAS,EAAGiJ,IAAK,CAC7E,GAAqB4J,YAAa+iD,mBAAmBlkD,YAAYzI,GAC5CqhE,SAAW1uD,wBAAwB/I,aAAe,gBAClDi5D,OAAS5tE,KAAK+sE,qBAAqBP,mBAAmBJ,SAAUz3D,WACjF+iD,oBAAmBpC,QAAQvqD,GAAGjJ,QAE9B+H,MAAM9C,KAAK,GAAIkgE,QAAOvP,mBAAmBpC,QAAQvqD,GAAIf,aAEzDH,MAAM9C,KAAK,GAAIsgE,aAAY1yD,WAAYi5D,OAAQ5jE,aAC/ChK,KAAKgtE,sBAAsBY,QAAUE,WAAan5D,WAAao5D,WAGnE,GAAqBC,eAAgBtW,mBAAmBpC,QAAQxzD,OAAS,CAIzE,OAHI41D,oBAAmBpC,QAAQ0Y,eAAelsE,QAC1C+H,MAAM9C,KAAK,GAAIkgE,QAAOvP,mBAAmBpC,QAAQ0Y,eAAgBhkE,aAE9Dk7D,WAEJ5nD,gBAEPK,eAAiB,8EAuBjBswD,UAA2B,SAAUxjE,QAErC,QAASwjE,WAAUtjE,KAAMtG,KACrB,MAAOoG,QAAO8kC,KAAKvvC,KAAM2K,KAAMtG,MAAQrE,KAE3C,MAJAC,WAAUguE,UAAWxjE,QAIdwjE,WACT/R,YAaEv9C,WAAa,OAEbuvD,4BAA8B,UAC9BjvD,kBAAoB,IACpBF,aAAe,KACfovD,oBAAqB,EAyBrBC,iBAAkC,WAClC,QAASA,kBAAiBluD,SAAU+R,QAChCjyB,KAAKkgB,SAAWA,SAChBlgB,KAAKiyB,OAASA,OAElB,MAAOm8C,qBAGPC,cACAC,QAAS,EACTC,MAAO,EAEXF,cAAaA,aAAaC,SAAW,UACrCD,aAAaA,aAAaE,OAAS,OAQnC,IAAIxwD,UAA0B,WAC1B,QAASA,UAASywD,cAAeC,gBAC7BzuE,KAAKwuE,cAAgBA,cACrBxuE,KAAKyuE,eAAiBA,eAmgB1B,MAxfA1wD,UAASxd,UAAUyd,QAMnB,SAAUnU,MAAOqM,qBACb,GAAI6tB,OAAQ/jC,IAMZ,OALAA,MAAK0uE,MAAML,aAAaC,QAASp4D,qBACjCrM,MAAMhD,QAAQ,SAAUyY,MAAQ,MAAOA,MAAK3Y,MAAMo9B,MAAO,QACrD/jC,KAAK2uE,cACL3uE,KAAKm3D,aAAattD,MAAMA,MAAM/H,OAAS,GAAI,kBAExC,GAAIssE,kBAAiBpuE,KAAK4uE,UAAW5uE,KAAKojE,UAYrDrlD,SAASxd,UAAU4d,MAOnB,SAAUtU,MAAOqU,aAAchI,qBAC3BlW,KAAK0uE,MAAML,aAAaE,MAAOr4D,qBAC/BlW,KAAK6uE,cAAgB3wD,YAErB,IAAqB4wD,SAAU,GAAI3kE,SAAQ,aAAeN,UAAwB,OAAe3F,OAAWA,IACvF6qE,eAAiBD,QAAQnoE,MAAM3G,KAAM,KAI1D,OAHIA,MAAK2uE,cACL3uE,KAAKm3D,aAAattD,MAAMA,MAAM/H,OAAS,GAAI,kBAExC,GAAIgwB,iBAAgBi9C,eAAe1kE,SAAUrK,KAAKojE,UAO7DrlD,SAASxd,UAAUw8C,mBAKnB,SAAU8wB,QAASrqE,SAEf,GAAqBmR,YAAa/K,SAAS5J,KAAM6tE,QAAQl5D,WAAYnR,QACrE,IAAIxD,KAAKgvE,QAAUX,aAAaE,MAC5B,MAAO,IAAI1xB,eAAcgxB,QAAQvqE,MAAOqR,WAAYk5D,QAAQ7jE,WAAY6jE,QAAQl7C,gBAAiBk7C,QAAQ/wB,gBAQjH/+B,SAASxd,UAAUq8C,eAKnB,SAAUqpB,IAAKziE,SACXxD,KAAKivE,uBAAuBhJ,IAC5B,IAAqBiJ,UAAWlvE,KAAKmvE,MAChCnvE,MAAKmvE,SAEFnvE,KAAKovE,0BACLpvE,KAAKqvE,aAAapJ,MAEtBjmE,KAAKmvE,QAAS,EAElB,IAAqB38C,OAAQ5oB,SAAS5J,KAAMimE,IAAIzzC,MAAOhvB,QAKvD,OAJIxD,MAAKgvE,QAAUX,aAAaE,QAC5BtI,IAAM,GAAItpB,WAAUspB,IAAIlzC,YAAakzC,IAAI7/D,KAAMosB,MAAOyzC,IAAIj8D,WAAYi8D,IAAIjzC,wBAE9EhzB,KAAKmvE,OAASD,SACPjJ,KAOXloD,SAASxd,UAAU48C,aAKnB,SAAUowB,QAAS/pE,SACf,GAAqB8rE,WAAYlxD,kBAAkBmvD,QACnD,IAAI+B,WAAatvE,KAAKovE,yBAElB,WADApvE,MAAKm3D,aAAaoW,QAAS,wDAG/B,IAAqBgC,WAAYhxD,kBAAkBgvD,QACnD,IAAIgC,YAAcvvE,KAAK2uE,aAEnB,WADA3uE,MAAKm3D,aAAaoW,QAAS,oCAG/B,KAAKvtE,KAAKwvE,cAAgBxvE,KAAKmvE,OAC3B,GAAKnvE,KAAK2uE,cAiBN,GAAIY,UAAW,CACX,GAAIvvE,KAAKyvE,QAAUzvE,KAAK0vE,iBAAkB,CACtC1vE,KAAK2vE,0BAA0BpC,QAASvtE,KAAK4vE,gBAC7C5vE,KAAK2uE,cAAe,CACpB,IAAqBz9D,SAA6BlR,KAAKqvE,YAAYrvE,KAAK4vE,eAAgB5vE,KAAK6vE,sBAExEhmE,MAAQ7J,KAAK8vE,kBAAkBvC,QAASr8D,QAC7D,OAAOtH,UAAS5J,KAAM6J,OAItB,WADA7J,MAAKm3D,aAAaoW,QAAS,wDA1BnC,IAAI+B,UAAW,CAEX,IAAKnB,oBAAuC,SAA+BnmC,QAAY,KAAG,CACtFmmC,oBAAqB,CACrB,IAAqBrS,SAAUyR,QAAQvjE,WAAW8xD,QAAU,KAAOyR,QAAQvjE,WAAW8xD,QAAU,EAEhG9zB,SAAQ+nC,KAAK,wEAA0ExC,QAAQvjE,WAAWD,MAAQ+xD,QAAU,KAEhI97D,KAAK2uE,cAAe,EACpB3uE,KAAK0vE,iBAAmB1vE,KAAKyvE,OAC7BzvE,KAAK4vE,kBACL5vE,KAAK6vE,qBAA0CtC,QAAc,MAAE/qE,QAAQ0rE,4BAA6B,IAAI9qE,OACxGpD,KAAKgwE,yBAAyBzC,WA0B9CxvD,SAASxd,UAAUm2C,UAKnB,SAAUnmC,KAAM/M,SAIZ,MAHIxD,MAAKovE,0BACLpvE,KAAKivE,uBAAuB1+D,MAEzBA,MAOXwN,SAASxd,UAAUq3C,aAKnB,SAAU5hB,GAAIxyB,SACV,GAAIugC,OAAQ/jC,IACZA,MAAKivE,uBAAuBj5C,IAC5Bh2B,KAAKyvE,QACL,IAAqBQ,eAAgBjwE,KAAKwvE,YACrBU,kBAAoBlwE,KAAKmwE,gBACzBC,cACAC,yBAAwC,GAIxCC,SAAW9xD,aAAawX,IACxBu6C,SAAWD,SAAWA,SAAShtE,MAAQ,GACvCktE,WAAaxwE,KAAKwuE,cAAch9C,KAAK,SAAU5R,KAAO,MAAOoW,IAAGv0B,OAASme,QAAY5f,KAAKmvE,SAC1GnvE,KAAKovE,yBACWqB,oBAAsBP,mBAAqBM,UAEhE,IADAxwE,KAAKmwE,gBAAkBD,mBAAqBM,WACvCxwE,KAAKovE,0BAA6BpvE,KAAKmvE,QAgBpCmB,UAAYG,qBACZzwE,KAAKm3D,aAAanhC,GAAI,2EAEtBh2B,KAAKgvE,OAASX,aAAaC,SAE3B1kE,SAAS5J,KAAMg2B,GAAG3rB,cArB0B,CAChD,GAAIimE,UAAYG,mBAAoB,CAChCzwE,KAAKwvE,aAAc,CACnB,IAAqBt+D,SAA6BlR,KAAKqvE,YAAYr5C,GAAG3rB,SAAUkmE,SAChFF,sBAAuBrwE,KAAK8vE,kBAAkB95C,GAAI9kB,SAEtD,GAAIlR,KAAKgvE,OAASX,aAAaC,QAAS,CACpC,GAAqBoC,gBAAiBJ,UAAYG,kBAC9CC,iBACA1wE,KAAKgwE,yBAAyBh6C,IAClCpsB,SAAS5J,KAAMg2B,GAAG3rB,UACdqmE,gBACA1wE,KAAK2vE,0BAA0B35C,GAAIA,GAAG3rB,WAYlD,GAAIrK,KAAKgvE,QAAUX,aAAaE,MAAO,EACD8B,sBAAwBr6C,GAAG3rB,UAClDxD,QAAQ,SAAUw1B,OACzB,GAAqBs0C,SAAUt0C,MAAM11B,MAAMo9B,MAAOvgC,QAC9CmtE,WAAY5sC,MAAMqrC,2BAGlBgB,WAAaA,WAAWxnE,OAAO+nE,YAQ3C,GAJA3wE,KAAK4wE,mBAAmB56C,IACxBh2B,KAAKyvE,SACLzvE,KAAKwvE,YAAcS,cACnBjwE,KAAKmwE,gBAAkBD,kBACnBlwE,KAAKgvE,QAAUX,aAAaE,MAAO,CACnC,GAAqBsC,iBAAkB7wE,KAAK8wE,qBAAqB96C,GACjE,OAAO,IAAI7rB,SAAQ6rB,GAAGv0B,KAAMovE,gBAAiBT,WAAYp6C,GAAGhsB,WAAYgsB,GAAGknB,gBAAiBlnB,GAAG5rB,eAEnG,MAAO,OAOX2T,SAASxd,UAAU08C,eAKnB,SAAUowB,UAAW7pE,SACjB,KAAM,IAAIgB,OAAM,qBAOpBuZ,SAASxd,UAAUmuE,MAKnB,SAAUl1C,KAAMtjB,qBACZlW,KAAKgvE,MAAQx1C,KACbx5B,KAAK2uE,cAAe,EACpB3uE,KAAKwvE,aAAc,EACnBxvE,KAAKyvE,OAAS,EACdzvE,KAAKmvE,QAAS,EACdnvE,KAAK+wE,4BAA0B7sE,GAC/BlE,KAAKojE,WACLpjE,KAAK4uE,aACL5uE,KAAKmwE,iBAAkB,EACvBnwE,KAAKgxE,mBAAqB3zD,yBAAyBnH,sBAMvD6H,SAASxd,UAAUqwE,mBAInB,SAAU56C,IACN,GAAI+N,OAAQ/jC,KACSixE,2BACAC,kBAAoBlxE,KAAKyuE,eAAez4C,GAAGv0B,SAChEu0B,IAAG1oB,MAAM4V,OAAO,SAAU3V,MAAQ,MAAOA,MAAK9L,KAAK6c,WAtVnC,WAuVXzX,QAAQ,SAAU0G,MACnB,MAAO0jE,yBAAwB1jE,KAAK9L,KAAK0B,MAxV7B,QAwVqDrB,SAC7DyL,KAAKjK,QAEb0yB,GAAG1oB,MAAMzG,QAAQ,SAAU0G,MACnBA,KAAK9L,OAAQwvE,yBACbltC,MAAMsrC,aAAa9hE,MAAO0jE,wBAAwB1jE,KAAK9L,OAElDyvE,kBAAkB1/C,KAAK,SAAU/vB,MAAQ,MAAO8L,MAAK9L,OAASA,QACnEsiC,MAAMsrC,aAAa9hE,UAS/BwQ,SAASxd,UAAU8uE,YAKnB,SAAUzoE,IAAKuqE,SACX,GAAkB,GAAdvqE,IAAI9E,QACU,GAAd8E,IAAI9E,QAAe8E,IAAI,YAAcisB,eAAmCjsB,IAAI,GAAKtD,MAEjF,MAAO,KAEX,IAAI8V,IAAKwF,kBAAkBuyD,SAAU54D,QAAUa,GAAGb,QAASiF,YAAcpE,GAAGoE,YAAalU,GAAK8P,GAAG9P,GAC5E4H,QAAUlR,KAAKgxE,mBAAmBpqE,IAAK2R,QAASiF,YAAalU,GAElF,OADAtJ,MAAK4uE,UAAU7nE,KAAKmK,SACbA,SAOX6M,SAASxd,UAAUuvE,kBAKnB,SAAU95C,GAAI9kB,SACV,GAAIA,SAAWlR,KAAKgvE,QAAUX,aAAaE,MAAO,CAC9C,GAAqB1kE,OAAQ7J,KAAK6uE,cAActuD,IAAIrP,QACpD,IAAIrH,MACA,MAAOA,MAEX7J,MAAKm3D,aAAanhC,GAAI,2CAA8Ch2B,KAAK6uE,cAAcz2D,OAAOlH,SAAW,KAE7G,UAMJ6M,SAASxd,UAAUuwE,qBAInB,SAAU96C,IACN,GAAI+N,OAAQ/jC,KACS60B,WAAamB,GAAG1oB,MAChB8jE,wBACrBv8C,YAAWhuB,QAAQ,SAAU0G,MACrBA,KAAK9L,KAAK6c,WA1ZF,WA2ZR8yD,sBAAsB7jE,KAAK9L,KAAK0B,MA3ZxB,QA2ZgDrB,SACpD8c,kBAAkBrR,KAAKjK,SAGnC,IAAqB+tE,wBA8BrB,OA7BAx8C,YAAWhuB,QAAQ,SAAU0G,MACzB,GAAIA,KAAK9L,OAASkd,aAAcpR,KAAK9L,KAAK6c,WAja9B,SAqaZ,GAAI/Q,KAAKjK,OAAuB,IAAdiK,KAAKjK,OAAe8tE,sBAAsB/qE,eAAekH,KAAK9L,MAAO,CACnF,GAAI2X,IAAKg4D,sBAAsB7jE,KAAK9L,MAAO8W,QAAUa,GAAGb,QAASiF,YAAcpE,GAAGoE,YAAalU,GAAK8P,GAAG9P,GAClF4H,QAAU6yB,MAAMitC,oBAAoBzjE,MAAOgL,QAASiF,YAAalU,IACjEO,MAAQk6B,MAAM8qC,cAActuD,IAAIrP,QACrD,IAAIrH,MACA,GAAoB,GAAhBA,MAAM/H,OACNuvE,qBAAqBtqE,KAAK,GAAI8rB,aAAYtlB,KAAK9L,KAAM,GAAI8L,KAAKvD,iBAE7D,IAAIH,MAAM,YAAc4rB,MAAM,CAC/B,GAAqBnyB,OAA2BuG,MAAM,GAAKvG,KAC3D+tE,sBAAqBtqE,KAAK,GAAI8rB,aAAYtlB,KAAK9L,KAAM6B,MAAOiK,KAAKvD,iBAGjE+5B,OAAMozB,aAAanhC,GAAI,yCAA4CzoB,KAAK9L,KAAO,WAAe6H,IAAMy6B,MAAM8qC,cAAcz2D,OAAOlH,UAAY,UAI/I6yB,OAAMozB,aAAanhC,GAAI,0CAA6CzoB,KAAK9L,KAAO,WAAe6H,IAAMy6B,MAAM8qC,cAAcz2D,OAAOlH,UAAY,UAIhJmgE,sBAAqBtqE,KAAKwG,QAG3B8jE,sBAUXtzD,SAASxd,UAAU0uE,uBAQnB,SAAU3vD,MACFtf,KAAK2uE,eAAiB3uE,KAAKmvE,QAAUnvE,KAAKyvE,QAAUzvE,KAAK0vE,kBACzD1vE,KAAK4vE,eAAe7oE,KAAKuY,OAQjCvB,SAASxd,UAAUyvE,yBAKnB,SAAU1wD,MACFtf,KAAKovE,yBACLpvE,KAAKm3D,aAAa73C,KAAM,4BAGxBtf,KAAK+wE,wBAA0B/wE,KAAK4uE,UAAU9sE,QAGtDtB,OAAO4f,eAAerC,SAASxd,UAAW,4BACtCggB,IAMA,WACI,WAAwC,KAAjCvgB,KAAK+wE,yBAEhBzwD,YAAY,EACZD,cAAc,IAqBlBtC,SAASxd,UAAUovE,0BAmBnB,SAAUrwD,KAAMgyD,gBACZ,IAAKtxE,KAAKovE,yBAEN,WADApvE,MAAKm3D,aAAa73C,KAAM,yBAG5B,IAAqBiyD,YAAavxE,KAAK+wE,uBAEvC,IAA2B,GADgBO,eAAe9oE,OAAO,SAAUsT,MAAOwD,MAAQ,MAAOxD,QAASwD,eAAgBjB,SAAU,EAAI,IAAO,GAE3I,IAAK,GAAqBtT,GAAI/K,KAAK4uE,UAAU9sE,OAAS,EAAGiJ,GAAsB,WAAgBA,IAAK,CAChG,GAAqBnE,KAAM5G,KAAK4uE,UAAU7jE,GAAGlB,KAC7C,MAAoB,GAAdjD,IAAI9E,QAAe8E,IAAI,YAAcqgE,SAAS,CAChDjnE,KAAK4uE,UAAUlJ,OAAO36D,EAAG,EACzB,QAIZ/K,KAAK+wE,4BAA0B7sE,IAOnC6Z,SAASxd,UAAU42D,aAKnB,SAAU73C,KAAMjb,KACZrE,KAAKojE,QAAQr8D,KAAK,GAAIknE,WAA6B3uD,KAAgB,WAAGjb,OAEnE0Z,YAkDPyzD,iBAAkC,WAClC,QAASA,oBACLxxE,KAAK2lE,gBAAiB,EACtB3lE,KAAKoiE,YAAc5kB,eAAeG,cAClC39C,KAAKskE,QAAS,EACdtkE,KAAKqkE,eAAgB,EACrBrkE,KAAK4kE,cAAe,EAoBxB,MAdA4M,kBAAiBjxE,UAAU4kE,mBAI3B,SAAU2C,eAAiB,OAAO,GAKlC0J,iBAAiBjxE,UAAUykE,gBAI3B,SAAUvjE,MAAQ,OAAO,GAClB+vE,oBAEPpyD,gBAAkB,GAAIoyD,kBAoBtBC,UAA2B,SAAUhnE,QAErC,QAASgnE,aACL,MAAOhnE,QAAO8kC,KAAKvvC,KAAMmf,sBAAwBnf,KAkBrD,MApBAC,WAAUwxE,UAAWhnE,QAUrBgnE,UAAUlxE,UAAUkzB,MAMpB,SAAU1d,OAAQjN,IAAKg6D,qBAEnB,WAD4B,KAAxBA,sBAAkCA,qBAAsB,GACrDr4D,OAAOlK,UAAUkzB,MAAM8b,KAAKvvC,KAAM+V,OAAQjN,IAAKg6D,sBAEnD2O,WACT5O,UAgBE6O,WAA4B,WAC5B,QAASA,eAaT,MALAA,YAAWnxE,UAAUoxE,iBAIrB,SAAUzgE,SAAW,MAAO,OACrBwgE,cAaPE,wBAAyC,SAAUnnE,QAGnD,QAASmnE,yBAAwB1gE,QAAS2gE,SACtC,GAAI9tC,OAAQt5B,OAAO8kC,KAAKvvC,OAASA,IAMjC,OALA+jC,OAAM8tC,QAAUA,QAChB9tC,MAAM+tC,oBACN/tC,MAAMguC,kBACNhuC,MAAMiuC,oBACN9gE,QAAQrH,MAAMhD,QAAQ,SAAUyY,MAAQ,MAAOA,MAAK3Y,MAAMo9B,SACnDA,MAsGX,MA/GA9jC,WAAU2xE,wBAAyBnnE,QAenCmnE,wBAAwBrxE,UAAUwf,aAIlC,SAAUC,cACN,MAAOhgB,MAAK8xE,iBAAiBzrE,eAAe2Z,cACxChgB,KAAK8xE,iBAAiB9xD,cACtB,MAMR4xD,wBAAwBrxE,UAAU0xE,eAIlC,SAAUC,YACN,MAAOlyE,MAAKgyE,iBAAiB3rE,eAAe6rE,YAAclyE,KAAKgyE,iBAAiBE,YAC5E,MAORN,wBAAwBrxE,UAAUm2C,UAKlC,SAAUnmC,KAAM/M,SAAW,MAAO,OAMlCouE,wBAAwBrxE,UAAU4lE,oBAKlC,SAAUC,GAAI5iE,SACVxD,KAAKmyE,qBAAqB/L,GAAGC,WAC7B57D,OAAOlK,UAAU4lE,oBAAoB52B,KAAKvvC,KAAMomE,GAAI5iE,SACpDxD,KAAKmyE,qBAAqB/L,GAAGE,YAOjCsL,wBAAwBrxE,UAAUgmE,iBAKlC,SAAUH,GAAI5iE,SAAWxD,KAAKmyE,qBAAqB/L,GAAG3kE,OAMtDmwE,wBAAwBrxE,UAAUimE,oBAKlC,SAAUJ,GAAI5iE,SACVxD,KAAKmyE,qBAAqB/L,GAAG3kE,OAMjCmwE,wBAAwBrxE,UAAU4xE,qBAIlC,SAAUnyD,cACN,GAAKA,eAAgBhgB,KAAK8xE,iBAAiBzrE,eAAe2Z,cAA1D,CAGA,GAAqBkyD,YAAalyE,KAAK6xE,QAAQ7xD,aAC/C,IAAIhgB,KAAKgyE,iBAAiB3rE,eAAe6rE,YAAa,CAElD,GAAqBE,QAASpyE,KAAK+xE,eAAeG,WAClDlyE,MAAK+xE,eAAeG,YAAcE,OAAS,EAC3CF,WAAaA,WAAa,IAAME,WAGhCpyE,MAAK+xE,eAAeG,YAAc,CAEtClyE,MAAK8xE,iBAAiB9xD,cAAgBkyD,WACtClyE,KAAKgyE,iBAAiBE,YAAclyD,eAEjC4xD,yBACTnK,gBAiBE4K,WAA4B,WAC5B,QAASt0D,aA8DT,MAxDAA,UAASxd,UAAU+xE,SAInB,SAAU1yD,KACN,GAAImkB,OAAQ/jC,KACSuyE,SAAWvyE,KAAKwyE,qBAAqB5yD,IAAItS,MAC9D,IAA2B,GAAvBsS,IAAIvV,SAASvI,OACb,MAAO,IAAM8d,IAAIne,KAAO8wE,SAAW,IAEvC,IAAqBE,aAAc7yD,IAAIvV,SAASzE,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAMo9B,QACxF,OAAO,IAAMnkB,IAAIne,KAAO8wE,SAAW,IAAME,YAAY5sE,KAAK,IAAM,KAAO+Z,IAAIne,KAAO,KAMtFsc,SAASxd,UAAUm2C,UAInB,SAAUnmC,MAAQ,MAAOA,MAAKjN,OAK9Bya,SAASxd,UAAUmyE,iBAInB,SAAUC,MACN,MAAO,QAAU3yE,KAAKwyE,qBAAqBG,KAAKrlE,OAAS,OAM7DyQ,SAASxd,UAAUiyE,qBAInB,SAAUllE,OACN,GAAqBilE,UAAW/xE,OAAOy2B,KAAK3pB,OAAO1H,IAAI,SAAUnE,MAAQ,MAAOA,MAAO,KAAQ6L,MAAM7L,MAAQ,MAASoE,KAAK,IAC3H,OAAO0sE,UAASzwE,OAAS,EAAI,IAAMywE,SAAW,IAMlDx0D,SAASxd,UAAUqyE,aAInB,SAAUC,SACN,MAAO,aAAeA,QAAQC,QAAU,OAASD,QAAQE,IAAM,QAE5Dh1D,YAEPwB,SAAW,GAAI8yD,YAYfW,YAA6B,WAC7B,QAASA,aAAYC,gBACjB,GAAIlvC,OAAQ/jC,IACZA,MAAKsN,SACL9M,OAAOy2B,KAAKg8C,gBAAgBpsE,QAAQ,SAAUqT,GAC1C6pB,MAAMz2B,MAAM4M,GAAKsF,UAAUyzD,eAAe/4D,MAYlD,MALA84D,aAAYzyE,UAAUoG,MAItB,SAAUpD,SAAW,MAAOA,SAAQmvE,iBAAiB1yE,OAC9CgzE,eAEPE,QAAyB,WACzB,QAASA,SAAQJ,QAASC,KACtB/yE,KAAK8yE,QAAUA,QACf9yE,KAAK+yE,IAAMA,IAWf,MALAG,SAAQ3yE,UAAUoG,MAIlB,SAAUpD,SAAW,MAAOA,SAAQqvE,aAAa5yE,OAC1CkzE,WAEPC,IAAqB,WACrB,QAASA,KAAI1xE,KAAMwxE,eAAgB5oE,cACR,KAAnB4oE,iBAA6BA,uBAChB,KAAb5oE,WAAuBA,YAC3B,IAAI05B,OAAQ/jC,IACZA,MAAKyB,KAAOA,KACZzB,KAAKqK,SAAWA,SAChBrK,KAAKsN,SACL9M,OAAOy2B,KAAKg8C,gBAAgBpsE,QAAQ,SAAUqT,GAC1C6pB,MAAMz2B,MAAM4M,GAAKsF,UAAUyzD,eAAe/4D,MAYlD,MALAi5D,KAAI5yE,UAAUoG,MAId,SAAUpD,SAAW,MAAOA,SAAQ+uE,SAAStyE,OACtCmzE,OAEPC,OAAwB,WACxB,QAAS39C,MAAK49C,gBACVrzE,KAAKsD,MAAQkc,UAAU6zD,gBAW3B,MALA59C,MAAKl1B,UAAUoG,MAIf,SAAUpD,SAAW,MAAOA,SAAQmzC,UAAU12C,OACvCy1B,QAEP69C,GAAoB,SAAU7oE,QAE9B,QAAS6oE,IAAGC,IAER,WADW,KAAPA,KAAiBA,GAAK,GACnB9oE,OAAO8kC,KAAKvvC,KAAM,KAAO,GAAIyD,OAAM8vE,GAAK,GAAG1tE,KAAK,OAAS7F,KAEpE,MALAC,WAAUqzE,GAAI7oE,QAKP6oE,IACTF,QACE3zD,iBACC,KAAM,UACN,KAAM,WACN,KAAM,WACN,KAAM,SACN,KAAM,SAkCPsB,MAAuB,SAAUtW,QAEjC,QAASsW,SACL,MAAkB,QAAXtW,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KAiF/D,MAnFAC,WAAU8gB,MAAOtW,QASjBsW,MAAMxgB,UAAUizE,MAKhB,SAAUtzD,SAAUuzD,QAChB,GAAqBlwE,SAAU,GAAImwE,eACdC,aACrBzzD,UAASrZ,QAAQ,SAAUqK,SACvB,GAAqB0iE,eACrB1iE,SAAQ01D,QAAQ//D,QAAQ,SAAUkP,QAC9B,GAAqB89D,iBAAkB,GAAIV,KAvBlC,iBAuB4DW,QAAS,YAC9ED,iBAAgBxpE,SAAStD,KAAK,GAAIusE,IAAG,IAAK,GAAIH,KAvB3C,WAuB+DY,eAAgB,eAAiB,GAAIX,QAAOr9D,OAAOnO,YAAa,GAAI0rE,IAAG,IAAK,GAAIH,KAvB/I,WAuBmKY,eAAgB,eAAiB,GAAIX,QAAO,GAAKr9D,OAAO8wD,aAAc,GAAIyM,IAAG,IACnPM,YAAY7sE,KAAK,GAAIusE,IAAG,GAAIO,kBAEhC,IAAqBG,WAAY,GAAIb,KA5BjC,cA4BkD7pE,GAAI4H,QAAQ5H,GAAI2qE,SAAU,UAC/E76D,GAAK46D,UAAU3pE,UAAUtD,KAAK/E,MAAMoX,IAAK,GAAIk6D,IAAG,GAAI,GAAIH,KAhCnD,YAgCwE5vE,QAAQ8b,UAAUnO,QAAQrH,SAASjB,OAAOgrE,cACpH1iE,QAAQsM,aACRw2D,UAAU3pE,SAAStD,KAAK,GAAIusE,IAAG,GAAI,GAAIH,KAAI,QAAUe,SAAU,IAAKjwD,KAAM,gBAAkB,GAAImvD,QAAOliE,QAAQsM,gBAE/GtM,QAAQqH,SACRy7D,UAAU3pE,SAAStD,KAAK,GAAIusE,IAAG,GAAI,GAAIH,KAAI,QAAUe,SAAU,IAAKjwD,KAAM,YAAc,GAAImvD,QAAOliE,QAAQqH,YAE/Gy7D,UAAU3pE,SAAStD,KAAK,GAAIusE,IAAG,IAC/BK,WAAW5sE,KAAK,GAAIusE,IAAG,GAAIU,UAC3B,IAAI56D,KAER,IAAqBkO,MAAO,GAAI6rD,KAAI,UAAYQ,WAAW/qE,QAAQ,GAAI0qE,IAAG,MACrDl2C,KAAO,GAAI+1C,KAAI,QAChCgB,kBAAmBV,QAjDJ,KAkDfQ,SAAU,YACVG,SAAU,iBACV,GAAId,IAAG,GAAIhsD,KAAM,GAAIgsD,IAAG,KACPe,MAAQ,GAAIlB,KAAI,SAAWmB,QAxDzC,MAwD4DC,MAvD9D,0CAuDgF,GAAIjB,IAAG,GAAIl2C,KAAM,GAAIk2C,KAC1G,OAAOj0D,YACH,GAAI2zD,cAAcsB,QAAS,MAAOE,SAAU,UAAY,GAAIlB,IAAMe,MAAO,GAAIf,OAQrFvyD,MAAMxgB,UAAUk0E,KAKhB,SAAUrkD,QAAStnB,KAEf,GAAqB4rE,aAAc,GAAIC,aACnCv7D,GAAKs7D,YAAYjhD,MAAMrD,QAAStnB,KAAM2qE,OAASr6D,GAAGq6D,OAAQmB,YAAcx7D,GAAGw7D,YAAa3iD,OAAS7Y,GAAG6Y,OAEnF4iD,oBACArmD,UAAY,GAAIsmD,UAMrC,IALAt0E,OAAOy2B,KAAK29C,aAAa/tE,QAAQ,SAAUkuE,OACvC,GAAI37D,IAAKoV,UAAUwmD,QAAQJ,YAAYG,OAAQjsE,KAAMmsE,UAAY77D,GAAG67D,UAAW37D,EAAIF,GAAG6Y,MACtFA,QAAOlrB,KAAK/E,MAAMiwB,OAAQ3Y,GAC1Bu7D,iBAAiBE,OAASE,YAE1BhjD,OAAOnwB,OACP,KAAM,IAAI0C,OAAM,wBAA0BytB,OAAOpsB,KAAK,MAE1D,QAAS4tE,OAAyB,OAAYoB,iBAAkBA,mBAMpE9zD,MAAMxgB,UAAU6X,OAIhB,SAAUlH,SAAW,MAAOkH,QAAOlH,UAC5B6P,OACT2wD,YACEgC,cAA+B,WAC/B,QAASA,kBA2GT,MApGAA,eAAcnzE,UAAUm2C,UAKxB,SAAUnmC,KAAM/M,SAAW,OAAQ,GAAI4vE,QAAO7iE,KAAKjN,SAMnDowE,cAAcnzE,UAAUwlE,eAKxB,SAAUb,UAAW1hE,SACjB,GAAIugC,OAAQ/jC,KACS6J,QAErB,OADAq7D,WAAU76D,SAASxD,QAAQ,SAAUyY,MAAQ,MAAOzV,OAAM9C,KAAK/E,MAAM6H,MAAOyV,KAAK3Y,MAAMo9B,UAChFl6B,OAOX6pE,cAAcnzE,UAAUylE,SAKxB,SAAUC,IAAKziE,SACX,GAAIugC,OAAQ/jC,KACS6J,OAAS,GAAIupE,QAAO,IAAMnN,IAAIuB,sBAAwB,KAAOvB,IAAI7/D,KAAO,MAK7F,OAJA5F,QAAOy2B,KAAKgvC,IAAIzzC,OAAO3rB,QAAQ,SAAUwS,GACrCxP,MAAM9C,KAAK/E,MAAM6H,OAAQ,GAAIupE,QAAO/5D,EAAI,OAAOzQ,OAAOq9D,IAAIzzC,MAAMnZ,GAAG1S,MAAMo9B,QAAS,GAAIqvC,QAAO,WAEjGvpE,MAAM9C,KAAK,GAAIqsE,QAAO,MACfvpE,OAOX6pE,cAAcnzE,UAAU4lE,oBAKxB,SAAUC,GAAI5iE,SACV,GAAqB0xE,OAAQv1D,eAAeymD,GAAGxmD,IAC/C,IAAIwmD,GAAG9B,OAEH,OAAQ,GAAI6O,KA9JD,KA8JyB7pE,GAAI88D,GAAGC,UAAW6O,MAAOA,MAAOC,aAAc,IAAM/O,GAAGxmD,IAAM,OAErG,IAAqBw1D,YAAa,GAAIjC,KAhKvB,KAgK+C7pE,GAAI88D,GAAGC,UAAW6O,MAAOA,MAAOC,aAAc,IAAM/O,GAAGxmD,IAAM,MACtGy1D,WAAa,GAAIlC,KAjKvB,KAiK+C7pE,GAAI88D,GAAGE,UAAW4O,MAAOA,MAAOC,aAAc,KAAO/O,GAAGxmD,IAAM,KAC5H,QAAQw1D,YAAYxsE,OAAO5I,KAAKqf,UAAU+mD,GAAG/7D,WAAYgrE,cAO7D3B,cAAcnzE,UAAUgmE,iBAKxB,SAAUH,GAAI5iE,SACV,OAAQ,GAAI2vE,KA/KG,KA+KqB7pE,GAAI88D,GAAG3kE,KAAM0zE,aAAc,KAAO/O,GAAG9iE,MAAQ,SAOrFowE,cAAcnzE,UAAUimE,oBAKxB,SAAUJ,GAAI5iE,SACV,GAAqB8xE,WAAY,IAAMlP,GAAG9iE,MAAMqR,WAAa,KAAOyxD,GAAG9iE,MAAM8C,KAAO,KAAO5F,OAAOy2B,KAAKmvC,GAAG9iE,MAAMkvB,OAAO5sB,IAAI,SAAUtC,OAAS,MAAOA,OAAQ,WAAauC,KAAK,KAAO,GACtL,QAAQ,GAAIstE,KA7LG,KA6LqB7pE,GAAI88D,GAAG3kE,KAAM0zE,aAAcG,cAMnE5B,cAAcnzE,UAAU8e,UAIxB,SAAUxV,OACN,GAAIk6B,OAAQ/jC,IACZ,UAAU4I,OAAO5G,SAAU6H,MAAMjE,IAAI,SAAU0Z;mDAAQ,MAAOA,MAAK3Y,MAAMo9B,WAEtE2vC,iBAEPiB,YAA6B,WAC7B,QAASA,eACL30E,KAAKu1E,QAAU,KAsJnB,MA/IAZ,aAAYp0E,UAAUkzB,MAKtB,SAAU4gD,MAAOvrE,KACb9I,KAAKw1E,cAAgB,KACrBx1E,KAAKy1E,eACL,IAAqBC,MAAM,GAAIjE,YAAYh+C,MAAM4gD,MAAOvrE,KAAK,EAG7D,OAFA9I,MAAKojE,QAAUsS,IAAIzjD,OACnBroB,SAAS5J,KAAM01E,IAAI1jD,UAAW,OAE1B4iD,YAAa50E,KAAKy1E,aAClBxjD,OAAQjyB,KAAKojE,QACbqQ,OAAQzzE,KAAKu1E,UAQrBZ,YAAYp0E,UAAUq3C,aAKtB,SAAUz/B,QAAS3U,SACf,OAAQ2U,QAAQ1W,MACZ,IA7OI,aA8OAzB,KAAKw1E,cAAiC,IACtC,IAAqBG,QAASx9D,QAAQ7K,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,OAAdA,KAAK9L,MAC/E,IAAKk0E,OAGA,CACD,GAAqBrsE,IAAKqsE,OAAOryE,KAC7BtD,MAAKy1E,aAAapvE,eAAeiD,IACjCtJ,KAAK41E,UAAUz9D,QAAS,mCAAqC7O,KAG7DM,SAAS5J,KAAMmY,QAAQ9N,SAAU,MACC,gBAAvBrK,MAAKw1E,cACZx1E,KAAKy1E,aAAansE,IAAMtJ,KAAKw1E,cAG7Bx1E,KAAK41E,UAAUz9D,QAAS,WAAa7O,GAAK,8BAblDtJ,MAAK41E,UAAUz9D,QAAS,yCAiB5B,MAEJ,KAvQM,SAwQN,IAvQc,aAwQV,KACJ,KAxQM,SAyQF,GAAqB09D,gBAAoC19D,QAAwB,gBAAEjO,IAAID,OAClE6rE,aAAkC39D,QAAsB,cAAEpO,MAAME,OAChEmmB,QAA6BjY,QAAwB,gBAAEpO,MAAMqzB,KAAKhN,QAClE2lD,UAAY3lD,QAAQjtB,MAAM0yE,eAAgBC,aAC/D91E,MAAKw1E,cAAgBO,SACrB,MACJ,KAlRI,OAmRA,GAAqBC,YAAa79D,QAAQ7K,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,oBAAdA,KAAK9L,MAC/Eu0E,cACAh2E,KAAKu1E,QAAUS,WAAW1yE,OAE9BsG,SAAS5J,KAAMmY,QAAQ9N,SAAU,KACjC,MACJ,SAGIT,SAAS5J,KAAMmY,QAAQ9N,SAAU,QAQ7CsqE,YAAYp0E,UAAU08C,eAKtB,SAAUowB,UAAW7pE,WAMrBmxE,YAAYp0E,UAAUm2C,UAKtB,SAAUnmC,KAAM/M,WAMhBmxE,YAAYp0E,UAAU48C,aAKtB,SAAUowB,QAAS/pE,WAMnBmxE,YAAYp0E,UAAUq8C,eAKtB,SAAUq5B,UAAWzyE,WAMrBmxE,YAAYp0E,UAAUw8C,mBAKtB,SAAUm5B,cAAe1yE,WAMzBmxE,YAAYp0E,UAAUq1E,UAKtB,SAAUt2D,KAAMpO,SACZlR,KAAKojE,QAAQr8D,KAAK,GAAIknE,WAA6B3uD,KAAgB,WAAGpO,WAEnEyjE,eAEPG,UAA2B,WAC3B,QAASA,cA8HT,MAvHAA,WAAUv0E,UAAUy0E,QAKpB,SAAU9jE,QAASpI,KACf,GAAqBqtE,SAAS,GAAI1E,YAAYh+C,MAAMviB,QAASpI,KAAK,EAIlE,OAHA9I,MAAKojE,QAAU+S,OAAOlkD,QAIlBgjD,UAH6Bj1E,KAAKojE,QAAQthE,OAAS,GAAgC,GAA3Bq0E,OAAOnkD,UAAUlwB,aACjE8G,OAAO5G,SAAU4H,SAAS5J,KAAMm2E,OAAOnkD,YAG/CC,OAAQjyB,KAAKojE,UAQrB0R,UAAUv0E,UAAUm2C,UAKpB,SAAUnmC,KAAM/M,SAAW,MAAO,IAAIyjE,QAAO12D,KAAKjN,MAA0BiN,KAAgB,aAM5FukE,UAAUv0E,UAAUq3C,aAKpB,SAAU5hB,GAAIxyB,SACV,GApZe,MAoZXwyB,GAAGv0B,KAA2B,CAC9B,GAAqB20E,UAAWpgD,GAAG1oB,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,OAAdA,KAAK9L,MAC5E,OAAI20E,UACO,GAAI/O,aAAY,GAAI+O,SAAS9yE,MAA0B0yB,GAAc,aAEhFh2B,KAAK41E,UAAU5/C,GAAI,iCACZ,MAEX,MA3ZU,QA2ZNA,GAAGv0B,QACOmH,OAAO5G,SAAU4H,SAAS5J,KAAMg2B,GAAG3rB,YAEjDrK,KAAK41E,UAAU5/C,GAAI,kBACZ,OAOX8+C,UAAUv0E,UAAUq8C,eAKpB,SAAUqpB,IAAKziE,SACX,GAAqB6yE,WAIrB,OAHAzsE,UAAS5J,KAAMimE,IAAIzzC,OAAO3rB,QAAQ,SAAUwS,GACxCg9D,QAAQh9D,EAAE/V,OAAS,GAAI4jE,WAAU7tD,EAAExP,MAAOo8D,IAAIj8D,cAE3C,GAAIm9D,KAAIlB,IAAIlzC,YAAakzC,IAAI7/D,KAAMiwE,QAASpQ,IAAIj8D,aAO3D8qE,UAAUv0E,UAAUw8C,mBAKpB,SAAU8wB,QAASrqE,SACf,OACIF,MAAOuqE,QAAQvqE,MACfuG,MAAOD,SAAS5J,KAAM6tE,QAAQl5D,cAQtCmgE,UAAUv0E,UAAU48C,aAKpB,SAAUowB,QAAS/pE,WAMnBsxE,UAAUv0E,UAAU08C,eAKpB,SAAUowB,UAAW7pE,WAMrBsxE,UAAUv0E,UAAUq1E,UAKpB,SAAUt2D,KAAMpO,SACZlR,KAAKojE,QAAQr8D,KAAK,GAAIknE,WAA6B3uD,KAAgB,WAAGpO,WAEnE4jE,aAuCPh0D,OAAwB,SAAUrW,QAElC,QAASqW,UACL,MAAkB,QAAXrW,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KAgF/D,MAlFAC,WAAU6gB,OAAQrW,QASlBqW,OAAOvgB,UAAUizE,MAKjB,SAAUtzD,SAAUuzD,QAChB,GAAqBlwE,SAAU,GAAI+yE,iBACdC,QACrBr2D,UAASrZ,QAAQ,SAAUqK,SACvB,GAAqB4pB,MAAO,GAAIq4C,KApB1B,QAoB6C7pE,GAAI4H,QAAQ5H,KAC1CktE,MAAQ,GAAIrD,KAAI,UACjCjiE,QAAQsM,aAAetM,QAAQqH,WAC3BrH,QAAQsM,aACRg5D,MAAMnsE,SAAStD,KAAK,GAAIusE,IAAG,GAAI,GAAIH,KAAI,QAAUsD,SAAU,gBAAkB,GAAIrD,QAAOliE,QAAQsM,gBAEhGtM,QAAQqH,SACRi+D,MAAMnsE,SAAStD,KAAK,GAAIusE,IAAG,GAAI,GAAIH,KAAI,QAAUsD,SAAU,YAAc,GAAIrD,QAAOliE,QAAQqH,aAGpGrH,QAAQ01D,QAAQ//D,QAAQ,SAAUkP,QAC9BygE,MAAMnsE,SAAStD,KAAK,GAAIusE,IAAG,GAAI,GAAIH,KAAI,QAAUsD,SAAU,aACvD,GAAIrD,QAAOr9D,OAAOnO,SAAW,IAAMmO,OAAO8wD,WAAa9wD,OAAOgxD,UAAYhxD,OAAO8wD,UAAY,IAAM9wD,OAAOgxD,QAAU,UAG5HyP,MAAMnsE,SAAStD,KAAK,GAAIusE,IAAG,IAC3Bx4C,KAAKzwB,SAAStD,KAAK,GAAIusE,IAAG,GAAIkD,MAC9B,IAAqBjoC,SAAU,GAAI4kC,KAAI,UACvC5kC,SAAQlkC,SAAStD,KAAK,GAAIusE,IAAG,GAAI,GAAIH,KAxC7B,YAwCoD5vE,QAAQ8b,UAAUnO,QAAQrH,QAAS,GAAIypE,IAAG,IACtGx4C,KAAKzwB,SAAStD,KAAK,GAAIusE,IAAG,GAAI/kC,QAAS,GAAI+kC,IAAG,IAC9CiD,MAAMxvE,KAAK,GAAIusE,IAAG,GAAIx4C,OAE1B,IAAqBsC,MAAO,GAAI+1C,KAAI,QAAUiB,SAAY,cAAe9qE,GAAI,UAAYitE,MAAM3tE,QAAQ,GAAI0qE,IAAG,MACzFe,MAAQ,GAAIlB,KA9CxB,SA8C0CmB,QArD1C,MAqD+DC,MApDjE,wCAoDkFmC,QAASjD,QAlD7E,OAkDkH,GAAIH,IAAG,GAAIl2C,KAAM,GAAIk2C,KAC5J,OAAOj0D,YACH,GAAI2zD,cAAcsB,QAAS,MAAOE,SAAU,UAAY,GAAIlB,IAAMe,MAAO,GAAIf,OAQrFxyD,OAAOvgB,UAAUk0E,KAKjB,SAAUrkD,QAAStnB,KAEf,GAAqB6tE,cAAe,GAAIC,cACpCx9D,GAAKu9D,aAAaljD,MAAMrD,QAAStnB,KAAM2qE,OAASr6D,GAAGq6D,OAAQmB,YAAcx7D,GAAGw7D,YAAa3iD,OAAS7Y,GAAG6Y,OAEpF4iD,oBACArmD,UAAY,GAAIqoD,YAMrC,IALAr2E,OAAOy2B,KAAK29C,aAAa/tE,QAAQ,SAAUkuE,OACvC,GAAI37D,IAAKoV,UAAUwmD,QAAQJ,YAAYG,OAAQjsE,KAAMmsE,UAAY77D,GAAG67D,UAAW37D,EAAIF,GAAG6Y,MACtFA,QAAOlrB,KAAK/E,MAAMiwB,OAAQ3Y,GAC1Bu7D,iBAAiBE,OAASE,YAE1BhjD,OAAOnwB,OACP,KAAM,IAAI0C,OAAM,yBAA2BytB,OAAOpsB,KAAK,MAE3D,QAAS4tE,OAAyB,OAAYoB,iBAAkBA,mBAMpE/zD,OAAOvgB,UAAU6X,OAIjB,SAAUlH,SAAW,MAAOsH,eAActH,UACnC4P,QACT4wD,YACE4E,gBAAiC,WACjC,QAAS5C,kBAqIT,MA9HAA,eAAcnzE,UAAUm2C,UAKxB,SAAUnmC,KAAM/M,SAAW,OAAQ,GAAI4vE,QAAO7iE,KAAKjN,SAMnDowE,cAAcnzE,UAAUwlE,eAKxB,SAAUb,UAAW1hE,SACjB,GAAIugC,OAAQ/jC,KACS6J,QAErB,OADAq7D,WAAU76D,SAASxD,QAAQ,SAAUyY,MAAQ,MAAOzV,OAAM9C,KAAK/E,MAAM6H,MAAOyV,KAAK3Y,MAAMo9B,UAChFl6B,OAOX6pE,cAAcnzE,UAAUylE,SAKxB,SAAUC,IAAKziE,SACX,GAAIugC,OAAQ/jC,KACS6J,OAAS,GAAIupE,QAAO,IAAMnN,IAAIuB,sBAAwB,KAAOvB,IAAI7/D,KAAO,MAK7F,OAJA5F,QAAOy2B,KAAKgvC,IAAIzzC,OAAO3rB,QAAQ,SAAUwS,GACrCxP,MAAM9C,KAAK/E,MAAM6H,OAAQ,GAAIupE,QAAO/5D,EAAI,OAAOzQ,OAAOq9D,IAAIzzC,MAAMnZ,GAAG1S,MAAMo9B,QAAS,GAAIqvC,QAAO,WAEjGvpE,MAAM9C,KAAK,GAAIqsE,QAAO,MACfvpE,OAOX6pE,cAAcnzE,UAAU4lE,oBAKxB,SAAUC,GAAI5iE,SACV,GAAIugC,OAAQ/jC,KACSoG,KAAOyZ,cAAcumD,GAAGxmD,IAC7C,IAAIwmD,GAAG9B,OAAQ,CAOX,OAN6B,GAAI6O,KA3JpB,MA4JT7pE,IAAKtJ,KAAK82E,sBAAsB9wE,WAChC27C,MAAOykB,GAAGC,UACVjgE,KAAMA,KACN2wE,KAAM,IAAM3Q,GAAGxmD,IAAM,QAI7B,GAAqBo3D,OAAQ,GAAI7D,KAlKT,MAmKpB7pE,IAAKtJ,KAAK82E,sBAAsB9wE,WAChCixE,WAAY7Q,GAAGC,UACf6Q,SAAU9Q,GAAGE,UACblgE,KAAMA,KACN+wE,UAAW,IAAM/Q,GAAGxmD,IAAM,IAC1Bw3D,QAAS,KAAOhR,GAAGxmD,IAAM,MAER/V,SAAWjB,OAAO5G,SAAUokE,GAAG/7D,SAASzE,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAMo9B,SAOrG,OANIl6B,OAAM/H,OACN+H,MAAMhD,QAAQ,SAAUyY,MAAQ,MAAO03D,OAAM3sE,SAAStD,KAAKuY,QAG3D03D,MAAM3sE,SAAStD,KAAK,GAAIqsE,QAAO,MAE3B4D,QAOZtD,cAAcnzE,UAAUgmE,iBAKxB,SAAUH,GAAI5iE,SACV,GAAqB6zE,QAASr3E,KAAK82E,sBAAsB9wE,UACzD,QAAQ,GAAImtE,KAhMK,MAiMT7pE,GAAI+tE,MACJ11B,MAAOykB,GAAG3kE,KACVs1E,KAAM,KAAO3Q,GAAG9iE,MAAQ,SAQpCowE,cAAcnzE,UAAUimE,oBAKxB,SAAUJ,GAAI5iE,SACV,GAAqBgvB,OAAQhyB,OAAOy2B,KAAKmvC,GAAG9iE,MAAMkvB,OAAO5sB,IAAI,SAAUtC,OAAS,MAAOA,OAAQ,WAAauC,KAAK,KAC5FwxE,OAASr3E,KAAK82E,sBAAsB9wE,UACzD,QAAQ,GAAImtE,KAnNK,MAmNqB7pE,GAAI+tE,MAAO11B,MAAOykB,GAAG3kE,KAAMs1E,KAAM,IAAM3Q,GAAG9iE,MAAMqR,WAAa,KAAOyxD,GAAG9iE,MAAM8C,KAAO,KAAOosB,MAAQ,QAM7IkhD,cAAcnzE,UAAU8e,UAIxB,SAAUxV,OACN,GAAIk6B,OAAQ/jC,IAEZ,OADAA,MAAK82E,mBAAqB,KAChBluE,OAAO5G,SAAU6H,MAAMjE,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAMo9B,WAEtE2vC,iBAEPkD,aAA8B,WAC9B,QAASA,gBACL52E,KAAKu1E,QAAU,KA4JnB,MArJAqB,cAAar2E,UAAUkzB,MAKvB,SAAU4gD,MAAOvrE,KACb9I,KAAKw1E,cAAgB,KACrBx1E,KAAKy1E,eACL,IAAqBC,MAAM,GAAIjE,YAAYh+C,MAAM4gD,MAAOvrE,KAAK,EAG7D,OAFA9I,MAAKojE,QAAUsS,IAAIzjD,OACnBroB,SAAS5J,KAAM01E,IAAI1jD,UAAW,OAE1B4iD,YAAa50E,KAAKy1E,aAClBxjD,OAAQjyB,KAAKojE,QACbqQ,OAAQzzE,KAAKu1E,UAQrBqB,aAAar2E,UAAUq3C,aAKvB,SAAUz/B,QAAS3U,SACf,OAAQ2U,QAAQ1W,MACZ,IApQM,OAqQFzB,KAAKw1E,cAAgB,IACrB,IAAqBG,QAASx9D,QAAQ7K,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,OAAdA,KAAK9L,MAC/E,IAAKk0E,OAGA,CACD,GAAqBrsE,IAAKqsE,OAAOryE,KAC7BtD,MAAKy1E,aAAapvE,eAAeiD,IACjCtJ,KAAK41E,UAAUz9D,QAAS,mCAAqC7O,KAG7DM,SAAS5J,KAAMmY,QAAQ9N,SAAU,MACC,gBAAvBrK,MAAKw1E,cACZx1E,KAAKy1E,aAAansE,IAAMtJ,KAAKw1E,cAG7Bx1E,KAAK41E,UAAUz9D,QAAS,WAAa7O,GAAK,8BAblDtJ,MAAK41E,UAAUz9D,QAAS,mCAiB5B,MACJ,KA5RQ,SA8RJ,KACJ,KA9RQ,SA+RJ,GAAqB09D,gBAAoC19D,QAAwB,gBAAEjO,IAAID,OAClE6rE,aAAkC39D,QAAsB,cAAEpO,MAAME,OAChEmmB,QAA6BjY,QAAwB,gBAAEpO,MAAMqzB,KAAKhN,QAClE2lD,UAAY3lD,QAAQjtB,MAAM0yE,eAAgBC,aAC/D91E,MAAKw1E,cAAgBO,SACrB,MACJ,KAvSK,QAwSD,GAAqBC,YAAa79D,QAAQ7K,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,YAAdA,KAAK9L,MAC/Eu0E,cACAh2E,KAAKu1E,QAAUS,WAAW1yE,MAE9B,IAAqBg0E,aAAcn/D,QAAQ7K,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,YAAdA,KAAK9L,MACpF,IAAI61E,YAAa,CACb,GAAqBhD,SAAUgD,YAAYh0E,KAC3B,SAAZgxE,QACAt0E,KAAK41E,UAAUz9D,QAAS,0BAA4Bm8D,QAAU,gDAG9D1qE,SAAS5J,KAAMmY,QAAQ9N,SAAU,MAGzC,KACJ,SACIT,SAAS5J,KAAMmY,QAAQ9N,SAAU,QAQ7CusE,aAAar2E,UAAU08C,eAKvB,SAAUowB,UAAW7pE,WAMrBozE,aAAar2E,UAAUm2C,UAKvB,SAAUnmC,KAAM/M,WAMhBozE,aAAar2E,UAAU48C,aAKvB,SAAUowB,QAAS/pE,WAMnBozE,aAAar2E,UAAUq8C,eAKvB,SAAUq5B,UAAWzyE,WAMrBozE,aAAar2E,UAAUw8C,mBAKvB,SAAUm5B,cAAe1yE,WAMzBozE,aAAar2E,UAAUq1E,UAKvB,SAAUt2D,KAAMpO,SACZlR,KAAKojE,QAAQr8D,KAAK,GAAIknE,WAAU3uD,KAAKtV,WAAYkH,WAE9C0lE,gBAEPC,YAA6B,WAC7B,QAAS/B,cAgJT,MAzIAA,WAAUv0E,UAAUy0E,QAKpB,SAAU9jE,QAASpI,KACf,GAAqBqtE,SAAS,GAAI1E,YAAYh+C,MAAMviB,QAASpI,KAAK,EAIlE,OAHA9I,MAAKojE,QAAU+S,OAAOlkD,QAIlBgjD,UAH6Bj1E,KAAKojE,QAAQthE,OAAS,GAAgC,GAA3Bq0E,OAAOnkD,UAAUlwB,aACjE8G,OAAO5G,SAAU4H,SAAS5J,KAAMm2E,OAAOnkD,YAG/CC,OAAQjyB,KAAKojE,UAQrB0R,UAAUv0E,UAAUm2C,UAKpB,SAAUnmC,KAAM/M,SAAW,MAAO,IAAIyjE,QAAO12D,KAAKjN,MAAOiN,KAAKvG,aAM9D8qE,UAAUv0E,UAAUq3C,aAKpB,SAAU5hB,GAAIxyB,SACV,GAAIugC,OAAQ/jC,IACZ,QAAQg2B,GAAGv0B,MACP,IAnba,KAobT,GAAqB20E,UAAWpgD,GAAG1oB,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,UAAdA,KAAK9L,MAC5E,IAAI20E,SACA,OAAQ,GAAI/O,aAAY,GAAI+O,SAAS9yE,MAAO0yB,GAAGhsB,YAEnDhK,MAAK41E,UAAU5/C,GAAI,oCACnB,MACJ,KAzboB,KA0bhB,GAAqBuhD,WAAYvhD,GAAG1oB,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,eAAdA,KAAK9L,OACxD+1E,QAAUxhD,GAAG1oB,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,aAAdA,KAAK9L,MAC3E,IAAK81E,UAGA,CAAA,GAAKC,QAGL,CACD,GAAqBC,SAAUF,UAAUj0E,MACpBo0E,MAAQF,QAAQl0E,MAChBuG,QACrB,OAAOA,OAAMjB,OAAO5G,MAAM6H,OAAQ,GAAIw9D,aAAY,GAAIoQ,QAASzhD,GAAGhsB,aAAapB,OAAOotB,GAAG3rB,SAASzE,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAMo9B,MAAO,SAAY,GAAIsjC,aAAY,GAAIqQ,MAAO1hD,GAAGhsB,eAN3LhK,KAAK41E,UAAU5/C,GAAI,4CAHnBh2B,MAAK41E,UAAU5/C,GAAI,yCAWvB,MACJ,KAxcQ,MAycJ,SAAUptB,OAAO5G,SAAU4H,SAAS5J,KAAMg2B,GAAG3rB,UACjD,SACIrK,KAAK41E,UAAU5/C,GAAI,kBAE3B,MAAO,OAOX8+C,UAAUv0E,UAAUq8C,eAKpB,SAAUqpB,IAAKziE,SACX,GAAqB6yE,WAIrB,OAHAzsE,UAAS5J,KAAMimE,IAAIzzC,OAAO3rB,QAAQ,SAAUwS,GACxCg9D,QAAQh9D,EAAE/V,OAAS,GAAI4jE,WAAU7tD,EAAExP,MAAOo8D,IAAIj8D,cAE3C,GAAIm9D,KAAIlB,IAAIlzC,YAAakzC,IAAI7/D,KAAMiwE,QAASpQ,IAAIj8D,aAO3D8qE,UAAUv0E,UAAUw8C,mBAKpB,SAAU8wB,QAASrqE,SACf,OACIF,MAAOuqE,QAAQvqE,MACfuG,SAAUjB,OAAO5G,SAAU4H,SAAS5J,KAAM6tE,QAAQl5D,eAQ1DmgE,UAAUv0E,UAAU48C,aAKpB,SAAUowB,QAAS/pE,WAMnBsxE,UAAUv0E,UAAU08C,eAKpB,SAAUowB,UAAW7pE,WAMrBsxE,UAAUv0E,UAAUq1E,UAKpB,SAAUt2D,KAAMpO,SACZlR,KAAKojE,QAAQr8D,KAAK,GAAIknE,WAAU3uD,KAAKtV,WAAYkH,WAE9C4jE,aAuCPl0D,IAAqB,SAAUnW,QAE/B,QAASmW,OACL,MAAkB,QAAXnW,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KA2E/D,MA7EAC,WAAU2gB,IAAKnW,QASfmW,IAAIrgB,UAAUizE,MAKd,SAAUtzD,SAAUuzD,QAChB,GAAqBkE,gBAAiB,GAAIC,gBACrBr0E,QAAU,GAAIs0E,YACdC,SAAW,GAAI3E,KAxBxB,gBA0CZ,OAjBAjzD,UAASrZ,QAAQ,SAAUqK,SACvB,GAAqB5D,QAAUhE,GAAI4H,QAAQ5H,GACvC4H,SAAQsM,cACRlQ,MAAY,KAAI4D,QAAQsM,aAExBtM,QAAQqH,UACRjL,MAAe,QAAI4D,QAAQqH,QAE/B,IAAqBw/D,cACrB7mE,SAAQ01D,QAAQ//D,QAAQ,SAAUkP,QAC9BgiE,WAAWhxE,KAAK,GAAIosE,KA/BhB,aAgCA,GAAIC,QAAOr9D,OAAOnO,SAAW,IAAMmO,OAAO8wD,WAAa9wD,OAAOgxD,UAAYhxD,OAAO8wD,UAAY,IAAM9wD,OAAOgxD,QAAU,UAG5H+Q,SAASztE,SAAStD,KAAK,GAAIusE,IAAG,GAAI,GAAIH,KAtC/B,MAsCiD7lE,MAAOyqE,WAAWnvE,OAAOrF,QAAQ8b,UAAUnO,QAAQrH,YAE/GiuE,SAASztE,SAAStD,KAAK,GAAIusE,KACpBj0D,WACH,GAAI2zD,cAAcsB,QAAS,MAAOE,SAAU,UAC5C,GAAIlB,IACJ,GAAIJ,SA7CI,gBAKL,ujBAyCH,GAAII,IACJqE,eAAeK,mBAAmBF,UAClC,GAAIxE,OAQZ1yD,IAAIrgB,UAAUk0E,KAKd,SAAUrkD,QAAStnB,KACf,KAAM,IAAItE,OAAM,gBAMpBoc,IAAIrgB,UAAU6X,OAId,SAAUlH,SAAW,MAAO4O,UAAS5O,UAKrC0P,IAAIrgB,UAAUoxE,iBAId,SAAUzgE,SACN,MAAO,IAAI0gE,yBAAwB1gE,QAAS6O,eAEzCa,KACT8wD,YACEmG,WAA4B,WAC5B,QAAS95D,aA+GT,MAxGAA,UAASxd,UAAUm2C,UAKnB,SAAUnmC,KAAM/M,SAAW,OAAQ,GAAI4vE,QAAO7iE,KAAKjN,SAMnDya,SAASxd,UAAUwlE,eAKnB,SAAUb,UAAW1hE,SACjB,GAAIugC,OAAQ/jC,KACS6J,QAErB,OADAq7D,WAAU76D,SAASxD,QAAQ,SAAUyY,MAAQ,MAAOzV,OAAM9C,KAAK/E,MAAM6H,MAAOyV,KAAK3Y,MAAMo9B,UAChFl6B,OAOXkU,SAASxd,UAAUylE,SAKnB,SAAUC,IAAKziE,SACX,GAAIugC,OAAQ/jC,KACS6J,OAAS,GAAIupE,QAAO,IAAMnN,IAAIuB,sBAAwB,KAAOvB,IAAI7/D,KAAO,MAK7F,OAJA5F,QAAOy2B,KAAKgvC,IAAIzzC,OAAO3rB,QAAQ,SAAUwS,GACrCxP,MAAM9C,KAAK/E,MAAM6H,OAAQ,GAAIupE,QAAO/5D,EAAI,OAAOzQ,OAAOq9D,IAAIzzC,MAAMnZ,GAAG1S,MAAMo9B,QAAS,GAAIqvC,QAAO,WAEjGvpE,MAAM9C,KAAK,GAAIqsE,QAAO,MACfvpE,OAOXkU,SAASxd,UAAU4lE,oBAKnB,SAAUC,GAAI5iE,SACV,GAAqBy0E,SAAU,GAAI9E,KA/IxB,SA+I+C,GAAIC,QAAO,IAAMhN,GAAGxmD,IAAM,OAC/Dw1D,WAAa,GAAIjC,KAjJrB,MAiJ+C1xE,KAAM2kE,GAAGC,YAAc4R,SACvF,IAAI7R,GAAG9B,OAEH,OAAQ8Q,WAEZ,IAAqB8C,SAAU,GAAI/E,KArJxB,SAqJ+C,GAAIC,QAAO,KAAOhN,GAAGxmD,IAAM,OAChEy1D,WAAa,GAAIlC,KAvJrB,MAuJ+C1xE,KAAM2kE,GAAGE,YAAc4R,SACvF,QAAQ9C,YAAYxsE,OAAO5I,KAAKqf,UAAU+mD,GAAG/7D,WAAYgrE,cAO7Dt3D,SAASxd,UAAUgmE,iBAKnB,SAAUH,GAAI5iE,SACV,GAAqB20E,OAAQ,GAAIhF,KApKtB,SAoK6C,GAAIC,QAAO,KAAOhN,GAAG9iE,MAAQ,OACrF,QAAQ,GAAI6vE,KAtKK,MAsKqB1xE,KAAM2kE,GAAG3kE,OAAS02E,UAO5Dp6D,SAASxd,UAAUimE,oBAKnB,SAAUJ,GAAI5iE,SACV,GAAqB20E,OAAQ,GAAIhF,KAlLtB,SAmLP,GAAIC,QAAO,IAAMhN,GAAG9iE,MAAMqR,WAAa,KAAOyxD,GAAG9iE,MAAM8C,KAAO,KAAO5F,OAAOy2B,KAAKmvC,GAAG9iE,MAAMkvB,OAAO5sB,IAAI,SAAUtC,OAAS,MAAOA,OAAQ,WAAauC,KAAK,KAAO,MAEpK,QAAQ,GAAIstE,KAtLK,MAsLqB1xE,KAAM2kE,GAAG3kE,OAAS02E,UAM5Dp6D,SAASxd,UAAU8e,UAInB,SAAUxV,OACN,GAAIk6B,OAAQ/jC,IACZ,UAAU4I,OAAO5G,SAAU6H,MAAMjE,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAMo9B,WAEtEhmB,YASP65D,eAAgC,WAChC,QAASA,mBA6DT,MAvDAA,gBAAer3E,UAAUy3E,mBAIzB,SAAU14D,MAEN,MADAA,MAAK3Y,MAAM3G,MACJsf,MAMXs4D,eAAer3E,UAAU+xE,SAIzB,SAAU1yD,KACN,GAAImkB,OAAQ/jC,IACZ,IAtOiB,OAsOb4f,IAAIne,MACJ,IAAKme,IAAIvV,UAAmC,GAAvBuV,IAAIvV,SAASvI,OAAa,CAC3C,GAAqBs2E,QAAS,GAAIhF,QAAOxzD,IAAItS,MAAY,MAAK,MAC9DsS,KAAIvV,UAAY,GAAI8oE,KAxOjB,SAwOwCiF,eAG1Cx4D,KAAIvV,UACTuV,IAAIvV,SAASxD,QAAQ,SAAUyY,MAAQ,MAAOA,MAAK3Y,MAAMo9B,UAOjE6zC,eAAer3E,UAAUm2C,UAIzB,SAAUnmC,QAKVqnE,eAAer3E,UAAUmyE,iBAIzB,SAAUC,QAKViF,eAAer3E,UAAUqyE,aAIzB,SAAUC,WACH+E,kBAwBP/2D,IAAqB,SAAUpW,QAE/B,QAASoW,OACL,MAAkB,QAAXpW,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KAoE/D,MAtEAC,WAAU4gB,IAAKpW,QASfoW,IAAItgB,UAAUizE,MAKd,SAAUtzD,SAAUuzD,QAAU,KAAM,IAAIjvE,OAAM,gBAM9Cqc,IAAItgB,UAAUk0E,KAKd,SAAUrkD,QAAStnB,KAEf,GAAqBuvE,WAAY,GAAIC,WACjCl/D,GAAKi/D,UAAU5kD,MAAMrD,QAAStnB,KAAM2qE,OAASr6D,GAAGq6D,OAAQmB,YAAcx7D,GAAGw7D,YAAa3iD,OAAS7Y,GAAG6Y,OAEjF4iD,oBACArmD,UAAY,GAAI+pD,YAcrC,IAVA/3E,OAAOy2B,KAAK29C,aAAa/tE,QAAQ,SAAUkuE,OAQvC90D,mBAAmB40D,iBAAkBE,MAPN,WAC3B,GAAI37D,IAAKoV,UAAUwmD,QAAQJ,YAAYG,OAAQjsE,KAAMmsE,UAAY77D,GAAG67D,UAAWhjD,OAAS7Y,GAAG6Y,MAC3F,IAAIA,OAAOnwB,OACP,KAAM,IAAI0C,OAAM,sBAAwBytB,OAAOpsB,KAAK,MAExD,OAAOovE,eAIXhjD,OAAOnwB,OACP,KAAM,IAAI0C,OAAM,sBAAwBytB,OAAOpsB,KAAK,MAExD,QAAS4tE,OAAyB,OAAYoB,iBAAkBA,mBAMpEh0D,IAAItgB,UAAU6X,OAId,SAAUlH,SAAW,MAAO4O,UAAS5O,UAKrC2P,IAAItgB,UAAUoxE,iBAId,SAAUzgE,SACN,MAAO,IAAI0gE,yBAAwB1gE,QAAS6O,eAEzCc,KACT6wD,YAmBE4G,UAA2B,WAC3B,QAASA,aACLt4E,KAAKu1E,QAAU,KA6InB,MAtIA+C,WAAU/3E,UAAUkzB,MAKpB,SAAU+kD,IAAK1vE,KACX9I,KAAKy4E,aAAe,EACpBz4E,KAAKy1E,eAGL,IAAqBC,MAAM,GAAIjE,YAAYh+C,MAAM+kD,IAAK1vE,KAAK,EAG3D,OAFA9I,MAAKojE,QAAUsS,IAAIzjD,OACnBroB,SAAS5J,KAAM01E,IAAI1jD,YAEf4iD,YAAa50E,KAAKy1E,aAClBxjD,OAAQjyB,KAAKojE,QACbqQ,OAAQzzE,KAAKu1E,UAQrB+C,UAAU/3E,UAAUq3C,aAKpB,SAAUz/B,QAAS3U,SACf,OAAQ2U,QAAQ1W,MACZ,IAtIY,oBAuIRzB,KAAKy4E,eACDz4E,KAAKy4E,aAAe,GACpBz4E,KAAK41E,UAAUz9D,QAAS,iDAE5B,IAAqBugE,UAAWvgE,QAAQ7K,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,SAAdA,KAAK9L,MAC7Ei3E,YACA14E,KAAKu1E,QAAUmD,SAASp1E,OAE5BsG,SAAS5J,KAAMmY,QAAQ9N,SAAU,MACjCrK,KAAKy4E,cACL,MACJ,KAjJW,cAkJP,GAAqB9C,QAASx9D,QAAQ7K,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,OAAdA,KAAK9L,MAC/E,IAAKk0E,OAGA,CACD,GAAqBrsE,IAAKqsE,OAAOryE,KACjC,IAAItD,KAAKy1E,aAAapvE,eAAeiD,IACjCtJ,KAAK41E,UAAUz9D,QAAS,mCAAqC7O,QAE5D,CACD,GAAqBusE,gBAAoC19D,QAAwB,gBAAEjO,IAAID,OAClE6rE,aAAkC39D,QAAsB,cAAEpO,MAAME,OAChEmmB,QAA6BjY,QAAwB,gBAAEpO,MAAMqzB,KAAKhN,QAClE2lD,UAAY3lD,QAAQjtB,MAAuB,eAAqC,aACrGnD,MAAKy1E,aAAansE,IAAMysE,eAZ5B/1E,MAAK41E,UAAUz9D,QAAS,0CAe5B,MACJ,SACInY,KAAK41E,UAAUz9D,QAAS,oBAQpCmgE,UAAU/3E,UAAU08C,eAKpB,SAAUowB,UAAW7pE,WAMrB80E,UAAU/3E,UAAUm2C,UAKpB,SAAUnmC,KAAM/M,WAMhB80E,UAAU/3E,UAAU48C,aAKpB,SAAUowB,QAAS/pE,WAMnB80E,UAAU/3E,UAAUq8C,eAKpB,SAAUq5B,UAAWzyE,WAMrB80E,UAAU/3E,UAAUw8C,mBAKpB,SAAUm5B,cAAe1yE,WAMzB80E,UAAU/3E,UAAUq1E,UAKpB,SAAUt2D,KAAMpO,SACZlR,KAAKojE,QAAQr8D,KAAK,GAAIknE,WAA6B3uD,KAAgB,WAAGpO,WAEnEonE,aAEPC,YAA6B,WAC7B,QAASzD,cA6HT,MAtHAA,WAAUv0E,UAAUy0E,QAKpB,SAAU9jE,QAASpI,KACf,GAAqBqtE,SAAS,GAAI1E,YAAYh+C,MAAMviB,QAASpI,KAAK,EAKlE,OAJA9I,MAAKojE,QAAU+S,OAAOlkD,QAKlBgjD,UAJ6Bj1E,KAAKojE,QAAQthE,OAAS,GAAgC,GAA3Bq0E,OAAOnkD,UAAUlwB,UAEzE8H,SAAS5J,KAAMm2E,OAAOnkD,WAGtBC,OAAQjyB,KAAKojE,UAQrB0R,UAAUv0E,UAAUm2C,UAKpB,SAAUnmC,KAAM/M,SAAW,MAAO,IAAIyjE,QAAO12D,KAAKjN,MAA0BiN,KAAgB,aAM5FukE,UAAUv0E,UAAUq8C,eAKpB,SAAUqpB,IAAKziE,SACX,GAAqB6yE,WAIrB,OAHAzsE,UAAS5J,KAAMimE,IAAIzzC,OAAO3rB,QAAQ,SAAUwS,GACxCg9D,QAAQh9D,EAAE/V,OAAS,GAAI4jE,WAAU7tD,EAAExP,MAAOo8D,IAAIj8D,cAE3C,GAAIm9D,KAAIlB,IAAIlzC,YAAakzC,IAAI7/D,KAAMiwE,QAASpQ,IAAIj8D,aAO3D8qE,UAAUv0E,UAAUw8C,mBAKpB,SAAU8wB,QAASrqE,SACf,OACIF,MAAOuqE,QAAQvqE,MACfuG,MAAOD,SAAS5J,KAAM6tE,QAAQl5D,cAQtCmgE,UAAUv0E,UAAUq3C,aAKpB,SAAU5hB,GAAIxyB,SACV,GA5TiB,OA4TbwyB,GAAGv0B,KAA6B,CAChC,GAAqB20E,UAAWpgD,GAAG1oB,MAAMoR,KAAK,SAAUnR,MAAQ,MAAqB,SAAdA,KAAK9L,MAC5E,IAAI20E,SACA,MAAO,IAAI/O,aAAY,GAAI+O,SAAS9yE,MAA0B0yB,GAAc,WAEhFh2B,MAAK41E,UAAU5/C,GAAI,wCAGnBh2B,MAAK41E,UAAU5/C,GAAI,iBAEvB,OAAO,OAOX8+C,UAAUv0E,UAAU48C,aAKpB,SAAUowB,QAAS/pE,WAMnBsxE,UAAUv0E,UAAU08C,eAKpB,SAAUowB,UAAW7pE,WAMrBsxE,UAAUv0E,UAAUq1E,UAKpB,SAAUt2D,KAAMpO,SACZlR,KAAKojE,QAAQr8D,KAAK,GAAIknE,WAA6B3uD,KAAgB,WAAGpO,WAEnE4jE,aAcPjtC,WAA4B,SAAUp9B,QAEtC,QAASo9B,cACL,MAAOp9B,QAAO8kC,KAAKvvC,KAAMkd,uBAAyBld,KAqBtD,MAvBAC,WAAU4nC,WAAYp9B,QAWtBo9B,WAAWtnC,UAAUkzB,MAOrB,SAAU1d,OAAQjN,IAAKg6D,oBAAqB5sD,qBAGxC,WAF4B,KAAxB4sD,sBAAkCA,qBAAsB,OAChC,KAAxB5sD,sBAAkCA,oBAAsBC,8BACrD1L,OAAOlK,UAAUkzB,MAAM8b,KAAKvvC,KAAM+V,OAAQjN,IAAKg6D,oBAAqB5sD,sBAExE2xB,YACTg7B,UAgBE8V,kBAAmC,WACnC,QAASA,mBAAkBC,kBAAmBnF,OAAQr7D,OAAQygE,cAAeC,2BAA4B9wC,aAC3E,KAAtB4wC,oBAAgCA,0BACD,KAA/BE,6BAAyCA,2BAA6BzjC,2BAA2BC,SACrGt1C,KAAK44E,kBAAoBA,kBACzB54E,KAAKoY,OAASA,OACdpY,KAAK64E,cAAgBA,cACrB74E,KAAK+4E,YAAc,GAAIC,mBAAkBJ,kBAAmBnF,OAAQr7D,OAAyB,cAAmB0gE,2BAA4B9wC,SAkDhJ,MAvCA2wC,mBAAkBlE,KAQlB,SAAUrkD,QAAStnB,IAAKmwE,WAAYH,2BAA4B9wC,SAC5D,GAAI5uB,IAAK6/D,WAAWxE,KAAKrkD,QAAStnB,KAAM2qE,OAASr6D,GAAGq6D,MAGpD,OAAO,IAAIkF,mBAHoEv/D,GAAGy7D,iBAGnCpB,OAFf,SAAU/wE,GAAK,MAAOu2E,YAAW7gE,OAAO1V,IACnC,SAAUA,GAAK,MAASu2E,YAAWtH,iBAAiBjvE,IACTo2E,2BAA4B9wC,UAOhH2wC,kBAAkBp4E,UAAUggB,IAI5B,SAAU24D,QACN,GAAqBC,MAAOn5E,KAAK+4E,YAAY/D,QAAQkE,OACrD,IAAIC,KAAKlnD,OAAOnwB,OACZ,KAAM,IAAI0C,OAAM20E,KAAKlnD,OAAOpsB,KAAK,MAErC,OAAOszE,MAAKtvE,OAMhB8uE,kBAAkBp4E,UAAUyzB,IAI5B,SAAUklD,QAAU,MAAOl5E,MAAKoY,OAAO8gE,SAAWl5E,MAAK44E,mBAChDD,qBAEPK,kBAAmC,WACnC,QAASA,mBAAkBJ,kBAAmBrD,QAAS6D,QAASC,eAAgBC,4BAA6BC,cAC/E,KAAtBX,oBAAgCA,sBACpC54E,KAAK44E,kBAAoBA,kBACzB54E,KAAKu1E,QAAUA,QACfv1E,KAAKo5E,QAAUA,QACfp5E,KAAKq5E,eAAiBA,eACtBr5E,KAAKs5E,4BAA8BA,4BACnCt5E,KAAKu5E,SAAWA,SAChBv5E,KAAKw5E,iBACLx5E,KAAKojE,WAsMT,MAhMA4V,mBAAkBz4E,UAAUy0E,QAI5B,SAAUkE,QACNl5E,KAAKw5E,cAAc13E,OAAS,EAC5B9B,KAAKojE,QAAQthE,OAAS,CAEtB,IAAqByO,MAAOvQ,KAAKy5E,eAAeP,QAE3BpwE,IAAMowE,OAAOrvE,MAAM,GAAGG,WAAWD,MAAMqzB,KAAKt0B,IAC5CqwE,MAAO,GAAItxC,aAAapU,MAAMljB,KAAMzH,KAAK,EAC9D,QACIe,MAAOsvE,KAAKnnD,UACZC,OAAQjyB,KAAKojE,QAAQx6D,OAAOuwE,KAAKlnD,UAQzC+mD,kBAAkBz4E,UAAUm2C,UAK5B,SAAUnmC,KAAM/M,SAGZ,MAAOgc,WAAUjP,KAAKjN,QAO1B01E,kBAAkBz4E,UAAUwlE,eAK5B,SAAUb,UAAW1hE,SACjB,GAAIugC,OAAQ/jC,IACZ,OAAOklE,WAAU76D,SAASzE,IAAI,SAAUmL,GAAK,MAAOA,GAAEpK,MAAMo9B,SAAWl+B,KAAK,KAOhFmzE,kBAAkBz4E,UAAUylE,SAK5B,SAAUC,IAAKziE,SACX,GAAIugC,OAAQ/jC,KACSwyB,MAAQhyB,OAAOy2B,KAAKgvC,IAAIzzC,OAAO5sB,IAAI,SAAUsU,GAAK,MAAOA,GAAI,KAAO+rD,IAAIzzC,MAAMtY,GAAGvT,MAAMo9B,OAAS,KAMrH,OAAO,KAHoB/jC,KAAK05E,QAAQhT,aAAargE,eAAe4/D,IAAItxD,YACpE3U,KAAK05E,QAAQhT,aAAaT,IAAItxD,YAC9BsxD,IAAItxD,YACW,KAAOsxD,IAAI7/D,KAAO,KAAOosB,MAAM3sB,KAAK,KAAO,KAOlEmzE,kBAAkBz4E,UAAUgmE,iBAK5B,SAAUH,GAAI5iE,SACV,GAAqBoqE,QAAS5tE,KAAK25E,QAAQvT,GAAG3kE,KAC9C,OAAIzB,MAAK05E,QAAQhT,aAAargE,eAAeunE,QAClC5tE,KAAK05E,QAAQhT,aAAakH,QAEjC5tE,KAAK05E,QAAQ/S,qBAAqBtgE,eAAeunE,QAC1C5tE,KAAKy5E,eAAez5E,KAAK05E,QAAQ/S,qBAAqBiH,UAEjE5tE,KAAK41E,UAAUxP,GAAI,wBAA2BA,GAAG3kE,KAAO,KACjD,KAUXu3E,kBAAkBz4E,UAAU4lE,oBAK5B,SAAUC,GAAI5iE,SACV,GAAIugC,OAAQ/jC,KACS4f,IAAM,GAAKwmD,GAAGxmD,IACdtS,MAAQ9M,OAAOy2B,KAAKmvC,GAAG94D,OAAO1H,IAAI,SAAUnE,MAAQ,MAAOA,MAAO,KAAQ2kE,GAAG94D,MAAM7L,MAAQ,MAASoE,KAAK,IAC9H,OAAIugE,IAAG9B,OACI,IAAM1kD,IAAM,IAAMtS,MAAQ,KAG9B,IAAMsS,IAAM,IAAMtS,MAAQ,IADD84D,GAAG/7D,SAASzE,IAAI,SAAUyT,GAAK,MAAOA,GAAE1S,MAAMo9B,SAAWl+B,KAAK,IAC5C,KAAO+Z,IAAM,KAUnEo5D,kBAAkBz4E,UAAUimE,oBAK5B,SAAUJ,GAAI5iE,SAEV,MAAOxD,MAAKy5E,eAAez5E,KAAK05E,QAAQ/S,qBAAqBP,GAAG3kE,QAUpEu3E,kBAAkBz4E,UAAUk5E,eAQ5B,SAAUP,QACN,GAGqBrvE,OAHjBk6B,MAAQ/jC,KACSsJ,GAAKtJ,KAAKo5E,QAAQF,QAClBU,OAAS55E,KAAKq5E,eAAiBr5E,KAAKq5E,eAAeH,QAAU,IAIlF,IAFAl5E,KAAKw5E,cAAczyE,MAAO1C,IAAKrE,KAAK05E,QAASE,OAAQ55E,KAAK25E,UAC1D35E,KAAK05E,QAAUR,OACXl5E,KAAK44E,kBAAkBvyE,eAAeiD,IAGtCO,MAAQ7J,KAAK44E,kBAAkBtvE,IAC/BtJ,KAAK25E,QAAU,SAAUl4E,MAAQ,MAAOm4E,QAA4BA,OAAO3H,eAAexwE,MAAUA,UAEnG,CAKD,GAAIzB,KAAKs5E,8BAAgCjkC,2BAA2B7wC,MAAO,CACvE,GAAqBimB,KAAMzqB,KAAKu1E,QAAU,gBAAmBv1E,KAAKu1E,QAAU,IAAO,EACnFv1E,MAAK41E,UAAUsD,OAAOrvE,MAAM,GAAI,oCAAuCP,GAAK,IAAOmhB,SAElF,IAAIzqB,KAAKu5E,UACVv5E,KAAKs5E,8BAAgCjkC,2BAA2BC,QAAS,CACzE,GAAqB7qB,KAAMzqB,KAAKu1E,QAAU,gBAAmBv1E,KAAKu1E,QAAU,IAAO,EACnFv1E,MAAKu5E,SAASxJ,KAAK,oCAAuCzmE,GAAK,IAAOmhB,KAE1E5gB,MAAQqvE,OAAOrvE,MACf7J,KAAK25E,QAAU,SAAUl4E,MAAQ,MAAOA,OAE5C,GAAqB8O,MAAO1G,MAAMjE,IAAI,SAAU0Z,MAAQ,MAAOA,MAAK3Y,MAAMo9B,SAAWl+B,KAAK,IACrErC,QAA6BxD,KAAKw5E,cAAchrC,KAGrE,OAFAxuC,MAAK05E,QAAUl2E,QAAQa,IACvBrE,KAAK25E,QAAUn2E,QAAQo2E,OAChBrpE,MAOXyoE,kBAAkBz4E,UAAUq1E,UAK5B,SAAU5/C,GAAI3xB,KACVrE,KAAKojE,QAAQr8D,KAAK,GAAIknE,WAAUj4C,GAAGhsB,WAAY3F,OAE5C20E,qBAcPpxC,eAAgC,WAChC,QAASA,gBAAe4lB,YAAatvC,aAAc27D,mBAAoB9xC,mBAAoBC,SAGvF,OAF2B,KAAvBD,qBAAiCA,mBAAqBsN,2BAA2BC,SACrFt1C,KAAKwtD,YAAcA,YACftvC,aAAc,CACd,GAAqB+6D,YAAav4D,iBAAiBm5D,mBACnD75E,MAAK85E,mBACDnB,kBAAkBlE,KAAKv2D,aAAc,OAAQ+6D,WAAYlxC,mBAAoBC,aAGjFhoC,MAAK85E,mBACD,GAAInB,sBAAsB,KAAMvgE,WAAQlU,GAAW6jC,mBAAoBC,SA0BnF,MAhBAJ,gBAAernC,UAAUkzB,MAOzB,SAAU1d,OAAQjN,IAAKg6D,oBAAqB5sD,yBACZ,KAAxB4sD,sBAAkCA,qBAAsB,OAChC,KAAxB5sD,sBAAkCA,oBAAsBC,6BAC5D,IAAqB4jE,aAAc/5E,KAAKwtD,YAAY/5B,MAAM1d,OAAQjN,IAAKg6D,oBAAqB5sD,oBAC5F,OAAI6jE,aAAY9nD,OAAOnwB,OACZ,GAAIgwB,iBAAgBioD,YAAY/nD,UAAW+nD,YAAY9nD,QAE3DhU,kBAAkB87D,YAAY/nD,UAAWhyB,KAAK85E,mBAAoB5jE,4BAEtE0xB,kBAkCP9lB,wBAA0B,mCAC1BR,eAAiB,8BACjBW,iBAAmB,gBACnBI,iBAAmB,aAuFnBE,eAAiB,YA2BjBy3D,KAAO,gBACP9sD,YAA6B,WAC7B,QAASA,gBA8FT,MA5FAA,aAAY+sD,8BACRx4E,KAAM,+BACN88B,WAAYy7C,MAEhB9sD,YAAY6nB,YAAetzC,KAAM,aAAc88B,WAAYy7C,MAC3D9sD,YAAYG,aAAgB5rB,KAAM,cAAe88B,WAAYy7C,MAC7D9sD,YAAYgoB,kBAAqBzzC,KAAM,mBAAoB88B,WAAYy7C,MACvE9sD,YAAYgtD,mBACRz4E,KAAM,oBACN88B,WAAYy7C,MAEhB9sD,YAAYitD,WAAc14E,KAAM,YAAa88B,WAAYy7C,MACzD9sD,YAAY+nB,aAAgBxzC,KAAM,cAAe88B,WAAYy7C,MAC7D9sD,YAAYI,iCACR7rB,KAAM,mCACN88B,WAAYy7C,MAEhB9sD,YAAYC,0BACR1rB,KAAM,2BACN88B,WAAYy7C,MAEhB9sD,YAAY8T,kBAAqBv/B,KAAM,mBAAoB88B,WAAYy7C,MACvE9sD,YAAYktD,cAAiB34E,KAAM,eAAgB88B,WAAYy7C,MAC/D9sD,YAAYmtD,iBAAoB54E,KAAM,kBAAmB88B,WAAYy7C,MACrE9sD,YAAYotD,qBACR74E,KAAM,OACN88B,WAAYy7C,MAEhB9sD,YAAYqtD,WACR94E,KAAM,OACN88B,WAAYy7C,MAEhB9sD,YAAYstD,mBACR/4E,KAAM,OACN88B,WAAYy7C,MAEhB9sD,YAAYutD,yBACRh5E,KAAM,yBACN88B,WAAYy7C,MAEhB9sD,YAAYwtD,UAAaj5E,KAAM,WAAY88B,WAAYy7C,MACvD9sD,YAAYib,mBACR1mC,KAAM,oBACN88B,WAAYy7C,MAEhB9sD,YAAYsjB,yBACR/uC,KAAM,0BACN88B,WAAYy7C,MAEhB9sD,YAAYgH,iBACRzyB,KAAM,kBACN88B,WAAYy7C,MAEhB9sD,YAAYytD,WAAcl5E,KAAM,YAAa88B,WAAYy7C,MACzD9sD,YAAY0tD,qBACRn5E,KAAM,sBACN88B,WAAYy7C,MAEhB9sD,YAAY2tD,mBACRp5E,KAAM,qBACN88B,WAAYy7C,MAEhB9sD,YAAY4tD,aAAgBr5E,KAAM,eAAgB88B,WAAYy7C,MAC9D9sD,YAAY6tD,aAAgBt5E,KAAM,eAAgB88B,WAAYy7C,MAC9D9sD,YAAY8tD,WAAcv5E,KAAM,aAAc88B,WAAYy7C,MAC1D9sD,YAAY+tD,UAAax5E,KAAM,WAAY88B,WAAYy7C,MACvD9sD,YAAYguD,SAAYz5E,KAAM,OAAQ88B,WAAYy7C,MAClD9sD,YAAYiuD,YAAe15E,KAAM,OAAQ88B,WAAYy7C,MACrD9sD,YAAYkuD,WAAc35E,KAAM,OAAQ88B,WAAYy7C,MACpD9sD,YAAYmuD,SAAY55E,KAAM,OAAQ88B,WAAYy7C,MAClD9sD,YAAYouD,cAAiB75E,KAAM,OAAQ88B,WAAYy7C,MACvD9sD,YAAYvC,aAAgBlpB,KAAM,OAAQ88B,WAAYy7C,MACtD9sD,YAAYquD,UAAa95E,KAAM,OAAQ88B,WAAYy7C,MACnD9sD,YAAYsuD,cAAiB/5E,KAAM,OAAQ88B,WAAYy7C,MACvD9sD,YAAYuuD,eAAkBh6E,KAAM,OAAQ88B,WAAYy7C,MACxD9sD,YAAYwuD,aAAgBj6E,KAAM,OAAQ88B,WAAYy7C,MACtD9sD,YAAYyuD,SAAYl6E,KAAM,OAAQ88B,WAAYy7C,MAClD9sD,YAAY0uD,WAAcn6E,KAAM,OAAQ88B,WAAYy7C,MACpD9sD,YAAY2uD,cAAiBp6E,KAAM,OAAQ88B,WAAYy7C,MACvD9sD,YAAY8O,aAAgBv6B,KAAM,OAAQ88B,WAAYy7C,MACtD9sD,YAAY4uD,qBAAwBr6E,KAAM,OAAQ88B,WAAYy7C,MAE9D9sD,YAAY6uD,eACRt6E,KAAM,gBACN88B,WAAYy7C,MAGhB9sD,YAAY8uD,gBACRv6E,KAAM,kBACN88B,WAAYy7C,MAEhB9sD,YAAY+uD,wBAA2Bx6E,KAAM,OAAQ88B,WAAYy7C,MAC1D9sD,eA8BP/J,gBACAC,OAAQ,EACRC,UAAW,EACXC,QAAS,EACTC,UAAW,EACXC,iBAAkB,EAClBC,oBAAqB,EACrBC,cAAe,EACfC,iBAAkB,EAEtBR,gBAAeA,eAAeC,QAAU,SACxCD,eAAeA,eAAeE,WAAa,YAC3CF,eAAeA,eAAeG,SAAW,UACzCH,eAAeA,eAAeI,WAAa,YAC3CJ,eAAeA,eAAeK,kBAAoB,mBAClDL,eAAeA,eAAeM,qBAAuB,sBACrDN,eAAeA,eAAeO,eAAiB,gBAC/CP,eAAeA,eAAeQ,kBAAoB,kBAClD,IAAIV,yBACAE,eAAeC,OAAQD,eAAeE,UAAWF,eAAeG,QAASH,eAAeI,UACxFJ,eAAeK,iBAAkBL,eAAeM,oBAAqBN,eAAeO,cACpFP,eAAeQ,kBAuDfu4D,iBAAmB,GAAI7mE,QAAO,8GAMlC,KAMIme,YAA6B,WAC7B,QAASA,eACLxzB,KAAKmY,QAAU,KACfnY,KAAKm8E,cACLn8E,KAAKsN,SACLtN,KAAK6zB,gBAuJT,MAjJAL,aAAYC,MAIZ,SAAUtD,UACN,GASqB3kB,OATAotC,WACAwjC,WAAa,SAAUr2E,IAAKs2E,QACzCA,OAAOxoD,aAAa/xB,OAAS,IAAMu6E,OAAOlkE,SAAuC,GAA5BkkE,OAAOF,WAAWr6E,QAChD,GAAvBu6E,OAAO/uE,MAAMxL,SACbu6E,OAAOlkE,QAAU,KAErBpS,IAAIgB,KAAKs1E,SAEQvnD,YAAc,GAAItB,aAElB8oD,QAAUxnD,YACVynD,OAAQ,CAE7B,KADAL,iBAAiBzkD,UAAY,EACtBjsB,MAAQ0wE,iBAAiBM,KAAKrsD,WAAW,CAC5C,GAAI3kB,MAAM,GAAI,CACV,GAAI+wE,MACA,KAAM,IAAI/3E,OAAM,4CAEpB+3E,QAAQ,EACRD,QAAU,GAAI9oD,aACdsB,YAAYjB,aAAa9sB,KAAKu1E,SAelC,GAbI9wE,MAAM,IACN8wE,QAAQtnD,WAAWxpB,MAAM,IAEzBA,MAAM,IACN8wE,QAAQ/mD,aAAa/pB,MAAM,IAE3BA,MAAM,IACN8wE,QAAQlnD,aAAa5pB,MAAM,GAAIA,MAAM,IAErCA,MAAM,KACN+wE,OAAQ,EACRD,QAAUxnD,aAEVtpB,MAAM,GAAI,CACV,GAAI+wE,MACA,KAAM,IAAI/3E,OAAM,+CAEpB43E,YAAWxjC,QAAS9jB,aACpBA,YAAcwnD,QAAU,GAAI9oD,cAIpC,MADA4oD,YAAWxjC,QAAS9jB,aACb8jB,SAKXplB,YAAYjzB,UAAUuzB,kBAGtB,WACI,MAAO9zB,MAAKy8E,sBAAkD,GAA1Bz8E,KAAKm8E,WAAWr6E,QAAoC,GAArB9B,KAAKsN,MAAMxL,QAC7C,IAA7B9B,KAAK6zB,aAAa/xB,QAK1B0xB,YAAYjzB,UAAUk8E,mBAGtB,WAAc,QAASz8E,KAAKmY,SAK5Bqb,YAAYjzB,UAAUy0B,WAItB,SAAU7c,aACU,KAAZA,UAAsBA,QAAU,MACpCnY,KAAKmY,QAAUA,SAOnBqb,YAAYjzB,UAAUm8E,2BAItB,WAII,IAAK,GAHgBlwE,SAAUxM,KAAKmY,SAAW,MAC1BwkE,UAAY38E,KAAKm8E,WAAWr6E,OAAS,EAAI,WAAc9B,KAAKm8E,WAAWt2E,KAAK,KAAO,IAAO,GAC1FyH,MAAQ,GACHvC,EAAI,EAAGA,EAAI/K,KAAKsN,MAAMxL,OAAQiJ,GAAK,EAAG,CAG5DuC,OAAS,IAFuBtN,KAAKsN,MAAMvC,IACY,KAAtB/K,KAAKsN,MAAMvC,EAAI,GAAY,KAAQ/K,KAAKsN,MAAMvC,EAAI,GAAK,IAAO,IAGnG,MAAOmS,sBAAqB1Q,SAAS83D,OAAS,IAAM93D,QAAUmwE,UAAYrvE,MAAQ,KAC9E,IAAMd,QAAUmwE,UAAYrvE,MAAQ,MAAQd,QAAU,KAO9DgnB,YAAYjzB,UAAU60B,aAKtB,SAAU3zB,KAAM6B,WACE,KAAVA,QAAoBA,MAAQ,IAChCtD,KAAKsN,MAAMvG,KAAKtF,KAAM6B,OAASA,MAAMmK,eAAiB,KAM1D+lB,YAAYjzB,UAAUg1B,aAItB,SAAU9zB,MAAQzB,KAAKm8E,WAAWp1E,KAAKtF,KAAKgM,gBAI5C+lB,YAAYjzB,UAAUyF,SAGtB,WACI,GAAqBD,KAAM/F,KAAKmY,SAAW,EAI3C,IAHInY,KAAKm8E,YACLn8E,KAAKm8E,WAAWt1E,QAAQ,SAAU+1E;6DAAS,MAAO72E,MAAO,IAAM62E,QAE/D58E,KAAKsN,MACL,IAAK,GAAqBvC,GAAI,EAAGA,EAAI/K,KAAKsN,MAAMxL,OAAQiJ,GAAK,EAAG,CAC5D,GAAqBomD,QAASnxD,KAAKsN,MAAMvC,GACpBzH,MAAQtD,KAAKsN,MAAMvC,EAAI,EAC5ChF,MAAO,IAAMorD,QAAU7tD,MAAQ,IAAMA,MAAQ,IAAM,IAI3D,MADAtD,MAAK6zB,aAAahtB,QAAQ,SAAUg2E,aAAe,MAAO92E,MAAO,QAAU82E,YAAc,MAClF92E,KAEJytB,eAMPspD,gBAAiC,WACjC,QAASA,mBACL98E,KAAK+8E,YAAc,GAAIl0D,KACvB7oB,KAAKg9E,mBAAqB,GAAIn0D,KAC9B7oB,KAAKi9E,UAAY,GAAIp0D,KACrB7oB,KAAKk9E,iBAAmB,GAAIr0D,KAC5B7oB,KAAKm9E,cAAgB,GAAIt0D,KACzB7oB,KAAKo9E,qBAAuB,GAAIv0D,KAChC7oB,KAAKq9E,iBA8QT,MAxQAP,iBAAgBQ,iBAIhB,SAAUzpD,cACN,GAAqB0pD,YAAa,GAAIT,gBAEtC,OADAS,YAAWC,eAAe3pD,aAAc,MACjC0pD,YAOXT,gBAAgBv8E,UAAUi9E,eAK1B,SAAUC,aAAcC,cACpB,GAAqBC,aAA+B,IAChDF,cAAa37E,OAAS,IACtB67E,YAAc,GAAIC,qBAAoBH,cACtCz9E,KAAKq9E,cAAct2E,KAAK42E,aAE5B,KAAK,GAAqB5yE,GAAI,EAAGA,EAAI0yE,aAAa37E,OAAQiJ,IACtD/K,KAAK69E,eAAeJ,aAAa1yE,GAAI2yE,aAAcC,cAU3Db,gBAAgBv8E,UAAUs9E,eAO1B,SAAU/oD,YAAa4oD,aAAcC,aACjC,GAAqBG,SAAU99E,KACVmY,QAAU2c,YAAY3c,QACtBgkE,WAAarnD,YAAYqnD,WACzB7uE,MAAQwnB,YAAYxnB,MACpBywE,WAAa,GAAIC,iBAAgBlpD,YAAa4oD,aAAcC,YACjF,IAAIxlE,QAAS,CACT,GAAqB8lE,YAA8B,IAAjB3wE,MAAMxL,QAAsC,IAAtBq6E,WAAWr6E,MAC/Dm8E,YACAj+E,KAAKk+E,aAAaJ,QAAQf,YAAa5kE,QAAS4lE,YAGhDD,QAAU99E,KAAKm+E,YAAYL,QAAQd,mBAAoB7kE,SAG/D,GAAIgkE,WACA,IAAK,GAAqBpxE,GAAI,EAAGA,EAAIoxE,WAAWr6E,OAAQiJ,IAAK,CACzD,GAAqBkzE,YAA8B,IAAjB3wE,MAAMxL,QAAgBiJ,IAAMoxE,WAAWr6E,OAAS,EAC7DwzB,UAAY6mD,WAAWpxE,EACxCkzE,YACAj+E,KAAKk+E,aAAaJ,QAAQb,UAAW3nD,UAAWyoD,YAGhDD,QAAU99E,KAAKm+E,YAAYL,QAAQZ,iBAAkB5nD,WAIjE,GAAIhoB,MACA,IAAK,GAAqBvC,GAAI,EAAGA,EAAIuC,MAAMxL,OAAQiJ,GAAK,EAAG,CACvD,GAAqBkzE,YAAalzE,IAAMuC,MAAMxL,OAAS,EAClC84D,OAASttD,MAAMvC,GACfzH,MAAQgK,MAAMvC,EAAI,EACvC,IAAIkzE,WAAY,CACZ,GAAqBG,aAAcN,QAAQX,cACtBkB,kBAAoBD,YAAY79D,IAAIq6C,OACpDyjB,qBACDA,kBAAoB,GAAIx1D,KACxBu1D,YAAY59D,IAAIo6C,OAAQyjB,oBAE5Br+E,KAAKk+E,aAAaG,kBAAmB/6E,MAAOy6E,gBAE3C,CACD,GAAqBO,YAAaR,QAAQV,qBACrBmB,iBAAmBD,WAAW/9D,IAAIq6C,OAClD2jB,oBACDA,iBAAmB,GAAI11D,KACvBy1D,WAAW99D,IAAIo6C,OAAQ2jB,mBAE3BT,QAAU99E,KAAKm+E,YAAYI,iBAAkBj7E,UAW7Dw5E,gBAAgBv8E,UAAU29E,aAM1B,SAAUt4E,IAAKnE,KAAMs8E,YACjB,GAAqBS,cAAe54E,IAAI2a,IAAI9e,KACvC+8E,gBACDA,gBACA54E,IAAI4a,IAAI/e,KAAM+8E,eAElBA,aAAaz3E,KAAKg3E,aAOtBjB,gBAAgBv8E,UAAU49E,YAK1B,SAAUv4E,IAAKnE,MACX,GAAqBq8E,SAAUl4E,IAAI2a,IAAI9e,KAKvC,OAJKq8E,WACDA,QAAU,GAAIhB,iBACdl3E,IAAI4a,IAAI/e,KAAMq8E,UAEXA,SAgBXhB,gBAAgBv8E,UAAUiL,MAO1B,SAAUspB,YAAa2pD,iBAKnB,IAAK,GAJgB/3E,SAAS,EACTyR,QAA6B2c,YAAoB,QACjDqnD,WAAarnD,YAAYqnD,WACzB7uE,MAAQwnB,YAAYxnB,MACfvC,EAAI,EAAGA,EAAI/K,KAAKq9E,cAAcv7E,OAAQiJ,IAC5D/K,KAAKq9E,cAActyE,GAAG2zE,gBAAiB,CAK3C,IAHAh4E,OAAS1G,KAAK2+E,eAAe3+E,KAAK+8E,YAAa5kE,QAAS2c,YAAa2pD,kBAAoB/3E,OACzFA,OAAS1G,KAAK4+E,cAAc5+E,KAAKg9E,mBAAoB7kE,QAAS2c,YAAa2pD,kBACvE/3E,OACAy1E,WACA,IAAK,GAAqBpxE,GAAI,EAAGA,EAAIoxE,WAAWr6E,OAAQiJ,IAAK,CACzD,GAAqBuqB,WAAY6mD,WAAWpxE,EAC5CrE,QACI1G,KAAK2+E,eAAe3+E,KAAKi9E,UAAW3nD,UAAWR,YAAa2pD,kBAAoB/3E,OACpFA,OACI1G,KAAK4+E,cAAc5+E,KAAKk9E,iBAAkB5nD,UAAWR,YAAa2pD,kBAC9D/3E,OAGhB,GAAI4G,MACA,IAAK,GAAqBvC,GAAI,EAAGA,EAAIuC,MAAMxL,OAAQiJ,GAAK,EAAG,CACvD,GAAqB8zE,QAASvxE,MAAMvC,GACfzH,MAAQgK,MAAMvC,EAAI,GAClBszE,kBAAuCr+E,KAAKm9E,cAAc58D,IAAIs+D,OAC/Ev7E,SACAoD,OACI1G,KAAK2+E,eAAeN,kBAAmB,GAAIvpD,YAAa2pD,kBAAoB/3E,QAEpFA,OACI1G,KAAK2+E,eAAeN,kBAAmB/6E,MAAOwxB,YAAa2pD,kBAAoB/3E,MACnF,IAAqB63E,kBAAsCv+E,KAAKo9E,qBAAqB78D,IAAIs+D,OACrFv7E,SACAoD,OAAS1G,KAAK4+E,cAAcL,iBAAkB,GAAIzpD,YAAa2pD,kBAAoB/3E,QAEvFA,OACI1G,KAAK4+E,cAAcL,iBAAkBj7E,MAAOwxB,YAAa2pD,kBAAoB/3E,OAGzF,MAAOA,SAWXo2E,gBAAgBv8E,UAAUo+E,eAQ1B,SAAU/4E,IAAKnE,KAAMqzB,YAAa2pD,iBAC9B,IAAK74E,KAAuB,gBAATnE,MACf,OAAO,CAEX,IAAqBq9E,aAAcl5E,IAAI2a,IAAI9e,UACtBs9E,gBAAqCn5E,IAAI2a,IAAI,IAIlE,IAHIw+D,kBACAD,YAAcA,YAAYl2E,OAAOm2E,kBAEV,IAAvBD,YAAYh9E,OACZ,OAAO,CAIX,KAAK,GAFgBi8E,YACAr3E,QAAS,EACJqE,EAAI,EAAGA,EAAI+zE,YAAYh9E,OAAQiJ,IACrDgzE,WAAae,YAAY/zE,GACzBrE,OAASq3E,WAAWiB,SAASlqD,YAAa2pD,kBAAoB/3E,MAElE,OAAOA,SAWXo2E,gBAAgBv8E,UAAUq+E,cAQ1B,SAAUh5E,IAAKnE,KAAMqzB,YAAa2pD,iBAC9B,IAAK74E,KAAuB,gBAATnE,MACf,OAAO,CAEX,IAAqBw9E,gBAAiBr5E,IAAI2a,IAAI9e,KAC9C,SAAKw9E,gBAMEA,eAAezzE,MAAMspB,YAAa2pD,kBAEtC3B,mBAEPc,oBAAqC,WACrC,QAASA,qBAAoBrzD,WACzBvqB,KAAKuqB,UAAYA,UACjBvqB,KAAK0+E,gBAAiB,EAE1B,MAAOd,wBAEPI,gBAAiC,WACjC,QAASA,iBAAgB7tD,SAAU+uD,UAAWvB,aAC1C39E,KAAKmwB,SAAWA,SAChBnwB,KAAKk/E,UAAYA,UACjBl/E,KAAK29E,YAAcA,YACnB39E,KAAK6zB,aAAe1D,SAAS0D,aA0BjC,MAnBAmqD,iBAAgBz9E,UAAUy+E,SAK1B,SAAUlqD,YAAaqqD,UACnB,GAAqBz4E,SAAS,CAC9B,IAAI1G,KAAK6zB,aAAa/xB,OAAS,KAAO9B,KAAK29E,cAAgB39E,KAAK29E,YAAYe,gBAAiB,CAEzFh4E,QADkCo2E,gBAAgBQ,iBAAiBt9E,KAAK6zB,cACnDroB,MAAMspB,YAAa,MAQ5C,OANIpuB,SAAUy4E,UAAcn/E,KAAK29E,aAAgB39E,KAAK29E,YAAYe,iBAC1D1+E,KAAK29E,cACL39E,KAAK29E,YAAYe,gBAAiB,GAEtCS,SAASn/E,KAAKmwB,SAAUnwB,KAAKk/E,YAE1Bx4E,QAEJs3E,mBAcPr5D,qBAAuB,kBACvBukB,wBAAyC,WACzC,QAASA,yBAAwBukB,QAASD,YAAa4xB,kBAAmBC,mBAAoBC,cAAeC,iBAAkBC,gBAAiBC,qBAAsBlG,SAAUmG,mBAAoB5vB,WAAY6vB,iBAC5M3/E,KAAKytD,QAAUA,QACfztD,KAAKwtD,YAAcA,YACnBxtD,KAAKo/E,kBAAoBA,kBACzBp/E,KAAKq/E,mBAAqBA,mBAC1Br/E,KAAKs/E,cAAgBA,cACrBt/E,KAAKu/E,iBAAmBA,iBACxBv/E,KAAKw/E,gBAAkBA,gBACvBx/E,KAAKy/E,qBAAuBA,qBAC5Bz/E,KAAKu5E,SAAWA,SAChBv5E,KAAK0/E,mBAAqBA,mBAC1B1/E,KAAK8vD,WAAaA,WAClB9vD,KAAK2/E,gBAAkBA,gBACvB3/E,KAAK4/E,6BAA+B,GAAI/2D,KACxC7oB,KAAK6/E,gBAAkB,GAAIh3D,KAC3B7oB,KAAK8/E,cAAgB,GAAIj3D,KACzB7oB,KAAK+/E,WAAa,GAAIl3D,KACtB7oB,KAAKggF,eAAiB,GAAIn3D,KAC1B7oB,KAAKigF,iBAAmB,GAAIp3D,KAk3ChC,MA72CAqgB,yBAAwB3oC,UAAU2/E,aAGlC,WAAc,MAAOlgF,MAAK8vD,YAK1B5mB,wBAAwB3oC,UAAUstD,cAIlC,SAAUznD,MACN,GAAqB+5E,SAAUngF,KAAK6/E,gBAAgBt/D,IAAIna,KACxDpG,MAAK6/E,gBAAgBrjD,OAAOp2B,MAC5BpG,KAAK4/E,6BAA6BpjD,OAAOp2B,MACzCpG,KAAK8/E,cAActjD,OAAOp2B,MAC1BpG,KAAK+/E,WAAWvjD,OAAOp2B,MACvBpG,KAAKigF,iBAAiBzjD,OAAOp2B,MAE7BpG,KAAKggF,eAAepyB,QAChBuyB,SACAngF,KAAKy/E,qBAAqB5xB,cAAcsyB,UAMhDj3C,wBAAwB3oC,UAAUotD,WAGlC,WACI3tD,KAAK6/E,gBAAgBjyB,QACrB5tD,KAAK4/E,6BAA6BhyB,QAClC5tD,KAAK8/E,cAAclyB,QACnB5tD,KAAK+/E,WAAWnyB,QAChB5tD,KAAKggF,eAAepyB,QACpB5tD,KAAKigF,iBAAiBryB,QACtB5tD,KAAKy/E,qBAAqB9xB,cAO9BzkB,wBAAwB3oC,UAAU6/E,kBAKlC,SAAUC,SAAU5+E,MAChB,GAAqB6+E,UAAW,KACXC,WAA8B,WAC/C,IAAKD,SACD,KAAM,IAAI97E,OAAM,wBAA0B/C,KAAO,aAAeiE,UAAU26E,UAAY,wBAE1F,OAAOC,UAASt+E,MAAMhC,KAAM6B,WAQhC,OANA0+E,YAAWC,YAAc,SAAUtgF,GAC/BogF,SAAWpgF,EACX,WAAgCK,UAAYL,EAAEK,WAGlD,WAAgCuF,eAAiBrE,KAC1C8+E,YAOXr3C,wBAAwB3oC,UAAUkgF,kBAKlC,SAAUC,QAASj/E,MACf,MAAIi/E,mBAAmBl5E,cACZxH,KAAK0/E,mBAAmBn/D,IAAIS,kBAAkB0/D,QAAQ94E,UAAWnG,MAGjEzB,KAAKogF,kBAAkBM,QAASj/E,OAO/CynC,wBAAwB3oC,UAAUogF,sBAIlC,SAAUD,SACN,MAAO1gF,MAAKygF,kBAAkBC,QAAS74E,cAAc64E,QAAS,KAMlEx3C,wBAAwB3oC,UAAUqgF,0BAIlC,SAAUF,SACN,MAAO1gF,MAAKygF,kBAAkBC,QAASz4E,kBAAkBy4E,WAM7Dx3C,wBAAwB3oC,UAAUsgF,qBAIlC,SAAUH,SACN,GAAqBj/E,MAAO2F,gBAAiBE,UAAWo5E,UAAa,OACrE,IAAIA,kBAAmBl5E,cACnB,MAAOxH,MAAK0/E,mBAAmBn/D,IAAImgE,QAAQ94E,SAAUnG,KAGrD,IAAqBq/E,WAA6B,YAElD,OADAA,WAAUh7E,eAAiBrE,KACpBq/E,WAOf53C,wBAAwB3oC,UAAUwgF,gBAIlC,SAAUL,SACN,MAAIA,mBAAmBl5E,cACZxH,KAAK0/E,mBAAmBn/D,IAAIS,kBAAkB0/D,QAAQ94E,UAAWI,iBAAiB04E,cAejGx3C,wBAAwB3oC,UAAUygF,oBAOlC,SAAU7wD,SAAUuwD,QAASjpC,OAAQC,SACjC,GAAIgpC,kBAAmBl5E,cACnB,MAAOxH,MAAK0/E,mBAAmBn/D,IAAIS,kBAAkB0/D,QAAQ94E,UAAWM,qBAAqBw4E,SAG7F,IAAqBO,UAAWjhF,KAAK4gF,0BAA0BF,QAI/D,OAD8C1gF,MAAK8vD,WAAWltC,yBAAyBsK,YAAY+uD,wBACrE9rD,SAAUuwD,QAA0B,SAAYjpC,OAAQC,aAQ9FxO,wBAAwB3oC,UAAU2gF,qBAKlC,SAAUzhF,QAASy6C,oBACTz6C,kBAAmB+H,gBACpB4R,GAAK,QAA6B8gC,oBAAoBnzC,KAAK/E,MAAMoX,GAAI8gC,mBAE1E,IAAI9gC,KAOR8vB,wBAAwB3oC,UAAU4gF,aAKlC,SAAU/6E,KAAMmP,MACZ,GAAqB6rE,aAAcphF,KAAK8/E,cAAcv/D,IAAIna,KAC1D,KAAKg7E,YAAa,CACd,GAAqB3hD,SAAUz/B,KAAKu/E,iBAAiB8B,eAAej7E,KACpEg7E,aAAc3hD,QAAUA,QAAQr5B,KAAO,KACvCpG,KAAK8/E,cAAct/D,IAAIpa,KAAMg7E,aAAe,MAEhD,MAAOA,cAAeA,YAAYrmC,cAAgBxlC,KAAO6rE,YAAc,MAO3El4C,wBAAwB3oC,UAAU+gF,yBAKlC,SAAUr4E,SAAUs4E,cAChB,GAAqBC,UAAWxhF,KAAK6gF,qBAAqB53E,SAAS7C,KAAKkB,UACnEi6E,gBACDA,aAAevhF,KAAK4gF,0BAA0BY,UAIlD,IAAqB3nC,UAAWrmB,YAAYC,MAAyBxqB,SAAkB,UAAG,GAAGyzE,6BAExE3iC,QAAU/5C,KAAKwtD,YAAY/5B,MAAMomB,SADnB,GAEnC,OAAOQ,0BAAyB55C,QAC5B65C,QAAQ,EACRl0C,MAAQkB,UAAWk6E,SAAUv1D,UAAYzD,mBACzCqxB,SAAU,GAAIF,0BACVC,cAAezR,kBAAkBoI,KACjCsJ,SAAUA,SACVC,YAR2B,GAS3BC,QAASA,QACTN,UACAC,aACAQ,sBACAD,cACA9wC,UAAU,EACV6wC,uBACAG,cAAe,KACf7R,qBAAqB,IAEzB7T,SAAU,KACVkc,gBAAiBH,wBAAwBE,QACzC+G,UACAC,WACA7V,QACA7Y,aAAa,EACbmH,SAAU,IACV/H,aACAgB,iBACAkB,WACAkwB,UACA3wB,eACA4wB,kBAAmB8mC,aACnB7mC,cAAkCpxC,GAAI,WAAYswC,cAAezR,kBAAkBoI,KAAMkJ,UAAY1J,SACrGjjB,mBACAG,iBAAkB,QAS1Bic,wBAAwB3oC,UAAUkhF,sBAMlC,SAAUz4E,aAAcsnD,cAAeoxB,QACnC,GAAI39C,OAAQ/jC,IACZ,IAAIA,KAAK6/E,gBAAgB7rD,IAAIs8B,eACzB,MAAO,KAEXA,eAAgBnqD,kBAAkBmqD,cAClC,IAAIl3C,IAAwBpZ,KAAK2hF,kCAAkCrxB,eAAkBsxB,WAAaxoE,GAAGwoE,WAAYjjD,SAAWvlB,GAAGulB,SAC1GkjD,wBAA0B,SAAUC,kBACrD,GAAqBC,mBAAoB,GAAI1nC,2BACzCC,QAAQ,EACRl0C,KAAMu4B,SAASv4B,KACf4iB,YAAa2V,SAAS3V,YACtBmH,SAAUwO,SAASxO,SACnBsE,SAAUkK,SAASlK,SACnBkc,gBAAiBhS,SAASgS,gBAC1B8G,OAAQ9Y,SAAS8Y,OACjBC,QAAS/Y,SAAS+Y,QAClB6C,cAAe5b,SAAS4b,cACxBnC,eAAgBzZ,SAASyZ,eACzBjd,eAAgBwD,SAASxD,eACzB/S,UAAWuW,SAASvW,UACpBgB,cAAeuV,SAASvV,cACxBkB,QAASqU,SAASrU,QAClBkwB,OAAQ7b,SAAS6b,OACjB3wB,YAAa8U,SAAS9U,YACtBiD,gBAAiB6R,SAAS7R,gBAC1B2tB,kBAAmB9b,SAAS8b,kBAC5BC,aAAc/b,SAAS+b,aACvBztB,iBAAkB0R,SAAS1R,iBAC3B4sB,SAAUioC,kBAOd,OALIA,mBACA/9C,MAAMm9C,qBAAwCviD,SAA0B,iBAAGmjD,iBAAiB5nC,oBAEhGnW,MAAM87C,gBAAgBr/D,IAAI8vC,cAAeyxB,mBACzCh+C,MAAM+7C,cAAct/D,IAAI8vC,cAAeyxB,kBAAkB3nC,aAClD,KAEX,IAAIzb,SAAS3V,YAAa,CACtB,GAAqB6wB,UAA8Blb,SAAkB,SAChDz1B,aAAelJ,KAAKy/E,qBAAqBxxB,mBAC1DjlD,aAAcA,aACduzC,cAAe+T,cACf96C,UAAWxV,KAAK8vD,WAAWkyB,mBAAmB1xB,cAAesxB,YAC7DhoC,cAAeC,SAASD,cACxBC,SAAUA,SAASA,SACnBC,YAAaD,SAASC,YACtBL,OAAQI,SAASJ,OACjBC,UAAWG,SAASH,UACpBO,WAAYJ,SAASI,WACrBE,cAAeN,SAASM,cACxB7R,oBAAqBuR,SAASvR,qBAElC,OAAIhiC,WAAU4C,eAAiBw4E,QAC3B1hF,KAAKm3D,aAAazyC,2BAA2B4rC,eAAgBA,eACtD,MAEJ3a,UAAUpvC,KAAK2C,aAAc24E,yBAKpC,MADAA,yBAAwB,MACjB,MAOf34C,wBAAwB3oC,UAAUohF,kCAIlC,SAAUrxB,eACN,GAAIvsB,OAAQ/jC,IAEZ,MADAswD,cAAgBnqD,kBAAkBmqD,gBAE9B,MAAO,KAEX,IAAqB2xB,YAAajiF,KAAK4/E,6BAA6Br/D,IAAI+vC,cACxE,IAAI2xB,WACA,MAAOA,WAEX,IAAqB9B,SAAUngF,KAAKq/E,mBAAmBnzE,QAAQokD,eAAe,EAC9E,KAAK6vB,QACD,MAAO,KAEX,IAAqB+B,mCAAiD,EACtE,IAAIpzE,gBAAgB3M,SAASg+E,SAAU,CAEnC,GAAqBl3E,UAA4B,OACjD6B,sBAAqB,SAAU7B,SAASwwC,QACxC3uC,qBAAqB,YAAa7B,SAASywC,WAC3C1uC,2BAA2B,gBAAiB/B,SAASkxC,cACrD,IAAqBF,YAAahxC,SAASgxC,UAC3CioC,+BAAgC,GAAIvoC,0BAChCC,cAAez1C,YAAY8E,SAAS2wC,eACpCC,SAAU11C,YAAY8E,SAAS4wC,UAC/BC,YAAa31C,YAAY8E,SAAS6wC,aAClCC,QAAS,KACTN,OAAQxwC,SAASwwC,WACjBC,UAAWzwC,SAASywC,cACpBO,WAAYA,eACZE,cAAeh2C,YAAY8E,SAASkxC,eACpChxC,WAAYF,SAAS4wC,SACrBG,uBACAE,sBACA5R,oBAAqBnkC,YAAYg8E,QAAQ73C,uBAGjD,GAAqB65C,yBAA2C,KAC3C/4D,iBACAg5D,0BACAjyD,SAAWgwD,QAAQhwD,QACxC,IAAIrhB,gBAAgB3M,SAASg+E,SAAU,CAEnC,GAAqBl3E,UAA4B,OACjDk5E,yBAA6Cl5E,SAAyB,gBAClEA,SAASmgB,gBACTA,cAAgBppB,KAAKqiF,sBAAsBp5E,SAASmgB,cAAeg5D,uBAAwB,sBAAyB39D,cAAc6rC,eAAiB,OAAUA,gBAE7JrnD,SAAS6jB,kBACTs1D,uBAAyBj+D,sBAAsBlb,SAAS6jB,iBACnDlnB,IAAI,SAAUQ,MAAQ,MAAS29B,OAAMu+C,2BAA2Bl8E,QAChEwC,OAAOw5E,yBAEXjyD,WACDA,SAAWnwB,KAAKw/E,gBAAgB+C,sCAK/BpyD,YACDnwB,KAAKm3D,aAAa/yD,YAAY,aAAeqgB,cAAc6rC,eAAiB,oCAAqCA,eACjHngC,SAAW,QAGnB,IAAqB/H,aACI,OAArB+3D,QAAQ/3D,YACRA,UAAYpoB,KAAKqiF,sBAAsBlC,QAAQ/3D,UAAWg6D,uBAAwB,kBAAqB39D,cAAc6rC,eAAiB,OAAUA,eAEpJ,IAAqBhmC,YACAT,cACE,OAAnBs2D,QAAQ71D,UACRA,QAAUtqB,KAAKwiF,oBAAoBrC,QAAQ71D,SAAS,EAAOgmC,eAC3DzmC,YAAc7pB,KAAKwiF,oBAAoBrC,QAAQ71D,SAAS,EAAMgmC,eAElE,IAAqB3xB,UAAW0b,yBAAyB55C,QACrD65C,QAAQ,EACRnqB,SAAUA,SACVsE,SAAUtwB,YAAYg8E,QAAQ1rD,UAC9BzL,cAAek5D,8BACf97E,KAAMpG,KAAKyiF,iBAAiBnyB,eAC5BzW,SAAUqoC,8BACVvxC,gBAAiBwxC,wBACjB1qC,OAAQ0oC,QAAQ1oC,WAChBC,QAASyoC,QAAQzoC,YACjB7V,KAAMs+C,QAAQt+C,SACdzZ,UAAWA,cACXgB,cAAeA,kBACfkB,QAASA,YACTkwB,OAAQ2lC,QAAQ3lC,WAChB3wB,YAAaA,gBACbiD,gBAAiBs1D,uBACjB3nC,kBAAmBynC,8BAAgCliF,KAAK2gF,sBAAsBrwB,eAC1E,KACJ5V,aAAcwnC,8BAAgCliF,KAAK+gF,gBAAgBzwB,eAAiB,KACpFrjC,iBAAkB,MAQtB,OANIi1D,iCACAvjD,SAAS1R,iBACLjtB,KAAKghF,oBAAoB7wD,SAAUmgC,cAAe3xB,SAAS8Y,OAAQ9Y,SAAS+Y,UAEpFuqC,YAAetjD,SAAUA,SAAUijD,WAAYzB,SAC/CngF,KAAK4/E,6BAA6Bp/D,IAAI8vC,cAAe2xB,YAC9CA,YAYX/4C,wBAAwB3oC,UAAUmiF,qBAMlC,SAAUpyB,eACN,GAAqB6vB,SAA6BngF,KAAK6/E,gBAAgBt/D,IAAI+vC,cAI3E,OAHK6vB,UACDngF,KAAKm3D,aAAa/yD,YAAY,8IAAgJqgB,cAAc6rC,eAAiB,KAAMA,eAEhN6vB,SAMXj3C,wBAAwB3oC,UAAUoiF,oBAIlC,SAAUjC,SACN,GAAqBkC,YAA+B5iF,KAAKmhF,aAAaT,QAASpnC,mBAAmBz4C,UAIlG,OAHK+hF,aACD5iF,KAAKm3D,aAAa/yD,YAAY,2DAA6DqgB,cAAci8D,SAAW,KAAMA,SAEvHkC,YAMX15C,wBAAwB3oC,UAAUijC,YAIlC,SAAUp9B,MACN,QAASpG,KAAKmhF,aAAa/6E,KAAMkzC,mBAAmBz4C,YAChDb,KAAKq/E,mBAAmB77C,YAAYp9B,OAM5C8iC,wBAAwB3oC,UAAUkjC,OAIlC,SAAUr9B,MACN,QAASpG,KAAKmhF,aAAa/6E,KAAMkzC,mBAAmBv4C,OAChDf,KAAKs/E,cAAc77C,OAAOr9B,OAMlC8iC,wBAAwB3oC,UAAUmjC,WAIlC,SAAUt9B,MACN,QAASpG,KAAKmhF,aAAa/6E,KAAMkzC,mBAAmBl4C,WAChDpB,KAAKo/E,kBAAkB17C,WAAWt9B,OAO1C8iC,wBAAwB3oC,UAAUsiF,mBAKlC,SAAUC,WAAYC,uBACQ,KAAtBA,oBAAgCA,kBAAoB,KACxD,IAAqBC,eAAkChjF,KAAKmhF,aAAa2B,WAAYxpC,mBAAmBl4C,SACxG,KAAK4hF,cAAe,CAChB,GAAqBt5E,YAAa1J,KAAK2jC,oBAAoBm/C,YAAY,EAAOC,kBAC9EC,eAAgBt5E,WAAaA,WAAW0wC,YAAc,KAClD4oC,eACAhjF,KAAK8/E,cAAct/D,IAAIsiE,WAAYE,eAG3C,MAAOA,gBAYX95C,wBAAwB3oC,UAAU0iF,qCAOlC,SAAUH,WAAYpB,OAAQzxB,iBAC1B,GAAIlsB,OAAQ/jC,SACY,KAApBiwD,kBAA8BA,iBAAkB,EACpD,IAAqBptB,UAAW7iC,KAAK2jC,oBAAoBm/C,WAAY7yB,iBAChDizB,UAUrB,OATIrgD,YACAA,SAASyB,mBAAmBz9B,QAAQ,SAAUyC,IAC1C,GAAqB65E,SAAUp/C,MAAM09C,sBAAsBqB,WAAYx5E,GAAGhC,UAAWo6E,OACjFyB,UACAD,QAAQn8E,KAAKo8E,WAGrBtgD,SAAS0B,cAAc19B,QAAQ,SAAUyC,IAAM,MAAOy6B,OAAMq/C,kBAAkB95E,GAAGhC,cAE9E0uC,QAAQF,IAAIotC,UAQvBh6C,wBAAwB3oC,UAAUojC,oBAMlC,SAAUm/C,WAAY7yB,gBAAiB8yB,mBACnC,GAAIh/C,OAAQ/jC,SACY,KAApBiwD,kBAA8BA,iBAAkB,OAC1B,KAAtB8yB,oBAAgCA,kBAAoB,MACxDD,WAAa38E,kBAAkB28E,WAC/B,IAAqBO,aAAcrjF,KAAKggF,eAAez/D,IAAIuiE,WAC3D,IAAIO,YACA,MAAOA,YAEX,IAAqBh6E,MAAOrJ,KAAKo/E,kBAAkBlzE,QAAQ42E,WAAY7yB,gBACvE,KAAK5mD,KACD,MAAO,KAEX,IAAqBi7B,uBACAg/C,gCACA/+C,iBACA8W,mBACAC,mBACAlzB,aACA0E,mBACAsuB,uBACAG,UACjBlyC,MAAKk6E,SACLp/D,sBAAsB9a,KAAKk6E,SAAS18E,QAAQ,SAAU28E,cAClD,GAAqBC,wBAAsC,EAC3D,IAAIr/D,YAAYo/D,cACZC,mBAAqBD,iBAEpB,IAAIA,cAAgBA,aAAa3gD,SAAU,CAC5C,GAAqB6gD,qBAAsBF,YAC3CC,oBAAqBC,oBAAoB7gD,SACrC6gD,oBAAoBt7D,WACpBA,UAAUrhB,KAAK/E,MAAMomB,UAAW2b,MAAMs+C,sBAAsBqB,oBAAoBt7D,UAAW0E,gBAAiB,8BAAgCrI,cAAcg/D,oBAAsB,OAASD,eAGjM,IAAIC,mBAoBA,WADA1/C,OAAMozB,aAAa/yD,YAAY,qBAAuBqgB,cAAc++D,cAAgB,6BAA+B/+D,cAAcq+D,YAAc,KAAMA,WAlBrJ,KAAI/+C,MAAM4/C,iBAAiBb,WAAYW,oBAAvC,CAIA,GAFKV,oBACDA,kBAAoB,GAAI7+D,MACxB6+D,kBAAkB/uD,IAAIyvD,oBAEtB,WADA1/C,OAAMozB,aAAa/yD,YAAY2/B,MAAM6/C,mBAAmBH,oBAAsB,KAAOh/D,cAAc++D,cAAgB,4CAA8C/+D,cAAcq+D,YAAc,MAAOA,WAGxMC,mBAAkBxmD,IAAIknD,mBACtB,IAAqBI,uBAAwB9/C,MAAM8+C,mBAAmBY,mBAAoBV,kBAE1F,IADAA,kBAAkBvmD,OAAOinD,qBACpBI,sBAED,WADA9/C,OAAMozB,aAAa/yD,YAAY,cAAgB2/B,MAAM6/C,mBAAmBJ,cAAgB,KAAO/+D,cAAc++D,cAAgB,6BAA+B/+D,cAAcq+D,YAAc,yCAA0CA,WAGtOznC,iBAAgBt0C,KAAK88E,0BAQ7Bx6E,KAAK3J,SACLykB,sBAAsB9a,KAAK3J,SAASmH,QAAQ,SAAUi9E,cAClD,IAAK1/D,YAAY0/D,cAEb,WADA//C,OAAMozB,aAAa/yD,YAAY,qBAAuBqgB,cAAcq/D,cAAgB,6BAA+Br/D,cAAcq+D,YAAc,KAAMA,WAKzJ,IAFKC,oBACDA,kBAAoB,GAAI7+D,MACxB6+D,kBAAkB/uD,IAAI8vD,cAEtB,WADA//C,OAAMozB,aAAa/yD,YAAY2/B,MAAM6/C,mBAAmBE,cAAgB,KAAOp+E,UAAUo+E,cAAgB,4CAA8Cr/D,cAAcq+D,YAAc,KAAMA,WAG7LC,mBAAkBxmD,IAAIunD,aACtB,IAAqBC,uBAAwBhgD,MAAM8+C,mBAAmBiB,aAAcf,kBACpFA,mBAAkBvmD,OAAOsnD,cACrBC,sBACAzoC,gBAAgBv0C,KAAKg9E,uBAGrBT,6BAA6Bv8E,KAAKg9B,MAAMigD,uBAAuBF,gBAM3E,IAAqBnmD,kBAAmB39B,KAAKikF,+BAA+B5oC,gBAAiBC,gBACzFjyC,MAAK66E,cACL//D,sBAAsB9a,KAAK66E,cAAcr9E,QAAQ,SAAUs9E,cACvD,IAAK//D,YAAY+/D,cAEb,WADApgD,OAAMozB,aAAa/yD,YAAY,qBAAuBqgB,cAAc0/D,cAAgB,6BAA+B1/D,cAAcq+D,YAAc,KAAMA,WAGzJ,IAAqBsB,oBAAqBrgD,MAAMigD,uBAAuBG,aACvE,IAAIpgD,MAAMP,YAAY2gD,cAClBxmD,iBAAiBqe,aAAaooC,oBAC9B9/C,mBAAmBv9B,KAAKq9E,oBACxBrgD,MAAMsgD,iBAAiBF,aAAcrB,gBAEpC,CAAA,IAAI/+C,MAAMN,OAAO0gD,cAQlB,WADApgD,OAAMozB,aAAa/yD,YAAY,cAAgB2/B,MAAM6/C,mBAAmBO,cAAgB,KAAO1/D,cAAc0/D,cAAgB,6BAA+B1/D,cAAcq+D,YAAc,2DAA4DA,WANpPnlD,kBAAiBue,QAAQkoC,oBACzBzmD,iBAAiBqF,MAAMj8B,KAAKq9E,oBAC5B7/C,cAAcx9B,KAAKq9E,oBACnBrgD,MAAMsgD,iBAAiBF,aAAcrB,cAQjD,IAAqB5nC,uBACAC,gBAwDrB,OAvDAmoC,8BAA6Bz8E,QAAQ,SAAUy9E,YAC3C,GAAI3mD,iBAAiB8d,cAAcznB,IAAIswD,WAAWh9E,WAC9C4zC,mBAAmBn0C,KAAKu9E,YACxB3mD,iBAAiBse,qBAAqBqoC,gBAErC,CAAA,IAAI3mD,iBAAiBge,SAAS3nB,IAAIswD,WAAWh9E,WAM9C,WADAy8B,OAAMozB,aAAa/yD,YAAY,gBAAkB2/B,MAAM6/C,mBAAmBU,WAAWh9E,WAAa,IAAMmd,cAAc6/D,WAAWh9E,WAAa,SAAWmd,cAAcq+D,YAAc,6CAA8CA,WAJnO3nC,eAAcp0C,KAAKu9E,YACnB3mD,iBAAiBwe,gBAAgBmoC,eASrCj7E,KAAK+e,WACLA,UAAUrhB,KAAK/E,MAAMomB,UAAWpoB,KAAKqiF,sBAAsBh5E,KAAK+e,UAAW0E,gBAAiB,8BAAgCrI,cAAcq+D,YAAc,OAASA,aAEjKz5E,KAAKyjB,iBACLA,gBAAgB/lB,KAAK/E,MAAM8qB,gBAAiB3I,sBAAsB9a,KAAKyjB,iBAClElnB,IAAI,SAAUQ,MAAQ,MAAS29B,OAAMu+C,2BAA2Bl8E,SAErEiD,KAAKk7E,WACLpgE,sBAAsB9a,KAAKk7E,WAAW19E,QAAQ,SAAUT,MACpD,IAAKge,YAAYhe,MAEb,WADA29B,OAAMozB,aAAa/yD,YAAY,qBAAuBqgB,cAAcre,MAAQ,+CAAiDqe,cAAcq+D,YAAc,KAAMA,WAGnK1nC,qBAAoBr0C,KAAKg9B,MAAMigD,uBAAuB59E,SAG9D0mB,gBAAgB/lB,KAAK/E,MAAM8qB,gBAAiBsuB,oBAAoBx1C,IAAI,SAAUQ,MAAQ,MAAS29B,OAAMu+C,2BAA2Bl8E,KAAKkB,cACjI+B,KAAKkyC,SACLA,QAAQx0C,KAAK/E,MAAMu5C,QAASp3B,sBAAsB9a,KAAKkyC,UAE3D8nC,YAAc,GAAIpoC,0BACd70C,KAAMpG,KAAKyiF,iBAAiBK,YAC5B16D,UAAWA,UACX0E,gBAAiBA,gBACjBsuB,oBAAqBA,oBACrBG,QAASA,QACTjX,mBAAoBA,mBACpB4W,mBAAoBA,mBACpB3W,cAAeA,cACf4W,cAAeA,cACfE,gBAAiBA,gBACjBC,gBAAiBA,gBACjB3d,iBAAkBA,iBAClBr0B,GAAID,KAAKC,IAAM,OAEnBwjB,gBAAgBjmB,QAAQ,SAAUyC,IAAM,MAAOq0B,kBAAiB0e,kBAAkB/yC,MAClF8e,UAAUvhB,QAAQ,SAAU8gB,UAAY,MAAOgW,kBAAiBoe,YAAYp0B,SAA2B,YAAgBvhB,QACvHu3B,iBAAiBye,UAAUinC,YAAYj9E,MACvCpG,KAAKggF,eAAex/D,IAAIsiE,WAAYO,aAC7BA,aAOXn6C,wBAAwB3oC,UAAUojF,iBAKlC,SAAUb,WAAYW,oBAClB,MAAIX,cAAeW,qBACfzjF,KAAKm3D,aAAa/yD,YAAY,IAAMqgB,cAAcq+D,YAAc,gCAAiCA,aAC1F,IAQf55C,wBAAwB3oC,UAAUqjF,mBAIlC,SAAUx9E,MACN,GAAIge,YAAYhe,MAAO,CACnB,GAAIpG,KAAKwjC,YAAYp9B,MACjB,MAAO,WAEX,IAAIpG,KAAKyjC,OAAOr9B,MACZ,MAAO,MAEX,IAAIpG,KAAK0jC,WAAWt9B,MAChB,MAAO,SAGf,MAAI,MAA0Bo+E,QACnB,WAEJ,SAOXt7C,wBAAwB3oC,UAAU8jF,iBAKlC,SAAUj+E,KAAM08E,YACZ,GAAqB2B,WAAYzkF,KAAKigF,iBAAiB1/D,IAAIna,KAC3D,IAAIq+E,WAAaA,YAAc3B,WAI3B,WAHA9iF,MAAKm3D,aAAa/yD,YAAY,QAAUqgB,cAAcre,MAAQ,8CAAgDqe,cAAcggE,WAAa,QAAUhgE,cAAcq+D,YAAc,4BAC9Ir+D,cAAcre,MAAQ,oCAAsCqe,cAAcggE,WAAa,QAAUhgE,cAAcq+D,YAAc,kEACvFr+D,cAAcre,MAAQ,iCAAmCqe,cAAcggE,WAAa,QAAUhgE,cAAcq+D,YAAc,KAAOA,WAG5M9iF,MAAKigF,iBAAiBz/D,IAAIpa,KAAM08E,aAOpC55C,wBAAwB3oC,UAAU0jF,+BAKlC,SAAU5oC,gBAAiBC,iBAEvB,GAAqB50C,QAAS,GAAI80C,mCACbkpC,eAAiB,GAAI77D,IA8B1C,OA7BAwyB,iBAAgBzyC,OAAO0yC,iBAAiBz0C,QAAQ,SAAU89E,YACtDA,WAAW7hD,QAAQj8B,QAAQ,SAAU+9E,KAAO,MAAOl+E,QAAO01C,UAAUwoC,OACpED,WAAW73D,gBAAgBjmB,QAAQ,SAAU2qD,MAAQ,MAAO9qD,QAAO21C,kBAAkBmV,OACrF,IAAqBqzB,aAAc,GAAI3gE,IACvCygE,YAAWv8D,UAAUvhB,QAAQ,SAAU6Y,OACnC,GAAqBolE,UAAW18E,eAAesX,MAAMiI,SAAShiB,OACzCo/E,YAAcL,eAAenkE,IAAIukE,SACjDC,eACDA,YAAc,GAAI7gE,KAClBwgE,eAAelkE,IAAIskE,SAAUC,aAEjC,IAAqBC,WAAYtlE,MAAM/f,OAAO2H,WAG1Cu9E,YAAY7wD,IAAI8wD,WAAcC,YAAY/wD,IAAIgxD,aAC9CD,YAAYxoD,IAAIyoD,WAChBH,YAAYtoD,IAAIuoD,UAChBp+E,OAAOq1C,YAAYr8B,MAAMiI,SAAUjI,MAAM/f,aAIrD27C,gBAAgBz0C,QAAQ,SAAU89E,YAC9BA,WAAWzpC,mBAAmBr0C,QAAQ,SAAUyC,IAAM,MAAO5C,QAAOu1C,qBAAqB3yC,MACzFq7E,WAAWxpC,cAAct0C,QAAQ,SAAUyC,IAAM,MAAO5C,QAAOy1C,gBAAgB7yC,QAEnF+xC,gBAAgBx0C,QAAQ,SAAU89E,YAC9BA,WAAWzpC,mBAAmBr0C,QAAQ,SAAUyC,IAAM,MAAO5C,QAAOs1C,aAAa1yC,MACjFq7E,WAAWxpC,cAAct0C,QAAQ,SAAUyC,IAAM,MAAO5C,QAAOw1C,QAAQ5yC,QAEpE5C,QAMXwiC,wBAAwB3oC,UAAUyjF,uBAIlC,SAAU59E,MAEN,MADAA,MAAOD,kBAAkBC,OAChBkB,UAAWlB,OAMxB8iC,wBAAwB3oC,UAAUqjC,aAIlC,SAAUx9B,MAEN,MADmCpG,MAAK8vD,WAAWE,YAAY5pD,MAC5CorB,KAAK,SAAUyzD,KAAO,MAAOxzC,kBAAiBtvC,SAAS8iF,QAM9E/7C,wBAAwB3oC,UAAU2kF,qBAIlC,SAAU9+E,MACN,OACI20C,YAAazB,mBAAmBC,WAChCnzC,KAAMpG,KAAKyiF,iBAAiBr8E,KAAM,MAAM,KAQhD8iC,wBAAwB3oC,UAAU4kF,uBAKlC,SAAU/+E,KAAMi7B,kBACS,KAAjBA,eAA2BA,aAAe,KAC9C,IAAqB+/C,aAAcphF,KAAKmhF,aAAa/6E,KAAMkzC,mBAAmBC,WAC9E,OAAI6nC,aACOA,YAAYh7E,KAEhBpG,KAAKyiF,iBAAiBr8E,KAAMi7B,eAQvC6H,wBAAwB3oC,UAAUkiF,iBAMlC,SAAUr8E,KAAMi7B,aAAc+jD,wBACL,KAAjB/jD,eAA2BA,aAAe,UACnB,KAAvB+jD,qBAAiCA,oBAAqB,EAC1D,IAAqB39E,YAAazH,KAAKgkF,uBAAuB59E,KAC9D,QACIkB,UAAWG,WAAWH,UACtB2kB,OAAQjsB,KAAKqlF,yBAAyB59E,WAAWH,UAAW+5B,aAAc+jD,oBAC1E58D,eAAgBxF,qBAAqBhjB,KAAK8vD,WAAYroD,WAAWH,aAQzE4hC,wBAAwB3oC,UAAU+kF,oBAKlC,SAAU7lF,QAAS4hC,cAGf,WAFqB,KAAjBA,eAA2BA,aAAe,MAC9C5hC,QAAU0G,kBAAkB1G,UACnB6H,UAAW7H,QAASwsB,OAAQjsB,KAAKqlF,yBAAyB5lF,QAAS4hC,gBAYhF6H,wBAAwB3oC,UAAUglF,gBAMlC,SAAUC,UACN,GAAqBC,UAAWzlF,KAAK+/E,WAAWx/D,IAAIilE,SAIpD,OAHKC,WACDzlF,KAAKm3D,aAAa/yD,YAAY,oIAAsIqgB,cAAc+gE,UAAY,KAAMA,UAEjMC,UAAY,MAMvBv8C,wBAAwB3oC,UAAUmlF,eAIlC,SAAUF,UACN,GAAqBG,aAAgC3lF,KAAKmhF,aAAaqE,SAAUlsC,mBAAmBv4C,KAIpG,OAHK4kF,cACD3lF,KAAKm3D,aAAa/yD,YAAY,sDAAwDqgB,cAAc+gE,UAAY,KAAMA,UAEnHG,aAMXz8C,wBAAwB3oC,UAAUqlF,sBAIlC,SAAUJ,UACN,GAAqBC,UAAWzlF,KAAK+/E,WAAWx/D,IAAIilE,SAIpD,OAHKC,YACDA,SAAWzlF,KAAKojF,kBAAkBoC,WAE/BC,UAMXv8C,wBAAwB3oC,UAAU6iF,kBAIlC,SAAUoC,UACNA,SAAWr/E,kBAAkBq/E,SAC7B,IAAqBK,gBAAoC7lF,KAAKs/E,cAAcpzE,QAAQs5E,UAC/DC,SAAW,GAAIzqC,sBAChC50C,KAAMpG,KAAKyiF,iBAAiB+C,UAC5B/jF,KAAMokF,eAAepkF,KACrBovC,OAAQg1C,eAAeh1C,MAI3B,OAFA7wC,MAAK+/E,WAAWv/D,IAAIglE,SAAUC,UAC9BzlF,KAAK8/E,cAAct/D,IAAIglE,SAAUC,SAASrrC,aACnCqrC,UAQXv8C,wBAAwB3oC,UAAU8kF,yBAMlC,SAAUS,WAAYzkD,aAAc+jD,oBAChC,GAAIrhD,OAAQ/jC,SACe,KAAvBolF,qBAAiCA,oBAAqB,EAC1D,IAAqBW,iBAAiB,EACjB1+D,OAASga,cAAgBrhC,KAAK8vD,WAAWk2B,WAAWF,gBACpDG,qBAAuB5+D,OAAOzhB,IAAI,SAAUolC,OAC7D,GAAqB1X,cAAc,EACdgnB,QAAS,EACT4rC,QAAS,EACTx5D,YAAa,EACbC,YAAa,EACbhnB,MAAQ,IAiC7B,OAhCIlC,OAAMC,QAAQsnC,OACdA,MAAMnkC,QAAQ,SAAUs/E,YAChBv0C,WAAWzvC,SAASgkF,YACpB7rC,QAAS,EAEJ5I,WAAWvvC,SAASgkF,YACzBD,QAAS,EAEJv0C,eAAexvC,SAASgkF,YAC7Bz5D,YAAa,EAER8kB,eAAervC,SAASgkF,YAC7Bx5D,YAAa,EAERijB,gBAAgBztC,SAASgkF,aAC9B7yD,aAAc,EACd3tB,MAAQwgF,WAAWt2C,eAEdL,aAAartC,SAASgkF,YAC3BxgF,MAAQwgF,WAAWxgF,MAEd8pC,qBAAqBttC,SAASgkF,aAAeA,qBAAsB3+E,cACxE7B,MAAQwgF,WAEH/hE,YAAY+hE,aAAwB,MAATxgF,QAChCA,MAAQwgF,cAKhBxgF,MAAQqlC,MAEC,MAATrlC,OACAogF,gBAAiB,EACO,OAGxBzyD,YAAaA,YACbgnB,OAAQA,OACR4rC,OAAQA,OACRx5D,WAAYA,WACZC,WAAYA,WACZhnB,MAAOo+B,MAAMqiD,kBAAkBzgF,SAGvC,IAAIogF,eAAgB,CAChB,GAAqBM,YAAaJ,qBAAqBrgF,IAAI,SAAU2lB,KAAO,MAAOA,KAAM9G,cAAc8G,IAAI5lB,OAAS,MAAQE,KAAK,MAC5GqL,QAAU,oCAAsCuT,cAAcqhE,YAAc,MAAQO,WAAa,IAClHjB,qBAAsBplF,KAAKytD,QAAQllB,0BACnCvoC,KAAKm3D,aAAa/yD,YAAY8M,SAAU40E,YAGxC9lF,KAAKu5E,SAASxJ,KAAK,YAAc7+D,QAAU,8CAGnD,MAAO+0E,uBAMX/8C,wBAAwB3oC,UAAU6lF,kBAIlC,SAAUzgF,OACNA,MAAQQ,kBAAkBR,MAQ1B,OANqB,gBAAVA,QACUrC,MAAOqC,QAGP8B,YAAcH,UAAW3B,SAYlDujC,wBAAwB3oC,UAAU8hF,sBAQlC,SAAUj6D,UAAWk+D,sBAAuBC,UAAWC,iBAAkBpgF,MACrE,GAAI29B,OAAQ/jC,IA8CZ,YA7CyB,KAArBwmF,mBAA+BA,qBACnCp+D,UAAUvhB,QAAQ,SAAU8gB,SAAU8+D,aAClC,GAAIhjF,MAAMC,QAAQikB,UACdoc,MAAMs+C,sBAAsB16D,SAAU2+D,sBAAuBC,UAAWC,sBAEvE,CACD7+D,SAAWxhB,kBAAkBwhB,SAC7B,IAAqB2E,kBAAgC,EACrD,IAAI3E,UAAgC,gBAAbA,WAAyBA,SAASthB,eAAe,WACpE09B,MAAM2iD,kBAAkB/+D,UACxB2E,aAAe,GAAIkwB,cAAa70B,SAAS68D,QAAS78D,cAEjD,CAAA,IAAIvD,YAAYuD,UAGhB,CAAA,OAAiB,KAAbA,SAEL,WADAoc,OAAMozB,aAAa/yD,YAAY;0MAI/B,IAAqBuiF,eAAmCv+D,UAAU5f,OAAO,SAAUo+E,MAAOC,aAAcC,iBAUpG,MATIA,iBAAkBL,YAClBG,MAAM7/E,KAAK,GAAK0d,cAAcoiE,eAEzBC,iBAAmBL,YACxBG,MAAM7/E,KAAK,IAAM0d,cAAcoiE,cAAgB,KAE1CC,iBAAmBL,YAAc,GACtCG,MAAM7/E,KAAK,OAER6/E,WAEN/gF,KAAK,KAEV,YADAk+B,OAAMozB,aAAa/yD,YAAY,YAAcmiF,WAAwB,YAAc,6DAA+DI,cAAgB,KAAMvgF,MApBxKkmB,aAAe,GAAIkwB,cAAa70B,UAAYI,SAAUJ,WAuBtD2E,aAAa3mB,QACbo+B,MAAM+rB,WAAWltC,yBAAyBsK,YAAY+sD,8BACtDqM,sBAAsBv/E,KAAK/E,MAAMskF,sBAAuBviD,MAAMgjD,gCAAgCz6D,aAAclmB,OAG5GogF,iBAAiBz/E,KAAKg9B,MAAMijD,oBAAoB16D,kBAIrDk6D,kBAMXt9C,wBAAwB3oC,UAAUmmF,kBAIlC,SAAU/+D,UACFA,SAASthB,eAAe,aAAoC,MAArBshB,SAASI,UAChD/nB,KAAKm3D,aAAa/yD,YAAY,wBAA0BqgB,cAAckD,SAAS68D,SAAW,wBAA0B78D,SAASI,SAAW,gOAQhJmhB,wBAAwB3oC,UAAUwmF,gCAKlC,SAAUp/D,SAAUvhB,MAChB,GAAI29B,OAAQ/jC,KACSinF,cACAC,uBACrB,OAAIv/D,UAASK,YAAcL,SAASC,aAAeD,SAASI,UACxD/nB,KAAKm3D,aAAa/yD,YAAY,kEAAmEgC,UAGhGuhB,SAASM,OAId3D,mBAAmBqD,SAASE,SAAUq/D,sBACtCA,qBAAqBrgF,QAAQ,SAAUY,YACnC,GAAqBiY,OAAQqkB,MAAMu+C,2BAA2B76E,WAAWH,WAAW,EAChFoY,QACAunE,WAAWlgF,KAAK2Y,SAGjBunE,aAVHjnF,KAAKm3D,aAAa/yD,YAAY,wEAAyEgC,WAiB/G8iC,wBAAwB3oC,UAAU+hF,2BAKlC,SAAU5B,QAASzwB,qBACS,KAApBA,kBAA8BA,iBAAkB,EACpD,IAAqBkwB,SAAUngF,KAAK2hF,kCAAkCjB,QACtE,IAAIP,SAAWA,QAAQxhD,SAAS3V,YAC5B,OAASuzB,cAAemkC,QAASzzD,iBAAqCkzD,QAAQxhD,SAA0B,iBAE5G,IAAqBikD,YAA+B5iF,KAAKmhF,aAAaT,QAASpnC,mBAAmBz4C,UAClG,IAAI+hF,YAAcA,WAAW55D,YACzB,OAASuzB,cAAemkC,QAASzzD,iBAAqC21D,WAA4B,iBAEtG,IAAI3yB,gBACA,KAAM7rD,aAAYs8E,QAAQj/E,KAAO,yCAErC,OAAO,OAMXynC,wBAAwB3oC,UAAUymF,oBAIlC,SAAUr/D,UACN,GAAqBw/D,iBAA+B,GAC/BC,oBAAuC,KACvCC,uBAA0C,KAC1C1hF,MAAQ3F,KAAKomF,kBAAkBz+D,SAAShiB,MAa7D,OAZIgiB,UAASI,UACTq/D,oBAAsBpnF,KAAKmlF,uBAAuBx9D,SAASI,SAAUJ,SAAS0Z,cAC9E8lD,YAAcC,oBAAoBn7D,OAC9BtE,SAAShiB,QAAUgiB,SAASI,WAE5BpiB,OAAU8B,WAAY2/E,uBAGrBz/D,SAASK,aACdq/D,uBAAyBrnF,KAAKslF,oBAAoB39D,SAASK,WAAYL,SAAS0Z,cAChF8lD,YAAcE,uBAAuBp7D,SAGrCtmB,MAAOA,MACPoiB,SAAUq/D,oBACVv/D,SAAUF,SAASE,SACnBG,WAAYq/D,uBACZz/D,YAAaD,SAASC,YAAc5nB,KAAKomF,kBAAkBz+D,SAASC,iBAAe1jB,GACnF4jB,KAAMq/D,YACNl/D,MAAON,SAASM,QASxBihB,wBAAwB3oC,UAAUiiF,oBAMlC,SAAUl4D,QAAS2lB,YAAaqgB,eAC5B,GAAIvsB,OAAQ/jC,KACS+F,MAOrB,OANAvF,QAAOy2B,KAAK3M,SAASzjB,QAAQ,SAAUygF,cACnC,GAAqBx9D,OAAQQ,QAAQg9D,aACjCx9D,OAAMmmB,cAAgBA,aACtBlqC,IAAIgB,KAAKg9B,MAAMwjD,kBAAkBz9D,MAAOw9D,aAAch3B,kBAGvDvqD,KAMXmjC,wBAAwB3oC,UAAUinF,kBAIlC,SAAUr3D,UAAY,MAAOA,UAAS3mB,MAAM,YAO5C0/B,wBAAwB3oC,UAAUgnF,kBAMlC,SAAUE,EAAGH,aAAcxB,YACvB,GACqBv7D,WADjBwZ,MAAQ/jC,IAeZ,OAb0B,gBAAfynF,GAAEt3D,SACT5F,UACIvqB,KAAKwnF,kBAAkBC,EAAEt3D,UAAUvqB,IAAI,SAAU8hF,SAAW,MAAO3jD,OAAMqiD,kBAAkBsB,WAG1FD,EAAEt3D,SAKH5F,WAAavqB,KAAKomF,kBAAkBqB,EAAEt3D,YAJtCnwB,KAAKm3D,aAAa/yD,YAAY,8CAAgDkjF,aAAe,SAAa7iE,cAAcqhE,YAAc,+CAAgDA,YACtLv7D,eAOJA,UAAWA,UACXylB,MAAOy3C,EAAEz3C,MACTE,YAAau3C,EAAEv3C,YAAao3C,aAAcA,aAC1CK,KAAMF,EAAEE,KAAO3nF,KAAKomF,kBAAkBqB,EAAEE,MAAyB,OASzEz+C,wBAAwB3oC,UAAU42D,aAMlC,SAAU5yD,MAAO6B,KAAMwhF,WACnB,IAAI5nF,KAAK2/E,gBAOL,KAAMp7E,MANNvE,MAAK2/E,gBAAgBp7E,MAAO6B,MACxBwhF,WACA5nF,KAAK2/E,gBAAgBp7E,MAAOqjF,YAOjC1+C,2BAsDP1kB,uBAAwC,SAAU/Z,QAElD,QAAS+Z,0BACL,MAAkB,QAAX/Z,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,KAe/D,MAjBAC,WAAUukB,uBAAwB/Z,QASlC+Z,uBAAuBjkB,UAAUwD,WAKjC,SAAUT,MAAOihB,mBACbA,kBAAkBxd,MAAOO,UAAWhE,SAEjCkhB,wBACTkxB,kBAoCEmyC,cACAC,MAAO,EAEXD,cAAaA,aAAaC,OAAS,OAInC,IAAIh5D,QAAwB,WACxB,QAASzK,MAAK0jE,eACQ,KAAdA,YAAwBA,UAAY,MACxC/nF,KAAK+nF,UAAYA,UACZA,YACD/nF,KAAK+nF,cAYb,MALA1jE,MAAK9jB,UAAUynF,YAIf,SAAUC,UAAY,OAAkE,IAAxCjoF,KAAe,UAAEkD,QAAQ+kF,WAClE5jE,QAGP6jE,iBACAh0C,QAAS,EACTi0C,KAAM,EACN3iF,OAAQ,EACR4iF,IAAK,EACLp3E,OAAQ,EACRk7B,SAAU,EACVm8C,SAAU,EAEdH,iBAAgBA,gBAAgBh0C,SAAW,UAC3Cg0C,gBAAgBA,gBAAgBC,MAAQ,OACxCD,gBAAgBA,gBAAgB1iF,QAAU,SAC1C0iF,gBAAgBA,gBAAgBE,KAAO,MACvCF,gBAAgBA,gBAAgBl3E,QAAU,SAC1Ck3E,gBAAgBA,gBAAgBh8C,UAAY,WAC5Cg8C,gBAAgBA,gBAAgBG,UAAY,UAC5C,IAAIC,aAA6B,SAAU79E,QAEvC,QAAS69E,aAAY7mF,KAAMsmF,eACL,KAAdA,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAM+nF,YAAc/nF,IAE5C,OADA+jC,OAAMtiC,KAAOA,KACNsiC,MAeX,MApBA9jC,WAAUqoF,YAAa79E,QAYvB69E,YAAY/nF,UAAUwuB,UAKtB,SAAUxrB,QAASC,SACf,MAAOD,SAAQglF,kBAAkBvoF,KAAMwD,UAEpC8kF,aACTx5D,QACErI,eAAgC,SAAUhc,QAE1C,QAASgc,gBAAenjB,MAAOykF,eACT,KAAdA,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAM+nF,YAAc/nF,IAE5C,OADA+jC,OAAMzgC,MAAQA,MACPygC,MAeX,MApBA9jC,WAAUwmB,eAAgBhc,QAY1Bgc,eAAelmB,UAAUwuB,UAKzB,SAAUxrB,QAASC,SACf,MAAOD,SAAQilF,oBAAoBxoF,KAAMwD,UAEtCijB,gBACTqI,QACE4R,UAA2B,SAAUj2B,QAErC,QAASi2B,WAAU+nD,GAAIV,eACD,KAAdA,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAM+nF,YAAc/nF,IAE5C,OADA+jC,OAAM0kD,GAAKA,GACJ1kD,MAeX,MApBA9jC,WAAUygC,UAAWj2B,QAYrBi2B,UAAUngC,UAAUwuB,UAKpB,SAAUxrB,QAASC,SACf,MAAOD,SAAQmlF,eAAe1oF,KAAMwD,UAEjCk9B,WACT5R,QACE65D,QAAyB,SAAUl+E,QAEnC,QAASk+E,SAAQC,UAAWb,eACN,KAAdA,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAM+nF,YAAc/nF,IAE5C,OADA+jC,OAAM6kD,UAAYA,WAAa,KACxB7kD,MAaX,MAlBA9jC,WAAU0oF,QAASl+E,QAYnBk+E,QAAQpoF,UAAUwuB,UAKlB,SAAUxrB,QAASC,SAAW,MAAOD,SAAQslF,aAAa7oF,KAAMwD,UACzDmlF,SACT75D,QACElD,aAAe,GAAI08D,aAAYJ,gBAAgBh0C,SAC/C7nB,cAAgB,GAAIi8D,aAAYJ,gBAAgBG,UAChDS,UAAY,GAAIR,aAAYJ,gBAAgBC,MAU5CY,gBATW,GAAIT,aAAYJ,gBAAgBE,KAC7B,GAAIE,aAAYJ,gBAAgBl3E,QAChC,GAAIs3E,aAAYJ,gBAAgB1iF,QAC9B,GAAI8iF,aAAYJ,gBAAgBh8C,WAOhD88C,OAAQ,EACRC,UAAW,EACXC,UAAW,EACXC,aAAc,EACdC,MAAO,EACPC,KAAM,EACNC,OAAQ,EACRC,SAAU,EACVC,OAAQ,EACRC,IAAK,EACLC,GAAI,GACJC,MAAO,GACPC,YAAa,GACbC,OAAQ,GACRC,aAAc,IAElBf,gBAAeA,eAAeC,QAAU,SACxCD,eAAeA,eAAeE,WAAa,YAC3CF,eAAeA,eAAeG,WAAa,YAC3CH,eAAeA,eAAeI,cAAgB,eAC9CJ,eAAeA,eAAeK,OAAS,QACvCL,eAAeA,eAAeM,MAAQ,OACtCN,eAAeA,eAAeO,QAAU,SACxCP,eAAeA,eAAeQ,UAAY,WAC1CR,eAAeA,eAAeS,QAAU,SACxCT,eAAeA,eAAeU,KAAO,MACrCV,eAAeA,eAAeW,IAAM,KACpCX,eAAeA,eAAeY,OAAS,QACvCZ,eAAeA,eAAea,aAAe,cAC7Cb,eAAeA,eAAec,QAAU,SACxCd,eAAeA,eAAee,cAAgB,cAkC9C,IAAIj7D,YAA4B,WAC5B,QAASA,YAAWzoB,KAAM4D,YACtBhK,KAAKoG,KAAOA,MAAQ,KACpBpG,KAAKgK,WAAaA,YAAc,KA6TpC,MAtTA6kB,YAAWtuB,UAAUgvB,KAKrB,SAAU9tB,KAAMuI,YACZ,MAAO,IAAI+/E,cAAa/pF,KAAMyB,KAAM,KAAMuI,aAQ9C6kB,WAAWtuB,UAAU0T,IAMrB,SAAU7O,MAAOgB,KAAM4D,YACnB,MAAO,IAAIggF,aAAYhqF,KAAMoF,MAAOgB,KAAM4D,aAQ9C6kB,WAAWtuB,UAAU0pF,WAMrB,SAAUxoF,KAAM4lB,OAAQrd,YACpB,MAAO,IAAIkgF,kBAAiBlqF,KAAMyB,KAAM4lB,OAAQ,KAAMrd,aAO1D6kB,WAAWtuB,UAAU4rB,OAKrB,SAAU9E,OAAQrd,YACd,MAAO,IAAImgF,oBAAmBnqF,KAAMqnB,OAAQ,KAAMrd,aAQtD6kB,WAAWtuB,UAAU2rB,YAMrB,SAAU7E,OAAQjhB,KAAM4D,YACpB,MAAO,IAAIogF,iBAAgBpqF,KAAMqnB,OAAQjhB,KAAM4D,aAQnD6kB,WAAWtuB,UAAU8pF,YAMrB,SAAUC,SAAUC,UAAWvgF,YAE3B,WADkB,KAAdugF,YAAwBA,UAAY,MACjC,GAAIC,iBAAgBxqF,KAAMsqF,SAAUC,UAAW,KAAMvgF,aAOhE6kB,WAAWtuB,UAAUkqF,OAKrB,SAAUC,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeC,OAAQhpF,KAAM0qF,IAAK,KAAM1gF,aAO1E6kB,WAAWtuB,UAAUqqF,UAKrB,SAAUF,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeE,UAAWjpF,KAAM0qF,IAAK,KAAM1gF,aAO7E6kB,WAAWtuB,UAAUsqF,UAKrB,SAAUH,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeG,UAAWlpF,KAAM0qF,IAAK,KAAM1gF,aAO7E6kB,WAAWtuB,UAAUy3B,aAKrB,SAAU0yD,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeI,aAAcnpF,KAAM0qF,IAAK,KAAM1gF,aAOhF6kB,WAAWtuB,UAAUilD,MAKrB,SAAUklC,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeK,MAAOppF,KAAM0qF,IAAK,KAAM1gF,aAOzE6kB,WAAWtuB,UAAUuqF,KAKrB,SAAUJ,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeM,KAAMrpF,KAAM0qF,IAAK,KAAM1gF,aAOxE6kB,WAAWtuB,UAAUwgD,OAKrB,SAAU2pC,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeO,OAAQtpF,KAAM0qF,IAAK,KAAM1gF,aAO1E6kB,WAAWtuB,UAAUwqF,SAKrB,SAAUL,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeQ,SAAUvpF,KAAM0qF,IAAK,KAAM1gF,aAO5E6kB,WAAWtuB,UAAUyqF,OAKrB,SAAUN,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeS,OAAQxpF,KAAM0qF,IAAK,KAAM1gF,aAO1E6kB,WAAWtuB,UAAUm+C,IAKrB,SAAUgsC,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeU,IAAKzpF,KAAM0qF,IAAK,KAAM1gF,aAOvE6kB,WAAWtuB,UAAU6mD,GAKrB,SAAUsjC,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeW,GAAI1pF,KAAM0qF,IAAK,KAAM1gF,aAOtE6kB,WAAWtuB,UAAU0qF,MAKrB,SAAUP,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAeY,MAAO3pF,KAAM0qF,IAAK,KAAM1gF,aAOzE6kB,WAAWtuB,UAAU2qF,YAKrB,SAAUR,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAea,YAAa5pF,KAAM0qF,IAAK,KAAM1gF,aAO/E6kB,WAAWtuB,UAAU4qF,OAKrB,SAAUT,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAec,OAAQ7pF,KAAM0qF,IAAK,KAAM1gF,aAO1E6kB,WAAWtuB,UAAU6qF,aAKrB,SAAUV,IAAK1gF,YACX,MAAO,IAAI2gF,oBAAmB5B,eAAee,aAAc9pF,KAAM0qF,IAAK,KAAM1gF,aAMhF6kB,WAAWtuB,UAAU8qF,QAIrB,SAAUrhF,YAGN,MAAOhK,MAAKyqF,OAAOa,gBAAiBthF,aAOxC6kB,WAAWtuB,UAAUw3B,KAKrB,SAAU3xB,KAAM4D,YACZ,MAAO,IAAIuhF,UAASvrF,KAAMoG,KAAM4D,aAKpC6kB,WAAWtuB,UAAUo5B,OAGrB,WAAc,MAAO,IAAIG,qBAAoB95B,KAAM,OAC5C6uB,cAGP28D,YACAC,KAAM,EACNC,MAAO,EACPC,WAAY,EACZC,WAAY,EAEhBJ,YAAWA,WAAWC,MAAQ,OAC9BD,WAAWA,WAAWE,OAAS,QAC/BF,WAAWA,WAAWG,YAAc,aACpCH,WAAWA,WAAWI,YAAc,YACpC,IAAI1lE,aAA6B,SAAUzb,QAEvC,QAASyb,aAAYzkB,KAAM2E,KAAM4D,YAC7B,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IASnD,OARoB,gBAATyB,OACPsiC,MAAMtiC,KAAOA,KACbsiC,MAAM8nD,QAAU,OAGhB9nD,MAAMtiC,KAAO,KACbsiC,MAAM8nD,QAA2B,MAE9B9nD,MAwCX,MAnDA9jC,WAAUimB,YAAazb,QAiBvByb,YAAY3lB,UAAUwkB,aAItB,SAAUzL,GACN,MAAOA,aAAa4M,cAAelmB,KAAKyB,OAAS6X,EAAE7X,MAAQzB,KAAK6rF,UAAYvyE,EAAEuyE,SAOlF3lE,YAAY3lB,UAAUylB,gBAKtB,SAAUziB,QAASC,SACf,MAAOD,SAAQuoF,iBAAiB9rF,KAAMwD,UAM1C0iB,YAAY3lB,UAAUigB,IAItB,SAAUld,OACN,IAAKtD,KAAKyB,KACN,KAAM,IAAI+C,OAAM,qBAAuBxE,KAAK6rF,QAAU,2BAE1D,OAAO,IAAIE,cAAa/rF,KAAKyB,KAAM6B,MAAO,KAAMtD,KAAKgK,aAElDkc,aACT2I,YACEk9D,aAA8B,SAAUthF,QAExC,QAASshF,cAAatqF,KAAM6B,MAAO8C,KAAM4D,YACrC,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,MAAQ9C,MAAM8C,KAAM4D,aAAehK,IAGjE,OAFA+jC,OAAMtiC,KAAOA,KACbsiC,MAAMzgC,MAAQA,MACPygC,MAuCX,MA5CA9jC,WAAU8rF,aAActhF,QAWxBshF,aAAaxrF,UAAUwkB,aAIvB,SAAUzL,GACN,MAAOA,aAAayyE,eAAgB/rF,KAAKyB,OAAS6X,EAAE7X,MAAQzB,KAAKsD,MAAMyhB,aAAazL,EAAEhW,QAO1FyoF,aAAaxrF,UAAUylB,gBAKvB,SAAUziB,QAASC,SACf,MAAOD,SAAQyoF,kBAAkBhsF,KAAMwD,UAO3CuoF,aAAaxrF,UAAU03B,WAKvB,SAAU7xB,KAAM2hF,WACZ,MAAO,IAAI3uD,gBAAep5B,KAAKyB,KAAMzB,KAAKsD,MAAO8C,KAAM2hF,UAAW/nF,KAAKgK,aAEpE+hF,cACTl9D,YACEo9D,aAA8B,SAAUxhF,QAExC,QAASwhF,cAAa13E,SAAUnP,MAAO9B,MAAO8C,KAAM4D,YAChD,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,MAAQ9C,MAAM8C,KAAM4D,aAAehK,IAIjE,OAHA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAM3+B,MAAQA,MACd2+B,MAAMzgC,MAAQA,MACPygC,MA2BX,MAjCA9jC,WAAUgsF,aAAcxhF,QAYxBwhF,aAAa1rF,UAAUwkB,aAIvB,SAAUzL,GACN,MAAOA,aAAa2yE,eAAgBjsF,KAAKuU,SAASwQ,aAAazL,EAAE/E,WAC7DvU,KAAKoF,MAAM2f,aAAazL,EAAElU,QAAUpF,KAAKsD,MAAMyhB,aAAazL,EAAEhW,QAOtE2oF,aAAa1rF,UAAUylB,gBAKvB,SAAUziB,QAASC,SACf,MAAOD,SAAQ2oF,kBAAkBlsF,KAAMwD,UAEpCyoF,cACTp9D,YACEs9D,cAA+B,SAAU1hF,QAEzC,QAAS0hF,eAAc53E,SAAU9S,KAAM6B,MAAO8C,KAAM4D,YAChD,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,MAAQ9C,MAAM8C,KAAM4D,aAAehK,IAIjE,OAHA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAMtiC,KAAOA,KACbsiC,MAAMzgC,MAAQA,MACPygC,MA2BX,MAjCA9jC,WAAUksF,cAAe1hF,QAYzB0hF,cAAc5rF,UAAUwkB,aAIxB,SAAUzL,GACN,MAAOA,aAAa6yE,gBAAiBnsF,KAAKuU,SAASwQ,aAAazL,EAAE/E,WAC9DvU,KAAKyB,OAAS6X,EAAE7X,MAAQzB,KAAKsD,MAAMyhB,aAAazL,EAAEhW,QAO1D6oF,cAAc5rF,UAAUylB,gBAKxB,SAAUziB,QAASC,SACf,MAAOD,SAAQ6oF,mBAAmBpsF,KAAMwD,UAErC2oF,eACTt9D,YAEEw9D,eACAC,YAAa,EACbC,oBAAqB,EACrBC,KAAM,EAEVH,eAAcA,cAAcC,aAAe,cAC3CD,cAAcA,cAAcE,qBAAuB,sBACnDF,cAAcA,cAAcG,MAAQ,MACpC,IAAItC,kBAAkC,SAAUz/E,QAE5C,QAASy/E,kBAAiB31E,SAAUu2B,OAAQnpC,KAAMyE,KAAM4D,YACpD,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAWnD,OAVA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAMpiC,KAAOA,KACS,gBAAXmpC,SACP/G,MAAMtiC,KAAOqpC,OACb/G,MAAM8nD,QAAU,OAGhB9nD,MAAMtiC,KAAO,KACbsiC,MAAM8nD,QAA2B,QAE9B9nD,MA2BX,MAxCA9jC,WAAUiqF,iBAAkBz/E,QAmB5By/E,iBAAiB3pF,UAAUwkB,aAI3B,SAAUzL,GACN,MAAOA,aAAa4wE,mBAAoBlqF,KAAKuU,SAASwQ,aAAazL,EAAE/E,WACjEvU,KAAKyB,OAAS6X,EAAE7X,MAAQzB,KAAK6rF,UAAYvyE,EAAEuyE,SAAW7mE,iBAAiBhlB,KAAK2B,KAAM2X,EAAE3X,OAO5FuoF,iBAAiB3pF,UAAUylB,gBAK3B,SAAUziB,QAASC,SACf,MAAOD,SAAQkpF,sBAAsBzsF,KAAMwD,UAExC0mF,kBACTr7D,YACEs7D,mBAAoC,SAAU1/E,QAE9C,QAAS0/E,oBAAmB/iE,GAAIzlB,KAAMyE,KAAM4D,YACxC,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAGnD,OAFA+jC,OAAM3c,GAAKA,GACX2c,MAAMpiC,KAAOA,KACNoiC,MA2BX,MAhCA9jC,WAAUkqF,mBAAoB1/E,QAW9B0/E,mBAAmB5pF,UAAUwkB,aAI7B,SAAUzL,GACN,MAAOA,aAAa6wE,qBAAsBnqF,KAAKonB,GAAGrC,aAAazL,EAAE8N,KAC7DpC,iBAAiBhlB,KAAK2B,KAAM2X,EAAE3X,OAOtCwoF,mBAAmB5pF,UAAUylB,gBAK7B,SAAUziB,QAASC,SACf,MAAOD,SAAQmpF,wBAAwB1sF,KAAMwD,UAE1C2mF,oBACTt7D,YACEu7D,gBAAiC,SAAU3/E,QAE3C,QAAS2/E,iBAAgBuC,UAAWhrF,KAAMyE,KAAM4D,YAC5C,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAGnD,OAFA+jC,OAAM4oD,UAAYA,UAClB5oD,MAAMpiC,KAAOA,KACNoiC,MA2BX,MAhCA9jC,WAAUmqF,gBAAiB3/E,QAW3B2/E,gBAAgB7pF,UAAUwkB,aAI1B,SAAUzL,GACN,MAAOA,aAAa8wE,kBAAmBpqF,KAAK2sF,UAAU5nE,aAAazL,EAAEqzE,YACjE3nE,iBAAiBhlB,KAAK2B,KAAM2X,EAAE3X,OAOtCyoF,gBAAgB7pF,UAAUylB,gBAK1B,SAAUziB,QAASC,SACf,MAAOD,SAAQqpF,qBAAqB5sF,KAAMwD,UAEvC4mF,iBACTv7D,YACEpH,YAA6B,SAAUhd,QAEvC,QAASgd,aAAYnkB,MAAO8C,KAAM4D,YAC9B,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAEnD,OADA+jC,OAAMzgC,MAAQA,MACPygC,MA0BX,MA9BA9jC,WAAUwnB,YAAahd,QAUvBgd,YAAYlnB,UAAUwkB,aAItB,SAAUzL,GACN,MAAOA,aAAamO,cAAeznB,KAAKsD,QAAUgW,EAAEhW,OAOxDmkB,YAAYlnB,UAAUylB,gBAKtB,SAAUziB,QAASC,SACf,MAAOD,SAAQspF,iBAAiB7sF,KAAMwD,UAEnCikB,aACToH,YACExI,aAA8B,SAAU5b,QAExC,QAAS4b,cAAa/iB,MAAO8C,KAAMggB,WAAYpc,gBACxB,KAAfoc,aAAyBA,WAAa,KAC1C,IAAI2d,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAGnD,OAFA+jC,OAAMzgC,MAAQA,MACdygC,MAAM3d,WAAaA,WACZ2d,MA2BX,MAjCA9jC,WAAUomB,aAAc5b,QAYxB4b,aAAa9lB,UAAUwkB,aAIvB,SAAUzL,GACN,MAAOA,aAAa+M,eAAgBrmB,KAAKsD,MAAM7B,OAAS6X,EAAEhW,MAAM7B,MAC5DzB,KAAKsD,MAAMi7B,aAAejlB,EAAEhW,MAAMi7B,YAAcv+B,KAAKsD,MAAMypC,UAAYzzB,EAAEhW,MAAMypC,SAOvF1mB,aAAa9lB,UAAUylB,gBAKvB,SAAUziB,QAASC,SACf,MAAOD,SAAQupF,kBAAkB9sF,KAAMwD,UAEpC6iB,cACTwI,YACEk+D,kBAAmC,WACnC,QAASA,mBAAkBxuD,WAAY98B,KAAMsrC,SACzC/sC,KAAKu+B,WAAaA,WAClBv+B,KAAKyB,KAAOA,KACZzB,KAAK+sC,QAAUA,QAEnB,MAAOggD,sBAEPvC,gBAAiC,SAAU//E,QAE3C,QAAS+/E,iBAAgBv7E,UAAWq7E,SAAUC,UAAWnkF,KAAM4D,gBACzC,KAAdugF,YAAwBA,UAAY,KACxC,IAAIxmD,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,MAAQkkF,SAASlkF,KAAM4D,aAAehK,IAIpE,OAHA+jC,OAAM90B,UAAYA,UAClB80B,MAAMwmD,UAAYA,UAClBxmD,MAAMumD,SAAWA,SACVvmD,MA2BX,MAlCA9jC,WAAUuqF,gBAAiB//E,QAa3B+/E,gBAAgBjqF,UAAUwkB,aAI1B,SAAUzL,GACN,MAAOA,aAAakxE,kBAAmBxqF,KAAKiP,UAAU8V,aAAazL,EAAErK,YACjEjP,KAAKsqF,SAASvlE,aAAazL,EAAEgxE,WAAa1lE,qBAAqB5kB,KAAKuqF,UAAWjxE,EAAEixE,YAOzFC,gBAAgBjqF,UAAUylB,gBAK1B,SAAUziB,QAASC,SACf,MAAOD,SAAQypF,qBAAqBhtF,KAAMwD,UAEvCgnF,iBACT37D,YACE5H,QAAyB,SAAUxc,QAEnC,QAASwc,SAAQhY,UAAWjF,YACxB,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAM8oF,UAAW9+E,aAAehK,IAExD,OADA+jC,OAAM90B,UAAYA,UACX80B,MA0BX,MA9BA9jC,WAAUgnB,QAASxc,QAUnBwc,QAAQ1mB,UAAUwkB,aAIlB,SAAUzL,GACN,MAAOA,aAAa2N,UAAWjnB,KAAKiP,UAAU8V,aAAazL,EAAErK,YAOjEgY,QAAQ1mB,UAAUylB,gBAKlB,SAAUziB,QAASC,SACf,MAAOD,SAAQ0pF,aAAajtF,KAAMwD,UAE/ByjB,SACT4H,YACE1H,cAA+B,SAAU1c,QAEzC,QAAS0c,eAAclY,UAAWjF,YAC9B,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMiP,UAAU7I,KAAM4D,aAAehK,IAE7D,OADA+jC,OAAM90B,UAAYA,UACX80B,MA0BX,MA9BA9jC,WAAUknB,cAAe1c,QAUzB0c,cAAc5mB,UAAUwkB,aAIxB,SAAUzL,GACN,MAAOA,aAAa6N,gBAAiBnnB,KAAKiP,UAAU8V,aAAazL,EAAErK,YAOvEkY,cAAc5mB,UAAUylB,gBAKxB,SAAUziB,QAASC,SACf,MAAOD,SAAQ2pF,uBAAuBltF,KAAMwD,UAEzC2jB,eACT0H,YACE08D,SAA0B,SAAU9gF,QAEpC,QAAS8gF,UAASjoF,MAAO8C,KAAM4D,YAC3B,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAEnD,OADA+jC,OAAMzgC,MAAQA,MACPygC,MA0BX,MA9BA9jC,WAAUsrF,SAAU9gF,QAUpB8gF,SAAShrF,UAAUwkB,aAInB,SAAUzL,GACN,MAAOA,aAAaiyE,WAAYvrF,KAAKsD,MAAMyhB,aAAazL,EAAEhW,QAO9DioF,SAAShrF,UAAUylB,gBAKnB,SAAUziB,QAASC,SACf,MAAOD,SAAQ4pF,cAAcntF,KAAMwD,UAEhC+nF,UACT18D,YACElD,QAAyB,WACzB,QAASA,SAAQlqB,KAAM2E,UACN,KAATA,OAAmBA,KAAO,MAC9BpG,KAAKyB,KAAOA,KACZzB,KAAKoG,KAAOA,KAWhB,MALAulB,SAAQprB,UAAUwkB,aAIlB,SAAUimB,OAAS,MAAOhrC,MAAKyB,OAASupC,MAAMvpC,MACvCkqB,WAEPpE,aAA8B,SAAU9c,QAExC,QAAS8c,cAAaF,OAAQgS,WAAYjzB,KAAM4D,YAC5C,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAGnD,OAFA+jC,OAAM1c,OAASA,OACf0c,MAAM1K,WAAaA,WACZ0K,MAyCX,MA9CA9jC,WAAUsnB,aAAc9c,QAWxB8c,aAAahnB,UAAUwkB,aAIvB,SAAUzL,GACN,MAAOA,aAAaiO,eAAgBvC,iBAAiBhlB,KAAKqnB,OAAQ/N,EAAE+N,SAChErC,iBAAiBhlB,KAAKq5B,WAAY/f,EAAE+f,aAO5C9R,aAAahnB,UAAUylB,gBAKvB,SAAUziB,QAASC,SACf,MAAOD,SAAQ6pF,kBAAkBptF,KAAMwD,UAO3C+jB,aAAahnB,UAAU03B,WAKvB,SAAUx2B,KAAMsmF,WAEZ,WADkB,KAAdA,YAAwBA,UAAY,MACjC,GAAIsF,qBAAoB5rF,KAAMzB,KAAKqnB,OAAQrnB,KAAKq5B,WAAYr5B,KAAKoG,KAAM2hF,UAAW/nF,KAAKgK,aAE3Fud,cACTsH,YACE87D,mBAAoC,SAAUlgF,QAE9C,QAASkgF,oBAAmB5xB,SAAUu0B,IAAK5C,IAAKtkF,KAAM4D,YAClD,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,MAAQknF,IAAIlnF,KAAM4D,aAAehK,IAI/D,OAHA+jC,OAAMg1B,SAAWA,SACjBh1B,MAAM2mD,IAAMA,IACZ3mD,MAAMupD,IAAMA,IACLvpD,MA2BX,MAjCA9jC,WAAU0qF,mBAAoBlgF,QAY9BkgF,mBAAmBpqF,UAAUwkB,aAI7B,SAAUzL,GACN,MAAOA,aAAaqxE,qBAAsB3qF,KAAK+4D,WAAaz/C,EAAEy/C,UAC1D/4D,KAAKstF,IAAIvoE,aAAazL,EAAEg0E,MAAQttF,KAAK0qF,IAAI3lE,aAAazL,EAAEoxE,MAOhEC,mBAAmBpqF,UAAUylB,gBAK7B,SAAUziB,QAASC,SACf,MAAOD,SAAQgqF,wBAAwBvtF,KAAMwD,UAE1CmnF,oBACT97D,YACEk7D,aAA8B,SAAUt/E,QAExC,QAASs/E,cAAax1E,SAAU9S,KAAM2E,KAAM4D,YACxC,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAGnD,OAFA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAMtiC,KAAOA,KACNsiC,MAsCX,MA3CA9jC,WAAU8pF,aAAct/E,QAWxBs/E,aAAaxpF,UAAUwkB,aAIvB,SAAUzL,GACN,MAAOA,aAAaywE,eAAgB/pF,KAAKuU,SAASwQ,aAAazL,EAAE/E,WAC7DvU,KAAKyB,OAAS6X,EAAE7X,MAOxBsoF,aAAaxpF,UAAUylB,gBAKvB,SAAUziB,QAASC,SACf,MAAOD,SAAQiqF,kBAAkBxtF,KAAMwD,UAM3CumF,aAAaxpF,UAAUigB,IAIvB,SAAUld,OACN,MAAO,IAAI6oF,eAAcnsF,KAAKuU,SAAUvU,KAAKyB,KAAM6B,MAAO,KAAMtD,KAAKgK,aAElE+/E,cACTl7D,YACEm7D,YAA6B,SAAUv/E,QAEvC,QAASu/E,aAAYz1E,SAAUnP,MAAOgB,KAAM4D,YACxC,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAGnD,OAFA+jC,OAAMxvB,SAAWA,SACjBwvB,MAAM3+B,MAAQA,MACP2+B,MAsCX,MA3CA9jC,WAAU+pF,YAAav/E,QAWvBu/E,YAAYzpF,UAAUwkB,aAItB,SAAUzL,GACN,MAAOA,aAAa0wE,cAAehqF,KAAKuU,SAASwQ,aAAazL,EAAE/E,WAC5DvU,KAAKoF,MAAM2f,aAAazL,EAAElU,QAOlC4kF,YAAYzpF,UAAUylB,gBAKtB,SAAUziB,QAASC,SACf,MAAOD,SAAQkqF,iBAAiBztF,KAAMwD,UAM1CwmF,YAAYzpF,UAAUigB,IAItB,SAAUld,OACN,MAAO,IAAI2oF,cAAajsF,KAAKuU,SAAUvU,KAAKoF,MAAO9B,MAAO,KAAMtD,KAAKgK,aAElEggF,aACTn7D,YACElI,iBAAkC,SAAUlc,QAE5C,QAASkc,kBAAiB+mE,QAAStnF,KAAM4D,YACrC,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAEnD,OADA+jC,OAAM2pD,QAAUA,QACT3pD,MA0BX,MA9BA9jC,WAAU0mB,iBAAkBlc,QAU5Bkc,iBAAiBpmB,UAAUwkB,aAI3B,SAAUzL,GACN,MAAOA,aAAaqN,mBAAoB3B,iBAAiBhlB,KAAK0tF,QAASp0E,EAAEo0E,UAO7E/mE,iBAAiBpmB,UAAUylB,gBAK3B,SAAUziB,QAASC,SACf,MAAOD,SAAQoqF,sBAAsB3tF,KAAMwD,UAExCmjB,kBACTkI,YACE/H,gBAAiC,WACjC,QAASA,iBAAgB7S,IAAK3Q,MAAOyjB,QACjC/mB,KAAKiU,IAAMA,IACXjU,KAAKsD,MAAQA,MACbtD,KAAK+mB,OAASA,OAalB,MAPAD,iBAAgBvmB,UAAUwkB,aAI1B,SAAUzL,GACN,MAAOtZ,MAAKiU,MAAQqF,EAAErF,KAAOjU,KAAKsD,MAAMyhB,aAAazL,EAAEhW,QAEpDwjB,mBAEPD,eAAgC,SAAUpc,QAE1C,QAASoc,gBAAe6mE,QAAStnF,KAAM4D,YACnC,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM4D,aAAehK,IAMnD,OALA+jC,OAAM2pD,QAAUA,QAChB3pD,MAAM6kD,UAAY,KACdxiF,OACA29B,MAAM6kD,UAAYxiF,KAAKwiF,WAEpB7kD,MA0BX,MAlCA9jC,WAAU4mB,eAAgBpc,QAc1Boc,eAAetmB,UAAUwkB,aAIzB,SAAUzL,GACN,MAAOA,aAAauN,iBAAkB7B,iBAAiBhlB,KAAK0tF,QAASp0E,EAAEo0E,UAO3E7mE,eAAetmB,UAAUylB,gBAKzB,SAAUziB,QAASC,SACf,MAAOD,SAAQqqF,oBAAoB5tF,KAAMwD,UAEtCqjB,gBACTgI,YACEg/D,UAA2B,SAAUpjF,QAErC,QAASojF,WAAU71E,MAAOhO,YACtB,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAMgY,MAAMA,MAAMlW,OAAS,GAAGsE,KAAM4D,aAAehK,IAE3E,OADA+jC,OAAM/rB,MAAQA,MACP+rB,MA0BX,MA9BA9jC,WAAU4tF,UAAWpjF,QAUrBojF,UAAUttF,UAAUwkB,aAIpB,SAAUzL,GACN,MAAOA,aAAau0E,YAAa7oE,iBAAiBhlB,KAAKgY,MAAOsB,EAAEtB,QAOpE61E,UAAUttF,UAAUylB,gBAKpB,SAAUziB,QAASC,SACf,MAAOD,SAAQuqF,eAAe9tF,KAAMwD,UAEjCqqF,WACTh/D,YASEtC,WAJY,GAAIrG,aAAYslE,WAAWC,KAAM,KAAM,MACtC,GAAIvlE,aAAYslE,WAAWE,MAAO,KAAM,MACnC,GAAIxlE,aAAYslE,WAAWG,WAAY,KAAM,MAC7C,GAAIzlE,aAAYslE,WAAWI,WAAY,KAAM,MACnD,GAAInkE,aAAY,KAAM,KAAM,OACxC6jE,gBAAkB,GAAI7jE,aAAY,KAAM4E,cAAe,MAEvD6L,cACAC,MAAO,EACP41D,QAAS,EACTptD,SAAU,EAEdzI,cAAaA,aAAaC,OAAS,QACnCD,aAAaA,aAAa61D,SAAW,UACrC71D,aAAaA,aAAayI,UAAY,UAItC,IAAI/R,WAA2B,WAC3B,QAASA,WAAUm5D,UAAW/9E,YAC1BhK,KAAK+nF,UAAYA,cACjB/nF,KAAKgK,WAAaA,YAAc,KAWpC,MALA4kB,WAAUruB,UAAUynF,YAIpB,SAAUC,UAAY,OAAkE,IAAxCjoF,KAAe,UAAEkD,QAAQ+kF,WAClEr5D,aAEPwK,eAAgC,SAAU3uB,QAE1C,QAAS2uB,gBAAe33B,KAAM6B,MAAO8C,KAAM2hF,UAAW/9E,gBAChC,KAAd+9E,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAM+nF,UAAW/9E,aAAehK,IAIxD,OAHA+jC,OAAMtiC,KAAOA,KACbsiC,MAAMzgC,MAAQA,MACdygC,MAAM39B,KAAOA,MAAQ9C,MAAM8C,KACpB29B,MA2BX,MAlCA9jC,WAAUm5B,eAAgB3uB,QAa1B2uB,eAAe74B,UAAUwkB,aAIzB,SAAUW,MACN,MAAOA,gBAAgB0T,iBAAkBp5B,KAAKyB,OAASikB,KAAKjkB,MACxDzB,KAAKsD,MAAMyhB,aAAaW,KAAKpiB,QAOrC81B,eAAe74B,UAAUslB,eAKzB,SAAUtiB,QAASC,SACf,MAAOD,SAAQyqF,oBAAoBhuF,KAAMwD,UAEtC41B,gBACTxK,WACEy+D,oBAAqC,SAAU5iF,QAE/C,QAAS4iF,qBAAoB5rF,KAAM4lB,OAAQgS,WAAYjzB,KAAM2hF,UAAW/9E,gBAClD,KAAd+9E,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAM+nF,UAAW/9E,aAAehK,IAKxD,OAJA+jC,OAAMtiC,KAAOA,KACbsiC,MAAM1c,OAASA,OACf0c,MAAM1K,WAAaA,WACnB0K,MAAM39B,KAAOA,MAAQ,KACd29B,MA2BX,MAnCA9jC,WAAUotF,oBAAqB5iF,QAc/B4iF,oBAAoB9sF,UAAUwkB,aAI9B,SAAUW,MACN,MAAOA,gBAAgB2nE,sBAAuBroE,iBAAiBhlB,KAAKqnB,OAAQ3B,KAAK2B,SAC7ErC,iBAAiBhlB,KAAKq5B,WAAY3T,KAAK2T,aAO/Cg0D,oBAAoB9sF,UAAUslB,eAK9B,SAAUtiB,QAASC,SACf,MAAOD,SAAQ0qF,yBAAyBjuF,KAAMwD,UAE3C6pF,qBACTz+D,WACEkL,oBAAqC,SAAUrvB,QAE/C,QAASqvB,qBAAoB/T,KAAM/b,YAC/B,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAM,KAAMgK,aAAehK,IAEnD,OADA+jC,OAAMhe,KAAOA,KACNge,MA0BX,MA9BA9jC,WAAU65B,oBAAqBrvB,QAU/BqvB,oBAAoBv5B,UAAUwkB,aAI9B,SAAUW,MACN,MAAOA,gBAAgBoU,sBAAuB95B,KAAK+lB,KAAKhB,aAAaW,KAAKK,OAO9E+T,oBAAoBv5B,UAAUslB,eAK9B,SAAUtiB,QAASC,SACf,MAAOD,SAAQ2qF,oBAAoBluF,KAAMwD,UAEtCs2B,qBACTlL,WACExC,gBAAiC,SAAU3hB,QAE3C,QAAS2hB,iBAAgB9oB,MAAO0G,YAC5B,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAM,KAAMgK,aAAehK,IAEnD,OADA+jC,OAAMzgC,MAAQA,MACPygC,MA0BX,MA9BA9jC,WAAUmsB,gBAAiB3hB,QAU3B2hB,gBAAgB7rB,UAAUwkB,aAI1B,SAAUW,MACN,MAAOA,gBAAgB0G,kBAAmBpsB,KAAKsD,MAAMyhB,aAAaW,KAAKpiB,QAO3E8oB,gBAAgB7rB,UAAUslB,eAK1B,SAAUtiB,QAASC,SACf,MAAOD,SAAQ4qF,gBAAgBnuF,KAAMwD,UAElC4oB,iBACTwC,WACEw/D,kBAAmC,WACnC,QAASA,mBAAkBhoF,KAAM2hF,WAC7B/nF,KAAK+nF,UAAYA,UACZA,YACD/nF,KAAK+nF,cAET/nF,KAAKoG,KAAOA,MAAQ,KAWxB,MALAgoF,mBAAkB7tF,UAAUynF,YAI5B,SAAUC,UAAY,OAAkE,IAAxCjoF,KAAe,UAAEkD,QAAQ+kF,WAClEmG,qBAqBPC,aAnB4B,SAAU5jF,QAEtC,QAAS6jF,YAAW7sF,KAAM2E,KAAM2hF,eACV,KAAdA,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM2hF,YAAc/nF,IAElD,OADA+jC,OAAMtiC,KAAOA,KACNsiC,MALX9jC,UAAUquF,WAAY7jF,QAWtB6jF,WAAW/tF,UAAUwkB,aAIrB,SAAU9K,GAAK,MAAOja,MAAKyB,OAASwY,EAAExY,OAExC2sF,mBAC+B,SAAU3jF,QAEvC,QAAS4jF,aAAY5sF,KAAM4lB,OAAQC,KAAMlhB,KAAM2hF,eACzB,KAAdA,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM2hF,YAAc/nF,IAIlD,OAHA+jC,OAAMtiC,KAAOA,KACbsiC,MAAM1c,OAASA,OACf0c,MAAMzc,KAAOA,KACNyc,MAaX,MApBA9jC,WAAUouF,YAAa5jF,QAavB4jF,YAAY9tF,UAAUwkB,aAItB,SAAUriB,GACN,MAAO1C,MAAKyB,OAASiB,EAAEjB,MAAQujB,iBAAiBhlB,KAAKsnB,KAAM5kB,EAAE4kB,OAE1D+mE,aACTD,oBACEG,YAA6B,SAAU9jF,QAEvC,QAAS8jF,aAAY9sF,KAAM6lB,KAAMlhB,KAAM2hF,eACjB,KAAdA,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAMoG,KAAM2hF,YAAc/nF,IAGlD,OAFA+jC,OAAMtiC,KAAOA,KACbsiC,MAAMzc,KAAOA,KACNyc,MAaX,MAnBA9jC,WAAUsuF,YAAa9jF,QAYvB8jF,YAAYhuF,UAAUwkB,aAItB,SAAUriB,GACN,MAAO1C,MAAKyB,OAASiB,EAAEjB,MAAQujB,iBAAiBhlB,KAAKsnB,KAAM5kB,EAAE4kB,OAE1DinE,aACTH,mBACEI,UAA2B,SAAU/jF,QAErC,QAAS+jF,WAAU/sF,KAAM+pC,OAAQH,OAAQX,QAASS,kBAAmBN,QAASk9C,UAAW/9E,gBACnE,KAAd+9E,YAAwBA,UAAY,KACxC,IAAIhkD,OAAQt5B,OAAO8kC,KAAKvvC,KAAM+nF,UAAW/9E,aAAehK,IAOxD,OANA+jC,OAAMtiC,KAAOA,KACbsiC,MAAMyH,OAASA,OACfzH,MAAMsH,OAASA,OACftH,MAAM2G,QAAUA,QAChB3G,MAAMoH,kBAAoBA,kBAC1BpH,MAAM8G,QAAUA,QACT9G,MA+BX,MAzCA9jC,WAAUuuF,UAAW/jF,QAgBrB+jF,UAAUjuF,UAAUwkB,aAIpB,SAAUW,MACN,MAAOA,gBAAgB8oE,YAAaxuF,KAAKyB,OAASikB,KAAKjkB,MACnDmjB,qBAAqB5kB,KAAKwrC,OAAQ9lB,KAAK8lB,SACvCxmB,iBAAiBhlB,KAAKqrC,OAAQ3lB,KAAK2lB,SACnCrmB,iBAAiBhlB,KAAK0qC,QAAShlB,KAAKglB,UACpC1qC,KAAKmrC,kBAAkBpmB,aAAaW,KAAKylB,oBACzCnmB,iBAAiBhlB,KAAK6qC,QAASnlB,KAAKmlB,UAO5C2jD,UAAUjuF,UAAUslB,eAKpB,SAAUtiB,QAASC,SACf,MAAOD,SAAQkrF,sBAAsBzuF,KAAMwD,UAExCgrF,WACT5/D,WACE8/D,OAAwB,SAAUjkF,QAElC,QAASikF,QAAOz/E,UAAWq7E,SAAUC,UAAWvgF,gBAC1B,KAAdugF,YAAwBA,aAC5B,IAAIxmD,OAAQt5B,OAAO8kC,KAAKvvC,KAAM,KAAMgK,aAAehK,IAInD,OAHA+jC,OAAM90B,UAAYA,UAClB80B,MAAMumD,SAAWA,SACjBvmD,MAAMwmD,UAAYA,UACXxmD,MA4BX,MAnCA9jC,WAAUyuF,OAAQjkF,QAalBikF,OAAOnuF,UAAUwkB,aAIjB,SAAUW,MACN,MAAOA,gBAAgBgpE,SAAU1uF,KAAKiP,UAAU8V,aAAaW,KAAKzW,YAC9D+V,iBAAiBhlB,KAAKsqF,SAAU5kE,KAAK4kE,WACrCtlE,iBAAiBhlB,KAAKuqF,UAAW7kE,KAAK6kE,YAO9CmE,OAAOnuF,UAAUslB,eAKjB,SAAUtiB,QAASC,SACf,MAAOD,SAAQorF,YAAY3uF,KAAMwD,UAE9BkrF,QACT9/D,WACEggE,YAA6B,SAAUnkF,QAEvC,QAASmkF,aAAYrhB,QAASvjE,YAC1B,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAM,KAAMgK,aAAehK,IAEnD,OADA+jC,OAAMwpC,QAAUA,QACTxpC,MAwBX,MA5BA9jC,WAAU2uF,YAAankF,QAUvBmkF,YAAYruF,UAAUwkB,aAItB,SAAUW,MAAQ,MAAOA,gBAAgBkpE,cAMzCA,YAAYruF,UAAUslB,eAKtB,SAAUtiB,QAASC,SACf,MAAOD,SAAQsrF,iBAAiB7uF,KAAMwD,UAEnCorF,aACThgE,WACEkgE,aAA8B,SAAUrkF,QAExC,QAASqkF,cAAaC,UAAWC,WAAYhlF,YACzC,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAM,KAAMgK,aAAehK,IAGnD,OAFA+jC,OAAMgrD,UAAYA,UAClBhrD,MAAMirD,WAAaA,WACZjrD,MA2BX,MAhCA9jC,WAAU6uF,aAAcrkF,QAWxBqkF,aAAavuF,UAAUwkB,aAIvB,SAAUW,MACN,MAAOA,gBAAgBopE,eAAgB9pE,iBAAiBhlB,KAAK+uF,UAAWrpE,KAAKqpE,YACzE/pE,iBAAiBhlB,KAAKgvF,WAAYtpE,KAAKspE,aAO/CF,aAAavuF,UAAUslB,eAKvB,SAAUtiB,QAASC,SACf,MAAOD,SAAQ0rF,kBAAkBjvF,KAAMwD,UAEpCsrF,cACTlgE,WACEsgE,UAA2B,SAAUzkF,QAErC,QAASykF,WAAU3qF,MAAOyF,YACtB,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,KAAM,KAAMgK,aAAehK,IAEnD,OADA+jC,OAAMx/B,MAAQA,MACPw/B,MA0BX,MA9BA9jC,WAAUivF,UAAWzkF,QAUrBykF,UAAU3uF,UAAUwkB,aAIpB,SAAUW,MACN,MAAOA,gBAAgBopE,eAAgB9uF,KAAKuE,MAAMwgB,aAAaW,KAAKnhB,QAOxE2qF,UAAU3uF,UAAUslB,eAKpB,SAAUtiB,QAASC,SACf,MAAOD,SAAQ4rF,eAAenvF,KAAMwD,UAEjC0rF,WACTtgE,WAKEwgE,iBAAkC,WAClC,QAASl5B,mBAybT,MAlbAA,gBAAe31D,UAAU8uF,cAKzB,SAAUtpE,KAAMviB,SAAW,MAAOuiB,OAMlCmwC,eAAe31D,UAAU+uF,cAKzB,SAAU5pE,KAAMliB,SAAW,MAAOkiB,OAMlCwwC,eAAe31D,UAAUurF,iBAKzB,SAAUllF,IAAKpD,SAAW,MAAOxD,MAAKqvF,cAAczoF,IAAKpD,UAMzD0yD,eAAe31D,UAAUyrF,kBAKzB,SAAUjmE,KAAMviB,SACZ,MAAOxD,MAAKqvF,cAAc,GAAItD,cAAahmE,KAAKtkB,KAAMskB,KAAKziB,MAAM0iB,gBAAgBhmB,KAAMwD,SAAUuiB,KAAK3f,KAAM2f,KAAK/b,YAAaxG;mIAOlI0yD,eAAe31D,UAAU2rF,kBAKzB,SAAUnmE,KAAMviB,SACZ,MAAOxD,MAAKqvF,cAAc,GAAIpD,cAAalmE,KAAKxR,SAASyR,gBAAgBhmB,KAAMwD,SAAUuiB,KAAK3gB,MAAM4gB,gBAAgBhmB,KAAMwD,SAAUuiB,KAAKziB,MAAM0iB,gBAAgBhmB,KAAMwD,SAAUuiB,KAAK3f,KAAM2f,KAAK/b,YAAaxG,UAOhN0yD,eAAe31D,UAAU6rF,mBAKzB,SAAUrmE,KAAMviB,SACZ,MAAOxD,MAAKqvF,cAAc,GAAIlD,eAAcpmE,KAAKxR,SAASyR,gBAAgBhmB,KAAMwD,SAAUuiB,KAAKtkB,KAAMskB,KAAKziB,MAAM0iB,gBAAgBhmB,KAAMwD,SAAUuiB,KAAK3f,KAAM2f,KAAK/b,YAAaxG,UAOjL0yD,eAAe31D,UAAUksF,sBAKzB,SAAU7lF,IAAKpD,SACX,GAAqBsnC,QAASlkC,IAAIilF,SAAWjlF,IAAInF,IACjD,OAAOzB,MAAKqvF,cAAc,GAAInF,kBAAiBtjF,IAAI2N,SAASyR,gBAAgBhmB,KAAMwD,SAA2B,OAAYxD,KAAKuvF,oBAAoB3oF,IAAIjF,KAAM6B,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAOrM0yD,eAAe31D,UAAUmsF,wBAKzB,SAAU9lF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAIlF,oBAAmBvjF,IAAIwgB,GAAGpB,gBAAgBhmB,KAAMwD,SAAUxD,KAAKuvF,oBAAoB3oF,IAAIjF,KAAM6B,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAOpK0yD,eAAe31D,UAAUqsF,qBAKzB,SAAUhmF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAIjF,iBAAgBxjF,IAAI+lF,UAAU3mE,gBAAgBhmB,KAAMwD,SAAUxD,KAAKuvF,oBAAoB3oF,IAAIjF,KAAM6B,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAOxK0yD,eAAe31D,UAAUssF,iBAKzB,SAAUjmF,IAAKpD,SAAW,MAAOxD,MAAKqvF,cAAczoF,IAAKpD,UAMzD0yD,eAAe31D,UAAUusF,kBAKzB,SAAUlmF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAczoF,IAAKpD,UAOnC0yD,eAAe31D,UAAUysF,qBAKzB,SAAUpmF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAI7E,iBAAgB5jF,IAAIqI,UAAU+W,gBAAgBhmB,KAAMwD,SAAUoD,IAAI0jF,SAAStkE,gBAAgBhmB,KAAMwD,SAA6BoD,IAAc,UAAEof,gBAAgBhmB,KAAMwD,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAO3O0yD,eAAe31D,UAAU0sF,aAKzB,SAAUrmF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAIpoE,SAAQrgB,IAAIqI,UAAU+W,gBAAgBhmB,KAAMwD,SAAUoD,IAAIoD,YAAaxG,UAOzG0yD,eAAe31D,UAAU2sF,uBAKzB,SAAUtmF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAIloE,eAAcvgB,IAAIqI,UAAU+W,gBAAgBhmB,KAAMwD,SAAUoD,IAAIoD,YAAaxG,UAO/G0yD,eAAe31D,UAAU4sF,cAKzB,SAAUvmF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAI9D,UAAS3kF,IAAItD,MAAM0iB,gBAAgBhmB,KAAMwD,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAOhH0yD,eAAe31D,UAAU6sF,kBAKzB,SAAUxmF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAI9nE,cAAa3gB,IAAIygB,OAAQrnB,KAAKolB,mBAAmBxe,IAAIyyB,WAAY71B,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAOxI0yD,eAAe31D,UAAUgtF,wBAKzB,SAAU3mF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAI1E,oBAAmB/jF,IAAImyD,SAAUnyD,IAAI0mF,IAAItnE,gBAAgBhmB,KAAMwD,SAAUoD,IAAI8jF,IAAI1kE,gBAAgBhmB,KAAMwD,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAO9K0yD,eAAe31D,UAAUitF,kBAKzB,SAAU5mF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAItF,cAAanjF,IAAI2N,SAASyR,gBAAgBhmB,KAAMwD,SAAUoD,IAAInF,KAAMmF,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAOjI0yD,eAAe31D,UAAUktF,iBAKzB,SAAU7mF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAIrF,aAAYpjF,IAAI2N,SAASyR,gBAAgBhmB,KAAMwD,SAAUoD,IAAIxB,MAAM4gB,gBAAgBhmB,KAAMwD,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAOhK0yD,eAAe31D,UAAUotF,sBAKzB,SAAU/mF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAI1oE,kBAAiB3mB,KAAKuvF,oBAAoB3oF,IAAI8mF,QAASlqF,SAAUoD,IAAIR,KAAMQ,IAAIoD,YAAaxG,UAO9H0yD,eAAe31D,UAAUqtF,oBAKzB,SAAUhnF,IAAKpD,SACX,GAAIugC,OAAQ/jC,KACS0tF,QAAU9mF,IAAI8mF,QAAQ9nF,IAAI,SAAU8Z,OACrD,MAAO,IAAIoH,iBAAgBpH,MAAMzL,IAAKyL,MAAMpc,MAAM0iB,gBAAgB+d,MAAOvgC,SAAUkc,MAAMqH,UAExEyoE,QAAU,GAAI7G,SAAQ/hF,IAAIgiF,UAAW,KAC1D,OAAO5oF,MAAKqvF,cAAc,GAAIxoE,gBAAe6mE,QAAS8B,QAAS5oF,IAAIoD,YAAaxG,UAOpF0yD,eAAe31D,UAAUutF,eAKzB,SAAUlnF,IAAKpD,SACX,MAAOxD,MAAKqvF,cAAc,GAAIxB,WAAU7tF,KAAKuvF,oBAAoB3oF,IAAIoR,MAAOxU,SAAUoD,IAAIoD,YAAaxG,UAO3G0yD,eAAe31D,UAAUgvF,oBAKzB,SAAUxjE,MAAOvoB,SACb,GAAIugC,OAAQ/jC,IACZ,OAAO+rB,OAAMnmB,IAAI,SAAUmgB,MAAQ,MAAOA,MAAKC,gBAAgB+d,MAAOvgC,YAO1E0yD,eAAe31D,UAAUytF,oBAKzB,SAAUtoE,KAAMliB,SACZ,MAAOxD,MAAKsvF,cAAc,GAAIl2D,gBAAe1T,KAAKjkB,KAAMikB,KAAKpiB,MAAM0iB,gBAAgBhmB,KAAMwD,SAAUkiB,KAAKtf,KAAMsf,KAAKqiE,UAAWriE,KAAK1b,YAAaxG,UAOpJ0yD,eAAe31D,UAAU0tF,yBAKzB,SAAUvoE,KAAMliB,SACZ,MAAOxD,MAAKsvF,cAAc,GAAIjC,qBAAoB3nE,KAAKjkB,KAAMikB,KAAK2B,OAAQrnB,KAAKolB,mBAAmBM,KAAK2T,WAAY71B,SAAUkiB,KAAKtf,KAAMsf,KAAKqiE,UAAWriE,KAAK1b,YAAaxG,UAO9K0yD,eAAe31D,UAAU2tF,oBAKzB,SAAUxoE,KAAMliB,SACZ,MAAOxD,MAAKsvF,cAAc,GAAIx1D,qBAAoBpU,KAAKK,KAAKC,gBAAgBhmB,KAAMwD,SAAUkiB,KAAK1b,YAAaxG,UAOlH0yD,eAAe31D,UAAU4tF,gBAKzB,SAAUzoE,KAAMliB,SACZ,MAAOxD,MAAKsvF,cAAc,GAAIljE,iBAAgB1G,KAAKpiB,MAAM0iB,gBAAgBhmB,KAAMwD,SAAUkiB,KAAK1b,YAAaxG,UAO/G0yD,eAAe31D,UAAUkuF,sBAKzB,SAAU/oE,KAAMliB,SACZ,GAAIugC,OAAQ/jC,KACSwrC,OAA4B9lB,KAAY,OAAEM,gBAAgBhmB,KAAMwD,SAChEknC,QAAUhlB,KAAKglB,QAAQ9kC,IAAI,SAAU+kC,QACtD,MAAO,IAAI4jD,aAAY5jD,OAAOlpC,KAAMsiC,MAAM3e,mBAAmBulB,OAAOrjB,KAAM9jB,SAAUmnC,OAAOvkC,KAAMukC,OAAOo9C,aAEvF0H,WAAa/pE,KAAKylB,mBACnC,GAAIkjD,aAAY3oE,KAAKylB,kBAAkB1pC,KAAMikB,KAAKylB,kBAAkB9jB,OAAQrnB,KAAKolB,mBAAmBM,KAAKylB,kBAAkB7jB,KAAM9jB,SAAUkiB,KAAKylB,kBAAkB/kC,KAAMsf,KAAKylB,kBAAkB48C,WAC9Kl9C,QAAUnlB,KAAKmlB,QAAQjlC,IAAI,SAAUklC,QACtD,MAAO,IAAIujD,aAAYvjD,OAAOrpC,KAAMqpC,OAAOzjB,OAAQ0c,MAAM3e,mBAAmB0lB,OAAOxjB,KAAM9jB,SAAUsnC,OAAO1kC,KAAM0kC,OAAOi9C,YAE3H,OAAO/nF,MAAKsvF,cAAc,GAAId,WAAU9oE,KAAKjkB,KAAM+pC,OAAQ9lB,KAAK2lB,OAAQX,QAAS+kD,WAAY5kD,QAASnlB,KAAKqiE,UAAWriE,KAAK1b,YAAaxG,UAO5I0yD,eAAe31D,UAAUouF,YAKzB,SAAUjpE,KAAMliB,SACZ,MAAOxD,MAAKsvF,cAAc,GAAIZ,QAAOhpE,KAAKzW,UAAU+W,gBAAgBhmB,KAAMwD,SAAUxD,KAAKolB,mBAAmBM,KAAK4kE,SAAU9mF,SAAUxD,KAAKolB,mBAAmBM,KAAK6kE,UAAW/mF,SAAUkiB,KAAK1b,YAAaxG,UAO7M0yD,eAAe31D,UAAU0uF,kBAKzB,SAAUvpE,KAAMliB,SACZ,MAAOxD,MAAKsvF,cAAc,GAAIR,cAAa9uF,KAAKolB,mBAAmBM,KAAKqpE,UAAWvrF,SAAUxD,KAAKolB,mBAAmBM,KAAKspE,WAAYxrF,SAAUkiB,KAAK1b,YAAaxG,UAOtK0yD,eAAe31D,UAAU4uF,eAKzB,SAAUzpE,KAAMliB,SACZ,MAAOxD,MAAKsvF,cAAc,GAAIJ,WAAUxpE,KAAKnhB,MAAMyhB,gBAAgBhmB,KAAMwD,SAAUkiB,KAAK1b,YAAaxG,UAOzG0yD,eAAe31D,UAAUsuF,iBAKzB,SAAUnpE,KAAMliB,SACZ,MAAOxD,MAAKsvF,cAAc5pE,KAAMliB,UAOpC0yD,eAAe31D,UAAU6kB,mBAKzB,SAAUF,MAAO1hB,SACb,GAAIugC,OAAQ/jC,IACZ,OAAOklB,OAAMtf,IAAI,SAAU8f,MAAQ,MAAOA,MAAKG,eAAeke,MAAOvgC,YAElE0yD,kBAEPw5B,sBAAuC,WACvC,QAASz5B,wBAshBT,MA/gBAA,qBAAoB11D,UAAUwuB,UAK9B,SAAUnoB,IAAKpD,SAAW,MAAOoD,MAMjCqvD,oBAAoB11D,UAAUylB,gBAK9B,SAAUpf,IAAKpD,SAIX,MAHIoD,KAAIR,MACJQ,IAAIR,KAAK2oB,UAAU/uB,KAAMwD,SAEtBoD,KAOXqvD,oBAAoB11D,UAAUgoF,kBAK9B,SAAUniF,KAAM5C,SAAW,MAAOxD,MAAK+uB,UAAU3oB,KAAM5C,UAMvDyyD,oBAAoB11D,UAAUioF,oBAK9B,SAAUpiF,KAAM5C,SAEZ,MADA4C,MAAK9C,MAAM0iB,gBAAgBhmB,KAAMwD,SAC1BxD,KAAK+uB,UAAU3oB,KAAM5C,UAOhCyyD,oBAAoB11D,UAAUmoF,eAK9B,SAAUtiF,KAAM5C,SAAW,MAAOxD,MAAK+uB,UAAU3oB,KAAM5C,UAMvDyyD,oBAAoB11D,UAAUsoF,aAK9B,SAAUziF,KAAM5C,SAAW,MAAOxD,MAAK+uB,UAAU3oB,KAAM5C,UAMvDyyD,oBAAoB11D,UAAUurF,iBAK9B,SAAUllF,IAAKpD,SACX,MAAOxD,MAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUyrF,kBAK9B,SAAUplF,IAAKpD,SAEX,MADAoD,KAAItD,MAAM0iB,gBAAgBhmB,KAAMwD,SACzBxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAU2rF,kBAK9B,SAAUtlF,IAAKpD,SAIX,MAHAoD,KAAI2N,SAASyR,gBAAgBhmB,KAAMwD,SACnCoD,IAAIxB,MAAM4gB,gBAAgBhmB,KAAMwD,SAChCoD,IAAItD,MAAM0iB,gBAAgBhmB,KAAMwD,SACzBxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAU6rF,mBAK9B,SAAUxlF,IAAKpD,SAGX,MAFAoD,KAAI2N,SAASyR,gBAAgBhmB,KAAMwD,SACnCoD,IAAItD,MAAM0iB,gBAAgBhmB,KAAMwD,SACzBxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUksF,sBAK9B,SAAU7lF,IAAKpD,SAGX,MAFAoD,KAAI2N,SAASyR,gBAAgBhmB,KAAMwD,SACnCxD,KAAKuvF,oBAAoB3oF,IAAIjF,KAAM6B,SAC5BxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUmsF,wBAK9B,SAAU9lF,IAAKpD,SAGX,MAFAoD,KAAIwgB,GAAGpB,gBAAgBhmB,KAAMwD,SAC7BxD,KAAKuvF,oBAAoB3oF,IAAIjF,KAAM6B,SAC5BxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUqsF,qBAK9B,SAAUhmF,IAAKpD,SAGX,MAFAoD,KAAI+lF,UAAU3mE,gBAAgBhmB,KAAMwD,SACpCxD,KAAKuvF,oBAAoB3oF,IAAIjF,KAAM6B,SAC5BxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUssF,iBAK9B,SAAUjmF,IAAKpD,SACX,MAAOxD,MAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUusF,kBAK9B,SAAUlmF,IAAKpD,SACX,GAAIugC,OAAQ/jC,IAIZ,OAHI4G,KAAIwf,YACJxf,IAAIwf,WAAWvf,QAAQ,SAAUT,MAAQ,MAAOA,MAAK2oB,UAAUgV,MAAOvgC,WAEnExD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUysF,qBAK9B,SAAUpmF,IAAKpD,SAIX,MAHAoD,KAAIqI,UAAU+W,gBAAgBhmB,KAAMwD,SACpCoD,IAAI0jF,SAAStkE,gBAAgBhmB,KAAMwD,SACjCoD,IAAc,UAAEof,gBAAgBhmB,KAAMwD,SACjCxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAU0sF,aAK9B,SAAUrmF,IAAKpD,SAEX,MADAoD,KAAIqI,UAAU+W,gBAAgBhmB,KAAMwD,SAC7BxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAU2sF,uBAK9B,SAAUtmF,IAAKpD,SAEX,MADAoD,KAAIqI,UAAU+W,gBAAgBhmB,KAAMwD,SAC7BxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAU4sF,cAK9B,SAAUvmF,IAAKpD,SAEX,MADAoD,KAAItD,MAAM0iB,gBAAgBhmB,KAAMwD,SACzBxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAU6sF,kBAK9B,SAAUxmF,IAAKpD,SAEX,MADAxD,MAAKolB,mBAAmBxe,IAAIyyB,WAAY71B,SACjCxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUgtF,wBAK9B,SAAU3mF,IAAKpD,SAGX,MAFAoD,KAAI0mF,IAAItnE,gBAAgBhmB,KAAMwD,SAC9BoD,IAAI8jF,IAAI1kE,gBAAgBhmB,KAAMwD,SACvBxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUitF,kBAK9B,SAAU5mF,IAAKpD,SAEX,MADAoD,KAAI2N,SAASyR,gBAAgBhmB,KAAMwD,SAC5BxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUktF,iBAK9B,SAAU7mF,IAAKpD,SAGX,MAFAoD,KAAI2N,SAASyR,gBAAgBhmB,KAAMwD,SACnCoD,IAAIxB,MAAM4gB,gBAAgBhmB,KAAMwD,SACzBxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUotF,sBAK9B,SAAU/mF,IAAKpD,SAEX,MADAxD,MAAKuvF,oBAAoB3oF,IAAI8mF,QAASlqF,SAC/BxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUqtF,oBAK9B,SAAUhnF,IAAKpD,SACX,GAAIugC,OAAQ/jC,IAEZ,OADA4G,KAAI8mF,QAAQ7mF,QAAQ,SAAU6Y,OAAS,MAAOA,OAAMpc,MAAM0iB,gBAAgB+d,MAAOvgC,WAC1ExD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUutF,eAK9B,SAAUlnF,IAAKpD,SAEX,MADAxD,MAAKuvF,oBAAoB3oF,IAAIoR,MAAOxU,SAC7BxD,KAAKgmB,gBAAgBpf,IAAKpD,UAOrCyyD,oBAAoB11D,UAAUgvF,oBAK9B,SAAUxjE,MAAOvoB,SACb,GAAIugC,OAAQ/jC,IACZ+rB,OAAMllB,QAAQ,SAAUkf,MAAQ,MAAOA,MAAKC,gBAAgB+d,MAAOvgC,YAOvEyyD,oBAAoB11D,UAAUytF,oBAK9B,SAAUtoE,KAAMliB,SAKZ,MAJAkiB,MAAKpiB,MAAM0iB,gBAAgBhmB,KAAMwD,SAC7BkiB,KAAKtf,MACLsf,KAAKtf,KAAK2oB,UAAU/uB,KAAMwD,SAEvBkiB,MAOXuwC,oBAAoB11D,UAAU0tF,yBAK9B,SAAUvoE,KAAMliB,SAKZ,MAJAxD,MAAKolB,mBAAmBM,KAAK2T,WAAY71B,SACrCkiB,KAAKtf,MACLsf,KAAKtf,KAAK2oB,UAAU/uB,KAAMwD,SAEvBkiB,MAOXuwC,oBAAoB11D,UAAU2tF,oBAK9B,SAAUxoE,KAAMliB,SAEZ,MADAkiB,MAAKK,KAAKC,gBAAgBhmB,KAAMwD,SACzBkiB,MAOXuwC,oBAAoB11D,UAAU4tF,gBAK9B,SAAUzoE,KAAMliB,SAEZ,MADAkiB,MAAKpiB,MAAM0iB,gBAAgBhmB,KAAMwD,SAC1BkiB,MAOXuwC,oBAAoB11D,UAAUkuF,sBAK9B,SAAU/oE,KAAMliB,SACZ,GAAIugC,OAAQ/jC,IAOZ,OANmB0lB,MAAY,OAAEM,gBAAgBhmB,KAAMwD,SACvDkiB,KAAKglB,QAAQ7jC,QAAQ,SAAU8jC,QAAU,MAAO5G,OAAM3e,mBAAmBulB,OAAOrjB,KAAM9jB,WAClFkiB,KAAKylB,mBACLnrC,KAAKolB,mBAAmBM,KAAKylB,kBAAkB7jB,KAAM9jB,SAEzDkiB,KAAKmlB,QAAQhkC,QAAQ,SAAUikC,QAAU,MAAO/G,OAAM3e,mBAAmB0lB,OAAOxjB,KAAM9jB,WAC/EkiB,MAOXuwC,oBAAoB11D,UAAUouF,YAK9B,SAAUjpE,KAAMliB,SAIZ,MAHAkiB,MAAKzW,UAAU+W,gBAAgBhmB,KAAMwD,SACrCxD,KAAKolB,mBAAmBM,KAAK4kE,SAAU9mF,SACvCxD,KAAKolB,mBAAmBM,KAAK6kE,UAAW/mF,SACjCkiB,MAOXuwC,oBAAoB11D,UAAU0uF,kBAK9B,SAAUvpE,KAAMliB,SAGZ,MAFAxD,MAAKolB,mBAAmBM,KAAKqpE,UAAWvrF,SACxCxD,KAAKolB,mBAAmBM,KAAKspE,WAAYxrF,SAClCkiB,MAOXuwC,oBAAoB11D,UAAU4uF,eAK9B,SAAUzpE,KAAMliB,SAEZ,MADAkiB,MAAKnhB,MAAMyhB,gBAAgBhmB,KAAMwD,SAC1BkiB,MAOXuwC,oBAAoB11D,UAAUsuF,iBAK9B,SAAUnpE,KAAMliB,SAAW,MAAOkiB,OAMlCuwC,oBAAoB11D,UAAU6kB,mBAK9B,SAAUF,MAAO1hB,SACb,GAAIugC,OAAQ/jC,IACZklB,OAAMre,QAAQ,SAAU6e,MAAQ,MAAOA,MAAKG,eAAeke,MAAOvgC,YAE/DyyD,uBAWP9wC,gBAAiC,SAAU1a,QAE3C,QAAS0a,mBACL,GAAI4e,OAAmB,OAAXt5B,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,IAEhE,OADA+jC,OAAM1e,SAAW,GAAInB,KACd6f,MA8CX,MAlDA9jC,WAAUklB,gBAAiB1a,QAW3B0a,gBAAgB5kB,UAAU0tF,yBAK1B,SAAUvoE,KAAMliB,SAEZ,MAAOkiB,OAOXP,gBAAgB5kB,UAAUkuF,sBAK1B,SAAU/oE,KAAMliB,SAEZ,MAAOkiB,OAOXP,gBAAgB5kB,UAAUurF,iBAK1B,SAAUllF,IAAKpD,SAIX,MAHIoD,KAAInF,MACJzB,KAAKqlB,SAASkX,IAAI31B,IAAInF,MAEnB,MAEJ0jB,iBACTuqE,uBAUEnqE,+BAAgD,SAAU9a,QAE1D,QAAS8a,kCACL,GAAIwe,OAAmB,OAAXt5B,QAAmBA,OAAOzI,MAAMhC,KAAM6B,YAAc7B,IAEhE,OADA+jC,OAAMve,sBACCue,MAgBX,MApBA9jC,WAAUslB,+BAAgC9a,QAW1C8a,+BAA+BhlB,UAAUusF,kBAKzC,SAAUxzE,EAAG9V,SAET,MADAxD,MAAKwlB,mBAAmBze,KAAKuS,EAAEhW,OACxBmH,OAAOlK,UAAUusF,kBAAkBv9C,KAAKvvC,KAAMsZ,EAAG9V,UAErD+hB,gCACTmqE,uBAyBE9pE,4BAA6C,SAAUnb,QAEvD,QAASmb,6BAA4B5b,YACjC,GAAI+5B,OAAQt5B,OAAO8kC,KAAKvvC,OAASA,IAEjC,OADA+jC,OAAM/5B,WAAaA,WACZ+5B,MAmDX,MAvDA9jC,WAAU2lB,4BAA6Bnb,QAUvCmb,4BAA4BrlB,UAAUovF,OAItC,SAAUvtF,KACN,GAAqBwtF,OAAQpvF,OAAOC,OAAO2B,IAAI/B,YAAYE,UAC3D,KAAK,GAAqBgvB,QAAQntB,KAC9BwtF,MAAMrgE,MAAQntB,IAAImtB,KAEtB,OAAOqgE,QAOXhqE,4BAA4BrlB,UAAU8uF,cAKtC,SAAUtpE,KAAMviB,SAKZ,MAJKuiB,MAAK/b,aACN+b,KAAO/lB,KAAK2vF,OAAO5pE,MACnBA,KAAK/b,WAAahK,KAAKgK,YAEpB+b,MAOXH,4BAA4BrlB,UAAU+uF,cAKtC,SAAU5pE,KAAMliB,SAKZ,MAJKkiB,MAAK1b,aACN0b,KAAO1lB,KAAK2vF,OAAOjqE,MACnBA,KAAK1b,WAAahK,KAAKgK,YAEpB0b,MAEJE,6BACTwpE,kBAyGE5lE,cAA+B,SAAU/e,QAEzC,QAAS+e,eAActY,QAASvG,MAC5B,MAAOF,QAAO8kC,KAAKvvC,KAAM2K,KAAMuG,UAAYlR,KAE/C,MAJAC,WAAUupB,cAAe/e,QAIlB+e,eACT0yC,YAKE2zB,oBAAqC,WACrC,QAASA,qBAAoBltE,UAAWgH,WACpC,GAAIoa,OAAQ/jC,IACZA,MAAK2iB,UAAYA,UACjB3iB,KAAK2pB,UAAYA,UACjB3pB,KAAKiyB,UACLjyB,KAAK6pB,YAAcH,gBAAgBC,WACnC3pB,KAAKopB,cAAgB,GAAIP,KACzBc,UAAUP,cAAcviB,QAAQ,SAAU8gB,UACyB,MAA3Doc,MAAM3a,cAAc7I,IAAInY,eAAeuf,SAAShiB,SAChDo+B,MAAM3a,cAAc5I,IAAIpY,eAAeuf,SAAShiB,QAAQ,KAIpE,MAAOkqF,wBAEPC,uBAAwC,WACxC,QAASA,wBAAuBC,YAAaC,QAASC,YAAaC,eAAgB5iF,MAAO6iF,KAAMp6D,WAAY7L,oBAAqBkmE,aAC7H,GAAIrsD,OAAQ/jC,IACZA,MAAK+vF,YAAcA,YACnB/vF,KAAKgwF,QAAUA,QACfhwF,KAAKiwF,YAAcA,YACnBjwF,KAAKkwF,eAAiBA,eACtBlwF,KAAKowF,YAAcA,YACnBpwF,KAAKqwF,sBAAwB,GAAIxnE,KACjC7oB,KAAKswF,eAAiB,GAAIznE,KAC1B7oB,KAAKuwF,eAAiB,GAAI1nE,KAC1B7oB,KAAKwwF,6BAA8B,EACnCxwF,KAAKywF,UACLnjF,MAAMzG,QAAQ,SAAUq0B,SAAW,MAAO6I,OAAM0sD,OAAOv1D,QAAQz5B,MAAQy5B,QAAQ53B,OAC/E,IAAqBotF,gBAAiBR,eAAetqF,IAAI,SAAU+qF,cAAgB,MAAOA,cAAa7nE,WAOvG,IANA9oB,KAAK4wF,cACDnoE,gCAAgCioE,eAAgBN,YAAaL,YAAY99D,QAC7EjyB,KAAK6wF,gBAAkB5mE,mBAAmBC,oBAAqBwmE,gBAC/DjtF,MAAMwgB,KAAKjkB,KAAK4wF,cAAc7uF,UAAU8E,QAAQ,SAAU8gB,UACtDoc,MAAM+sD,iBAAiBnpE,SAAShiB,MAAOgiB,SAAShiB,MAAOo+B,MAAMwsD,kBAE7Dx6D,WAAY,CACZ,GAAqBg7D,eAAgBruE,gCAAgC1iB,KAAK+vF,YAAYptE,UAAWuK,YAAY+nB,YAC7Gj1C,MAAK8wF,iBAAiBC,cAAeA,cAAe/wF,KAAKuwF,gBAE7DJ,KAAKtpF,QAAQ,SAAUmqF,QACnB,GAAqBC,mBAAoBD,OAAO1tF,OAC5Cof,gCAAgCqhB,MAAMgsD,YAAYptE,UAAWuK,YAAY6nB,WAC7EhR,OAAM+sD,kBAAmBxtF,MAAO0tF,OAAOvvF,MAAQwvF,kBAAmBltD,MAAMwsD,kBAExEvwF,KAAKuwF,eAAehwE,IAAIvgB,KAAK+vF,YAAYptE,UAAUC,yBAAyBsK,YAAYgoB,qBACxFl1C,KAAKwwF,6BAA8B,GAGvC/sF,MAAMwgB,KAAKjkB,KAAK4wF,cAAc7uF,UAAU8E,QAAQ,SAAU8gB,WACzBA,SAASQ,OAAS4b,MAAMwsD,eAAehwE,IAAInY,eAAeuf,SAAShiB,UAE5Fo+B,MAAMmtD,0BAA0BvpE,SAASY,aAAcZ,SAAShiB,OAAO,KA+RnF,MAxRAmqF,wBAAuBvvF,UAAU4wF,aAGjC,WACI,GAAIptD,OAAQ/jC,IAEZyD,OAAMwgB,KAAKjkB,KAAK4wF,cAAc7uF,UAAU8E,QAAQ,SAAU8gB,UACtDoc,MAAMmtD,0BAA0BvpE,SAASY,aAAcZ,SAAShiB,OAAO,MAG/EnF,OAAO4f,eAAe0vE,uBAAuBvvF,UAAW,sBACpDggB,IAGA,WAEI,GAAqB6wE,kBACAC,iBASrB,OARArxF,MAAKqwF,sBAAsBxpF,QAAQ,SAAU8gB,UACrCA,SAASQ,MACTkpE,eAAetqF,KAAK4gB,UAGpBypE,cAAcrqF,KAAK4gB,YAGpBypE,cAAcxoF,OAAOyoF,iBAEhC/wE,YAAY,EACZD,cAAc,IAElB7f,OAAO4f,eAAe0vE,uBAAuBvvF,UAAW,4BACpDggB,IAGA,WACI,GAAqB+wE,qBAAsBtxF,KAAKuxF,mBAAmB3rF,IAAI,SAAU+hB,UAAY,MAAOA,UAAShiB,MAAM8B,aAC9F+pF,iBAAmBxxF,KAAKkwF,eAAe/sF,OAK5D,OAJAquF,kBAAiBp9D,KAAK,SAAUq9D,KAAMC,MAClC,MAAOJ,qBAAoBpuF,QAAQuuF,KAAK3oE,UAAU1iB,MAC9CkrF,oBAAoBpuF,QAAQwuF,KAAK5oE,UAAU1iB,QAE5CorF,kBAEXlxE,YAAY,EACZD,cAAc,IAElB7f,OAAO4f,eAAe0vE,uBAAuBvvF,UAAW,gBACpDggB,IAGA,WACI,GAAqBoxE,cAErB,OADA3xF,MAAKuwF,eAAe1pF,QAAQ,SAAU8zC,SAAWg3C,WAAW5qF,KAAK/E,MAAM2vF,WAAYh3C,WAC5Eg3C,YAEXrxE,YAAY,EACZD,cAAc,IAQlByvE,uBAAuBvvF,UAAUuwF,iBAMjC,SAAUnrF,MAAOisF,aAAcC,iBAC3B7xF,KAAK8xF,eAAensF,OAAOkB,QAAQ,SAAUijB,OACzC,GAAqBioE,YAAajoE,MAAMzgB,KAAKs+E,MAAQiK,aAChC9M,SAAW18E,eAAe2pF,YAC1B31D,aAAey1D,gBAAgBtxE,IAAIukE,SACnD1oD,gBACDA,gBACAy1D,gBAAgBrxE,IAAIskE,SAAU1oD,eAElCA,aAAar1B,MAAOijB,QAASF,MAAME,QAAS1mB,MAAOyuF,gBAO3DjC,uBAAuBvvF,UAAUuxF,eAIjC,SAAUnsF,OAKN,IAJA,GAGqB2kB,SAHA5jB,UACAsrF,UAAYhyF,KACZiyF,SAAW,EAEX,OAAdD,WACH1nE,QAAU0nE,UAAUnB,gBAAgBtwE,IAAInY,eAAezC,QACnD2kB,SACA5jB,OAAOK,KAAK/E,MAAM0E,OAAQ4jB,QAAQpH,OAAO,SAAU4G,OAAS,MAAOA,OAAMzgB,KAAK6mC,aAAe+hD,UAAY,KAEzGD,UAAU9B,eAAepuF,OAAS,GAClCmwF,WAEJD,UAAYA,UAAUhC,OAM1B,OAJA1lE,SAAUtqB,KAAK+vF,YAAYlmE,YAAYtJ,IAAInY,eAAezC,QACtD2kB,SACA5jB,OAAOK,KAAK/E,MAAM0E,OAAQ4jB,SAEvB5jB,QAQXopF,uBAAuBvvF,UAAU2wF,0BAMjC,SAAUgB,uBAAwBvsF,MAAOwiB,OACrC,GAAI4b,OAAQ/jC,KACSupB,iBAAmBvpB,KAAK4wF,cAAcrwE,IAAInY,eAAezC,OAC9E,KAAK4jB,mBAAsB2oE,yBAA2BjpE,gBAAgBpoB,WAClEqxF,yBAA2BjpE,gBAAgBE,gBAC3CI,iBAAiBhB,eAAiBU,gBAAgBI,iBAChD6oE,yBAA2BjpE,gBAAgBI,gBACzC6oE,yBAA2BjpE,gBAAgBE,gBAC3CI,iBAAiBhB,eAAiBU,gBAAgBsvB,QACtD,MAAO,KAEX,IAAqB45C,wBAAyBnyF,KAAKqwF,sBAAsB9vE,IAAInY,eAAezC,OAC5F,IAAIwsF,uBACA,MAAOA,uBAEX,IAAsD,MAAlDnyF,KAAKswF,eAAe/vE,IAAInY,eAAezC,QAEvC,MADA3F,MAAK+vF,YAAY99D,OAAOlrB,KAAK,GAAIyiB,eAAc,yCAA2CrhB,UAAUxC,OAAQ3F,KAAKowF,cAC1G,IAEXpwF,MAAKswF,eAAe9vE,IAAIpY,eAAezC,QAAQ,EAC/C,IAAqBysF,sBAAuB7oE,iBAAiBnB,UAAUxiB,IAAI,SAAU+hB,UACjF,GAAqB0qE,qBAAsB1qE,SAASE,SAC/ByqE,uBAA4C3qE,SAAqB,YACjE4qE,oBAAmC,EACxD,IAA4B,MAAxB5qE,SAASC,YAAqB,CAC9B,GAAqB4qE,eAAmCzuD,MAAM0uD,eAAelpE,iBAAiBhB,cAAgB5iB,MAAOgiB,SAASC,aAAeO,MAClH,OAAvBqqE,cAAc7sF,MACd2sF,uBAAyBE,cAAc7sF,OAGvC2sF,uBAA0C,KAC1CD,oBAAsBG,cAAclvF,WAGvC,IAAIqkB,SAASK,WAAY,CAC1B,GAAqBF,MAAOH,SAASG,MAAQH,SAASK,WAAWiE,MACjEsmE,iBACIzqE,KAAKliB,IAAI,SAAU2lB,KAAO,MAASwY,OAAM0uD,eAAelpE,iBAAiBhB,aAAcgD,IAAKpD,aAE/F,IAAIR,SAASI,SAAU,CACxB,GAAqBD,MAAOH,SAASG,MAAQH,SAASI,SAASkE,MAC/DsmE,iBACIzqE,KAAKliB,IAAI,SAAU2lB,KAAO,MAASwY,OAAM0uD,eAAelpE,iBAAiBhB,aAAcgD,IAAKpD,SAEpG,MAAOT,oBAAmBC,UACtBC,YAAa0qE,uBACbzqE,SAAUwqE,oBACVvqE,KAAMyqE,mBAMd,OAHAJ,wBACIjqE,sBAAsBqB,kBAAoBpB,MAAOA,MAAOC,UAAWgqE,uBACvEpyF,KAAKqwF,sBAAsB7vE,IAAIpY,eAAezC,OAAQwsF,wBAC/CA,wBAQXrC,uBAAuBvvF,UAAUmyF,oBAMjC,SAAUR,uBAAwB3mE,IAAKpD,OAEnC,OADc,KAAVA,QAAoBA,OAAQ,GAC5BoD,IAAI+H,YAAa,CACjB,GAAqB6B,WAAYn1B,KAAKywF,OAA0BllE,IAAU,MAAEjoB,MAC5E,QAASmpB,SAAS,EAAMnpB,MAAoB,MAAb6xB,UAAoB,KAAOA,WAE9D,GAAiB,MAAb5J,IAAI5lB,MAAe,CAEnB,GAAKusF,yBAA2BjpE,gBAAgBpoB,WAC5CqxF,yBAA2BjpE,gBAAgBnoB,UAAY,CACvD,GAAIsH,eAAemjB,IAAI5lB,SACnB3F,KAAK+vF,YAAYptE,UAAUC,yBAAyBsK,YAAY+tD,WAChE7yE,eAAemjB,IAAI5lB,SACf3F,KAAK+vF,YAAYptE,UAAUC,yBAAyBsK,YAAY6nB,aACpE3sC,eAAemjB,IAAI5lB,SACf3F,KAAK+vF,YAAYptE,UAAUC,yBAAyBsK,YAAYgtD,oBACpE9xE,eAAemjB,IAAI5lB,SACf3F,KAAK+vF,YAAYptE,UAAUC,yBAAyBsK,YAAY+nB,aACpE,MAAO1pB,IAEPnjB,gBAAemjB,IAAI5lB,SACnB3F,KAAK+vF,YAAYptE,UAAUC,yBAAyBsK,YAAYgoB,oBAChE,KAA0Bs7C,6BAA8B,GAIhE,GAAIpoF,eAAemjB,IAAI5lB,SACnB3F,KAAK+vF,YAAYptE,UAAUC,yBAAyBsK,YAAYwtD,UAChE,MAAOnvD,IAGX,IAAgF,MAA5EvrB,KAAKkxF,0BAA0BgB,uBAAwB3mE,IAAI5lB,MAAOwiB,OAClE,MAAOoD,KAGf,MAAO,OAQXukE,uBAAuBvvF,UAAUkyF,eAMjC,SAAUP,uBAAwB3mE,IAAKpD,WACrB,KAAVA,QAAoBA,OAAQ,EAChC,IAAqBwqE,aAAc3yF,KACd4yF,UAAYzqE,MACZzhB,OAAS,IAI9B,IAHK6kB,IAAImB,aACLhmB,OAAS1G,KAAK0yF,oBAAoBR,uBAAwB3mE,IAAKpD,QAE/DoD,IAAI26D,QACCx/E,QAAU6kB,IAAIoB,aACfjmB,QAAW+lB,SAAS,EAAMnpB,MAAO,WAGpC,CAED,MAAQoD,QAAUisF,YAAY3C,SAAS,CACnC,GAAqB6C,aAAcF,WACnCA,aAAcA,YAAY3C,QACtB6C,YAAY5C,cACZ2C,WAAY,GAEhBlsF,OAASisF,YAAYD,oBAAoBzpE,gBAAgBE,cAAeoC,IAAKqnE,WAG5ElsF,SAIGA,QAHC6kB,IAAI+uB,QAAUt6C,KAAK+vF,YAAYpmE,UAAU2wB,QAC1Ct6C,KAAK+vF,YAAYpmE,UAAUvjB,KAAKkB,YAAcc,eAAkCmjB,IAAU,QACJ,MAAtFvrB,KAAK+vF,YAAY3mE,cAAc7I,IAAInY,eAAkCmjB,IAAU,QACtEA,IAGAA,IAAIoB,WAAajmB,QAAW+lB,SAAS,EAAMnpB,MAAO,MAAS,MAOhF,MAHKoD,SACD1G,KAAK+vF,YAAY99D,OAAOlrB,KAAK,GAAIyiB,eAAc,mBAAqBrhB,UAA8BojB,IAAW,OAAIvrB,KAAKowF,cAEnH1pF,QAEJopF,0BAEPgD,yBAA0C,WAC1C,QAASA,0BAAyBnwE,UAAWkgB,SAAUkwD,eAAgB/oF,YACnE,GAAI+5B,OAAQ/jC,IACZA,MAAK2iB,UAAYA,UACjB3iB,KAAKqwF,sBAAwB,GAAIxnE,KACjC7oB,KAAKswF,eAAiB,GAAIznE,KAC1B7oB,KAAKojE,WACLpjE,KAAK4wF,cAAgB,GAAI/nE,KACzBga,SAASlF,iBAAiBmF,QAAQj8B,QAAQ,SAAUmC,cAEhD+f,oBAD0CpjB,OAAS8B,WAAYuB,cAAgB+e,SAAU/e,eACnDigB,gBAAgBE,eAAe,EAAMnf,WAAY+5B,MAAMq/B,QAASr/B,MAAM6sD,iBAEhH7nE,kBAAkB8Z,SAASlF,iBAAiBvV,UAAUxiB,IAAI,SAAU8Z,OAAS,MAAOA,OAAMiI,WAAa/e,OAAOmqF,gBAAiB9pE,gBAAgBE,eAAe,EAAOnf,WAAYhK,KAAKojE,QAASpjE,KAAK4wF,eAiIxM,MA5HAkC,0BAAyBvyF,UAAUkzB,MAGnC,WACI,GAAIsQ,OAAQ/jC,IAIZ,IAHAyD,MAAMwgB,KAAKjkB,KAAK4wF,cAAc7uF,UAAU8E,QAAQ,SAAU8gB,UACtDoc,MAAMmtD,0BAA0BvpE,SAAShiB,MAAOgiB,SAASQ,SAEzDnoB,KAAKojE,QAAQthE,OAAS,EAAG,CACzB,GAAqBkxF,aAAchzF,KAAKojE,QAAQv9D,KAAK,KACrD,MAAM,IAAIrB,OAAM,2BAA6BwuF,aAGjD,GAAqB5B,kBACAC,iBASrB,OARArxF,MAAKqwF,sBAAsBxpF,QAAQ,SAAU8gB,UACrCA,SAASQ,MACTkpE,eAAetqF,KAAK4gB,UAGpBypE,cAAcrqF,KAAK4gB,YAGpBypE,cAAcxoF,OAAOyoF,iBAOhCyB,yBAAyBvyF,UAAU2wF,0BAKnC,SAAUvrF,MAAOwiB,OACb,GAAI4b,OAAQ/jC,KACSupB,iBAAmBvpB,KAAK4wF,cAAcrwE,IAAInY,eAAezC,OAC9E,KAAK4jB,iBACD,MAAO,KAEX,IAAqB4oE,wBAAyBnyF,KAAKqwF,sBAAsB9vE,IAAInY,eAAezC,OAC5F,IAAIwsF,uBACA,MAAOA,uBAEX,IAAsD,MAAlDnyF,KAAKswF,eAAe/vE,IAAInY,eAAezC,QAEvC,MADA3F,MAAKojE,QAAQr8D,KAAK,GAAIyiB,eAAc,yCAA2CrhB,UAAUxC,OAAQ4jB,iBAAiBvf,aAC3G,IAEXhK,MAAKswF,eAAe9vE,IAAIpY,eAAezC,QAAQ,EAC/C,IAAqBysF,sBAAuB7oE,iBAAiBnB,UAAUxiB,IAAI,SAAU+hB,UACjF,GAAqB0qE,qBAAsB1qE,SAASE,SAC/ByqE,uBAA4C3qE,SAAqB,YACjE4qE,oBAAmC,EACxD,IAA4B,MAAxB5qE,SAASC,YAAqB,CAC9B,GAAqB4qE,eAAgBzuD,MAAM0uD,gBAAiB9sF,MAAOgiB,SAASC,aAAeO,MAAOoB,iBAAiBvf,WACxF,OAAvBwoF,cAAc7sF,MACd2sF,uBAAyBE,cAAc7sF,OAGvC2sF,uBAA0C,KAC1CD,oBAAsBG,cAAclvF,WAGvC,IAAIqkB,SAASK,WAAY,CAC1B,GAAqBF,MAAOH,SAASG,MAAQH,SAASK,WAAWiE,MACjEsmE,iBACIzqE,KAAKliB,IAAI,SAAU2lB,KAAO,MAAOwY,OAAM0uD,eAAelnE,IAAKpD,MAAOoB,iBAAiBvf,kBAEtF,IAAI2d,SAASI,SAAU,CACxB,GAAqBD,MAAOH,SAASG,MAAQH,SAASI,SAASkE,MAC/DsmE,iBACIzqE,KAAKliB,IAAI,SAAU2lB,KAAO,MAAOwY,OAAM0uD,eAAelnE,IAAKpD,MAAOoB,iBAAiBvf,cAE3F,MAAO0d,oBAAmBC,UACtBC,YAAa0qE,uBACbzqE,SAAUwqE,oBACVvqE,KAAMyqE,mBAMd,OAHAJ,wBACIjqE,sBAAsBqB,kBAAoBpB,MAAOA,MAAOC,UAAWgqE,uBACvEpyF,KAAKqwF,sBAAsB7vE,IAAIpY,eAAezC,OAAQwsF,wBAC/CA,wBAQXW,yBAAyBvyF,UAAUkyF,eAMnC,SAAUlnE,IAAKpD,MAAO8qE,yBACJ,KAAV9qE,QAAoBA,OAAQ,EAChC,IAAqB+qE,aAAa,CAC7B3nE,KAAImB,YAA2B,MAAbnB,IAAI5lB,QAEnByC,eAAemjB,IAAI5lB,SACnB3F,KAAK2iB,UAAUC,yBAAyBsK,YAAYwtD,WACpDtyE,eAAemjB,IAAI5lB,SACf3F,KAAK2iB,UAAUC,yBAAyBsK,YAAYC,0BACxD+lE,YAAa,EAG4C,MAApDlzF,KAAKkxF,0BAA0B3lE,IAAI5lB,MAAOwiB,SAC/C+qE,YAAa,GAGrB,IAAqBxsF,QAAS6kB,GAS9B,OARIA,KAAI26D,SAAWgN,aACX3nE,IAAIoB,WACJjmB,QAAW+lB,SAAS,EAAMnpB,MAAO,MAGjCtD,KAAKojE,QAAQr8D,KAAK,GAAIyiB,eAAc,mBAAqBrhB,UAA8BojB,IAAW,OAAI0nE,uBAGvGvsF,QAEJosF,4BAkJPpoE,2BAA4C,WAC5C,QAASA,4BAA2BD,KAChCzqB,KAAKyqB,IAAMA,IAgEf,MAzDAC,4BAA2BnqB,UAAUoD,WAKrC,SAAUqL,IAAK5I,MACX,GAAI29B,OAAQ/jC,IACZ,OAAO0mB,YAAW1X,IAAIpJ,IAAI,SAAUtC,OAAS,MAAOD,YAAWC,MAAOygC,MAAO,QAAW39B,OAO5FskB,2BAA2BnqB,UAAUsD,eAKrC,SAAU+B,IAAKQ,MACX,GAAI29B,OAAQ/jC,KACS0tF,WACAyF,UAAY,GAAIjvE,KAAIte,KAAOA,IAAe,SAI/D,OAHApF,QAAOy2B,KAAKrxB,KAAKiB,QAAQ,SAAUoN,KAC/By5E,QAAQ3mF,KAAK,GAAI+f,iBAAgB7S,IAAK5Q,WAAWuC,IAAIqO,KAAM8vB,MAAO,MAAOovD,UAAUn/D,IAAI/f,SAEpF,GAAI4S,gBAAe6mE,QAAStnF,OAOvCskB,2BAA2BnqB,UAAUuD,eAKrC,SAAUR,MAAO8C,MAAQ,MAAOohB,SAAQlkB,MAAO8C,OAM/CskB,2BAA2BnqB,UAAUwD,WAKrC,SAAUT,MAAO8C,MACb,MAAI9C,iBAAiBurB,YACVvrB,MAGAtD,KAAKyqB,IAAItE,WAAW7iB,QAG5BonB,8BA0OP0oE,sBAAuC,WACvC,QAASA,uBAAsBC,oBAC3BrzF,KAAKqzF,mBAAqBA,mBAE9B,MAAOD,0BAEPE,QAAUrtE,SAAS,MACnB2jB,iBAAkC,WAClC,QAASA,kBAAiBjnB,WACtB3iB,KAAK2iB,UAAYA,UA2ErB,MAnEAinB,kBAAiBrpC,UAAUgzF,QAM3B,SAAU9oE,IAAK+oE,aAAcT,gBACzB,GAAqB/oF,YAAasL,eAAe,WAAYk+E,aAAaptF,MACrD2mB,wBAA0BymE,aAAa71D,iBAAiB7Q,gBACxDsuB,oBAAsBo4C,aAAap4C,oBACnCq4C,eAAiB,GAAIX,0BAAyB9yF,KAAK2iB,UAAW6wE,aAAcT,eAAgB/oF,YAC5F0pF,cAAgB7mE,oCAAoC7sB,KAAK2iB,UAAW8H,IAAK,EAAcsC,0BACvGnkB,OAAO6qF,eAAehgE,QAAQ7tB,IAAI,SAAU+hB,UAAY,MAAOgD,aAAYF,IAAK9C,aAChF/hB,IAAI,SAAUwT,IACf,GAAI8R,cAAe9R,GAAG8R,aAAcC,SAAW/R,GAAG+R,SAAUN,MAAQzR,GAAGyR,MAAOO,UAAYhS,GAAGgS,SAC7F,OAAOjF,YAAW+G,YAAYstD,mBAAmBruD,QAC7C3E,QAAQqD,OAAQO,UAAWF,aAAcC,aAG5BwoE,YAAcxtE,WAAW+G,YAAYqtD,WAAWpuD,QAAQzF,WAAWgtE,gBACnEE,mBAAqBxsE,IAAI,GAAIuE,SAA2B2nE,QAAa,QAAM,GAAIlnE,iBAAgBunE,cAAetnE,eAC9GgnE,mBAAqBjsF,eAAeosF,aAAaptF,MAAQ,WAM9E,IALApG,KAAK6zF,uBAAuBppE,IAAK+oE,aAAaptF,KAAKkB,UAAW6e,WAAW+G,YAAYotD,qBAAqBnuD,QACtG1B,IAAItE,WAAWqtE,aAAaptF,KAAKkB,WACjCof,WAAW00B,oBAAoBx1C,IAAI,SAAU0D,IAAM,MAAOmhB,KAAItE,WAAW7c,GAAGhC,cAC5EssF,sBAEAJ,aAAalqF,GAAI,CACjB,GAAqBwqF,qBAAsB3tE,WAAW+G,YAAYutD,yBAC7DtuD,QAAQ3E,QAAQgsE,aAAalqF,IAAK2c,SAASotE,sBAC3C15D,QACLlP,KAAI4O,WAAWtyB,KAAK+sF,qBAExB,MAAO,IAAIV,uBAAsBC,qBAOrCzpD,iBAAiBrpC,UAAUwzF,WAK3B,SAAUtpE,IAAKupE,mBACXh0F,KAAK6zF,uBAAuBppE,IAAKupE,kBAAmBznE,YAQxDqd,iBAAiBrpC,UAAUszF,uBAM3B,SAAUppE,IAAKnjB,UAAWhE,OACtB,GAAqB+vF,oBAAqBjsF,gBAAiBE,UAAWA,YAAe,YAChE2sF,oBAAsBhuE,SAASotE,oBAC/C7yE,IAAIld,OACJ20B,WAAW3R,WAAW4G,YAAYmtD,iBAAqC7zD,eAAeiE,IAAItE,WAAW7e,cAAiBugF,aAAaC,SAAU5vD,aAAaC,MAAOD,aAAayI,UACnLlW,KAAI4O,WAAWtyB,KAAKktF,sBAEjBrqD,oBAiBPT,iBAAkC,WAClC,QAASA,kBAAiB2mB,YACtB9vD,KAAK8vD,WAAaA,WAkCtB,MA5BA3mB,kBAAiB5oC,UAAUmjC,WAI3B,SAAUt9B,MAAQ,MAAOpG,MAAK8vD,WAAWE,YAAY5pD,MAAMorB,KAAK6f,eAAelvC,WAM/EgnC,iBAAiB5oC,UAAU2L,QAK3B,SAAU9F,KAAM6pD,qBACY,KAApBA,kBAA8BA,iBAAkB,EACpD,IAAqBujC,cAAezkF,SAAS/O,KAAK8vD,WAAWE,YAAY5pD,MAAOirC,eAAelvC,SAC/F,IAAIqxF,aACA,MAAOA,aAGP,IAAIvjC,gBACA,KAAM,IAAIzrD,OAAM,mCAAqCkB,UAAUU,MAAQ,KAE3E,OAAO,OAGR+iC,oBAiBP+qD,mBAAoC,WACpC,QAASA,oBAAmB92D,UACX,KAATA,OAAmBA,KAAO,MAC9Bp9B,KAAKo9B,KAAOA,KACZp9B,KAAKm0F,eAAiB,GAAItrE,KAC1B7oB,KAAKo0F,SACLp0F,KAAKq0F,SAAW,EAChBr0F,KAAKs0F,aAAc,EA8IvB,MAtIAJ,oBAAmB3zF,UAAUg0F,UAK7B,SAAUzrF,IAAKsnB,SAKX,WAJgB,KAAZA,UAAsBA,QAAU,MAC/BpwB,KAAKm0F,eAAengE,IAAIlrB,MACzB9I,KAAKm0F,eAAe3zE,IAAI1X,IAAKsnB,SAE1BpwB,MAKXk0F,mBAAmB3zF,UAAUi0F,QAG7B,WAGI,MAFAx0F,MAAKo0F,MAAMrtF,SACX/G,KAAKq0F,SAAW,EACTr0F,MASXk0F,mBAAmB3zF,UAAUk0F,WAO7B,SAAUC,KAAM/oD,UAAWgpD,YAAaC,YACpC,IAAK50F,KAAK60F,YACN,KAAM,IAAIrwF,OAAM,oDAEpB,IAAiB,MAAbmnC,YAAsB3rC,KAAKm0F,eAAengE,IAAI2X,WAC9C,KAAM,IAAInnC,OAAM,wBAA2BmnC,UAAY,IAE3D,IAAY,MAAR+oD,KACA,KAAM,IAAIlwF,OAAM,oDAEpB,IAAIkwF,KAAO10F,KAAKq0F,SACZ,KAAM,IAAI7vF,OAAM,0CAEpB,IAAImnC,YAA6B,MAAfgpD,aAAqC,MAAdC,YACrC,KAAM,IAAIpwF,OAAM;0IAKpB,OAHAxE,MAAKs0F,aAAc,EACnBt0F,KAAKq0F,SAAWK,KAChB10F,KAAK60F,YAAY9tF,MAAO2tF,KAAMA,KAAM/oD,UAAWA,UAAWgpD,YAAaA,YAAaC,WAAYA,aACzF50F,MAEXQ,OAAO4f,eAAe8zE,mBAAmB3zF,UAAW,eAChDggB,IAGA,WAAc,MAAOvgB,MAAKo0F,MAAMjxF,OAAO,GAAG,IAC1Cmd,YAAY,EACZD,cAAc,IAKlB6zE,mBAAmB3zF,UAAUu0F,OAG7B,WACI,GAAI/wD,OAAQ/jC,IACZ,KAAKA,KAAKs0F,YACN,MAAO,KAEX,IAAqBS,cAAe,GAAIlsE,KACnB+9C,WACAutB,iBACrB1wF,OAAMwgB,KAAKjkB,KAAKm0F,eAAel9D,QAAQpwB,QAAQ,SAAUiC,IAAKiC,GAC1DgqF,aAAav0E,IAAI1X,IAAKiC,GACtB67D,QAAQ7/D,KAAK+B,KACbqrF,eAAeptF,KAAKg9B,MAAMowD,eAAe5zE,IAAIzX,MAAQ,OAEzD,IAAqBksF,UAAW,GACXX,SAAW,EACXY,gBAAkB,EAClBC,gBAAkB,EAClBC,eAAiB,CA0BtC,OAzBAn1F,MAAKo0F,MAAMvtF,QAAQ,SAAUunC,UACzBimD,SAAW,EACXW,UAAY5mD,SACPxoC,IAAI,SAAU2oC,SAEf,GAAqB6mD,UAAWvnE,YAAY0gB,QAAQmmD,KAAOL,SAc3D,OAbAA,UAAW9lD,QAAQmmD,KACM,MAArBnmD,QAAQ5C,YAERypD,UACIvnE,YAA+BknE,aAAax0E,IAAIguB,QAAQ5C,WAAespD,iBAC3EA,gBAAqCF,aAAax0E,IAAIguB,QAAQ5C,WAE9DypD,UAAYvnE,YAA+B0gB,QAAoB,YAAI2mD,iBACnEA,gBAAqC3mD,QAAoB,YAEzD6mD,UAAYvnE,YAA+B0gB,QAAmB,WAAI4mD,gBAClEA,eAAoC5mD,QAAmB,YAEpD6mD,WAENvvF,KAAK,KACVmvF,UAAY,MAEhBA,SAAWA,SAAS7xF,MAAM,GAAI,IAE1Bi6B,KAAQp9B,KAAKo9B,MAAQ,GACrBk3C,QAtII,EAuIJ+gB,WAAc,GACdzuB,QAAWA,QACXutB,eAAkBA,eAClBa,SAAYA,WAMpBd,mBAAmB3zF,UAAU+rC,YAG7B,WACI,MAAOtsC,MAAKs0F,YAAc,qDAAuB/mE,eAAe0rB,KAAKvzC,UAAU1F,KAAM,KAAM,IACvF,IAEDk0F,sBAqCPnmE,WAAa,mEAuBbI,+BAAiC,iBACjCC,qBAAuB,wBACvBE,aAAe,KACfgnE,kBAAoBrvE,SAAS,QAAS,KAAM,MAC5CsvE,kBAAoBtvE,SAAS,QAAS,KAAM,MAK5CuvE,aAA8B,WAC9B,QAASA,cAAazwD,QAClB/kC,KAAK+kC,OAASA,OACd/kC,KAAKy1F,YAAc,EACnBz1F,KAAKgY,SACLhY,KAAK01F,YAET,MAAOF,iBAEP9mE,sBAAuC,WACvC,QAASA,uBAAsBinE,SAC3B31F,KAAK21F,QAAUA,QACf31F,KAAK41F,YACL51F,KAAK61F,mBAAqB,EAC1B71F,KAAK81F,QAAU,GAAIN,cAAaG,UA0PpC,MArPAjnE,uBAAsBC,WAGtB,WAAc,MAAO,IAAID,uBAAsB,IAC/CluB,OAAO4f,eAAesO,sBAAsBnuB,UAAW,gBACnDggB,IAGA,WAAc,MAAOvgB,MAAK81F,OAAO91F,KAAK81F,OAAOh0F,OAAS,IACtDwe,YAAY,EACZD,cAAc,IAOlBqO,sBAAsBnuB,UAAUw1F,QAKhC,SAAU9xE,KAAM+xE,cACK,KAAbA,WAAuBA,SAAW,IACtCh2F,KAAKi2F,MAAMhyE,MAAQ,KAAM+xE,UAAU,IAKvCtnE,sBAAsBnuB,UAAU21F,YAGhC,WAAc,MAA0C,KAAnCl2F,KAAKm2F,aAAan+E,MAAMlW,QAI7C4sB,sBAAsBnuB,UAAU61F,WAGhC,WACI,MAAOp2F,MAAKm2F,aAAapxD,OAASzW,aAAaxsB,OAAS9B,KAAKm2F,aAAaV,aAQ9E/mE,sBAAsBnuB,UAAU01F,MAMhC,SAAUhyE,KAAMiN,KAAMmlE,aACF,KAAZA,UAAsBA,SAAU,GAChCnlE,KAAKpvB,OAAS,IACd9B,KAAKm2F,aAAan+E,MAAMjR,KAAKmqB,MAC7BlxB,KAAKm2F,aAAaV,aAAevkE,KAAKpvB,OACtC9B,KAAKm2F,aAAaT,SAAS3uF,KAAKkd,MAAQA,KAAKja,YAAc,OAE3DqsF,SACAr2F,KAAK81F,OAAO/uF,KAAK,GAAIyuF,cAAax1F,KAAK21F,WAM/CjnE,sBAAsBnuB,UAAU+1F,oBAGhC,WACQt2F,KAAKk2F,eACLl2F,KAAK81F,OAAOtnD,OAMpB9f,sBAAsBnuB,UAAUg2F,UAGhC,WACIv2F,KAAK21F,UACD31F,KAAKk2F,gBACLl2F,KAAKm2F,aAAapxD,OAAS/kC,KAAK21F,UAMxCjnE,sBAAsBnuB,UAAUi2F,UAGhC,WACIx2F,KAAK21F,UACD31F,KAAKk2F,gBACLl2F,KAAKm2F,aAAapxD,OAAS/kC,KAAK21F,UAOxCjnE,sBAAsBnuB,UAAUk2F,UAIhC,SAAUC,OAAS12F,KAAK41F,SAAS7uF,KAAK2vF,QAItChoE,sBAAsBnuB,UAAUo2F,SAGhC,WAAc,MAA0B32F,MAAK41F,SAASpnD,OACtDhuC,OAAO4f,eAAesO,sBAAsBnuB,UAAW,gBACnDggB,IAGA,WACI,MAAOvgB,MAAK41F,SAAS9zF,OAAS,EAAI9B,KAAK41F,SAAS51F,KAAK41F,SAAS9zF,OAAS,GAAK,MAEhFwe,YAAY,EACZD,cAAc,IAKlBqO,sBAAsBnuB,UAAUyuB,SAGhC,WACI,MAAOhvB,MAAK42F,YACPhxF,IAAI,SAAUiW,GAAK,MAAOA,GAAE7D,MAAMlW,OAAS,EAAIusB,cAAcxS,EAAEkpB,QAAUlpB,EAAE7D,MAAMnS,KAAK,IAAM,KAC5FA,KAAK,OAOd6oB,sBAAsBnuB,UAAU8rC,qBAKhC,SAAUS,YAAa+pD,kBACE,KAAjBA,eAA2BA,aAAe,EAY9C,KAAK,GAXgBjxF,KAAM,GAAIsuF,oBAAmBpnD,aAC7BgqD,mBAAoB,EACpBC,uBAAyB,WACrCD,oBAIDlxF,IAAI2uF,UAAUznD,YAAa,KAAK2nD,WAAW,EAAG3nD,YAAa,EAAG,GAC9DgqD,mBAAoB,IAGF/rF,EAAI,EAAGA,EAAI8rF,aAAc9rF,IAC/CnF,IAAI4uF,UACJuC,wBAmCJ,OAjCA/2F,MAAK42F,YAAY/vF,QAAQ,SAAUm+B,KAAMgyD,SACrCpxF,IAAI4uF,SAMJ,KALA,GAAqByC,OAAQjyD,KAAK0wD,SACb19E,MAAQgtB,KAAKhtB,MACb08E,KAAO1vD,KAAKD,OAASzW,aAAaxsB,OAClCo1F,QAAU,EAExBA,QAAUD,MAAMn1F,SAAWm1F,MAAMC,UACpCxC,MAAQ18E,MAAMk/E,SAASp1F,OACvBo1F,SAQJ,KANIA,QAAUD,MAAMn1F,QAAsB,IAAZk1F,SAA0B,IAATtC,KAC3CoC,mBAAoB,EAGpBC,yBAEGG,QAAUD,MAAMn1F,QAAQ,CAC3B,GAAqB6I,MAA0BssF,MAAMC,SAChCnhF,OAASpL,KAAKZ,MAAMqzB,KACpB+5D,WAAaxsF,KAAKZ,MAAMi7B,KACxBoyD,UAAYzsF,KAAKZ,MAAMkxD,GAM5C,KALAr1D,IAAI2uF,UAAUx+E,OAAOjN,IAAKiN,OAAOqa,SAC5BqkE,WAAWC,KAAM3+E,OAAOjN,IAAKquF,WAAYC,WAC9C1C,MAAQ18E,MAAMk/E,SAASp1F,OACvBo1F,UAEOA,QAAUD,MAAMn1F,SAAW6I,OAASssF,MAAMC,WAAaD,MAAMC,WAChExC,MAAQ18E,MAAMk/E,SAASp1F,OACvBo1F,aAILtxF,KAMX8oB,sBAAsBnuB,UAAU82F,qBAIhC,SAAUv7E,OAAS,MAAO9b,MAAK61F,mBAAqB/5E,OAMpD4S,sBAAsBnuB,UAAUuJ,OAKhC,SAAUk7B,KAAMC,QACZ,GAAqBqyD,aAAct3F,KAAK81F,OAAO9wD,KAAOhlC,KAAK61F,mBAC3D,IAAIyB,YAEA,IAAK,GADgBC,aAActyD,OAAS5W,cAAcipE,YAAYvyD,QAAQjjC,OACpDmvB,UAAY,EAAGA,UAAYqmE,YAAYt/E,MAAMlW,OAAQmvB,YAAa,CACxF,GAAqBC,MAAOomE,YAAYt/E,MAAMiZ,UAC9C,IAAIC,KAAKpvB,OAASy1F,YACd,MAAOD,aAAY5B,SAASzkE,UAEhCsmE,cAAermE,KAAKpvB,OAG5B,MAAO,OAEXtB,OAAO4f,eAAesO,sBAAsBnuB,UAAW,eACnDggB,IAGA,WACI,MAAIvgB,MAAK81F,OAAOh0F,QAA+D,IAArD9B,KAAK81F,OAAO91F,KAAK81F,OAAOh0F,OAAS,GAAGkW,MAAMlW,OACzD9B,KAAK81F,OAAO3yF,MAAM,GAAI,GAE1BnD,KAAK81F,QAEhBx1E,YAAY,EACZD,cAAc,IAEXqO,yBAKP8oE,uBAAwC,WACxC,QAASA,wBAAuBC,wBAC5Bz3F,KAAKy3F,uBAAyBA,uBA4iBlC,MAriBAD,wBAAuBj3F,UAAU2tF,oBAKjC,SAAUxoE,KAAM+E,KAGZ,MAFA/E,MAAKK,KAAKC,gBAAgBhmB,KAAMyqB,KAChCA,IAAIsrE,QAAQrwE,KAAM,KACX,MAOX8xE,uBAAuBj3F,UAAU4tF,gBAKjC,SAAUzoE,KAAM+E,KAIZ,MAHAA,KAAIwrE,MAAMvwE,KAAM,WAChBA,KAAKpiB,MAAM0iB,gBAAgBhmB,KAAMyqB,KACjCA,IAAIsrE,QAAQrwE,KAAM,KACX,MAOX8xE,uBAAuBj3F,UAAUouF,YAKjC,SAAUjpE,KAAM+E,KACZA,IAAIwrE,MAAMvwE,KAAM,QAChBA,KAAKzW,UAAU+W,gBAAgBhmB,KAAMyqB,KACrCA,IAAIwrE,MAAMvwE,KAAM,MAChB,IAAqBgyE,aAAgC,MAAlBhyE,KAAK6kE,WAAqB7kE,KAAK6kE,UAAUzoF,OAAS,CAoBrF,OAnBI4jB,MAAK4kE,SAASxoF,QAAU,IAAM41F,aAC9BjtE,IAAIwrE,MAAMvwE,KAAM,KAChB1lB,KAAKolB,mBAAmBM,KAAK4kE,SAAU7/D,KACvCA,IAAI6rE,sBACJ7rE,IAAIwrE,MAAMvwE,KAAM,OAGhB+E,IAAIsrE,UACJtrE,IAAI8rE,YACJv2F,KAAKolB,mBAAmBM,KAAK4kE,SAAU7/D,KACvCA,IAAI+rE,YACAkB,cACAjtE,IAAIsrE,QAAQrwE,KAAM,YAClB+E,IAAI8rE,YACJv2F,KAAKolB,mBAAmBM,KAAK6kE,UAAW9/D,KACxCA,IAAI+rE,cAGZ/rE,IAAIsrE,QAAQrwE,KAAM,KACX,MAOX8xE,uBAAuBj3F,UAAU4uF,eAKjC,SAAUzpE,KAAM+E,KAIZ,MAHAA,KAAIwrE,MAAMvwE,KAAM,UAChBA,KAAKnhB,MAAMyhB,gBAAgBhmB,KAAMyqB,KACjCA,IAAIsrE,QAAQrwE,KAAM,KACX,MAOX8xE,uBAAuBj3F,UAAUsuF,iBAKjC,SAAUnpE,KAAM+E,KAGZ,MAF6B/E,MAAK6nD,QAAQ/jE,MAAM,MAC1C3C,QAAQ,SAAUm+B,MAAQva,IAAIsrE,QAAQrwE,KAAM,MAAQsf,QACnD,MAOXwyD,uBAAuBj3F,UAAUyrF,kBAKjC,SAAUjmE,KAAM0E,KACZ,GAAqBktE,cAAeltE,IAAIyrE,aASxC,OARKyB,eACDltE,IAAIwrE,MAAMlwE,KAAM,KAEpB0E,IAAIwrE,MAAMlwE,KAAMA,KAAKtkB,KAAO,OAC5BskB,KAAKziB,MAAM0iB,gBAAgBhmB,KAAMyqB,KAC5BktE,cACDltE,IAAIwrE,MAAMlwE,KAAM,KAEb,MAOXyxE,uBAAuBj3F,UAAU2rF,kBAKjC,SAAUnmE,KAAM0E,KACZ,GAAqBktE,cAAeltE,IAAIyrE,aAYxC,OAXKyB,eACDltE,IAAIwrE,MAAMlwE,KAAM,KAEpBA,KAAKxR,SAASyR,gBAAgBhmB,KAAMyqB,KACpCA,IAAIwrE,MAAMlwE,KAAM,KAChBA,KAAK3gB,MAAM4gB,gBAAgBhmB,KAAMyqB,KACjCA,IAAIwrE,MAAMlwE,KAAM,QAChBA,KAAKziB,MAAM0iB,gBAAgBhmB,KAAMyqB,KAC5BktE,cACDltE,IAAIwrE,MAAMlwE,KAAM,KAEb,MAOXyxE,uBAAuBj3F,UAAU6rF,mBAKjC,SAAUrmE,KAAM0E,KACZ,GAAqBktE,cAAeltE,IAAIyrE,aAUxC,OATKyB,eACDltE,IAAIwrE,MAAMlwE,KAAM,KAEpBA,KAAKxR,SAASyR,gBAAgBhmB,KAAMyqB,KACpCA,IAAIwrE,MAAMlwE,KAAM,IAAMA,KAAKtkB,KAAO,OAClCskB,KAAKziB,MAAM0iB,gBAAgBhmB,KAAMyqB,KAC5BktE,cACDltE,IAAIwrE,MAAMlwE,KAAM,KAEb,MAOXyxE,uBAAuBj3F,UAAUksF,sBAKjC,SAAU1mE,KAAM0E,KACZ1E,KAAKxR,SAASyR,gBAAgBhmB,KAAMyqB,IACpC,IAAqBhpB,MAAOskB,KAAKtkB,IACjC,OAAoB,OAAhBskB,KAAK8lE,SAEO,OADZpqF,KAAOzB,KAAK43F,qBAAqB7xE,KAAK8lE,UAG3B,MAGfphE,IAAIwrE,MAAMlwE,KAAM,IAAMtkB,KAAO,KAC7BzB,KAAKuvF,oBAAoBxpE,KAAKpkB,KAAM8oB,IAAK,KACzCA,IAAIwrE,MAAMlwE,KAAM,KACT,OAOXyxE,uBAAuBj3F,UAAUmsF,wBAKjC,SAAU3mE,KAAM0E,KAKZ,MAJA1E,MAAKqB,GAAGpB,gBAAgBhmB,KAAMyqB,KAC9BA,IAAIwrE,MAAMlwE,KAAM,KAChB/lB,KAAKuvF,oBAAoBxpE,KAAKpkB,KAAM8oB,IAAK,KACzCA,IAAIwrE,MAAMlwE,KAAM,KACT,MAOXyxE,uBAAuBj3F,UAAUurF,iBAKjC,SAAUllF,IAAK6jB,KACX,GAAqBi9D,SAA6B9gF,IAAS,IAC3D,IAAmB,MAAfA,IAAIilF,QACJ,OAAQjlF,IAAIilF,SACR,IAAKL,YAAWE,MACZhE,QAAU,OACV,MACJ,KAAK8D,YAAWC,KACZ/D,QAAU,MACV,MACJ,KAAK8D,YAAWG,WACZjE,QAA6B4N,kBAAuB,IACpD,MACJ,KAAK9J,YAAWI,WACZlE,QAA6B6N,kBAAuB,IACpD,MACJ,SACI,KAAM,IAAI/wF,OAAM,4BAA8BoC,IAAIilF,SAI9D,MADAphE,KAAIwrE,MAAMrvF,IAAK8gF,SACR,MAOX8P,uBAAuBj3F,UAAUqsF,qBAKjC,SAAUhmF,IAAK6jB,KAMX,MALAA,KAAIwrE,MAAMrvF,IAAK,QACfA,IAAI+lF,UAAU3mE,gBAAgBhmB,KAAMyqB,KACpCA,IAAIwrE,MAAMrvF,IAAK,KACf5G,KAAKuvF,oBAAoB3oF,IAAIjF,KAAM8oB,IAAK,KACxCA,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX4wF,uBAAuBj3F,UAAUssF,iBAKjC,SAAUjmF,IAAK6jB,KACX,GAAqBnnB,OAAQsD,IAAItD,KAOjC,OANqB,gBAAVA,OACPmnB,IAAIwrE,MAAMrvF,IAAKonB,iBAAiB1qB,MAAOtD,KAAKy3F,yBAG5ChtE,IAAIwrE,MAAMrvF,IAAK,GAAKtD,OAEjB,MAOXk0F,uBAAuBj3F,UAAUysF,qBAKjC,SAAUpmF,IAAK6jB,KAQX,MAPAA,KAAIwrE,MAAMrvF,IAAK,KACfA,IAAIqI,UAAU+W,gBAAgBhmB,KAAMyqB,KACpCA,IAAIwrE,MAAMrvF,IAAK,MACfA,IAAI0jF,SAAStkE,gBAAgBhmB,KAAMyqB,KACnCA,IAAIwrE,MAAMrvF,IAAK,MACbA,IAAc,UAAEof,gBAAgBhmB,KAAMyqB,KACxCA,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX4wF,uBAAuBj3F,UAAU0sF,aAKjC,SAAUrmF,IAAK6jB,KAGX,MAFAA,KAAIwrE,MAAMrvF,IAAK,KACfA,IAAIqI,UAAU+W,gBAAgBhmB,KAAMyqB,KAC7B,MAOX+sE,uBAAuBj3F,UAAU2sF,uBAKjC,SAAUtmF,IAAK6jB,KAEX,MADA7jB,KAAIqI,UAAU+W,gBAAgBhmB,KAAMyqB,KAC7B,MAOX+sE,uBAAuBj3F,UAAUgtF,wBAKjC,SAAU3mF,IAAK6jB,KACX,GAAqBotE,MACrB,QAAQjxF,IAAImyD,UACR,IAAKgwB,gBAAeC,OAChB6O,MAAQ,IACR,MACJ,KAAK9O,gBAAeG,UAChB2O,MAAQ,KACR,MACJ,KAAK9O,gBAAeE,UAChB4O,MAAQ,IACR,MACJ,KAAK9O,gBAAeI,aAChB0O,MAAQ,KACR,MACJ,KAAK9O,gBAAeU,IAChBoO,MAAQ,IACR,MACJ,KAAK9O,gBAAeW,GAChBmO,MAAQ,IACR,MACJ,KAAK9O,gBAAeM,KAChBwO,MAAQ,GACR,MACJ,KAAK9O,gBAAeK,MAChByO,MAAQ,GACR,MACJ,KAAK9O,gBAAeO,OAChBuO,MAAQ,GACR,MACJ,KAAK9O,gBAAeQ,SAChBsO,MAAQ,GACR,MACJ,KAAK9O,gBAAeS,OAChBqO,MAAQ,GACR,MACJ,KAAK9O,gBAAeY,MAChBkO,MAAQ,GACR,MACJ,KAAK9O,gBAAea,YAChBiO,MAAQ,IACR,MACJ,KAAK9O,gBAAec,OAChBgO,MAAQ,GACR,MACJ,KAAK9O,gBAAee,aAChB+N,MAAQ,IACR,MACJ,SACI,KAAM,IAAIrzF,OAAM,oBAAsBoC,IAAImyD,UAOlD,MALAtuC,KAAIwrE,MAAMrvF,IAAK,KACfA,IAAI0mF,IAAItnE,gBAAgBhmB,KAAMyqB,KAC9BA,IAAIwrE,MAAMrvF,IAAK,IAAMixF,MAAQ,KAC7BjxF,IAAI8jF,IAAI1kE,gBAAgBhmB,KAAMyqB,KAC9BA,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX4wF,uBAAuBj3F,UAAUitF,kBAKjC,SAAU5mF,IAAK6jB,KAIX,MAHA7jB,KAAI2N,SAASyR,gBAAgBhmB,KAAMyqB,KACnCA,IAAIwrE,MAAMrvF,IAAK,KACf6jB,IAAIwrE,MAAMrvF,IAAKA,IAAInF,MACZ,MAOX+1F,uBAAuBj3F,UAAUktF,iBAKjC,SAAU7mF,IAAK6jB,KAKX,MAJA7jB,KAAI2N,SAASyR,gBAAgBhmB,KAAMyqB,KACnCA,IAAIwrE,MAAMrvF,IAAK,KACfA,IAAIxB,MAAM4gB,gBAAgBhmB,KAAMyqB,KAChCA,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX4wF,uBAAuBj3F,UAAUotF,sBAKjC,SAAU/mF,IAAK6jB,KAIX,MAHAA,KAAIwrE,MAAMrvF,IAAK,KACf5G,KAAKuvF,oBAAoB3oF,IAAI8mF,QAASjjE,IAAK,KAC3CA,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX4wF,uBAAuBj3F,UAAUqtF,oBAKjC,SAAUhnF,IAAK6jB,KACX,GAAIsZ,OAAQ/jC,IAOZ,OANAyqB,KAAIwrE,MAAMrvF,IAAK,KACf5G,KAAK83F,gBAAgB,SAAUp4E,OAC3B+K,IAAIwrE,MAAMrvF,IAAKonB,iBAAiBtO,MAAMzL,IAAK8vB,MAAM0zD,uBAAwB/3E,MAAMqH,QAAU,KACzFrH,MAAMpc,MAAM0iB,gBAAgB+d,MAAOtZ,MACpC7jB,IAAI8mF,QAASjjE,IAAK,KACrBA,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX4wF,uBAAuBj3F,UAAUutF,eAKjC,SAAUlnF,IAAK6jB,KAIX,MAHAA,KAAIwrE,MAAMrvF,IAAK,KACf5G,KAAKuvF,oBAAoB3oF,IAAIoR,MAAOyS,IAAK,KACzCA,IAAIwrE,MAAMrvF,IAAK,KACR,MAQX4wF,uBAAuBj3F,UAAUgvF,oBAMjC,SAAU/7E,YAAaiX,IAAKstE,WACxB,GAAIh0D,OAAQ/jC,IACZA,MAAK83F,gBAAgB,SAAU/xE,MAAQ,MAAOA,MAAKC,gBAAgB+d,MAAOtZ,MAASjX,YAAaiX,IAAKstE,YAUzGP,uBAAuBj3F,UAAUu3F,gBAQjC,SAAU5gD,QAAS1jC,YAAaiX,IAAKstE,WAEjC,IAAK,GADgBC,oBAAoB,EACfjtF,EAAI,EAAGA,EAAIyI,YAAY1R,OAAQiJ,IACjDA,EAAI,IACA0f,IAAI2rE,aAAe,IACnB3rE,IAAIwrE,MAAM,KAAM8B,WAAW,GACtBC,oBAEDvtE,IAAI8rE,YACJ9rE,IAAI8rE,YACJyB,mBAAoB,IAIxBvtE,IAAIwrE,MAAM,KAAM8B,WAAW,IAGnC7gD,QAAQ1jC,YAAYzI,GAEpBitF,qBAEAvtE,IAAI+rE,YACJ/rE,IAAI+rE,cAQZgB,uBAAuBj3F,UAAU6kB,mBAKjC,SAAUiU,WAAY5O,KAClB,GAAIsZ,OAAQ/jC,IACZq5B,YAAWxyB,QAAQ,SAAU6e,MAAQ,MAAOA,MAAKG,eAAeke,MAAOtZ,QAEpE+sE,0BAiFPj6D,kBAAmC,WACnC,QAASA,sBA6DT,MAnDAA,mBAAkBh9B,UAAU03F,yBAQ5B,SAAUnrD,YAAa5nB,MAAOmY,SAAU66D,eAAgBC,qBACnC,KAAb96D,WAAuBA,SAAW,QACf,KAAnB66D,iBAA6BA,gBAAiB,EAClD,IAAqB1pE,WAAY,GAAIC,mBAAkB0pE,iBAClC1tE,IAAMiE,sBAAsBC,YACjDH,WAAUpJ,mBAAmBF,MAAOuF,IACpC,IAAqB2tE,eAAgB/6D,SAAWA,SAAS7zB,MAAM,QAC/DglB,WAAU6pE,UAAUxxF,QAAQ,SAAUwxF,UAAWC,oBAC7C,GAAqBC,eAAgBF,UAAUzyF,IAAI,SAAU4yF,UAAY,MAAOA,UAAS/2F,KAAO,OAAS+2F,SAASC,KAAO5yF,KAAK,IAC9HuyF,eAAcrxF,KAAK,WAAawxF,cAAgB,WAAaD,mBAAqB,QAEtF9pE,UAAUkqE,oBAAoB7xF,QAAQ,SAAUiG,OAAQ6rF,oBAEpDP,cAAcrxF,KAAK,eACA+F,OAAS,UAAY6rF,mBAAqB,OAEjE,IAAqBC,IAAKV,eACtBztE,IAAI4hB,qBAAqBS,YAAasrD,cAAct2F,QAAQwqC,cAC5D,GACiB8nD,MAAQgE,cAAcxvF,QAAQ6hB,IAAIuE,WAAY4pE,IAMnE,OALIA,KAEAxE,MAAMrtF,KAAK,IAEf0jB,IAAI4sE,qBAAqBe,cAAct2F,SAC9B+2F,WAAYzE,MAAMvuF,KAAK,MAAOrC,QAASinB,MAQpD8S,kBAAkBh9B,UAAUi9B,eAM5B,SAAUsP,YAAa5nB,MAAOmY,UAE1B,WADiB,KAAbA,WAAuBA,SAAW,IAC/Br9B,KAAKi4F,yBAAyBnrD,YAAa5nB,MAAOmY,UAAUw7D,YAEhEt7D,qBAEP9O,kBAAmC,SAAUhkB,QAE7C,QAASgkB,mBAAkB0pE,iBACvB,GAAIp0D,OAAQt5B,OAAO8kC,KAAKvvC,MAAM,IAAUA,IAKxC,OAJA+jC,OAAMo0D,gBAAkBA,gBACxBp0D,MAAM+0D,eAAiB,EACvB/0D,MAAM20D,oBAAsB,GAAI7vE,KAChCkb,MAAMs0D,UAAY,GAAIxvE,KACfkb,MAuiBX,MA9iBA9jC,WAAUwuB,kBAAmBhkB,QAe7BgkB,kBAAkBluB,UAAUwuB,UAM5B,SAAUugB,EAAG7kB,IAAKsuE,iBACM,KAAhBA,cAA0BA,YAAc,OACxCzpD,GACAtvC,KAAK84F,iBACLxpD,EAAEvgB,UAAU/uB,KAAMyqB,KAClBzqB,KAAK84F,kBAGLruE,IAAIwrE,MAAM,KAAM8C,cAQxBtqE,kBAAkBluB,UAAUssF,iBAK5B,SAAUjmF,IAAK6jB,KACX,GAAqBnnB,OAAQsD,IAAItD,KACjC,OAAa,OAATA,OAAiBsD,IAAIR,MAAQimB,eAC7B5B,IAAIwrE,MAAMrvF,IAAK,IAAMtD,MAAQ,YACtB,MAEJmH,OAAOlK,UAAUssF,iBAAiBt9C,KAAKvvC,KAAM4G,IAAK6jB,MAW7DgE,kBAAkBluB,UAAUotF,sBAK5B,SAAU/mF,IAAK6jB,KACgB,IAAvB7jB,IAAI8mF,QAAQ5rF,QACZ2oB,IAAIwrE,MAAMrvF,IAAK,IAEnB,IAAqBF,QAAS+D,OAAOlK,UAAUotF,sBAAsBp+C,KAAKvvC,KAAM4G,IAAK6jB,IAIrF,OAH2B,KAAvB7jB,IAAI8mF,QAAQ5rF,QACZ2oB,IAAIwrE,MAAMrvF,IAAK,cAEZF,QAOX+nB,kBAAkBluB,UAAUusF,kBAK5B,SAAUlmF,IAAK6jB,KAEX,MADAzqB,MAAKg5F,iBAAiBpyF,IAAItD,MAAOsD,IAAIwf,WAAYqE,KAC1C,MAOXgE,kBAAkBluB,UAAU2sF,uBAK5B,SAAUtmF,IAAK6jB,KACX,GAAqB/jB,QAAS+D,OAAOlK,UAAU2sF,uBAAuB39C,KAAKvvC,KAAM4G,IAAK6jB,IAEtF,OADAA,KAAIwrE,MAAMrvF,IAAK,KACRF,QAOX+nB,kBAAkBluB,UAAUytF,oBAK5B,SAAUtoE,KAAM+E,KACZ,GAAI/E,KAAKsiE,YAAY9vD,aAAayI,WAAajb,KAAKpiB,gBAAiB+iB,gBAChEX,KAAKtf,KAAM,CAEZ,GAAIgT,IAAKsM,KAAKpiB,MAAMA,MAAO6tD,OAAS/3C,GAAG3X,KAAM88B,WAAanlB,GAAGmlB,UAC7D,IAAIA,WAAY,CACZ,GAAqB85D,WAAYr4F,KAAKq4F,UAAU93E,IAAIge,WAMpD,OALK85D,aACDA,aACAr4F,KAAKq4F,UAAU73E,IAAI+d,WAAY85D,YAEnCA,UAAUtxF,MAAOtF,KAAuB,OAAYg3F,GAAI/yE,KAAKjkB,OACtD,MAiBf,MAdIikB,MAAKsiE,YAAY9vD,aAAayI,WAC9BlW,IAAIwrE,MAAMvwE,KAAM,WAEhBA,KAAKsiE,YAAY9vD,aAAaC,OAC9B1N,IAAIwrE,MAAMvwE,KAAM,SAGhB+E,IAAIwrE,MAAMvwE,KAAM,OAEpB+E,IAAIwrE,MAAMvwE,KAAM,IAAMA,KAAKjkB,MAC3BzB,KAAKi5F,gBAAgBvzE,KAAKtf,KAAMqkB,KAChCA,IAAIwrE,MAAMvwE,KAAM,OAChBA,KAAKpiB,MAAM0iB,gBAAgBhmB,KAAMyqB,KACjCA,IAAIsrE,QAAQrwE,KAAM,KACX,MAOX+I,kBAAkBluB,UAAU4sF,cAK5B,SAAUvmF,IAAK6jB,KAMX,MALAA,KAAIwrE,MAAMrvF,IAAK,MACbA,IAAS,KAAEmoB,UAAU/uB,KAAMyqB,KAC7BA,IAAIwrE,MAAMrvF,IAAK,KACfA,IAAItD,MAAM0iB,gBAAgBhmB,KAAMyqB,KAChCA,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX6nB,kBAAkBluB,UAAUqsF,qBAK5B,SAAUhmF,IAAK6jB,KAQX,MAPAA,KAAIwrE,MAAMrvF,IAAK,QACf5G,KAAK84F,iBACLlyF,IAAI+lF,UAAU3mE,gBAAgBhmB,KAAMyqB,KACpCzqB,KAAK84F,iBACLruE,IAAIwrE,MAAMrvF,IAAK,KACf5G,KAAKuvF,oBAAoB3oF,IAAIjF,KAAM8oB,IAAK,KACxCA,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX6nB,kBAAkBluB,UAAUkuF,sBAK5B,SAAU/oE,KAAM+E,KACZ,GAAIsZ,OAAQ/jC,IAuBZ,OAtBAyqB,KAAIgsE,UAAU/wE,MACVA,KAAKsiE,YAAY9vD,aAAayI,WAC9BlW,IAAIwrE,MAAMvwE,KAAM,WAEpB+E,IAAIwrE,MAAMvwE,KAAM,SAAWA,KAAKjkB,MACb,MAAfikB,KAAK8lB,SACL/gB,IAAIwrE,MAAMvwE,KAAM,aAChB1lB,KAAK84F,iBACLpzE,KAAK8lB,OAAOxlB,gBAAgBhmB,KAAMyqB,KAClCzqB,KAAK84F,kBAETruE,IAAIsrE,QAAQrwE,KAAM,MAClB+E,IAAI8rE,YACJ7wE,KAAK2lB,OAAOxkC,QAAQ,SAAUykC,OAAS,MAAOvH,OAAMm1D,iBAAiB5tD,MAAO7gB,OAC9C,MAA1B/E,KAAKylB,mBACLnrC,KAAKm5F,uBAAuBzzE,KAAM+E,KAEtC/E,KAAKglB,QAAQ7jC,QAAQ,SAAU8jC,QAAU,MAAO5G,OAAMq1D,kBAAkBzuD,OAAQlgB,OAChF/E,KAAKmlB,QAAQhkC,QAAQ,SAAUikC,QAAU,MAAO/G,OAAMs1D,kBAAkBvuD,OAAQrgB,OAChFA,IAAI+rE,YACJ/rE,IAAIsrE,QAAQrwE,KAAM,KAClB+E,IAAIksE,WACG,MAOXloE,kBAAkBluB,UAAU24F,iBAK5B,SAAU5tD,MAAO7gB,KACT6gB,MAAM08C,YAAY9vD,aAAa61D,UAE/BtjE,IAAIwrE,MAAM,KAAM,gBAEpBxrE,IAAIwrE,MAAM,KAAM3qD,MAAM7pC,MACtBzB,KAAKi5F,gBAAgB3tD,MAAMllC,KAAMqkB,KACjCA,IAAIsrE,QAAQ,KAAM,MAOtBtnE,kBAAkBluB,UAAU64F,kBAK5B,SAAUzuD,OAAQlgB,KACVkgB,OAAOq9C,YAAY9vD,aAAa61D,UAChCtjE,IAAIwrE,MAAM,KAAM,YAEpBxrE,IAAIwrE,MAAM,KAAM,OAAStrD,OAAOlpC,KAAO,MACvCzB,KAAKi5F,gBAAgBtuD,OAAOvkC,KAAMqkB,KAClCA,IAAIsrE,QAAQ,KAAM,MAClBtrE,IAAI8rE,YACJv2F,KAAKolB,mBAAmBulB,OAAOrjB,KAAMmD,KACrCA,IAAI+rE,YACJ/rE,IAAIsrE,QAAQ,KAAM,MAOtBtnE,kBAAkBluB,UAAU44F,uBAK5B,SAAUzzE,KAAM+E,KACZA,IAAIwrE,MAAMvwE,KAAM,gBAChB1lB,KAAKs5F,aAAa5zE,KAAKylB,kBAAkB9jB,OAAQoD,KACjDA,IAAIsrE,QAAQrwE,KAAM,OAClB+E,IAAI8rE,YACJv2F,KAAKolB,mBAAmBM,KAAKylB,kBAAkB7jB,KAAMmD,KACrDA,IAAI+rE,YACJ/rE,IAAIsrE,QAAQrwE,KAAM,MAOtB+I,kBAAkBluB,UAAU84F,kBAK5B,SAAUvuD,OAAQrgB,KACVqgB,OAAOk9C,YAAY9vD,aAAa61D,UAChCtjE,IAAIwrE,MAAM,KAAM,YAEpBxrE,IAAIwrE,MAAM,KAAMnrD,OAAOrpC,KAAO,KAC9BzB,KAAKs5F,aAAaxuD,OAAOzjB,OAAQoD,KACjCA,IAAIwrE,MAAM,KAAM,KAChBj2F,KAAKi5F,gBAAgBnuD,OAAO1kC,KAAMqkB,IAAK,QACvCA,IAAIsrE,QAAQ,KAAM,MAClBtrE,IAAI8rE,YACJv2F,KAAKolB,mBAAmB0lB,OAAOxjB,KAAMmD,KACrCA,IAAI+rE,YACJ/rE,IAAIsrE,QAAQ,KAAM,MAOtBtnE,kBAAkBluB,UAAU6sF,kBAK5B,SAAUxmF,IAAK6jB,KAUX,MATAA,KAAIwrE,MAAMrvF,IAAK,KACf5G,KAAKs5F,aAAa1yF,IAAIygB,OAAQoD,KAC9BA,IAAIwrE,MAAMrvF,IAAK,KACf5G,KAAKi5F,gBAAgBryF,IAAIR,KAAMqkB,IAAK,QACpCA,IAAIsrE,QAAQnvF,IAAK,SACjB6jB,IAAI8rE,YACJv2F,KAAKolB,mBAAmBxe,IAAIyyB,WAAY5O,KACxCA,IAAI+rE,YACJ/rE,IAAIwrE,MAAMrvF,IAAK,KACR,MAOX6nB,kBAAkBluB,UAAU0tF,yBAK5B,SAAUvoE,KAAM+E,KAaZ,MAZI/E,MAAKsiE,YAAY9vD,aAAayI,WAC9BlW,IAAIwrE,MAAMvwE,KAAM,WAEpB+E,IAAIwrE,MAAMvwE,KAAM,YAAcA,KAAKjkB,KAAO,KAC1CzB,KAAKs5F,aAAa5zE,KAAK2B,OAAQoD,KAC/BA,IAAIwrE,MAAMvwE,KAAM,KAChB1lB,KAAKi5F,gBAAgBvzE,KAAKtf,KAAMqkB,IAAK,QACrCA,IAAIsrE,QAAQrwE,KAAM,MAClB+E,IAAI8rE,YACJv2F,KAAKolB,mBAAmBM,KAAK2T,WAAY5O,KACzCA,IAAI+rE,YACJ/rE,IAAIsrE,QAAQrwE,KAAM,KACX,MAOX+I,kBAAkBluB,UAAU0uF,kBAK5B,SAAUvpE,KAAM+E,KACZA,IAAIsrE,QAAQrwE,KAAM,SAClB+E,IAAI8rE,YACJv2F,KAAKolB,mBAAmBM,KAAKqpE,UAAWtkE,KACxCA,IAAI+rE,YACJ/rE,IAAIsrE,QAAQrwE,KAAM,YAAc4vE,kBAAkB7zF,KAAO,OACzDgpB,IAAI8rE,WACJ,IAAqBvH,aAAgCuG,kBAAkB/0E,IAAI80E,kBAAkB/lE,KAAK,QAAS,OAAO0I,WAAW,MACrHC,aAAaC,SACZvvB,OAAO8c,KAAKspE,WAIrB,OAHAhvF,MAAKolB,mBAAmB4pE,WAAYvkE,KACpCA,IAAI+rE,YACJ/rE,IAAIsrE,QAAQrwE,KAAM,KACX,MAOX+I,kBAAkBluB,UAAUgoF,kBAK5B,SAAUniF,KAAMqkB,KACZ,GAAqB8uE,QACrB,QAAQnzF,KAAK3E,MACT,IAAKymF,iBAAgBC,KACjBoR,QAAU,SACV,MACJ,KAAKrR,iBAAgBh0C,QACjBqlD,QAAU,KACV,MACJ,KAAKrR,iBAAgBh8C,SACjBqtD,QAAU,UACV,MACJ,KAAKrR,iBAAgBl3E,OAGrB,IAAKk3E,iBAAgBE,IACjBmR,QAAU,QACV,MACJ,KAAKrR,iBAAgB1iF,OACjB+zF,QAAU,QACV,MACJ,SACI,KAAM,IAAI/0F,OAAM,4BAA8B4B,KAAK3E,MAG3D,MADAgpB,KAAIwrE,MAAM,KAAMsD,SACT,MAOX9qE,kBAAkBluB,UAAUioF,oBAK5B,SAAU5hF,IAAK6jB,KAEX,MADA7jB,KAAItD,MAAM0iB,gBAAgBhmB,KAAMyqB,KACzB,MAOXgE,kBAAkBluB,UAAUmoF,eAK5B,SAAUtiF,KAAMqkB,KAGZ,MAFAzqB,MAAK+uB,UAAU3oB,KAAKqiF,GAAIh+D,KACxBA,IAAIwrE,MAAM,KAAM,MACT,MAOXxnE,kBAAkBluB,UAAUsoF,aAK5B,SAAUziF,KAAMqkB,KAIZ,MAHAA,KAAIwrE,MAAM,KAAM,mBAChBj2F,KAAK+uB,UAAU3oB,KAAKwiF,UAAWn+D,KAC/BA,IAAIwrE,MAAM,KAAM,KACT,MAMXxnE,kBAAkBluB,UAAUq3F,qBAI5B,SAAU9sD,QACN,GAAqBrpC,KACrB,QAAQqpC,QACJ,IAAKuhD,eAAcC,YACf7qF,KAAO,QACP,MACJ,KAAK4qF,eAAcE,oBACf9qF,KAAO,WACP,MACJ,KAAK4qF,eAAcG,KACf/qF,KAAO,MACP,MACJ,SACI,KAAM,IAAI+C,OAAM,2BAA6BsmC,QAErD,MAAOrpC,OAOXgtB,kBAAkBluB,UAAU+4F,aAK5B,SAAUjyE,OAAQoD,KACd,GAAIsZ,OAAQ/jC,IACZA,MAAK83F,gBAAgB,SAAU9sD,OAC3BvgB,IAAIwrE,MAAM,KAAMjrD,MAAMvpC,MACtBsiC,MAAMk1D,gBAAgBjuD,MAAM5kC,KAAMqkB,MACnCpD,OAAQoD,IAAK,MAQpBgE,kBAAkBluB,UAAUy4F,iBAM5B,SAAU11F,MAAO8iB,WAAYqE,KACzB,GAAIsZ,OAAQ/jC,KACRyB,KAAO6B,MAAM7B,KAAM88B,WAAaj7B,MAAMi7B,UAC1C,IAAIv+B,KAAKm4F,iBAAmBn4F,KAAKm4F,gBAAgB70F,OAE7C,WADAmnB,KAAIwrE,MAAM,KAAM,gBAGpB,IAAI13D,WAAY,CACZ,GAAqBzxB,QAAS9M,KAAK04F,oBAAoBn4E,IAAIge,WAC7C,OAAVzxB,SACAA,OAAS,IAAM9M,KAAK04F,oBAAoBc,KACxCx5F,KAAK04F,oBAAoBl4E,IAAI+d,WAAYzxB,SAE7C2d,IAAIwrE,MAAM,KAAMnpF,OAAS,KAG7B,GADA2d,IAAIwrE,MAAM,KAAuB,MAC7Bj2F,KAAK84F,eAAiB,EAAG,EAMiB1yE,gBACnBtkB,OAAS,IAC5B2oB,IAAIwrE,MAAM,KAAM,KAChBj2F,KAAK83F,gBAAgB,SAAU1xF,MAAQ,MAAOA,MAAK2oB,UAAUgV,MAAOtZ,MAA0B,WAAgBA,IAAK,KACnHA,IAAIwrE,MAAM,KAAM,QAU5BxnE,kBAAkBluB,UAAU04F,gBAM5B,SAAU7yF,KAAMqkB,IAAKsuE,aACb3yF,OAASimB,gBACT5B,IAAIwrE,MAAM,KAAM,KAChBj2F,KAAK+uB,UAAU3oB,KAAMqkB,IAAKsuE,eAG3BtqE,mBACT+oE,wBAoBEnuD,aAA8B,WAC9B,QAASA,cAAaymB,YAClB9vD,KAAK8vD,WAAaA,WA2CtB,MArCAzmB,cAAa9oC,UAAUkjC,OAIvB,SAAUr9B,MACN,GAAqB2pD,cAAe/vD,KAAK8vD,WAAWE,YAAY7pD,kBAAkBC,MAClF,OAAO2pD,eAAgBA,aAAav+B,KAAKof,WAAWzuC,WAWxDknC,aAAa9oC,UAAU2L,QAMvB,SAAU9F,KAAM6pD,qBACY,KAApBA,kBAA8BA,iBAAkB,EACpD,IAAqBwpC,OAAQz5F,KAAK8vD,WAAWE,YAAY7pD,kBAAkBC,MAC3E,IAAIqzF,MAAO,CACP,GAAqB7X,YAAa7yE,SAAS0qF,MAAO7oD,WAAWzuC,SAC7D,IAAIy/E,WACA,MAAOA,YAGf,GAAI3xB,gBACA,KAAM,IAAIzrD,OAAM,8BAAgCkB,UAAUU,MAE9D,OAAO,OAEJijC,gBAiBPha,kBAaJJ,iBAAgBiF,gBAAgB2d,MAC5B,gBACA,cACA,gBAEJ5iB,gBAAgBiF,gBAAgB7lB,OAAQ,YAExC4gB,gBAAgBiF,gBAAgB4d,KAC5B,eAAgB,YAAa,YAAa,YAAa,SACvD,SAAU,kBAAmB,kBAAmB,WAAY,cAC5D,UAAW,aAAc,YAAa,WAAY,SAClD,aAAc,gBAAiB,YAAa,eAAgB,cAEhE7iB,gBAAgBiF,gBAAgB6d,cAC5B,cACA,kBACA,YACA,YACA,YACA,eACA,gBACA,aACA,YACA,YACA,kBACA,cACA;;;;;;;AAiBJ,GAAI2nD,uBAAuC,WACvC,QAASA,0BAET,MAAOA,0BAcPC,QAAU,UACVC,OAAS,SACTC,OAAS,SACTC,OAAS,SA2CTC,QACA,iYAEA,s1BACA,qgCACA,gOACA,2uBACA,uBACA,2CACA,uBACA,wCACA,uBACA,kCACA,yCACA,mLACA,8JACA,eACA,yBACA,iCACA,iQACA,yHACA,sCACA,+BACA,4BACA,0BACA,8BACA,yCACA,6BACA,0BACA,uDACA,wCACA,qCACA,uGACA,iGACA,sOACA,mDACA,sBACA,wCACA,6BACA,2JACA,oJACA,wbACA,+BACA,8BACA,6BACA,wIACA,yBACA,4HACA,8BACA,mDACA,2DACA,sCACA,kDACA,uIACA,yCACA,6EACA,wDACA,wBACA,gDACA,yBACA,2BACA,qCACA,mCACA,gGACA,wGACA,wBACA,0BACA,mDACA,sBACA,2CACA,8BACA,mHACA,+DACA,oHACA,iDACA,wDACA,0BACA,qNACA,2BACA,sDACA,iCACA,yBACA,oCACA,wBACA,+BACA,qCACA,wCACA,6BACA,+BACA,2BACA,mBACA,sBACA,8BACA,sBACA,4BACA,kCACA,0BACA,+BACA,gCACA,gCACA,6BACA,2BACA,sBACA,+CACA,+CACA,+CACA,+CACA,6BACA,sBACA,sBACA,0BACA,2BACA,uBACA,2BACA,iCACA,0BACA,qBACA,2BACA,qBACA,oCACA,wBACA,4BACA,2BACA,qCACA,oBACA,qBACA,mBACA,uBACA,2BACA,sBACA,8BACA,+BACA,qCACA,2BACA,mDACA,yBACA,2BACA,mBACA,8CACA,6BACA,qBACA,mCACA,kCACA,kCACA,oBACA,0BACA,8BACA,2BACA,wEACA,gFACA,yBACA,8BACA,sBAEAC,eACAC,MAAS,YACTC,IAAO,UACPC,WAAc,aACdC,UAAa,YACbC,SAAY,WACZC,SAAY,YAEZvxD,yBAA0C,SAAUt+B,QAEpD,QAASs+B,4BACL,GAAIhF,OAAQt5B,OAAO8kC,KAAKvvC,OAASA,IAqCjC,OApCA+jC,OAAMw2D,WACNR,OAAOlzF,QAAQ,SAAU2zF,aACrB,GAAqBp0F,SACjBgT,GAAKohF,YAAYhxF,MAAM,KAAMixF,QAAUrhF,GAAG,GAAIshF,cAAgBthF,GAAG,GAChDuhF,WAAaD,cAAclxF,MAAM,KAClD+P,GAAKkhF,QAAQjxF,MAAM,KAAMoxF,UAAYrhF,GAAG,GAAIshF,UAAYthF,GAAG,EAC/DqhF,WAAUpxF,MAAM,KAAK3C,QAAQ,SAAU+Y,KAAO,MAAOmkB,OAAMw2D,QAAQ36E,IAAInS,eAAiBrH,MACxF,IAAqB00F,WAAYD,WAA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","file":"compiler.umd.min.js","sourcesContent":["/**\n * @license Angular v5.2.11\n * (c) 2010-2018 Google, Inc. https://angular.io/\n * License: MIT\n */\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n\ttypeof define === 'function' && define.amd ? define('@angular/compiler', ['exports'], factory) :\n\t(factory((global.ng = global.ng || {}, global.ng.compiler = {})));\n}(this, (function (exports) { 'use strict';\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = Object.setPrototypeOf ||\r\n    ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n    function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n\r\nfunction __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nvar __assign = Object.assign || function __assign(t) {\r\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n        s = arguments[i];\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n    }\r\n    return t;\r\n};\n\n/**\n * @license Angular v5.2.11\n * (c) 2010-2018 Google, Inc. https://angular.io/\n * License: MIT\n */\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Attention:\n// This file duplicates types and values from @angular/core\n// so that we are able to make @angular/compiler independent of @angular/core.\n// This is important to prevent a build cycle, as @angular/core needs to\n// be compiled with the compiler.\n/**\n * @record\n */\nfunction Inject() { }\nvar createInject = makeMetadataFactory('Inject', function (token) { return ({ token: token }); });\nvar createInjectionToken = makeMetadataFactory('InjectionToken', function (desc) { return ({ _desc: desc }); });\n/**\n * @record\n */\nfunction Attribute() { }\nvar createAttribute = makeMetadataFactory('Attribute', function (attributeName) { return ({ attributeName: attributeName }); });\n/**\n * @record\n */\nfunction Query() { }\nvar createContentChildren = makeMetadataFactory('ContentChildren', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: false, isViewQuery: false, descendants: false }, data));\n});\nvar createContentChild = makeMetadataFactory('ContentChild', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: true, isViewQuery: false, descendants: true }, data));\n});\nvar createViewChildren = makeMetadataFactory('ViewChildren', function (selector, data) {\n    if (data === void 0) { data = {}; }\n    return (__assign({ selector: selector, first: false, isViewQuery: true, descendants: true }, data));\n});\nvar createViewChild = makeMetadataFactory('ViewChild', function (selector, data) {\n    return (__assign({ selector: selector, first: true, isViewQuery: true, descendants: true }, data));\n});\n/**\n * @record\n */\nfunction Directive() { }\nvar createDirective = makeMetadataFactory('Directive', function (dir) {\n    if (dir === void 0) { dir = {}; }\n    return dir;\n});\n/**\n * @record\n */\nfunction Component() { }\n/** @enum {number} */\nvar ViewEncapsulation = {\n    Emulated: 0,\n    Native: 1,\n    None: 2,\n};\nViewEncapsulation[ViewEncapsulation.Emulated] = \"Emulated\";\nViewEncapsulation[ViewEncapsulation.Native] = \"Native\";\nViewEncapsulation[ViewEncapsulation.None] = \"None\";\n/** @enum {number} */\nvar ChangeDetectionStrategy = {\n    OnPush: 0,\n    Default: 1,\n};\nChangeDetectionStrategy[ChangeDetectionStrategy.OnPush] = \"OnPush\";\nChangeDetectionStrategy[ChangeDetectionStrategy.Default] = \"Default\";\nvar createComponent = makeMetadataFactory('Component', function (c) {\n    if (c === void 0) { c = {}; }\n    return (__assign({ changeDetection: ChangeDetectionStrategy.Default }, c));\n});\n/**\n * @record\n */\nfunction Pipe() { }\nvar createPipe = makeMetadataFactory('Pipe', function (p) { return (__assign({ pure: true }, p)); });\n/**\n * @record\n */\nfunction Input() { }\nvar createInput = makeMetadataFactory('Input', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });\n/**\n * @record\n */\nfunction Output() { }\nvar createOutput = makeMetadataFactory('Output', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); });\n/**\n * @record\n */\nfunction HostBinding() { }\nvar createHostBinding = makeMetadataFactory('HostBinding', function (hostPropertyName) { return ({ hostPropertyName: hostPropertyName }); });\n/**\n * @record\n */\nfunction HostListener() { }\nvar createHostListener = makeMetadataFactory('HostListener', function (eventName, args) { return ({ eventName: eventName, args: args }); });\n/**\n * @record\n */\nfunction NgModule() { }\nvar createNgModule = makeMetadataFactory('NgModule', function (ngModule) { return ngModule; });\n/**\n * @record\n */\nfunction ModuleWithProviders() { }\n/**\n * @record\n */\nfunction SchemaMetadata() { }\nvar CUSTOM_ELEMENTS_SCHEMA = {\n    name: 'custom-elements'\n};\nvar NO_ERRORS_SCHEMA = {\n    name: 'no-errors-schema'\n};\nvar createOptional = makeMetadataFactory('Optional');\nvar createInjectable = makeMetadataFactory('Injectable');\nvar createSelf = makeMetadataFactory('Self');\nvar createSkipSelf = makeMetadataFactory('SkipSelf');\nvar createHost = makeMetadataFactory('Host');\nvar Type = Function;\n/** @enum {number} */\nvar SecurityContext = {\n    NONE: 0,\n    HTML: 1,\n    STYLE: 2,\n    SCRIPT: 3,\n    URL: 4,\n    RESOURCE_URL: 5,\n};\nSecurityContext[SecurityContext.NONE] = \"NONE\";\nSecurityContext[SecurityContext.HTML] = \"HTML\";\nSecurityContext[SecurityContext.STYLE] = \"STYLE\";\nSecurityContext[SecurityContext.SCRIPT] = \"SCRIPT\";\nSecurityContext[SecurityContext.URL] = \"URL\";\nSecurityContext[SecurityContext.RESOURCE_URL] = \"RESOURCE_URL\";\n/** @enum {number} */\nvar NodeFlags = {\n    None: 0,\n    TypeElement: 1,\n    TypeText: 2,\n    ProjectedTemplate: 4,\n    CatRenderNode: 3,\n    TypeNgContent: 8,\n    TypePipe: 16,\n    TypePureArray: 32,\n    TypePureObject: 64,\n    TypePurePipe: 128,\n    CatPureExpression: 224,\n    TypeValueProvider: 256,\n    TypeClassProvider: 512,\n    TypeFactoryProvider: 1024,\n    TypeUseExistingProvider: 2048,\n    LazyProvider: 4096,\n    PrivateProvider: 8192,\n    TypeDirective: 16384,\n    Component: 32768,\n    CatProviderNoDirective: 3840,\n    CatProvider: 20224,\n    OnInit: 65536,\n    OnDestroy: 131072,\n    DoCheck: 262144,\n    OnChanges: 524288,\n    AfterContentInit: 1048576,\n    AfterContentChecked: 2097152,\n    AfterViewInit: 4194304,\n    AfterViewChecked: 8388608,\n    EmbeddedViews: 16777216,\n    ComponentView: 33554432,\n    TypeContentQuery: 67108864,\n    TypeViewQuery: 134217728,\n    StaticQuery: 268435456,\n    DynamicQuery: 536870912,\n    CatQuery: 201326592,\n    // mutually exclusive values...\n    Types: 201347067,\n};\n/** @enum {number} */\nvar DepFlags = {\n    None: 0,\n    SkipSelf: 1,\n    Optional: 2,\n    Value: 8,\n};\n/** @enum {number} */\nvar ArgumentType = { Inline: 0, Dynamic: 1, };\n/** @enum {number} */\nvar BindingFlags = {\n    TypeElementAttribute: 1,\n    TypeElementClass: 2,\n    TypeElementStyle: 4,\n    TypeProperty: 8,\n    SyntheticProperty: 16,\n    SyntheticHostProperty: 32,\n    CatSyntheticProperty: 48,\n    // mutually exclusive values...\n    Types: 15,\n};\n/** @enum {number} */\nvar QueryBindingType = { First: 0, All: 1, };\n/** @enum {number} */\nvar QueryValueType = {\n    ElementRef: 0,\n    RenderElement: 1,\n    TemplateRef: 2,\n    ViewContainerRef: 3,\n    Provider: 4,\n};\n/** @enum {number} */\nvar ViewFlags = {\n    None: 0,\n    OnPush: 2,\n};\n/** @enum {number} */\nvar MissingTranslationStrategy = {\n    Error: 0,\n    Warning: 1,\n    Ignore: 2,\n};\nMissingTranslationStrategy[MissingTranslationStrategy.Error] = \"Error\";\nMissingTranslationStrategy[MissingTranslationStrategy.Warning] = \"Warning\";\nMissingTranslationStrategy[MissingTranslationStrategy.Ignore] = \"Ignore\";\n/**\n * @record\n * @template T\n */\nfunction MetadataFactory() { }\n/**\n * @template T\n * @param {?} name\n * @param {?=} props\n * @return {?}\n */\nfunction makeMetadataFactory(name, props) {\n    var /** @type {?} */ factory = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var /** @type {?} */ values = props ? props.apply(void 0, args) : {};\n        return __assign({ ngMetadataName: name }, values);\n    };\n    factory.isTypeOf = function (obj) { return obj && obj.ngMetadataName === name; };\n    factory.ngMetadataName = name;\n    return factory;\n}\n/**\n * @record\n */\nfunction Route() { }\n\n\n\nvar core = Object.freeze({\n\tInject: Inject,\n\tcreateInject: createInject,\n\tcreateInjectionToken: createInjectionToken,\n\tAttribute: Attribute,\n\tcreateAttribute: createAttribute,\n\tQuery: Query,\n\tcreateContentChildren: createContentChildren,\n\tcreateContentChild: createContentChild,\n\tcreateViewChildren: createViewChildren,\n\tcreateViewChild: createViewChild,\n\tDirective: Directive,\n\tcreateDirective: createDirective,\n\tComponent: Component,\n\tViewEncapsulation: ViewEncapsulation,\n\tChangeDetectionStrategy: ChangeDetectionStrategy,\n\tcreateComponent: createComponent,\n\tPipe: Pipe,\n\tcreatePipe: createPipe,\n\tInput: Input,\n\tcreateInput: createInput,\n\tOutput: Output,\n\tcreateOutput: createOutput,\n\tHostBinding: HostBinding,\n\tcreateHostBinding: createHostBinding,\n\tHostListener: HostListener,\n\tcreateHostListener: createHostListener,\n\tNgModule: NgModule,\n\tcreateNgModule: createNgModule,\n\tModuleWithProviders: ModuleWithProviders,\n\tSchemaMetadata: SchemaMetadata,\n\tCUSTOM_ELEMENTS_SCHEMA: CUSTOM_ELEMENTS_SCHEMA,\n\tNO_ERRORS_SCHEMA: NO_ERRORS_SCHEMA,\n\tcreateOptional: createOptional,\n\tcreateInjectable: createInjectable,\n\tcreateSelf: createSelf,\n\tcreateSkipSelf: createSkipSelf,\n\tcreateHost: createHost,\n\tType: Type,\n\tSecurityContext: SecurityContext,\n\tNodeFlags: NodeFlags,\n\tDepFlags: DepFlags,\n\tArgumentType: ArgumentType,\n\tBindingFlags: BindingFlags,\n\tQueryBindingType: QueryBindingType,\n\tQueryValueType: QueryValueType,\n\tViewFlags: ViewFlags,\n\tMissingTranslationStrategy: MissingTranslationStrategy,\n\tMetadataFactory: MetadataFactory,\n\tRoute: Route\n});\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar DASH_CASE_REGEXP = /-+([a-z0-9])/g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction dashCaseToCamelCase(input) {\n    return input.replace(DASH_CASE_REGEXP, function () {\n        var m = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            m[_i] = arguments[_i];\n        }\n        return m[1].toUpperCase();\n    });\n}\n/**\n * @param {?} input\n * @param {?} defaultValues\n * @return {?}\n */\nfunction splitAtColon(input, defaultValues) {\n    return _splitAt(input, ':', defaultValues);\n}\n/**\n * @param {?} input\n * @param {?} defaultValues\n * @return {?}\n */\nfunction splitAtPeriod(input, defaultValues) {\n    return _splitAt(input, '.', defaultValues);\n}\n/**\n * @param {?} input\n * @param {?} character\n * @param {?} defaultValues\n * @return {?}\n */\nfunction _splitAt(input, character, defaultValues) {\n    var /** @type {?} */ characterIndex = input.indexOf(character);\n    if (characterIndex == -1)\n        return defaultValues;\n    return [input.slice(0, characterIndex).trim(), input.slice(characterIndex + 1).trim()];\n}\n/**\n * @param {?} value\n * @param {?} visitor\n * @param {?} context\n * @return {?}\n */\nfunction visitValue(value, visitor, context) {\n    if (Array.isArray(value)) {\n        return visitor.visitArray(/** @type {?} */ (value), context);\n    }\n    if (isStrictStringMap(value)) {\n        return visitor.visitStringMap(/** @type {?} */ (value), context);\n    }\n    if (value == null || typeof value == 'string' || typeof value == 'number' ||\n        typeof value == 'boolean') {\n        return visitor.visitPrimitive(value, context);\n    }\n    return visitor.visitOther(value, context);\n}\n/**\n * @param {?} val\n * @return {?}\n */\nfunction isDefined(val) {\n    return val !== null && val !== undefined;\n}\n/**\n * @template T\n * @param {?} val\n * @return {?}\n */\nfunction noUndefined(val) {\n    return val === undefined ? /** @type {?} */ ((null)) : val;\n}\n/**\n * @record\n */\n\nvar ValueTransformer = /** @class */ (function () {\n    function ValueTransformer() {\n    }\n    /**\n     * @param {?} arr\n     * @param {?} context\n     * @return {?}\n     */\n    ValueTransformer.prototype.visitArray = /**\n     * @param {?} arr\n     * @param {?} context\n     * @return {?}\n     */\n    function (arr, context) {\n        var _this = this;\n        return arr.map(function (value) { return visitValue(value, _this, context); });\n    };\n    /**\n     * @param {?} map\n     * @param {?} context\n     * @return {?}\n     */\n    ValueTransformer.prototype.visitStringMap = /**\n     * @param {?} map\n     * @param {?} context\n     * @return {?}\n     */\n    function (map, context) {\n        var _this = this;\n        var /** @type {?} */ result = {};\n        Object.keys(map).forEach(function (key) { result[key] = visitValue(map[key], _this, context); });\n        return result;\n    };\n    /**\n     * @param {?} value\n     * @param {?} context\n     * @return {?}\n     */\n    ValueTransformer.prototype.visitPrimitive = /**\n     * @param {?} value\n     * @param {?} context\n     * @return {?}\n     */\n    function (value, context) { return value; };\n    /**\n     * @param {?} value\n     * @param {?} context\n     * @return {?}\n     */\n    ValueTransformer.prototype.visitOther = /**\n     * @param {?} value\n     * @param {?} context\n     * @return {?}\n     */\n    function (value, context) { return value; };\n    return ValueTransformer;\n}());\nvar SyncAsync = {\n    assertSync: function (value) {\n        if (isPromise(value)) {\n            throw new Error(\"Illegal state: value cannot be a promise\");\n        }\n        return value;\n    },\n    then: function (value, cb) { return isPromise(value) ? value.then(cb) : cb(value); },\n    all: function (syncAsyncValues) {\n        return syncAsyncValues.some(isPromise) ? Promise.all(syncAsyncValues) : /** @type {?} */ (syncAsyncValues);\n    }\n};\n/**\n * @param {?} msg\n * @param {?=} parseErrors\n * @return {?}\n */\nfunction syntaxError(msg, parseErrors) {\n    var /** @type {?} */ error = Error(msg);\n    (/** @type {?} */ (error))[ERROR_SYNTAX_ERROR] = true;\n    if (parseErrors)\n        (/** @type {?} */ (error))[ERROR_PARSE_ERRORS] = parseErrors;\n    return error;\n}\nvar ERROR_SYNTAX_ERROR = 'ngSyntaxError';\nvar ERROR_PARSE_ERRORS = 'ngParseErrors';\n/**\n * @param {?} error\n * @return {?}\n */\nfunction isSyntaxError(error) {\n    return (/** @type {?} */ (error))[ERROR_SYNTAX_ERROR];\n}\n/**\n * @param {?} error\n * @return {?}\n */\nfunction getParseErrors(error) {\n    return (/** @type {?} */ (error))[ERROR_PARSE_ERRORS] || [];\n}\n/**\n * @param {?} s\n * @return {?}\n */\nfunction escapeRegExp(s) {\n    return s.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n}\nvar STRING_MAP_PROTO = Object.getPrototypeOf({});\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction isStrictStringMap(obj) {\n    return typeof obj === 'object' && obj !== null && Object.getPrototypeOf(obj) === STRING_MAP_PROTO;\n}\n/**\n * @param {?} str\n * @return {?}\n */\nfunction utf8Encode(str) {\n    var /** @type {?} */ encoded = '';\n    for (var /** @type {?} */ index = 0; index < str.length; index++) {\n        var /** @type {?} */ codePoint = str.charCodeAt(index);\n        // decode surrogate\n        // see https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n        if (codePoint >= 0xd800 && codePoint <= 0xdbff && str.length > (index + 1)) {\n            var /** @type {?} */ low = str.charCodeAt(index + 1);\n            if (low >= 0xdc00 && low <= 0xdfff) {\n                index++;\n                codePoint = ((codePoint - 0xd800) << 10) + low - 0xdc00 + 0x10000;\n            }\n        }\n        if (codePoint <= 0x7f) {\n            encoded += String.fromCharCode(codePoint);\n        }\n        else if (codePoint <= 0x7ff) {\n            encoded += String.fromCharCode(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80);\n        }\n        else if (codePoint <= 0xffff) {\n            encoded += String.fromCharCode((codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);\n        }\n        else if (codePoint <= 0x1fffff) {\n            encoded += String.fromCharCode(((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80);\n        }\n    }\n    return encoded;\n}\n/**\n * @record\n */\n\n/**\n * @param {?} token\n * @return {?}\n */\nfunction stringify(token) {\n    if (typeof token === 'string') {\n        return token;\n    }\n    if (token instanceof Array) {\n        return '[' + token.map(stringify).join(', ') + ']';\n    }\n    if (token == null) {\n        return '' + token;\n    }\n    if (token.overriddenName) {\n        return \"\" + token.overriddenName;\n    }\n    if (token.name) {\n        return \"\" + token.name;\n    }\n    var /** @type {?} */ res = token.toString();\n    if (res == null) {\n        return '' + res;\n    }\n    var /** @type {?} */ newLineIndex = res.indexOf('\\n');\n    return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\n}\n/**\n * Lazily retrieves the reference value from a forwardRef.\n * @param {?} type\n * @return {?}\n */\nfunction resolveForwardRef(type) {\n    if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__')) {\n        return type();\n    }\n    else {\n        return type;\n    }\n}\n/**\n * Determine if the argument is shaped like a Promise\n * @param {?} obj\n * @return {?}\n */\nfunction isPromise(obj) {\n    // allow any Promise/A+ compliant thenable.\n    // It's up to the caller to ensure that obj.then conforms to the spec\n    return !!obj && typeof obj.then === 'function';\n}\nvar Version = /** @class */ (function () {\n    function Version(full) {\n        this.full = full;\n        var /** @type {?} */ splits = full.split('.');\n        this.major = splits[0];\n        this.minor = splits[1];\n        this.patch = splits.slice(2).join('.');\n    }\n    return Version;\n}());\n/**\n * @record\n */\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * \\@stable\n */\nvar VERSION = new Version('5.2.11');\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * An Abstract Syntax Tree node representing part of a parsed Angular template.\n * @record\n */\n\n/**\n * A segment of text within the template.\n */\nvar TextAst = /** @class */ (function () {\n    function TextAst(value, ngContentIndex, sourceSpan) {\n        this.value = value;\n        this.ngContentIndex = ngContentIndex;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    TextAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitText(this, context); };\n    return TextAst;\n}());\n/**\n * A bound expression within the text of a template.\n */\nvar BoundTextAst = /** @class */ (function () {\n    function BoundTextAst(value, ngContentIndex, sourceSpan) {\n        this.value = value;\n        this.ngContentIndex = ngContentIndex;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    BoundTextAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitBoundText(this, context);\n    };\n    return BoundTextAst;\n}());\n/**\n * A plain attribute on an element.\n */\nvar AttrAst = /** @class */ (function () {\n    function AttrAst(name, value, sourceSpan) {\n        this.name = name;\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    AttrAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitAttr(this, context); };\n    return AttrAst;\n}());\n/**\n * A binding for an element property (e.g. `[property]=\"expression\"`) or an animation trigger (e.g.\n * `[\\@trigger]=\"stateExp\"`)\n */\nvar BoundElementPropertyAst = /** @class */ (function () {\n    function BoundElementPropertyAst(name, type, securityContext, value, unit, sourceSpan) {\n        this.name = name;\n        this.type = type;\n        this.securityContext = securityContext;\n        this.value = value;\n        this.unit = unit;\n        this.sourceSpan = sourceSpan;\n        this.isAnimation = this.type === PropertyBindingType.Animation;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    BoundElementPropertyAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitElementProperty(this, context);\n    };\n    return BoundElementPropertyAst;\n}());\n/**\n * A binding for an element event (e.g. `(event)=\"handler()\"`) or an animation trigger event (e.g.\n * `(\\@trigger.phase)=\"callback($event)\"`).\n */\nvar BoundEventAst = /** @class */ (function () {\n    function BoundEventAst(name, target, phase, handler, sourceSpan) {\n        this.name = name;\n        this.target = target;\n        this.phase = phase;\n        this.handler = handler;\n        this.sourceSpan = sourceSpan;\n        this.fullName = BoundEventAst.calcFullName(this.name, this.target, this.phase);\n        this.isAnimation = !!this.phase;\n    }\n    /**\n     * @param {?} name\n     * @param {?} target\n     * @param {?} phase\n     * @return {?}\n     */\n    BoundEventAst.calcFullName = /**\n     * @param {?} name\n     * @param {?} target\n     * @param {?} phase\n     * @return {?}\n     */\n    function (name, target, phase) {\n        if (target) {\n            return target + \":\" + name;\n        }\n        else if (phase) {\n            return \"@\" + name + \".\" + phase;\n        }\n        else {\n            return name;\n        }\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    BoundEventAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitEvent(this, context);\n    };\n    return BoundEventAst;\n}());\n/**\n * A reference declaration on an element (e.g. `let someName=\"expression\"`).\n */\nvar ReferenceAst = /** @class */ (function () {\n    function ReferenceAst(name, value, sourceSpan) {\n        this.name = name;\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ReferenceAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitReference(this, context);\n    };\n    return ReferenceAst;\n}());\n/**\n * A variable declaration on a <ng-template> (e.g. `var-someName=\"someLocalName\"`).\n */\nvar VariableAst = /** @class */ (function () {\n    function VariableAst(name, value, sourceSpan) {\n        this.name = name;\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    VariableAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitVariable(this, context);\n    };\n    return VariableAst;\n}());\n/**\n * An element declaration in a template.\n */\nvar ElementAst = /** @class */ (function () {\n    function ElementAst(name, attrs, inputs, outputs, references, directives, providers, hasViewContainer, queryMatches, children, ngContentIndex, sourceSpan, endSourceSpan) {\n        this.name = name;\n        this.attrs = attrs;\n        this.inputs = inputs;\n        this.outputs = outputs;\n        this.references = references;\n        this.directives = directives;\n        this.providers = providers;\n        this.hasViewContainer = hasViewContainer;\n        this.queryMatches = queryMatches;\n        this.children = children;\n        this.ngContentIndex = ngContentIndex;\n        this.sourceSpan = sourceSpan;\n        this.endSourceSpan = endSourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ElementAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitElement(this, context);\n    };\n    return ElementAst;\n}());\n/**\n * A `<ng-template>` element included in an Angular template.\n */\nvar EmbeddedTemplateAst = /** @class */ (function () {\n    function EmbeddedTemplateAst(attrs, outputs, references, variables, directives, providers, hasViewContainer, queryMatches, children, ngContentIndex, sourceSpan) {\n        this.attrs = attrs;\n        this.outputs = outputs;\n        this.references = references;\n        this.variables = variables;\n        this.directives = directives;\n        this.providers = providers;\n        this.hasViewContainer = hasViewContainer;\n        this.queryMatches = queryMatches;\n        this.children = children;\n        this.ngContentIndex = ngContentIndex;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    EmbeddedTemplateAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitEmbeddedTemplate(this, context);\n    };\n    return EmbeddedTemplateAst;\n}());\n/**\n * A directive property with a bound value (e.g. `*ngIf=\"condition\").\n */\nvar BoundDirectivePropertyAst = /** @class */ (function () {\n    function BoundDirectivePropertyAst(directiveName, templateName, value, sourceSpan) {\n        this.directiveName = directiveName;\n        this.templateName = templateName;\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    BoundDirectivePropertyAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitDirectiveProperty(this, context);\n    };\n    return BoundDirectivePropertyAst;\n}());\n/**\n * A directive declared on an element.\n */\nvar DirectiveAst = /** @class */ (function () {\n    function DirectiveAst(directive, inputs, hostProperties, hostEvents, contentQueryStartId, sourceSpan) {\n        this.directive = directive;\n        this.inputs = inputs;\n        this.hostProperties = hostProperties;\n        this.hostEvents = hostEvents;\n        this.contentQueryStartId = contentQueryStartId;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    DirectiveAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitDirective(this, context);\n    };\n    return DirectiveAst;\n}());\n/**\n * A provider declared on an element\n */\nvar ProviderAst = /** @class */ (function () {\n    function ProviderAst(token, multiProvider, eager, providers, providerType, lifecycleHooks, sourceSpan) {\n        this.token = token;\n        this.multiProvider = multiProvider;\n        this.eager = eager;\n        this.providers = providers;\n        this.providerType = providerType;\n        this.lifecycleHooks = lifecycleHooks;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ProviderAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        // No visit method in the visitor for now...\n        return null;\n    };\n    return ProviderAst;\n}());\n/** @enum {number} */\nvar ProviderAstType = {\n    PublicService: 0,\n    PrivateService: 1,\n    Component: 2,\n    Directive: 3,\n    Builtin: 4,\n};\nProviderAstType[ProviderAstType.PublicService] = \"PublicService\";\nProviderAstType[ProviderAstType.PrivateService] = \"PrivateService\";\nProviderAstType[ProviderAstType.Component] = \"Component\";\nProviderAstType[ProviderAstType.Directive] = \"Directive\";\nProviderAstType[ProviderAstType.Builtin] = \"Builtin\";\n/**\n * Position where content is to be projected (instance of `<ng-content>` in a template).\n */\nvar NgContentAst = /** @class */ (function () {\n    function NgContentAst(index, ngContentIndex, sourceSpan) {\n        this.index = index;\n        this.ngContentIndex = ngContentIndex;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    NgContentAst.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitNgContent(this, context);\n    };\n    return NgContentAst;\n}());\n/** @enum {number} */\nvar PropertyBindingType = {\n    /**\n       * A normal binding to a property (e.g. `[property]=\"expression\"`).\n       */\n    Property: 0,\n    /**\n       * A binding to an element attribute (e.g. `[attr.name]=\"expression\"`).\n       */\n    Attribute: 1,\n    /**\n       * A binding to a CSS class (e.g. `[class.name]=\"condition\"`).\n       */\n    Class: 2,\n    /**\n       * A binding to a style rule (e.g. `[style.rule]=\"expression\"`).\n       */\n    Style: 3,\n    /**\n       * A binding to an animation reference (e.g. `[animate.key]=\"expression\"`).\n       */\n    Animation: 4,\n};\nPropertyBindingType[PropertyBindingType.Property] = \"Property\";\nPropertyBindingType[PropertyBindingType.Attribute] = \"Attribute\";\nPropertyBindingType[PropertyBindingType.Class] = \"Class\";\nPropertyBindingType[PropertyBindingType.Style] = \"Style\";\nPropertyBindingType[PropertyBindingType.Animation] = \"Animation\";\n/**\n * @record\n */\n\n/**\n * A visitor for {\\@link TemplateAst} trees that will process each node.\n * @record\n */\n\n/**\n * A visitor that accepts each node but doesn't do anything. It is intended to be used\n * as the base class for a visitor that is only interested in a subset of the node types.\n */\nvar NullTemplateVisitor = /** @class */ (function () {\n    function NullTemplateVisitor() {\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitNgContent = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitEmbeddedTemplate = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitElement = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitReference = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitVariable = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitEvent = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitElementProperty = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitAttr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitBoundText = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitText = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitDirective = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullTemplateVisitor.prototype.visitDirectiveProperty = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    return NullTemplateVisitor;\n}());\n/**\n * Base class that can be used to build a visitor that visits each node\n * in an template ast recursively.\n */\nvar RecursiveTemplateAstVisitor = /** @class */ (function (_super) {\n    __extends(RecursiveTemplateAstVisitor, _super);\n    function RecursiveTemplateAstVisitor() {\n        return _super.call(this) || this;\n    }\n    // Nodes with children\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveTemplateAstVisitor.prototype.visitEmbeddedTemplate = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.visitChildren(context, function (visit) {\n            visit(ast.attrs);\n            visit(ast.references);\n            visit(ast.variables);\n            visit(ast.directives);\n            visit(ast.providers);\n            visit(ast.children);\n        });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveTemplateAstVisitor.prototype.visitElement = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.visitChildren(context, function (visit) {\n            visit(ast.attrs);\n            visit(ast.inputs);\n            visit(ast.outputs);\n            visit(ast.references);\n            visit(ast.directives);\n            visit(ast.providers);\n            visit(ast.children);\n        });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveTemplateAstVisitor.prototype.visitDirective = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.visitChildren(context, function (visit) {\n            visit(ast.inputs);\n            visit(ast.hostProperties);\n            visit(ast.hostEvents);\n        });\n    };\n    /**\n     * @template T\n     * @param {?} context\n     * @param {?} cb\n     * @return {?}\n     */\n    RecursiveTemplateAstVisitor.prototype.visitChildren = /**\n     * @template T\n     * @param {?} context\n     * @param {?} cb\n     * @return {?}\n     */\n    function (context, cb) {\n        var /** @type {?} */ results = [];\n        var /** @type {?} */ t = this;\n        /**\n         * @template T\n         * @param {?} children\n         * @return {?}\n         */\n        function visit(children) {\n            if (children && children.length)\n                results.push(templateVisitAll(t, children, context));\n        }\n        cb(visit);\n        return [].concat.apply([], results);\n    };\n    return RecursiveTemplateAstVisitor;\n}(NullTemplateVisitor));\n/**\n * Visit every node in a list of {\\@link TemplateAst}s with the given {\\@link TemplateAstVisitor}.\n * @param {?} visitor\n * @param {?} asts\n * @param {?=} context\n * @return {?}\n */\nfunction templateVisitAll(visitor, asts, context) {\n    if (context === void 0) { context = null; }\n    var /** @type {?} */ result = [];\n    var /** @type {?} */ visit = visitor.visit ?\n        function (ast) { return ((visitor.visit))(ast, context) || ast.visit(visitor, context); } :\n        function (ast) { return ast.visit(visitor, context); };\n    asts.forEach(function (ast) {\n        var /** @type {?} */ astResult = visit(ast);\n        if (astResult) {\n            result.push(astResult);\n        }\n    });\n    return result;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar CompilerConfig = /** @class */ (function () {\n    function CompilerConfig(_a) {\n        var _b = _a === void 0 ? {} : _a, _c = _b.defaultEncapsulation, defaultEncapsulation = _c === void 0 ? ViewEncapsulation.Emulated : _c, _d = _b.useJit, useJit = _d === void 0 ? true : _d, _e = _b.jitDevMode, jitDevMode = _e === void 0 ? false : _e, _f = _b.missingTranslation, missingTranslation = _f === void 0 ? null : _f, enableLegacyTemplate = _b.enableLegacyTemplate, preserveWhitespaces = _b.preserveWhitespaces, strictInjectionParameters = _b.strictInjectionParameters;\n        this.defaultEncapsulation = defaultEncapsulation;\n        this.useJit = !!useJit;\n        this.jitDevMode = !!jitDevMode;\n        this.missingTranslation = missingTranslation;\n        this.enableLegacyTemplate = enableLegacyTemplate === true;\n        this.preserveWhitespaces = preserveWhitespacesDefault(noUndefined(preserveWhitespaces));\n        this.strictInjectionParameters = strictInjectionParameters === true;\n    }\n    return CompilerConfig;\n}());\n/**\n * @param {?} preserveWhitespacesOption\n * @param {?=} defaultSetting\n * @return {?}\n */\nfunction preserveWhitespacesDefault(preserveWhitespacesOption, defaultSetting) {\n    if (defaultSetting === void 0) { defaultSetting = true; }\n    return preserveWhitespacesOption === null ? defaultSetting : preserveWhitespacesOption;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A token representing the a reference to a static type.\n *\n * This token is unique for a filePath and name and can be used as a hash table key.\n */\nvar StaticSymbol = /** @class */ (function () {\n    function StaticSymbol(filePath, name, members) {\n        this.filePath = filePath;\n        this.name = name;\n        this.members = members;\n    }\n    /**\n     * @return {?}\n     */\n    StaticSymbol.prototype.assertNoMembers = /**\n     * @return {?}\n     */\n    function () {\n        if (this.members.length) {\n            throw new Error(\"Illegal state: symbol without members expected, but got \" + JSON.stringify(this) + \".\");\n        }\n    };\n    return StaticSymbol;\n}());\n/**\n * A cache of static symbol used by the StaticReflector to return the same symbol for the\n * same symbol values.\n */\nvar StaticSymbolCache = /** @class */ (function () {\n    function StaticSymbolCache() {\n        this.cache = new Map();\n    }\n    /**\n     * @param {?} declarationFile\n     * @param {?} name\n     * @param {?=} members\n     * @return {?}\n     */\n    StaticSymbolCache.prototype.get = /**\n     * @param {?} declarationFile\n     * @param {?} name\n     * @param {?=} members\n     * @return {?}\n     */\n    function (declarationFile, name, members) {\n        members = members || [];\n        var /** @type {?} */ memberSuffix = members.length ? \".\" + members.join('.') : '';\n        var /** @type {?} */ key = \"\\\"\" + declarationFile + \"\\\".\" + name + memberSuffix;\n        var /** @type {?} */ result = this.cache.get(key);\n        if (!result) {\n            result = new StaticSymbol(declarationFile, name, members);\n            this.cache.set(key, result);\n        }\n        return result;\n    };\n    return StaticSymbolCache;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// group 0: \"[prop] or (event) or @trigger\"\n// group 1: \"prop\" from \"[prop]\"\n// group 2: \"event\" from \"(event)\"\n// group 3: \"@trigger\" from \"@trigger\"\nvar HOST_REG_EXP = /^(?:(?:\\[([^\\]]+)\\])|(?:\\(([^\\)]+)\\)))|(\\@[-\\w]+)$/;\n/**\n * @param {?} name\n * @return {?}\n */\nfunction _sanitizeIdentifier(name) {\n    return name.replace(/\\W/g, '_');\n}\nvar _anonymousTypeIndex = 0;\n/**\n * @param {?} compileIdentifier\n * @return {?}\n */\nfunction identifierName(compileIdentifier) {\n    if (!compileIdentifier || !compileIdentifier.reference) {\n        return null;\n    }\n    var /** @type {?} */ ref = compileIdentifier.reference;\n    if (ref instanceof StaticSymbol) {\n        return ref.name;\n    }\n    if (ref['__anonymousType']) {\n        return ref['__anonymousType'];\n    }\n    var /** @type {?} */ identifier = stringify(ref);\n    if (identifier.indexOf('(') >= 0) {\n        // case: anonymous functions!\n        identifier = \"anonymous_\" + _anonymousTypeIndex++;\n        ref['__anonymousType'] = identifier;\n    }\n    else {\n        identifier = _sanitizeIdentifier(identifier);\n    }\n    return identifier;\n}\n/**\n * @param {?} compileIdentifier\n * @return {?}\n */\nfunction identifierModuleUrl(compileIdentifier) {\n    var /** @type {?} */ ref = compileIdentifier.reference;\n    if (ref instanceof StaticSymbol) {\n        return ref.filePath;\n    }\n    // Runtime type\n    return \"./\" + stringify(ref);\n}\n/**\n * @param {?} compType\n * @param {?} embeddedTemplateIndex\n * @return {?}\n */\nfunction viewClassName(compType, embeddedTemplateIndex) {\n    return \"View_\" + identifierName({ reference: compType }) + \"_\" + embeddedTemplateIndex;\n}\n/**\n * @param {?} compType\n * @return {?}\n */\nfunction rendererTypeName(compType) {\n    return \"RenderType_\" + identifierName({ reference: compType });\n}\n/**\n * @param {?} compType\n * @return {?}\n */\nfunction hostViewClassName(compType) {\n    return \"HostView_\" + identifierName({ reference: compType });\n}\n/**\n * @param {?} compType\n * @return {?}\n */\nfunction componentFactoryName(compType) {\n    return identifierName({ reference: compType }) + \"NgFactory\";\n}\n/**\n * @record\n */\n\n/**\n * @record\n */\n\n/** @enum {number} */\nvar CompileSummaryKind = {\n    Pipe: 0,\n    Directive: 1,\n    NgModule: 2,\n    Injectable: 3,\n};\nCompileSummaryKind[CompileSummaryKind.Pipe] = \"Pipe\";\nCompileSummaryKind[CompileSummaryKind.Directive] = \"Directive\";\nCompileSummaryKind[CompileSummaryKind.NgModule] = \"NgModule\";\nCompileSummaryKind[CompileSummaryKind.Injectable] = \"Injectable\";\n/**\n * A CompileSummary is the data needed to use a directive / pipe / module\n * in other modules / components. However, this data is not enough to compile\n * the directive / module itself.\n * @record\n */\n\n/**\n * @record\n */\n\n/**\n * @record\n */\n\n/**\n * @record\n */\n\n/**\n * @param {?} token\n * @return {?}\n */\nfunction tokenName(token) {\n    return token.value != null ? _sanitizeIdentifier(token.value) : identifierName(token.identifier);\n}\n/**\n * @param {?} token\n * @return {?}\n */\nfunction tokenReference(token) {\n    if (token.identifier != null) {\n        return token.identifier.reference;\n    }\n    else {\n        return token.value;\n    }\n}\n/**\n * @record\n */\n\n/**\n * Metadata regarding compilation of a type.\n * @record\n */\n\n/**\n * @record\n */\n\n/**\n * Metadata about a stylesheet\n */\nvar CompileStylesheetMetadata = /** @class */ (function () {\n    function CompileStylesheetMetadata(_a) {\n        var _b = _a === void 0 ? {} : _a, moduleUrl = _b.moduleUrl, styles = _b.styles, styleUrls = _b.styleUrls;\n        this.moduleUrl = moduleUrl || null;\n        this.styles = _normalizeArray(styles);\n        this.styleUrls = _normalizeArray(styleUrls);\n    }\n    return CompileStylesheetMetadata;\n}());\n/**\n * Summary Metadata regarding compilation of a template.\n * @record\n */\n\n/**\n * Metadata regarding compilation of a template.\n */\nvar CompileTemplateMetadata = /** @class */ (function () {\n    function CompileTemplateMetadata(_a) {\n        var encapsulation = _a.encapsulation, template = _a.template, templateUrl = _a.templateUrl, htmlAst = _a.htmlAst, styles = _a.styles, styleUrls = _a.styleUrls, externalStylesheets = _a.externalStylesheets, animations = _a.animations, ngContentSelectors = _a.ngContentSelectors, interpolation = _a.interpolation, isInline = _a.isInline, preserveWhitespaces = _a.preserveWhitespaces;\n        this.encapsulation = encapsulation;\n        this.template = template;\n        this.templateUrl = templateUrl;\n        this.htmlAst = htmlAst;\n        this.styles = _normalizeArray(styles);\n        this.styleUrls = _normalizeArray(styleUrls);\n        this.externalStylesheets = _normalizeArray(externalStylesheets);\n        this.animations = animations ? flatten(animations) : [];\n        this.ngContentSelectors = ngContentSelectors || [];\n        if (interpolation && interpolation.length != 2) {\n            throw new Error(\"'interpolation' should have a start and an end symbol.\");\n        }\n        this.interpolation = interpolation;\n        this.isInline = isInline;\n        this.preserveWhitespaces = preserveWhitespaces;\n    }\n    /**\n     * @return {?}\n     */\n    CompileTemplateMetadata.prototype.toSummary = /**\n     * @return {?}\n     */\n    function () {\n        return {\n            ngContentSelectors: this.ngContentSelectors,\n            encapsulation: this.encapsulation,\n        };\n    };\n    return CompileTemplateMetadata;\n}());\n/**\n * @record\n */\n\n/**\n * @record\n */\n\n/**\n * Metadata regarding compilation of a directive.\n */\nvar CompileDirectiveMetadata = /** @class */ (function () {\n    function CompileDirectiveMetadata(_a) {\n        var isHost = _a.isHost, type = _a.type, isComponent = _a.isComponent, selector = _a.selector, exportAs = _a.exportAs, changeDetection = _a.changeDetection, inputs = _a.inputs, outputs = _a.outputs, hostListeners = _a.hostListeners, hostProperties = _a.hostProperties, hostAttributes = _a.hostAttributes, providers = _a.providers, viewProviders = _a.viewProviders, queries = _a.queries, guards = _a.guards, viewQueries = _a.viewQueries, entryComponents = _a.entryComponents, template = _a.template, componentViewType = _a.componentViewType, rendererType = _a.rendererType, componentFactory = _a.componentFactory;\n        this.isHost = !!isHost;\n        this.type = type;\n        this.isComponent = isComponent;\n        this.selector = selector;\n        this.exportAs = exportAs;\n        this.changeDetection = changeDetection;\n        this.inputs = inputs;\n        this.outputs = outputs;\n        this.hostListeners = hostListeners;\n        this.hostProperties = hostProperties;\n        this.hostAttributes = hostAttributes;\n        this.providers = _normalizeArray(providers);\n        this.viewProviders = _normalizeArray(viewProviders);\n        this.queries = _normalizeArray(queries);\n        this.guards = guards;\n        this.viewQueries = _normalizeArray(viewQueries);\n        this.entryComponents = _normalizeArray(entryComponents);\n        this.template = template;\n        this.componentViewType = componentViewType;\n        this.rendererType = rendererType;\n        this.componentFactory = componentFactory;\n    }\n    /**\n     * @param {?} __0\n     * @return {?}\n     */\n    CompileDirectiveMetadata.create = /**\n     * @param {?} __0\n     * @return {?}\n     */\n    function (_a) {\n        var isHost = _a.isHost, type = _a.type, isComponent = _a.isComponent, selector = _a.selector, exportAs = _a.exportAs, changeDetection = _a.changeDetection, inputs = _a.inputs, outputs = _a.outputs, host = _a.host, providers = _a.providers, viewProviders = _a.viewProviders, queries = _a.queries, guards = _a.guards, viewQueries = _a.viewQueries, entryComponents = _a.entryComponents, template = _a.template, componentViewType = _a.componentViewType, rendererType = _a.rendererType, componentFactory = _a.componentFactory;\n        var /** @type {?} */ hostListeners = {};\n        var /** @type {?} */ hostProperties = {};\n        var /** @type {?} */ hostAttributes = {};\n        if (host != null) {\n            Object.keys(host).forEach(function (key) {\n                var /** @type {?} */ value = host[key];\n                var /** @type {?} */ matches = key.match(HOST_REG_EXP);\n                if (matches === null) {\n                    hostAttributes[key] = value;\n                }\n                else if (matches[1] != null) {\n                    hostProperties[matches[1]] = value;\n                }\n                else if (matches[2] != null) {\n                    hostListeners[matches[2]] = value;\n                }\n            });\n        }\n        var /** @type {?} */ inputsMap = {};\n        if (inputs != null) {\n            inputs.forEach(function (bindConfig) {\n                // canonical syntax: `dirProp: elProp`\n                // if there is no `:`, use dirProp = elProp\n                var /** @type {?} */ parts = splitAtColon(bindConfig, [bindConfig, bindConfig]);\n                inputsMap[parts[0]] = parts[1];\n            });\n        }\n        var /** @type {?} */ outputsMap = {};\n        if (outputs != null) {\n            outputs.forEach(function (bindConfig) {\n                // canonical syntax: `dirProp: elProp`\n                // if there is no `:`, use dirProp = elProp\n                var /** @type {?} */ parts = splitAtColon(bindConfig, [bindConfig, bindConfig]);\n                outputsMap[parts[0]] = parts[1];\n            });\n        }\n        return new CompileDirectiveMetadata({\n            isHost: isHost,\n            type: type,\n            isComponent: !!isComponent, selector: selector, exportAs: exportAs, changeDetection: changeDetection,\n            inputs: inputsMap,\n            outputs: outputsMap,\n            hostListeners: hostListeners,\n            hostProperties: hostProperties,\n            hostAttributes: hostAttributes,\n            providers: providers,\n            viewProviders: viewProviders,\n            queries: queries,\n            guards: guards,\n            viewQueries: viewQueries,\n            entryComponents: entryComponents,\n            template: template,\n            componentViewType: componentViewType,\n            rendererType: rendererType,\n            componentFactory: componentFactory,\n        });\n    };\n    /**\n     * @return {?}\n     */\n    CompileDirectiveMetadata.prototype.toSummary = /**\n     * @return {?}\n     */\n    function () {\n        return {\n            summaryKind: CompileSummaryKind.Directive,\n            type: this.type,\n            isComponent: this.isComponent,\n            selector: this.selector,\n            exportAs: this.exportAs,\n            inputs: this.inputs,\n            outputs: this.outputs,\n            hostListeners: this.hostListeners,\n            hostProperties: this.hostProperties,\n            hostAttributes: this.hostAttributes,\n            providers: this.providers,\n            viewProviders: this.viewProviders,\n            queries: this.queries,\n            guards: this.guards,\n            viewQueries: this.viewQueries,\n            entryComponents: this.entryComponents,\n            changeDetection: this.changeDetection,\n            template: this.template && this.template.toSummary(),\n            componentViewType: this.componentViewType,\n            rendererType: this.rendererType,\n            componentFactory: this.componentFactory\n        };\n    };\n    return CompileDirectiveMetadata;\n}());\n/**\n * @record\n */\n\nvar CompilePipeMetadata = /** @class */ (function () {\n    function CompilePipeMetadata(_a) {\n        var type = _a.type, name = _a.name, pure = _a.pure;\n        this.type = type;\n        this.name = name;\n        this.pure = !!pure;\n    }\n    /**\n     * @return {?}\n     */\n    CompilePipeMetadata.prototype.toSummary = /**\n     * @return {?}\n     */\n    function () {\n        return {\n            summaryKind: CompileSummaryKind.Pipe,\n            type: this.type,\n            name: this.name,\n            pure: this.pure\n        };\n    };\n    return CompilePipeMetadata;\n}());\n/**\n * @record\n */\n\n/**\n * Metadata regarding compilation of a module.\n */\nvar CompileNgModuleMetadata = /** @class */ (function () {\n    function CompileNgModuleMetadata(_a) {\n        var type = _a.type, providers = _a.providers, declaredDirectives = _a.declaredDirectives, exportedDirectives = _a.exportedDirectives, declaredPipes = _a.declaredPipes, exportedPipes = _a.exportedPipes, entryComponents = _a.entryComponents, bootstrapComponents = _a.bootstrapComponents, importedModules = _a.importedModules, exportedModules = _a.exportedModules, schemas = _a.schemas, transitiveModule = _a.transitiveModule, id = _a.id;\n        this.type = type || null;\n        this.declaredDirectives = _normalizeArray(declaredDirectives);\n        this.exportedDirectives = _normalizeArray(exportedDirectives);\n        this.declaredPipes = _normalizeArray(declaredPipes);\n        this.exportedPipes = _normalizeArray(exportedPipes);\n        this.providers = _normalizeArray(providers);\n        this.entryComponents = _normalizeArray(entryComponents);\n        this.bootstrapComponents = _normalizeArray(bootstrapComponents);\n        this.importedModules = _normalizeArray(importedModules);\n        this.exportedModules = _normalizeArray(exportedModules);\n        this.schemas = _normalizeArray(schemas);\n        this.id = id || null;\n        this.transitiveModule = transitiveModule || null;\n    }\n    /**\n     * @return {?}\n     */\n    CompileNgModuleMetadata.prototype.toSummary = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ module = /** @type {?} */ ((this.transitiveModule));\n        return {\n            summaryKind: CompileSummaryKind.NgModule,\n            type: this.type,\n            entryComponents: module.entryComponents,\n            providers: module.providers,\n            modules: module.modules,\n            exportedDirectives: module.exportedDirectives,\n            exportedPipes: module.exportedPipes\n        };\n    };\n    return CompileNgModuleMetadata;\n}());\nvar TransitiveCompileNgModuleMetadata = /** @class */ (function () {\n    function TransitiveCompileNgModuleMetadata() {\n        this.directivesSet = new Set();\n        this.directives = [];\n        this.exportedDirectivesSet = new Set();\n        this.exportedDirectives = [];\n        this.pipesSet = new Set();\n        this.pipes = [];\n        this.exportedPipesSet = new Set();\n        this.exportedPipes = [];\n        this.modulesSet = new Set();\n        this.modules = [];\n        this.entryComponentsSet = new Set();\n        this.entryComponents = [];\n        this.providers = [];\n    }\n    /**\n     * @param {?} provider\n     * @param {?} module\n     * @return {?}\n     */\n    TransitiveCompileNgModuleMetadata.prototype.addProvider = /**\n     * @param {?} provider\n     * @param {?} module\n     * @return {?}\n     */\n    function (provider, module) {\n        this.providers.push({ provider: provider, module: module });\n    };\n    /**\n     * @param {?} id\n     * @return {?}\n     */\n    TransitiveCompileNgModuleMetadata.prototype.addDirective = /**\n     * @param {?} id\n     * @return {?}\n     */\n    function (id) {\n        if (!this.directivesSet.has(id.reference)) {\n            this.directivesSet.add(id.reference);\n            this.directives.push(id);\n        }\n    };\n    /**\n     * @param {?} id\n     * @return {?}\n     */\n    TransitiveCompileNgModuleMetadata.prototype.addExportedDirective = /**\n     * @param {?} id\n     * @return {?}\n     */\n    function (id) {\n        if (!this.exportedDirectivesSet.has(id.reference)) {\n            this.exportedDirectivesSet.add(id.reference);\n            this.exportedDirectives.push(id);\n        }\n    };\n    /**\n     * @param {?} id\n     * @return {?}\n     */\n    TransitiveCompileNgModuleMetadata.prototype.addPipe = /**\n     * @param {?} id\n     * @return {?}\n     */\n    function (id) {\n        if (!this.pipesSet.has(id.reference)) {\n            this.pipesSet.add(id.reference);\n            this.pipes.push(id);\n        }\n    };\n    /**\n     * @param {?} id\n     * @return {?}\n     */\n    TransitiveCompileNgModuleMetadata.prototype.addExportedPipe = /**\n     * @param {?} id\n     * @return {?}\n     */\n    function (id) {\n        if (!this.exportedPipesSet.has(id.reference)) {\n            this.exportedPipesSet.add(id.reference);\n            this.exportedPipes.push(id);\n        }\n    };\n    /**\n     * @param {?} id\n     * @return {?}\n     */\n    TransitiveCompileNgModuleMetadata.prototype.addModule = /**\n     * @param {?} id\n     * @return {?}\n     */\n    function (id) {\n        if (!this.modulesSet.has(id.reference)) {\n            this.modulesSet.add(id.reference);\n            this.modules.push(id);\n        }\n    };\n    /**\n     * @param {?} ec\n     * @return {?}\n     */\n    TransitiveCompileNgModuleMetadata.prototype.addEntryComponent = /**\n     * @param {?} ec\n     * @return {?}\n     */\n    function (ec) {\n        if (!this.entryComponentsSet.has(ec.componentType)) {\n            this.entryComponentsSet.add(ec.componentType);\n            this.entryComponents.push(ec);\n        }\n    };\n    return TransitiveCompileNgModuleMetadata;\n}());\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction _normalizeArray(obj) {\n    return obj || [];\n}\nvar ProviderMeta = /** @class */ (function () {\n    function ProviderMeta(token, _a) {\n        var useClass = _a.useClass, useValue = _a.useValue, useExisting = _a.useExisting, useFactory = _a.useFactory, deps = _a.deps, multi = _a.multi;\n        this.token = token;\n        this.useClass = useClass || null;\n        this.useValue = useValue;\n        this.useExisting = useExisting;\n        this.useFactory = useFactory || null;\n        this.dependencies = deps || null;\n        this.multi = !!multi;\n    }\n    return ProviderMeta;\n}());\n/**\n * @template T\n * @param {?} list\n * @return {?}\n */\nfunction flatten(list) {\n    return list.reduce(function (flat, item) {\n        var /** @type {?} */ flatItem = Array.isArray(item) ? flatten(item) : item;\n        return (/** @type {?} */ (flat)).concat(flatItem);\n    }, []);\n}\n/**\n * @param {?} url\n * @return {?}\n */\nfunction jitSourceUrl(url) {\n    // Note: We need 3 \"/\" so that ng shows up as a separate domain\n    // in the chrome dev tools.\n    return url.replace(/(\\w+:\\/\\/[\\w:-]+)?(\\/+)?/, 'ng:///');\n}\n/**\n * @param {?} ngModuleType\n * @param {?} compMeta\n * @param {?} templateMeta\n * @return {?}\n */\nfunction templateSourceUrl(ngModuleType, compMeta, templateMeta) {\n    var /** @type {?} */ url;\n    if (templateMeta.isInline) {\n        if (compMeta.type.reference instanceof StaticSymbol) {\n            // Note: a .ts file might contain multiple components with inline templates,\n            // so we need to give them unique urls, as these will be used for sourcemaps.\n            url = compMeta.type.reference.filePath + \".\" + compMeta.type.reference.name + \".html\";\n        }\n        else {\n            url = identifierName(ngModuleType) + \"/\" + identifierName(compMeta.type) + \".html\";\n        }\n    }\n    else {\n        url = /** @type {?} */ ((templateMeta.templateUrl));\n    }\n    return compMeta.type.reference instanceof StaticSymbol ? url : jitSourceUrl(url);\n}\n/**\n * @param {?} meta\n * @param {?} id\n * @return {?}\n */\nfunction sharedStylesheetJitUrl(meta, id) {\n    var /** @type {?} */ pathParts = /** @type {?} */ ((meta.moduleUrl)).split(/\\/\\\\/g);\n    var /** @type {?} */ baseName = pathParts[pathParts.length - 1];\n    return jitSourceUrl(\"css/\" + id + baseName + \".ngstyle.js\");\n}\n/**\n * @param {?} moduleMeta\n * @return {?}\n */\nfunction ngModuleJitUrl(moduleMeta) {\n    return jitSourceUrl(identifierName(moduleMeta.type) + \"/module.ngfactory.js\");\n}\n/**\n * @param {?} ngModuleType\n * @param {?} compMeta\n * @return {?}\n */\nfunction templateJitUrl(ngModuleType, compMeta) {\n    return jitSourceUrl(identifierName(ngModuleType) + \"/\" + identifierName(compMeta.type) + \".ngfactory.js\");\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A path is an ordered set of elements. Typically a path is to  a\n * particular offset in a source file. The head of the list is the top\n * most node. The tail is the node that contains the offset directly.\n *\n * For example, the expresion `a + b + c` might have an ast that looks\n * like:\n *     +\n *    / \\\n *   a   +\n *      / \\\n *     b   c\n *\n * The path to the node at offset 9 would be `['+' at 1-10, '+' at 7-10,\n * 'c' at 9-10]` and the path the node at offset 1 would be\n * `['+' at 1-10, 'a' at 1-2]`.\n * @template T\n */\nvar AstPath = /** @class */ (function () {\n    function AstPath(path, position) {\n        if (position === void 0) { position = -1; }\n        this.path = path;\n        this.position = position;\n    }\n    Object.defineProperty(AstPath.prototype, \"empty\", {\n        get: /**\n         * @return {?}\n         */\n        function () { return !this.path || !this.path.length; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(AstPath.prototype, \"head\", {\n        get: /**\n         * @return {?}\n         */\n        function () { return this.path[0]; },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(AstPath.prototype, \"tail\", {\n        get: /**\n         * @return {?}\n         */\n        function () { return this.path[this.path.length - 1]; },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * @param {?} node\n     * @return {?}\n     */\n    AstPath.prototype.parentOf = /**\n     * @param {?} node\n     * @return {?}\n     */\n    function (node) {\n        return node && this.path[this.path.indexOf(node) - 1];\n    };\n    /**\n     * @param {?} node\n     * @return {?}\n     */\n    AstPath.prototype.childOf = /**\n     * @param {?} node\n     * @return {?}\n     */\n    function (node) { return this.path[this.path.indexOf(node) + 1]; };\n    /**\n     * @template N\n     * @param {?} ctor\n     * @return {?}\n     */\n    AstPath.prototype.first = /**\n     * @template N\n     * @param {?} ctor\n     * @return {?}\n     */\n    function (ctor) {\n        for (var /** @type {?} */ i = this.path.length - 1; i >= 0; i--) {\n            var /** @type {?} */ item = this.path[i];\n            if (item instanceof ctor)\n                return /** @type {?} */ (item);\n        }\n    };\n    /**\n     * @param {?} node\n     * @return {?}\n     */\n    AstPath.prototype.push = /**\n     * @param {?} node\n     * @return {?}\n     */\n    function (node) { this.path.push(node); };\n    /**\n     * @return {?}\n     */\n    AstPath.prototype.pop = /**\n     * @return {?}\n     */\n    function () { return /** @type {?} */ ((this.path.pop())); };\n    return AstPath;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @record\n */\n\nvar Text = /** @class */ (function () {\n    function Text(value, sourceSpan) {\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    Text.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitText(this, context); };\n    return Text;\n}());\nvar Expansion = /** @class */ (function () {\n    function Expansion(switchValue, type, cases, sourceSpan, switchValueSourceSpan) {\n        this.switchValue = switchValue;\n        this.type = type;\n        this.cases = cases;\n        this.sourceSpan = sourceSpan;\n        this.switchValueSourceSpan = switchValueSourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    Expansion.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitExpansion(this, context); };\n    return Expansion;\n}());\nvar ExpansionCase = /** @class */ (function () {\n    function ExpansionCase(value, expression, sourceSpan, valueSourceSpan, expSourceSpan) {\n        this.value = value;\n        this.expression = expression;\n        this.sourceSpan = sourceSpan;\n        this.valueSourceSpan = valueSourceSpan;\n        this.expSourceSpan = expSourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ExpansionCase.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitExpansionCase(this, context); };\n    return ExpansionCase;\n}());\nvar Attribute$1 = /** @class */ (function () {\n    function Attribute(name, value, sourceSpan, valueSpan) {\n        this.name = name;\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n        this.valueSpan = valueSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    Attribute.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitAttribute(this, context); };\n    return Attribute;\n}());\nvar Element = /** @class */ (function () {\n    function Element(name, attrs, children, sourceSpan, startSourceSpan, endSourceSpan) {\n        if (startSourceSpan === void 0) { startSourceSpan = null; }\n        if (endSourceSpan === void 0) { endSourceSpan = null; }\n        this.name = name;\n        this.attrs = attrs;\n        this.children = children;\n        this.sourceSpan = sourceSpan;\n        this.startSourceSpan = startSourceSpan;\n        this.endSourceSpan = endSourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    Element.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitElement(this, context); };\n    return Element;\n}());\nvar Comment = /** @class */ (function () {\n    function Comment(value, sourceSpan) {\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    Comment.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitComment(this, context); };\n    return Comment;\n}());\n/**\n * @record\n */\n\n/**\n * @param {?} visitor\n * @param {?} nodes\n * @param {?=} context\n * @return {?}\n */\nfunction visitAll(visitor, nodes, context) {\n    if (context === void 0) { context = null; }\n    var /** @type {?} */ result = [];\n    var /** @type {?} */ visit = visitor.visit ?\n        function (ast) { return ((visitor.visit))(ast, context) || ast.visit(visitor, context); } :\n        function (ast) { return ast.visit(visitor, context); };\n    nodes.forEach(function (ast) {\n        var /** @type {?} */ astResult = visit(ast);\n        if (astResult) {\n            result.push(astResult);\n        }\n    });\n    return result;\n}\nvar RecursiveVisitor = /** @class */ (function () {\n    function RecursiveVisitor() {\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveVisitor.prototype.visitElement = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        this.visitChildren(context, function (visit) {\n            visit(ast.attrs);\n            visit(ast.children);\n        });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveVisitor.prototype.visitAttribute = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveVisitor.prototype.visitText = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveVisitor.prototype.visitComment = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveVisitor.prototype.visitExpansion = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.visitChildren(context, function (visit) { visit(ast.cases); });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveVisitor.prototype.visitExpansionCase = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @template T\n     * @param {?} context\n     * @param {?} cb\n     * @return {?}\n     */\n    RecursiveVisitor.prototype.visitChildren = /**\n     * @template T\n     * @param {?} context\n     * @param {?} cb\n     * @return {?}\n     */\n    function (context, cb) {\n        var /** @type {?} */ results = [];\n        var /** @type {?} */ t = this;\n        /**\n         * @template T\n         * @param {?} children\n         * @return {?}\n         */\n        function visit(children) {\n            if (children)\n                results.push(visitAll(t, children, context));\n        }\n        cb(visit);\n        return [].concat.apply([], results);\n    };\n    return RecursiveVisitor;\n}());\n/**\n * @param {?} ast\n * @return {?}\n */\nfunction spanOf(ast) {\n    var /** @type {?} */ start = ast.sourceSpan.start.offset;\n    var /** @type {?} */ end = ast.sourceSpan.end.offset;\n    if (ast instanceof Element) {\n        if (ast.endSourceSpan) {\n            end = ast.endSourceSpan.end.offset;\n        }\n        else if (ast.children && ast.children.length) {\n            end = spanOf(ast.children[ast.children.length - 1]).end;\n        }\n    }\n    return { start: start, end: end };\n}\n/**\n * @param {?} nodes\n * @param {?} position\n * @return {?}\n */\nfunction findNode(nodes, position) {\n    var /** @type {?} */ path = [];\n    var /** @type {?} */ visitor = new /** @class */ (function (_super) {\n        __extends(class_1, _super);\n        function class_1() {\n            return _super !== null && _super.apply(this, arguments) || this;\n        }\n        /**\n         * @param {?} ast\n         * @param {?} context\n         * @return {?}\n         */\n        class_1.prototype.visit = /**\n         * @param {?} ast\n         * @param {?} context\n         * @return {?}\n         */\n        function (ast, context) {\n            var /** @type {?} */ span = spanOf(ast);\n            if (span.start <= position && position < span.end) {\n                path.push(ast);\n            }\n            else {\n                // Returning a value here will result in the children being skipped.\n                return true;\n            }\n        };\n        return class_1;\n    }(RecursiveVisitor));\n    visitAll(visitor, nodes);\n    return new AstPath(path, position);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @param {?} identifier\n * @param {?} value\n * @return {?}\n */\nfunction assertArrayOfStrings(identifier, value) {\n    if (value == null) {\n        return;\n    }\n    if (!Array.isArray(value)) {\n        throw new Error(\"Expected '\" + identifier + \"' to be an array of strings.\");\n    }\n    for (var /** @type {?} */ i = 0; i < value.length; i += 1) {\n        if (typeof value[i] !== 'string') {\n            throw new Error(\"Expected '\" + identifier + \"' to be an array of strings.\");\n        }\n    }\n}\nvar INTERPOLATION_BLACKLIST_REGEXPS = [\n    /^\\s*$/,\n    /[<>]/,\n    /^[{}]$/,\n    /&(#|[a-z])/i,\n    /^\\/\\//,\n];\n/**\n * @param {?} identifier\n * @param {?} value\n * @return {?}\n */\nfunction assertInterpolationSymbols(identifier, value) {\n    if (value != null && !(Array.isArray(value) && value.length == 2)) {\n        throw new Error(\"Expected '\" + identifier + \"' to be an array, [start, end].\");\n    }\n    else if (value != null) {\n        var /** @type {?} */ start_1 = /** @type {?} */ (value[0]);\n        var /** @type {?} */ end_1 = /** @type {?} */ (value[1]);\n        // black list checking\n        INTERPOLATION_BLACKLIST_REGEXPS.forEach(function (regexp) {\n            if (regexp.test(start_1) || regexp.test(end_1)) {\n                throw new Error(\"['\" + start_1 + \"', '\" + end_1 + \"'] contains unusable interpolation symbol.\");\n            }\n        });\n    }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar InterpolationConfig = /** @class */ (function () {\n    function InterpolationConfig(start, end) {\n        this.start = start;\n        this.end = end;\n    }\n    /**\n     * @param {?} markers\n     * @return {?}\n     */\n    InterpolationConfig.fromArray = /**\n     * @param {?} markers\n     * @return {?}\n     */\n    function (markers) {\n        if (!markers) {\n            return DEFAULT_INTERPOLATION_CONFIG;\n        }\n        assertInterpolationSymbols('interpolation', markers);\n        return new InterpolationConfig(markers[0], markers[1]);\n    };\n    return InterpolationConfig;\n}());\nvar DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar StyleWithImports = /** @class */ (function () {\n    function StyleWithImports(style, styleUrls) {\n        this.style = style;\n        this.styleUrls = styleUrls;\n    }\n    return StyleWithImports;\n}());\n/**\n * @param {?} url\n * @return {?}\n */\nfunction isStyleUrlResolvable(url) {\n    if (url == null || url.length === 0 || url[0] == '/')\n        return false;\n    var /** @type {?} */ schemeMatch = url.match(URL_WITH_SCHEMA_REGEXP);\n    return schemeMatch === null || schemeMatch[1] == 'package' || schemeMatch[1] == 'asset';\n}\n/**\n * Rewrites stylesheets by resolving and removing the \\@import urls that\n * are either relative or don't have a `package:` scheme\n * @param {?} resolver\n * @param {?} baseUrl\n * @param {?} cssText\n * @return {?}\n */\nfunction extractStyleUrls(resolver, baseUrl, cssText) {\n    var /** @type {?} */ foundUrls = [];\n    var /** @type {?} */ modifiedCssText = cssText.replace(CSS_STRIPPABLE_COMMENT_REGEXP, '')\n        .replace(CSS_IMPORT_REGEXP, function () {\n        var m = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            m[_i] = arguments[_i];\n        }\n        var /** @type {?} */ url = m[1] || m[2];\n        if (!isStyleUrlResolvable(url)) {\n            // Do not attempt to resolve non-package absolute URLs with URI\n            // scheme\n            return m[0];\n        }\n        foundUrls.push(resolver.resolve(baseUrl, url));\n        return '';\n    });\n    return new StyleWithImports(modifiedCssText, foundUrls);\n}\nvar CSS_IMPORT_REGEXP = /@import\\s+(?:url\\()?\\s*(?:(?:['\"]([^'\"]*))|([^;\\)\\s]*))[^;]*;?/g;\nvar CSS_STRIPPABLE_COMMENT_REGEXP = /\\/\\*(?!#\\s*(?:sourceURL|sourceMappingURL)=)[\\s\\S]+?\\*\\//g;\nvar URL_WITH_SCHEMA_REGEXP = /^([^:/?#]+):/;\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @enum {number} */\nvar TagContentType = {\n    RAW_TEXT: 0,\n    ESCAPABLE_RAW_TEXT: 1,\n    PARSABLE_DATA: 2,\n};\nTagContentType[TagContentType.RAW_TEXT] = \"RAW_TEXT\";\nTagContentType[TagContentType.ESCAPABLE_RAW_TEXT] = \"ESCAPABLE_RAW_TEXT\";\nTagContentType[TagContentType.PARSABLE_DATA] = \"PARSABLE_DATA\";\n/**\n * @record\n */\n\n/**\n * @param {?} elementName\n * @return {?}\n */\nfunction splitNsName(elementName) {\n    if (elementName[0] != ':') {\n        return [null, elementName];\n    }\n    var /** @type {?} */ colonIndex = elementName.indexOf(':', 1);\n    if (colonIndex == -1) {\n        throw new Error(\"Unsupported format \\\"\" + elementName + \"\\\" expecting \\\":namespace:name\\\"\");\n    }\n    return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];\n}\n/**\n * @param {?} tagName\n * @return {?}\n */\nfunction isNgContainer(tagName) {\n    return splitNsName(tagName)[1] === 'ng-container';\n}\n/**\n * @param {?} tagName\n * @return {?}\n */\nfunction isNgContent(tagName) {\n    return splitNsName(tagName)[1] === 'ng-content';\n}\n/**\n * @param {?} tagName\n * @return {?}\n */\nfunction isNgTemplate(tagName) {\n    return splitNsName(tagName)[1] === 'ng-template';\n}\n/**\n * @param {?} fullName\n * @return {?}\n */\nfunction getNsPrefix(fullName) {\n    return fullName === null ? null : splitNsName(fullName)[0];\n}\n/**\n * @param {?} prefix\n * @param {?} localName\n * @return {?}\n */\nfunction mergeNsAndName(prefix, localName) {\n    return prefix ? \":\" + prefix + \":\" + localName : localName;\n}\n// see http://www.w3.org/TR/html51/syntax.html#named-character-references\n// see https://html.spec.whatwg.org/multipage/entities.json\n// This list is not exhaustive to keep the compiler footprint low.\n// The `&#123;` / `&#x1ab;` syntax should be used when the named character reference does not\n// exist.\nvar NAMED_ENTITIES = {\n    'Aacute': '\\u00C1',\n    'aacute': '\\u00E1',\n    'Acirc': '\\u00C2',\n    'acirc': '\\u00E2',\n    'acute': '\\u00B4',\n    'AElig': '\\u00C6',\n    'aelig': '\\u00E6',\n    'Agrave': '\\u00C0',\n    'agrave': '\\u00E0',\n    'alefsym': '\\u2135',\n    'Alpha': '\\u0391',\n    'alpha': '\\u03B1',\n    'amp': '&',\n    'and': '\\u2227',\n    'ang': '\\u2220',\n    'apos': '\\u0027',\n    'Aring': '\\u00C5',\n    'aring': '\\u00E5',\n    'asymp': '\\u2248',\n    'Atilde': '\\u00C3',\n    'atilde': '\\u00E3',\n    'Auml': '\\u00C4',\n    'auml': '\\u00E4',\n    'bdquo': '\\u201E',\n    'Beta': '\\u0392',\n    'beta': '\\u03B2',\n    'brvbar': '\\u00A6',\n    'bull': '\\u2022',\n    'cap': '\\u2229',\n    'Ccedil': '\\u00C7',\n    'ccedil': '\\u00E7',\n    'cedil': '\\u00B8',\n    'cent': '\\u00A2',\n    'Chi': '\\u03A7',\n    'chi': '\\u03C7',\n    'circ': '\\u02C6',\n    'clubs': '\\u2663',\n    'cong': '\\u2245',\n    'copy': '\\u00A9',\n    'crarr': '\\u21B5',\n    'cup': '\\u222A',\n    'curren': '\\u00A4',\n    'dagger': '\\u2020',\n    'Dagger': '\\u2021',\n    'darr': '\\u2193',\n    'dArr': '\\u21D3',\n    'deg': '\\u00B0',\n    'Delta': '\\u0394',\n    'delta': '\\u03B4',\n    'diams': '\\u2666',\n    'divide': '\\u00F7',\n    'Eacute': '\\u00C9',\n    'eacute': '\\u00E9',\n    'Ecirc': '\\u00CA',\n    'ecirc': '\\u00EA',\n    'Egrave': '\\u00C8',\n    'egrave': '\\u00E8',\n    'empty': '\\u2205',\n    'emsp': '\\u2003',\n    'ensp': '\\u2002',\n    'Epsilon': '\\u0395',\n    'epsilon': '\\u03B5',\n    'equiv': '\\u2261',\n    'Eta': '\\u0397',\n    'eta': '\\u03B7',\n    'ETH': '\\u00D0',\n    'eth': '\\u00F0',\n    'Euml': '\\u00CB',\n    'euml': '\\u00EB',\n    'euro': '\\u20AC',\n    'exist': '\\u2203',\n    'fnof': '\\u0192',\n    'forall': '\\u2200',\n    'frac12': '\\u00BD',\n    'frac14': '\\u00BC',\n    'frac34': '\\u00BE',\n    'frasl': '\\u2044',\n    'Gamma': '\\u0393',\n    'gamma': '\\u03B3',\n    'ge': '\\u2265',\n    'gt': '>',\n    'harr': '\\u2194',\n    'hArr': '\\u21D4',\n    'hearts': '\\u2665',\n    'hellip': '\\u2026',\n    'Iacute': '\\u00CD',\n    'iacute': '\\u00ED',\n    'Icirc': '\\u00CE',\n    'icirc': '\\u00EE',\n    'iexcl': '\\u00A1',\n    'Igrave': '\\u00CC',\n    'igrave': '\\u00EC',\n    'image': '\\u2111',\n    'infin': '\\u221E',\n    'int': '\\u222B',\n    'Iota': '\\u0399',\n    'iota': '\\u03B9',\n    'iquest': '\\u00BF',\n    'isin': '\\u2208',\n    'Iuml': '\\u00CF',\n    'iuml': '\\u00EF',\n    'Kappa': '\\u039A',\n    'kappa': '\\u03BA',\n    'Lambda': '\\u039B',\n    'lambda': '\\u03BB',\n    'lang': '\\u27E8',\n    'laquo': '\\u00AB',\n    'larr': '\\u2190',\n    'lArr': '\\u21D0',\n    'lceil': '\\u2308',\n    'ldquo': '\\u201C',\n    'le': '\\u2264',\n    'lfloor': '\\u230A',\n    'lowast': '\\u2217',\n    'loz': '\\u25CA',\n    'lrm': '\\u200E',\n    'lsaquo': '\\u2039',\n    'lsquo': '\\u2018',\n    'lt': '<',\n    'macr': '\\u00AF',\n    'mdash': '\\u2014',\n    'micro': '\\u00B5',\n    'middot': '\\u00B7',\n    'minus': '\\u2212',\n    'Mu': '\\u039C',\n    'mu': '\\u03BC',\n    'nabla': '\\u2207',\n    'nbsp': '\\u00A0',\n    'ndash': '\\u2013',\n    'ne': '\\u2260',\n    'ni': '\\u220B',\n    'not': '\\u00AC',\n    'notin': '\\u2209',\n    'nsub': '\\u2284',\n    'Ntilde': '\\u00D1',\n    'ntilde': '\\u00F1',\n    'Nu': '\\u039D',\n    'nu': '\\u03BD',\n    'Oacute': '\\u00D3',\n    'oacute': '\\u00F3',\n    'Ocirc': '\\u00D4',\n    'ocirc': '\\u00F4',\n    'OElig': '\\u0152',\n    'oelig': '\\u0153',\n    'Ograve': '\\u00D2',\n    'ograve': '\\u00F2',\n    'oline': '\\u203E',\n    'Omega': '\\u03A9',\n    'omega': '\\u03C9',\n    'Omicron': '\\u039F',\n    'omicron': '\\u03BF',\n    'oplus': '\\u2295',\n    'or': '\\u2228',\n    'ordf': '\\u00AA',\n    'ordm': '\\u00BA',\n    'Oslash': '\\u00D8',\n    'oslash': '\\u00F8',\n    'Otilde': '\\u00D5',\n    'otilde': '\\u00F5',\n    'otimes': '\\u2297',\n    'Ouml': '\\u00D6',\n    'ouml': '\\u00F6',\n    'para': '\\u00B6',\n    'permil': '\\u2030',\n    'perp': '\\u22A5',\n    'Phi': '\\u03A6',\n    'phi': '\\u03C6',\n    'Pi': '\\u03A0',\n    'pi': '\\u03C0',\n    'piv': '\\u03D6',\n    'plusmn': '\\u00B1',\n    'pound': '\\u00A3',\n    'prime': '\\u2032',\n    'Prime': '\\u2033',\n    'prod': '\\u220F',\n    'prop': '\\u221D',\n    'Psi': '\\u03A8',\n    'psi': '\\u03C8',\n    'quot': '\\u0022',\n    'radic': '\\u221A',\n    'rang': '\\u27E9',\n    'raquo': '\\u00BB',\n    'rarr': '\\u2192',\n    'rArr': '\\u21D2',\n    'rceil': '\\u2309',\n    'rdquo': '\\u201D',\n    'real': '\\u211C',\n    'reg': '\\u00AE',\n    'rfloor': '\\u230B',\n    'Rho': '\\u03A1',\n    'rho': '\\u03C1',\n    'rlm': '\\u200F',\n    'rsaquo': '\\u203A',\n    'rsquo': '\\u2019',\n    'sbquo': '\\u201A',\n    'Scaron': '\\u0160',\n    'scaron': '\\u0161',\n    'sdot': '\\u22C5',\n    'sect': '\\u00A7',\n    'shy': '\\u00AD',\n    'Sigma': '\\u03A3',\n    'sigma': '\\u03C3',\n    'sigmaf': '\\u03C2',\n    'sim': '\\u223C',\n    'spades': '\\u2660',\n    'sub': '\\u2282',\n    'sube': '\\u2286',\n    'sum': '\\u2211',\n    'sup': '\\u2283',\n    'sup1': '\\u00B9',\n    'sup2': '\\u00B2',\n    'sup3': '\\u00B3',\n    'supe': '\\u2287',\n    'szlig': '\\u00DF',\n    'Tau': '\\u03A4',\n    'tau': '\\u03C4',\n    'there4': '\\u2234',\n    'Theta': '\\u0398',\n    'theta': '\\u03B8',\n    'thetasym': '\\u03D1',\n    'thinsp': '\\u2009',\n    'THORN': '\\u00DE',\n    'thorn': '\\u00FE',\n    'tilde': '\\u02DC',\n    'times': '\\u00D7',\n    'trade': '\\u2122',\n    'Uacute': '\\u00DA',\n    'uacute': '\\u00FA',\n    'uarr': '\\u2191',\n    'uArr': '\\u21D1',\n    'Ucirc': '\\u00DB',\n    'ucirc': '\\u00FB',\n    'Ugrave': '\\u00D9',\n    'ugrave': '\\u00F9',\n    'uml': '\\u00A8',\n    'upsih': '\\u03D2',\n    'Upsilon': '\\u03A5',\n    'upsilon': '\\u03C5',\n    'Uuml': '\\u00DC',\n    'uuml': '\\u00FC',\n    'weierp': '\\u2118',\n    'Xi': '\\u039E',\n    'xi': '\\u03BE',\n    'Yacute': '\\u00DD',\n    'yacute': '\\u00FD',\n    'yen': '\\u00A5',\n    'yuml': '\\u00FF',\n    'Yuml': '\\u0178',\n    'Zeta': '\\u0396',\n    'zeta': '\\u03B6',\n    'zwj': '\\u200D',\n    'zwnj': '\\u200C',\n};\n// The &ngsp; pseudo-entity is denoting a space. see:\n// https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart\nvar NGSP_UNICODE = '\\uE500';\nNAMED_ENTITIES['ngsp'] = NGSP_UNICODE;\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar NG_CONTENT_SELECT_ATTR = 'select';\nvar LINK_ELEMENT = 'link';\nvar LINK_STYLE_REL_ATTR = 'rel';\nvar LINK_STYLE_HREF_ATTR = 'href';\nvar LINK_STYLE_REL_VALUE = 'stylesheet';\nvar STYLE_ELEMENT = 'style';\nvar SCRIPT_ELEMENT = 'script';\nvar NG_NON_BINDABLE_ATTR = 'ngNonBindable';\nvar NG_PROJECT_AS = 'ngProjectAs';\n/**\n * @param {?} ast\n * @return {?}\n */\nfunction preparseElement(ast) {\n    var /** @type {?} */ selectAttr = /** @type {?} */ ((null));\n    var /** @type {?} */ hrefAttr = /** @type {?} */ ((null));\n    var /** @type {?} */ relAttr = /** @type {?} */ ((null));\n    var /** @type {?} */ nonBindable = false;\n    var /** @type {?} */ projectAs = /** @type {?} */ ((null));\n    ast.attrs.forEach(function (attr) {\n        var /** @type {?} */ lcAttrName = attr.name.toLowerCase();\n        if (lcAttrName == NG_CONTENT_SELECT_ATTR) {\n            selectAttr = attr.value;\n        }\n        else if (lcAttrName == LINK_STYLE_HREF_ATTR) {\n            hrefAttr = attr.value;\n        }\n        else if (lcAttrName == LINK_STYLE_REL_ATTR) {\n            relAttr = attr.value;\n        }\n        else if (attr.name == NG_NON_BINDABLE_ATTR) {\n            nonBindable = true;\n        }\n        else if (attr.name == NG_PROJECT_AS) {\n            if (attr.value.length > 0) {\n                projectAs = attr.value;\n            }\n        }\n    });\n    selectAttr = normalizeNgContentSelect(selectAttr);\n    var /** @type {?} */ nodeName = ast.name.toLowerCase();\n    var /** @type {?} */ type = PreparsedElementType.OTHER;\n    if (isNgContent(nodeName)) {\n        type = PreparsedElementType.NG_CONTENT;\n    }\n    else if (nodeName == STYLE_ELEMENT) {\n        type = PreparsedElementType.STYLE;\n    }\n    else if (nodeName == SCRIPT_ELEMENT) {\n        type = PreparsedElementType.SCRIPT;\n    }\n    else if (nodeName == LINK_ELEMENT && relAttr == LINK_STYLE_REL_VALUE) {\n        type = PreparsedElementType.STYLESHEET;\n    }\n    return new PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs);\n}\n/** @enum {number} */\nvar PreparsedElementType = {\n    NG_CONTENT: 0,\n    STYLE: 1,\n    STYLESHEET: 2,\n    SCRIPT: 3,\n    OTHER: 4,\n};\nPreparsedElementType[PreparsedElementType.NG_CONTENT] = \"NG_CONTENT\";\nPreparsedElementType[PreparsedElementType.STYLE] = \"STYLE\";\nPreparsedElementType[PreparsedElementType.STYLESHEET] = \"STYLESHEET\";\nPreparsedElementType[PreparsedElementType.SCRIPT] = \"SCRIPT\";\nPreparsedElementType[PreparsedElementType.OTHER] = \"OTHER\";\nvar PreparsedElement = /** @class */ (function () {\n    function PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs) {\n        this.type = type;\n        this.selectAttr = selectAttr;\n        this.hrefAttr = hrefAttr;\n        this.nonBindable = nonBindable;\n        this.projectAs = projectAs;\n    }\n    return PreparsedElement;\n}());\n/**\n * @param {?} selectAttr\n * @return {?}\n */\nfunction normalizeNgContentSelect(selectAttr) {\n    if (selectAttr === null || selectAttr.length === 0) {\n        return '*';\n    }\n    return selectAttr;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @record\n */\n\nvar DirectiveNormalizer = /** @class */ (function () {\n    function DirectiveNormalizer(_resourceLoader, _urlResolver, _htmlParser, _config) {\n        this._resourceLoader = _resourceLoader;\n        this._urlResolver = _urlResolver;\n        this._htmlParser = _htmlParser;\n        this._config = _config;\n        this._resourceLoaderCache = new Map();\n    }\n    /**\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype.clearCache = /**\n     * @return {?}\n     */\n    function () { this._resourceLoaderCache.clear(); };\n    /**\n     * @param {?} normalizedDirective\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype.clearCacheFor = /**\n     * @param {?} normalizedDirective\n     * @return {?}\n     */\n    function (normalizedDirective) {\n        var _this = this;\n        if (!normalizedDirective.isComponent) {\n            return;\n        }\n        var /** @type {?} */ template = /** @type {?} */ ((normalizedDirective.template));\n        this._resourceLoaderCache.delete(/** @type {?} */ ((template.templateUrl)));\n        template.externalStylesheets.forEach(function (stylesheet) { _this._resourceLoaderCache.delete(/** @type {?} */ ((stylesheet.moduleUrl))); });\n    };\n    /**\n     * @param {?} url\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype._fetch = /**\n     * @param {?} url\n     * @return {?}\n     */\n    function (url) {\n        var /** @type {?} */ result = this._resourceLoaderCache.get(url);\n        if (!result) {\n            result = this._resourceLoader.get(url);\n            this._resourceLoaderCache.set(url, result);\n        }\n        return result;\n    };\n    /**\n     * @param {?} prenormData\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype.normalizeTemplate = /**\n     * @param {?} prenormData\n     * @return {?}\n     */\n    function (prenormData) {\n        var _this = this;\n        if (isDefined(prenormData.template)) {\n            if (isDefined(prenormData.templateUrl)) {\n                throw syntaxError(\"'\" + stringify(prenormData.componentType) + \"' component cannot define both template and templateUrl\");\n            }\n            if (typeof prenormData.template !== 'string') {\n                throw syntaxError(\"The template specified for component \" + stringify(prenormData.componentType) + \" is not a string\");\n            }\n        }\n        else if (isDefined(prenormData.templateUrl)) {\n            if (typeof prenormData.templateUrl !== 'string') {\n                throw syntaxError(\"The templateUrl specified for component \" + stringify(prenormData.componentType) + \" is not a string\");\n            }\n        }\n        else {\n            throw syntaxError(\"No template specified for component \" + stringify(prenormData.componentType));\n        }\n        if (isDefined(prenormData.preserveWhitespaces) &&\n            typeof prenormData.preserveWhitespaces !== 'boolean') {\n            throw syntaxError(\"The preserveWhitespaces option for component \" + stringify(prenormData.componentType) + \" must be a boolean\");\n        }\n        return SyncAsync.then(this._preParseTemplate(prenormData), function (preparsedTemplate) { return _this._normalizeTemplateMetadata(prenormData, preparsedTemplate); });\n    };\n    /**\n     * @param {?} prenomData\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype._preParseTemplate = /**\n     * @param {?} prenomData\n     * @return {?}\n     */\n    function (prenomData) {\n        var _this = this;\n        var /** @type {?} */ template;\n        var /** @type {?} */ templateUrl;\n        if (prenomData.template != null) {\n            template = prenomData.template;\n            templateUrl = prenomData.moduleUrl;\n        }\n        else {\n            templateUrl = this._urlResolver.resolve(prenomData.moduleUrl, /** @type {?} */ ((prenomData.templateUrl)));\n            template = this._fetch(templateUrl);\n        }\n        return SyncAsync.then(template, function (template) { return _this._preparseLoadedTemplate(prenomData, template, templateUrl); });\n    };\n    /**\n     * @param {?} prenormData\n     * @param {?} template\n     * @param {?} templateAbsUrl\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype._preparseLoadedTemplate = /**\n     * @param {?} prenormData\n     * @param {?} template\n     * @param {?} templateAbsUrl\n     * @return {?}\n     */\n    function (prenormData, template, templateAbsUrl) {\n        var /** @type {?} */ isInline = !!prenormData.template;\n        var /** @type {?} */ interpolationConfig = InterpolationConfig.fromArray(/** @type {?} */ ((prenormData.interpolation)));\n        var /** @type {?} */ rootNodesAndErrors = this._htmlParser.parse(template, templateSourceUrl({ reference: prenormData.ngModuleType }, { type: { reference: prenormData.componentType } }, { isInline: isInline, templateUrl: templateAbsUrl }), true, interpolationConfig);\n        if (rootNodesAndErrors.errors.length > 0) {\n            var /** @type {?} */ errorString = rootNodesAndErrors.errors.join('\\n');\n            throw syntaxError(\"Template parse errors:\\n\" + errorString);\n        }\n        var /** @type {?} */ templateMetadataStyles = this._normalizeStylesheet(new CompileStylesheetMetadata({ styles: prenormData.styles, moduleUrl: prenormData.moduleUrl }));\n        var /** @type {?} */ visitor = new TemplatePreparseVisitor();\n        visitAll(visitor, rootNodesAndErrors.rootNodes);\n        var /** @type {?} */ templateStyles = this._normalizeStylesheet(new CompileStylesheetMetadata({ styles: visitor.styles, styleUrls: visitor.styleUrls, moduleUrl: templateAbsUrl }));\n        var /** @type {?} */ styles = templateMetadataStyles.styles.concat(templateStyles.styles);\n        var /** @type {?} */ inlineStyleUrls = templateMetadataStyles.styleUrls.concat(templateStyles.styleUrls);\n        var /** @type {?} */ styleUrls = this\n            ._normalizeStylesheet(new CompileStylesheetMetadata({ styleUrls: prenormData.styleUrls, moduleUrl: prenormData.moduleUrl }))\n            .styleUrls;\n        return {\n            template: template,\n            templateUrl: templateAbsUrl, isInline: isInline,\n            htmlAst: rootNodesAndErrors, styles: styles, inlineStyleUrls: inlineStyleUrls, styleUrls: styleUrls,\n            ngContentSelectors: visitor.ngContentSelectors,\n        };\n    };\n    /**\n     * @param {?} prenormData\n     * @param {?} preparsedTemplate\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype._normalizeTemplateMetadata = /**\n     * @param {?} prenormData\n     * @param {?} preparsedTemplate\n     * @return {?}\n     */\n    function (prenormData, preparsedTemplate) {\n        var _this = this;\n        return SyncAsync.then(this._loadMissingExternalStylesheets(preparsedTemplate.styleUrls.concat(preparsedTemplate.inlineStyleUrls)), function (externalStylesheets) {\n            return _this._normalizeLoadedTemplateMetadata(prenormData, preparsedTemplate, externalStylesheets);\n        });\n    };\n    /**\n     * @param {?} prenormData\n     * @param {?} preparsedTemplate\n     * @param {?} stylesheets\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype._normalizeLoadedTemplateMetadata = /**\n     * @param {?} prenormData\n     * @param {?} preparsedTemplate\n     * @param {?} stylesheets\n     * @return {?}\n     */\n    function (prenormData, preparsedTemplate, stylesheets) {\n        var _this = this;\n        // Algorithm:\n        // - produce exactly 1 entry per original styleUrl in\n        // CompileTemplateMetadata.externalStylesheets whith all styles inlined\n        // - inline all styles that are referenced by the template into CompileTemplateMetadata.styles.\n        // Reason: be able to determine how many stylesheets there are even without loading\n        // the template nor the stylesheets, so we can create a stub for TypeScript always synchronously\n        // (as resouce loading may be async)\n        var /** @type {?} */ styles = preparsedTemplate.styles.slice();\n        this._inlineStyles(preparsedTemplate.inlineStyleUrls, stylesheets, styles);\n        var /** @type {?} */ styleUrls = preparsedTemplate.styleUrls;\n        var /** @type {?} */ externalStylesheets = styleUrls.map(function (styleUrl) {\n            var /** @type {?} */ stylesheet = /** @type {?} */ ((stylesheets.get(styleUrl)));\n            var /** @type {?} */ styles = stylesheet.styles.slice();\n            _this._inlineStyles(stylesheet.styleUrls, stylesheets, styles);\n            return new CompileStylesheetMetadata({ moduleUrl: styleUrl, styles: styles });\n        });\n        var /** @type {?} */ encapsulation = prenormData.encapsulation;\n        if (encapsulation == null) {\n            encapsulation = this._config.defaultEncapsulation;\n        }\n        if (encapsulation === ViewEncapsulation.Emulated && styles.length === 0 &&\n            styleUrls.length === 0) {\n            encapsulation = ViewEncapsulation.None;\n        }\n        return new CompileTemplateMetadata({\n            encapsulation: encapsulation,\n            template: preparsedTemplate.template,\n            templateUrl: preparsedTemplate.templateUrl,\n            htmlAst: preparsedTemplate.htmlAst, styles: styles, styleUrls: styleUrls,\n            ngContentSelectors: preparsedTemplate.ngContentSelectors,\n            animations: prenormData.animations,\n            interpolation: prenormData.interpolation,\n            isInline: preparsedTemplate.isInline, externalStylesheets: externalStylesheets,\n            preserveWhitespaces: preserveWhitespacesDefault(prenormData.preserveWhitespaces, this._config.preserveWhitespaces),\n        });\n    };\n    /**\n     * @param {?} styleUrls\n     * @param {?} stylesheets\n     * @param {?} targetStyles\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype._inlineStyles = /**\n     * @param {?} styleUrls\n     * @param {?} stylesheets\n     * @param {?} targetStyles\n     * @return {?}\n     */\n    function (styleUrls, stylesheets, targetStyles) {\n        var _this = this;\n        styleUrls.forEach(function (styleUrl) {\n            var /** @type {?} */ stylesheet = /** @type {?} */ ((stylesheets.get(styleUrl)));\n            stylesheet.styles.forEach(function (style) { return targetStyles.push(style); });\n            _this._inlineStyles(stylesheet.styleUrls, stylesheets, targetStyles);\n        });\n    };\n    /**\n     * @param {?} styleUrls\n     * @param {?=} loadedStylesheets\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype._loadMissingExternalStylesheets = /**\n     * @param {?} styleUrls\n     * @param {?=} loadedStylesheets\n     * @return {?}\n     */\n    function (styleUrls, loadedStylesheets) {\n        var _this = this;\n        if (loadedStylesheets === void 0) { loadedStylesheets = new Map(); }\n        return SyncAsync.then(SyncAsync.all(styleUrls.filter(function (styleUrl) { return !loadedStylesheets.has(styleUrl); })\n            .map(function (styleUrl) {\n            return SyncAsync.then(_this._fetch(styleUrl), function (loadedStyle) {\n                var /** @type {?} */ stylesheet = _this._normalizeStylesheet(new CompileStylesheetMetadata({ styles: [loadedStyle], moduleUrl: styleUrl }));\n                loadedStylesheets.set(styleUrl, stylesheet);\n                return _this._loadMissingExternalStylesheets(stylesheet.styleUrls, loadedStylesheets);\n            });\n        })), function (_) { return loadedStylesheets; });\n    };\n    /**\n     * @param {?} stylesheet\n     * @return {?}\n     */\n    DirectiveNormalizer.prototype._normalizeStylesheet = /**\n     * @param {?} stylesheet\n     * @return {?}\n     */\n    function (stylesheet) {\n        var _this = this;\n        var /** @type {?} */ moduleUrl = /** @type {?} */ ((stylesheet.moduleUrl));\n        var /** @type {?} */ allStyleUrls = stylesheet.styleUrls.filter(isStyleUrlResolvable)\n            .map(function (url) { return _this._urlResolver.resolve(moduleUrl, url); });\n        var /** @type {?} */ allStyles = stylesheet.styles.map(function (style) {\n            var /** @type {?} */ styleWithImports = extractStyleUrls(_this._urlResolver, moduleUrl, style);\n            allStyleUrls.push.apply(allStyleUrls, styleWithImports.styleUrls);\n            return styleWithImports.style;\n        });\n        return new CompileStylesheetMetadata({ styles: allStyles, styleUrls: allStyleUrls, moduleUrl: moduleUrl });\n    };\n    return DirectiveNormalizer;\n}());\nvar TemplatePreparseVisitor = /** @class */ (function () {\n    function TemplatePreparseVisitor() {\n        this.ngContentSelectors = [];\n        this.styles = [];\n        this.styleUrls = [];\n        this.ngNonBindableStackCount = 0;\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    TemplatePreparseVisitor.prototype.visitElement = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var /** @type {?} */ preparsedElement = preparseElement(ast);\n        switch (preparsedElement.type) {\n            case PreparsedElementType.NG_CONTENT:\n                if (this.ngNonBindableStackCount === 0) {\n                    this.ngContentSelectors.push(preparsedElement.selectAttr);\n                }\n                break;\n            case PreparsedElementType.STYLE:\n                var /** @type {?} */ textContent_1 = '';\n                ast.children.forEach(function (child) {\n                    if (child instanceof Text) {\n                        textContent_1 += child.value;\n                    }\n                });\n                this.styles.push(textContent_1);\n                break;\n            case PreparsedElementType.STYLESHEET:\n                this.styleUrls.push(preparsedElement.hrefAttr);\n                break;\n            default:\n                break;\n        }\n        if (preparsedElement.nonBindable) {\n            this.ngNonBindableStackCount++;\n        }\n        visitAll(this, ast.children);\n        if (preparsedElement.nonBindable) {\n            this.ngNonBindableStackCount--;\n        }\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    TemplatePreparseVisitor.prototype.visitExpansion = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { visitAll(this, ast.cases); };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    TemplatePreparseVisitor.prototype.visitExpansionCase = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        visitAll(this, ast.expression);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    TemplatePreparseVisitor.prototype.visitComment = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return null; };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    TemplatePreparseVisitor.prototype.visitAttribute = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return null; };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    TemplatePreparseVisitor.prototype.visitText = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return null; };\n    return TemplatePreparseVisitor;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar QUERY_METADATA_IDENTIFIERS = [\n    createViewChild,\n    createViewChildren,\n    createContentChild,\n    createContentChildren,\n];\nvar DirectiveResolver = /** @class */ (function () {\n    function DirectiveResolver(_reflector) {\n        this._reflector = _reflector;\n    }\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    DirectiveResolver.prototype.isDirective = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ typeMetadata = this._reflector.annotations(resolveForwardRef(type));\n        return typeMetadata && typeMetadata.some(isDirectiveMetadata);\n    };\n    /**\n     * @param {?} type\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    DirectiveResolver.prototype.resolve = /**\n     * @param {?} type\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    function (type, throwIfNotFound) {\n        if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n        var /** @type {?} */ typeMetadata = this._reflector.annotations(resolveForwardRef(type));\n        if (typeMetadata) {\n            var /** @type {?} */ metadata = findLast(typeMetadata, isDirectiveMetadata);\n            if (metadata) {\n                var /** @type {?} */ propertyMetadata = this._reflector.propMetadata(type);\n                var /** @type {?} */ guards = this._reflector.guards(type);\n                return this._mergeWithPropertyMetadata(metadata, propertyMetadata, guards, type);\n            }\n        }\n        if (throwIfNotFound) {\n            throw new Error(\"No Directive annotation found on \" + stringify(type));\n        }\n        return null;\n    };\n    /**\n     * @param {?} dm\n     * @param {?} propertyMetadata\n     * @param {?} guards\n     * @param {?} directiveType\n     * @return {?}\n     */\n    DirectiveResolver.prototype._mergeWithPropertyMetadata = /**\n     * @param {?} dm\n     * @param {?} propertyMetadata\n     * @param {?} guards\n     * @param {?} directiveType\n     * @return {?}\n     */\n    function (dm, propertyMetadata, guards, directiveType) {\n        var /** @type {?} */ inputs = [];\n        var /** @type {?} */ outputs = [];\n        var /** @type {?} */ host = {};\n        var /** @type {?} */ queries = {};\n        Object.keys(propertyMetadata).forEach(function (propName) {\n            var /** @type {?} */ input = findLast(propertyMetadata[propName], function (a) { return createInput.isTypeOf(a); });\n            if (input) {\n                if (input.bindingPropertyName) {\n                    inputs.push(propName + \": \" + input.bindingPropertyName);\n                }\n                else {\n                    inputs.push(propName);\n                }\n            }\n            var /** @type {?} */ output = findLast(propertyMetadata[propName], function (a) { return createOutput.isTypeOf(a); });\n            if (output) {\n                if (output.bindingPropertyName) {\n                    outputs.push(propName + \": \" + output.bindingPropertyName);\n                }\n                else {\n                    outputs.push(propName);\n                }\n            }\n            var /** @type {?} */ hostBindings = propertyMetadata[propName].filter(function (a) { return createHostBinding.isTypeOf(a); });\n            hostBindings.forEach(function (hostBinding) {\n                if (hostBinding.hostPropertyName) {\n                    var /** @type {?} */ startWith = hostBinding.hostPropertyName[0];\n                    if (startWith === '(') {\n                        throw new Error(\"@HostBinding can not bind to events. Use @HostListener instead.\");\n                    }\n                    else if (startWith === '[') {\n                        throw new Error(\"@HostBinding parameter should be a property name, 'class.<name>', or 'attr.<name>'.\");\n                    }\n                    host[\"[\" + hostBinding.hostPropertyName + \"]\"] = propName;\n                }\n                else {\n                    host[\"[\" + propName + \"]\"] = propName;\n                }\n            });\n            var /** @type {?} */ hostListeners = propertyMetadata[propName].filter(function (a) { return createHostListener.isTypeOf(a); });\n            hostListeners.forEach(function (hostListener) {\n                var /** @type {?} */ args = hostListener.args || [];\n                host[\"(\" + hostListener.eventName + \")\"] = propName + \"(\" + args.join(',') + \")\";\n            });\n            var /** @type {?} */ query = findLast(propertyMetadata[propName], function (a) { return QUERY_METADATA_IDENTIFIERS.some(function (i) { return i.isTypeOf(a); }); });\n            if (query) {\n                queries[propName] = query;\n            }\n        });\n        return this._merge(dm, inputs, outputs, host, queries, guards, directiveType);\n    };\n    /**\n     * @param {?} def\n     * @return {?}\n     */\n    DirectiveResolver.prototype._extractPublicName = /**\n     * @param {?} def\n     * @return {?}\n     */\n    function (def) { return splitAtColon(def, [/** @type {?} */ ((null)), def])[1].trim(); };\n    /**\n     * @param {?} bindings\n     * @return {?}\n     */\n    DirectiveResolver.prototype._dedupeBindings = /**\n     * @param {?} bindings\n     * @return {?}\n     */\n    function (bindings) {\n        var /** @type {?} */ names = new Set();\n        var /** @type {?} */ publicNames = new Set();\n        var /** @type {?} */ reversedResult = [];\n        // go last to first to allow later entries to overwrite previous entries\n        for (var /** @type {?} */ i = bindings.length - 1; i >= 0; i--) {\n            var /** @type {?} */ binding = bindings[i];\n            var /** @type {?} */ name_1 = this._extractPublicName(binding);\n            publicNames.add(name_1);\n            if (!names.has(name_1)) {\n                names.add(name_1);\n                reversedResult.push(binding);\n            }\n        }\n        return reversedResult.reverse();\n    };\n    /**\n     * @param {?} directive\n     * @param {?} inputs\n     * @param {?} outputs\n     * @param {?} host\n     * @param {?} queries\n     * @param {?} guards\n     * @param {?} directiveType\n     * @return {?}\n     */\n    DirectiveResolver.prototype._merge = /**\n     * @param {?} directive\n     * @param {?} inputs\n     * @param {?} outputs\n     * @param {?} host\n     * @param {?} queries\n     * @param {?} guards\n     * @param {?} directiveType\n     * @return {?}\n     */\n    function (directive, inputs, outputs, host, queries, guards, directiveType) {\n        var /** @type {?} */ mergedInputs = this._dedupeBindings(directive.inputs ? directive.inputs.concat(inputs) : inputs);\n        var /** @type {?} */ mergedOutputs = this._dedupeBindings(directive.outputs ? directive.outputs.concat(outputs) : outputs);\n        var /** @type {?} */ mergedHost = directive.host ? __assign({}, directive.host, host) : host;\n        var /** @type {?} */ mergedQueries = directive.queries ? __assign({}, directive.queries, queries) : queries;\n        if (createComponent.isTypeOf(directive)) {\n            var /** @type {?} */ comp = /** @type {?} */ (directive);\n            return createComponent({\n                selector: comp.selector,\n                inputs: mergedInputs,\n                outputs: mergedOutputs,\n                host: mergedHost,\n                exportAs: comp.exportAs,\n                moduleId: comp.moduleId,\n                queries: mergedQueries,\n                changeDetection: comp.changeDetection,\n                providers: comp.providers,\n                viewProviders: comp.viewProviders,\n                entryComponents: comp.entryComponents,\n                template: comp.template,\n                templateUrl: comp.templateUrl,\n                styles: comp.styles,\n                styleUrls: comp.styleUrls,\n                encapsulation: comp.encapsulation,\n                animations: comp.animations,\n                interpolation: comp.interpolation,\n                preserveWhitespaces: directive.preserveWhitespaces,\n            });\n        }\n        else {\n            return createDirective({\n                selector: directive.selector,\n                inputs: mergedInputs,\n                outputs: mergedOutputs,\n                host: mergedHost,\n                exportAs: directive.exportAs,\n                queries: mergedQueries,\n                providers: directive.providers, guards: guards\n            });\n        }\n    };\n    return DirectiveResolver;\n}());\n/**\n * @param {?} type\n * @return {?}\n */\nfunction isDirectiveMetadata(type) {\n    return createDirective.isTypeOf(type) || createComponent.isTypeOf(type);\n}\n/**\n * @template T\n * @param {?} arr\n * @param {?} condition\n * @return {?}\n */\nfunction findLast(arr, condition) {\n    for (var /** @type {?} */ i = arr.length - 1; i >= 0; i--) {\n        if (condition(arr[i])) {\n            return arr[i];\n        }\n    }\n    return null;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar $EOF = 0;\nvar $TAB = 9;\nvar $LF = 10;\nvar $VTAB = 11;\nvar $FF = 12;\nvar $CR = 13;\nvar $SPACE = 32;\nvar $BANG = 33;\nvar $DQ = 34;\nvar $HASH = 35;\nvar $$ = 36;\nvar $PERCENT = 37;\nvar $AMPERSAND = 38;\nvar $SQ = 39;\nvar $LPAREN = 40;\nvar $RPAREN = 41;\nvar $STAR = 42;\nvar $PLUS = 43;\nvar $COMMA = 44;\nvar $MINUS = 45;\nvar $PERIOD = 46;\nvar $SLASH = 47;\nvar $COLON = 58;\nvar $SEMICOLON = 59;\nvar $LT = 60;\nvar $EQ = 61;\nvar $GT = 62;\nvar $QUESTION = 63;\nvar $0 = 48;\nvar $9 = 57;\nvar $A = 65;\nvar $E = 69;\nvar $F = 70;\nvar $X = 88;\nvar $Z = 90;\nvar $LBRACKET = 91;\nvar $BACKSLASH = 92;\nvar $RBRACKET = 93;\nvar $CARET = 94;\nvar $_ = 95;\nvar $a = 97;\nvar $e = 101;\nvar $f = 102;\nvar $n = 110;\nvar $r = 114;\nvar $t = 116;\nvar $u = 117;\nvar $v = 118;\nvar $x = 120;\nvar $z = 122;\nvar $LBRACE = 123;\nvar $BAR = 124;\nvar $RBRACE = 125;\nvar $NBSP = 160;\n\n\n\nvar $BT = 96;\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isWhitespace(code) {\n    return (code >= $TAB && code <= $SPACE) || (code == $NBSP);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isDigit(code) {\n    return $0 <= code && code <= $9;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isAsciiLetter(code) {\n    return code >= $a && code <= $z || code >= $A && code <= $Z;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isAsciiHexDigit(code) {\n    return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @enum {number} */\nvar TokenType = {\n    Character: 0,\n    Identifier: 1,\n    Keyword: 2,\n    String: 3,\n    Operator: 4,\n    Number: 5,\n    Error: 6,\n};\nTokenType[TokenType.Character] = \"Character\";\nTokenType[TokenType.Identifier] = \"Identifier\";\nTokenType[TokenType.Keyword] = \"Keyword\";\nTokenType[TokenType.String] = \"String\";\nTokenType[TokenType.Operator] = \"Operator\";\nTokenType[TokenType.Number] = \"Number\";\nTokenType[TokenType.Error] = \"Error\";\nvar KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];\nvar Lexer = /** @class */ (function () {\n    function Lexer() {\n    }\n    /**\n     * @param {?} text\n     * @return {?}\n     */\n    Lexer.prototype.tokenize = /**\n     * @param {?} text\n     * @return {?}\n     */\n    function (text) {\n        var /** @type {?} */ scanner = new _Scanner(text);\n        var /** @type {?} */ tokens = [];\n        var /** @type {?} */ token = scanner.scanToken();\n        while (token != null) {\n            tokens.push(token);\n            token = scanner.scanToken();\n        }\n        return tokens;\n    };\n    return Lexer;\n}());\nvar Token = /** @class */ (function () {\n    function Token(index, type, numValue, strValue) {\n        this.index = index;\n        this.type = type;\n        this.numValue = numValue;\n        this.strValue = strValue;\n    }\n    /**\n     * @param {?} code\n     * @return {?}\n     */\n    Token.prototype.isCharacter = /**\n     * @param {?} code\n     * @return {?}\n     */\n    function (code) {\n        return this.type == TokenType.Character && this.numValue == code;\n    };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isNumber = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Number; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isString = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.String; };\n    /**\n     * @param {?} operater\n     * @return {?}\n     */\n    Token.prototype.isOperator = /**\n     * @param {?} operater\n     * @return {?}\n     */\n    function (operater) {\n        return this.type == TokenType.Operator && this.strValue == operater;\n    };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isIdentifier = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Identifier; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isKeyword = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Keyword; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isKeywordLet = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Keyword && this.strValue == 'let'; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isKeywordAs = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Keyword && this.strValue == 'as'; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isKeywordNull = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Keyword && this.strValue == 'null'; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isKeywordUndefined = /**\n     * @return {?}\n     */\n    function () {\n        return this.type == TokenType.Keyword && this.strValue == 'undefined';\n    };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isKeywordTrue = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Keyword && this.strValue == 'true'; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isKeywordFalse = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Keyword && this.strValue == 'false'; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isKeywordThis = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Keyword && this.strValue == 'this'; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.isError = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Error; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.toNumber = /**\n     * @return {?}\n     */\n    function () { return this.type == TokenType.Number ? this.numValue : -1; };\n    /**\n     * @return {?}\n     */\n    Token.prototype.toString = /**\n     * @return {?}\n     */\n    function () {\n        switch (this.type) {\n            case TokenType.Character:\n            case TokenType.Identifier:\n            case TokenType.Keyword:\n            case TokenType.Operator:\n            case TokenType.String:\n            case TokenType.Error:\n                return this.strValue;\n            case TokenType.Number:\n                return this.numValue.toString();\n            default:\n                return null;\n        }\n    };\n    return Token;\n}());\n/**\n * @param {?} index\n * @param {?} code\n * @return {?}\n */\nfunction newCharacterToken(index, code) {\n    return new Token(index, TokenType.Character, code, String.fromCharCode(code));\n}\n/**\n * @param {?} index\n * @param {?} text\n * @return {?}\n */\nfunction newIdentifierToken(index, text) {\n    return new Token(index, TokenType.Identifier, 0, text);\n}\n/**\n * @param {?} index\n * @param {?} text\n * @return {?}\n */\nfunction newKeywordToken(index, text) {\n    return new Token(index, TokenType.Keyword, 0, text);\n}\n/**\n * @param {?} index\n * @param {?} text\n * @return {?}\n */\nfunction newOperatorToken(index, text) {\n    return new Token(index, TokenType.Operator, 0, text);\n}\n/**\n * @param {?} index\n * @param {?} text\n * @return {?}\n */\nfunction newStringToken(index, text) {\n    return new Token(index, TokenType.String, 0, text);\n}\n/**\n * @param {?} index\n * @param {?} n\n * @return {?}\n */\nfunction newNumberToken(index, n) {\n    return new Token(index, TokenType.Number, n, '');\n}\n/**\n * @param {?} index\n * @param {?} message\n * @return {?}\n */\nfunction newErrorToken(index, message) {\n    return new Token(index, TokenType.Error, 0, message);\n}\nvar EOF = new Token(-1, TokenType.Character, 0, '');\nvar _Scanner = /** @class */ (function () {\n    function _Scanner(input) {\n        this.input = input;\n        this.peek = 0;\n        this.index = -1;\n        this.length = input.length;\n        this.advance();\n    }\n    /**\n     * @return {?}\n     */\n    _Scanner.prototype.advance = /**\n     * @return {?}\n     */\n    function () {\n        this.peek = ++this.index >= this.length ? $EOF : this.input.charCodeAt(this.index);\n    };\n    /**\n     * @return {?}\n     */\n    _Scanner.prototype.scanToken = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ input = this.input, /** @type {?} */ length = this.length;\n        var /** @type {?} */ peek = this.peek, /** @type {?} */ index = this.index;\n        // Skip whitespace.\n        while (peek <= $SPACE) {\n            if (++index >= length) {\n                peek = $EOF;\n                break;\n            }\n            else {\n                peek = input.charCodeAt(index);\n            }\n        }\n        this.peek = peek;\n        this.index = index;\n        if (index >= length) {\n            return null;\n        }\n        // Handle identifiers and numbers.\n        if (isIdentifierStart(peek))\n            return this.scanIdentifier();\n        if (isDigit(peek))\n            return this.scanNumber(index);\n        var /** @type {?} */ start = index;\n        switch (peek) {\n            case $PERIOD:\n                this.advance();\n                return isDigit(this.peek) ? this.scanNumber(start) :\n                    newCharacterToken(start, $PERIOD);\n            case $LPAREN:\n            case $RPAREN:\n            case $LBRACE:\n            case $RBRACE:\n            case $LBRACKET:\n            case $RBRACKET:\n            case $COMMA:\n            case $COLON:\n            case $SEMICOLON:\n                return this.scanCharacter(start, peek);\n            case $SQ:\n            case $DQ:\n                return this.scanString();\n            case $HASH:\n            case $PLUS:\n            case $MINUS:\n            case $STAR:\n            case $SLASH:\n            case $PERCENT:\n            case $CARET:\n                return this.scanOperator(start, String.fromCharCode(peek));\n            case $QUESTION:\n                return this.scanComplexOperator(start, '?', $PERIOD, '.');\n            case $LT:\n            case $GT:\n                return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, '=');\n            case $BANG:\n            case $EQ:\n                return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, '=', $EQ, '=');\n            case $AMPERSAND:\n                return this.scanComplexOperator(start, '&', $AMPERSAND, '&');\n            case $BAR:\n                return this.scanComplexOperator(start, '|', $BAR, '|');\n            case $NBSP:\n                while (isWhitespace(this.peek))\n                    this.advance();\n                return this.scanToken();\n        }\n        this.advance();\n        return this.error(\"Unexpected character [\" + String.fromCharCode(peek) + \"]\", 0);\n    };\n    /**\n     * @param {?} start\n     * @param {?} code\n     * @return {?}\n     */\n    _Scanner.prototype.scanCharacter = /**\n     * @param {?} start\n     * @param {?} code\n     * @return {?}\n     */\n    function (start, code) {\n        this.advance();\n        return newCharacterToken(start, code);\n    };\n    /**\n     * @param {?} start\n     * @param {?} str\n     * @return {?}\n     */\n    _Scanner.prototype.scanOperator = /**\n     * @param {?} start\n     * @param {?} str\n     * @return {?}\n     */\n    function (start, str) {\n        this.advance();\n        return newOperatorToken(start, str);\n    };\n    /**\n     * Tokenize a 2/3 char long operator\n     *\n     * @param start start index in the expression\n     * @param one first symbol (always part of the operator)\n     * @param twoCode code point for the second symbol\n     * @param two second symbol (part of the operator when the second code point matches)\n     * @param threeCode code point for the third symbol\n     * @param three third symbol (part of the operator when provided and matches source expression)\n     */\n    /**\n     * Tokenize a 2/3 char long operator\n     *\n     * @param {?} start start index in the expression\n     * @param {?} one first symbol (always part of the operator)\n     * @param {?} twoCode code point for the second symbol\n     * @param {?} two second symbol (part of the operator when the second code point matches)\n     * @param {?=} threeCode code point for the third symbol\n     * @param {?=} three third symbol (part of the operator when provided and matches source expression)\n     * @return {?}\n     */\n    _Scanner.prototype.scanComplexOperator = /**\n     * Tokenize a 2/3 char long operator\n     *\n     * @param {?} start start index in the expression\n     * @param {?} one first symbol (always part of the operator)\n     * @param {?} twoCode code point for the second symbol\n     * @param {?} two second symbol (part of the operator when the second code point matches)\n     * @param {?=} threeCode code point for the third symbol\n     * @param {?=} three third symbol (part of the operator when provided and matches source expression)\n     * @return {?}\n     */\n    function (start, one, twoCode, two, threeCode, three) {\n        this.advance();\n        var /** @type {?} */ str = one;\n        if (this.peek == twoCode) {\n            this.advance();\n            str += two;\n        }\n        if (threeCode != null && this.peek == threeCode) {\n            this.advance();\n            str += three;\n        }\n        return newOperatorToken(start, str);\n    };\n    /**\n     * @return {?}\n     */\n    _Scanner.prototype.scanIdentifier = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ start = this.index;\n        this.advance();\n        while (isIdentifierPart(this.peek))\n            this.advance();\n        var /** @type {?} */ str = this.input.substring(start, this.index);\n        return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, str) :\n            newIdentifierToken(start, str);\n    };\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _Scanner.prototype.scanNumber = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) {\n        var /** @type {?} */ simple = (this.index === start);\n        this.advance(); // Skip initial digit.\n        while (true) {\n            if (isDigit(this.peek)) {\n                // Do nothing.\n            }\n            else if (this.peek == $PERIOD) {\n                simple = false;\n            }\n            else if (isExponentStart(this.peek)) {\n                this.advance();\n                if (isExponentSign(this.peek))\n                    this.advance();\n                if (!isDigit(this.peek))\n                    return this.error('Invalid exponent', -1);\n                simple = false;\n            }\n            else {\n                break;\n            }\n            this.advance();\n        }\n        var /** @type {?} */ str = this.input.substring(start, this.index);\n        var /** @type {?} */ value = simple ? parseIntAutoRadix(str) : parseFloat(str);\n        return newNumberToken(start, value);\n    };\n    /**\n     * @return {?}\n     */\n    _Scanner.prototype.scanString = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ start = this.index;\n        var /** @type {?} */ quote = this.peek;\n        this.advance(); // Skip initial quote.\n        var /** @type {?} */ buffer = '';\n        var /** @type {?} */ marker = this.index;\n        var /** @type {?} */ input = this.input;\n        while (this.peek != quote) {\n            if (this.peek == $BACKSLASH) {\n                buffer += input.substring(marker, this.index);\n                this.advance();\n                var /** @type {?} */ unescapedCode = void 0;\n                // Workaround for TS2.1-introduced type strictness\n                this.peek = this.peek;\n                if (this.peek == $u) {\n                    // 4 character hex code for unicode character.\n                    var /** @type {?} */ hex = input.substring(this.index + 1, this.index + 5);\n                    if (/^[0-9a-f]+$/i.test(hex)) {\n                        unescapedCode = parseInt(hex, 16);\n                    }\n                    else {\n                        return this.error(\"Invalid unicode escape [\\\\u\" + hex + \"]\", 0);\n                    }\n                    for (var /** @type {?} */ i = 0; i < 5; i++) {\n                        this.advance();\n                    }\n                }\n                else {\n                    unescapedCode = unescape(this.peek);\n                    this.advance();\n                }\n                buffer += String.fromCharCode(unescapedCode);\n                marker = this.index;\n            }\n            else if (this.peek == $EOF) {\n                return this.error('Unterminated quote', 0);\n            }\n            else {\n                this.advance();\n            }\n        }\n        var /** @type {?} */ last = input.substring(marker, this.index);\n        this.advance(); // Skip terminating quote.\n        return newStringToken(start, buffer + last);\n    };\n    /**\n     * @param {?} message\n     * @param {?} offset\n     * @return {?}\n     */\n    _Scanner.prototype.error = /**\n     * @param {?} message\n     * @param {?} offset\n     * @return {?}\n     */\n    function (message, offset) {\n        var /** @type {?} */ position = this.index + offset;\n        return newErrorToken(position, \"Lexer Error: \" + message + \" at column \" + position + \" in expression [\" + this.input + \"]\");\n    };\n    return _Scanner;\n}());\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isIdentifierStart(code) {\n    return ($a <= code && code <= $z) || ($A <= code && code <= $Z) ||\n        (code == $_) || (code == $$);\n}\n/**\n * @param {?} input\n * @return {?}\n */\nfunction isIdentifier(input) {\n    if (input.length == 0)\n        return false;\n    var /** @type {?} */ scanner = new _Scanner(input);\n    if (!isIdentifierStart(scanner.peek))\n        return false;\n    scanner.advance();\n    while (scanner.peek !== $EOF) {\n        if (!isIdentifierPart(scanner.peek))\n            return false;\n        scanner.advance();\n    }\n    return true;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isIdentifierPart(code) {\n    return isAsciiLetter(code) || isDigit(code) || (code == $_) ||\n        (code == $$);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isExponentStart(code) {\n    return code == $e || code == $E;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isExponentSign(code) {\n    return code == $MINUS || code == $PLUS;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isQuote(code) {\n    return code === $SQ || code === $DQ || code === $BT;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction unescape(code) {\n    switch (code) {\n        case $n:\n            return $LF;\n        case $f:\n            return $FF;\n        case $r:\n            return $CR;\n        case $t:\n            return $TAB;\n        case $v:\n            return $VTAB;\n        default:\n            return code;\n    }\n}\n/**\n * @param {?} text\n * @return {?}\n */\nfunction parseIntAutoRadix(text) {\n    var /** @type {?} */ result = parseInt(text);\n    if (isNaN(result)) {\n        throw new Error('Invalid integer literal when parsing ' + text);\n    }\n    return result;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ParserError = /** @class */ (function () {\n    function ParserError(message, input, errLocation, ctxLocation) {\n        this.input = input;\n        this.errLocation = errLocation;\n        this.ctxLocation = ctxLocation;\n        this.message = \"Parser Error: \" + message + \" \" + errLocation + \" [\" + input + \"] in \" + ctxLocation;\n    }\n    return ParserError;\n}());\nvar ParseSpan = /** @class */ (function () {\n    function ParseSpan(start, end) {\n        this.start = start;\n        this.end = end;\n    }\n    return ParseSpan;\n}());\nvar AST = /** @class */ (function () {\n    function AST(span) {\n        this.span = span;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    AST.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return null;\n    };\n    /**\n     * @return {?}\n     */\n    AST.prototype.toString = /**\n     * @return {?}\n     */\n    function () { return 'AST'; };\n    return AST;\n}());\n/**\n * Represents a quoted expression of the form:\n *\n * quote = prefix `:` uninterpretedExpression\n * prefix = identifier\n * uninterpretedExpression = arbitrary string\n *\n * A quoted expression is meant to be pre-processed by an AST transformer that\n * converts it into another AST that no longer contains quoted expressions.\n * It is meant to allow third-party developers to extend Angular template\n * expression language. The `uninterpretedExpression` part of the quote is\n * therefore not interpreted by the Angular's own expression parser.\n */\nvar Quote = /** @class */ (function (_super) {\n    __extends(Quote, _super);\n    function Quote(span, prefix, uninterpretedExpression, location) {\n        var _this = _super.call(this, span) || this;\n        _this.prefix = prefix;\n        _this.uninterpretedExpression = uninterpretedExpression;\n        _this.location = location;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Quote.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitQuote(this, context);\n    };\n    /**\n     * @return {?}\n     */\n    Quote.prototype.toString = /**\n     * @return {?}\n     */\n    function () { return 'Quote'; };\n    return Quote;\n}(AST));\nvar EmptyExpr = /** @class */ (function (_super) {\n    __extends(EmptyExpr, _super);\n    function EmptyExpr() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    EmptyExpr.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        // do nothing\n    };\n    return EmptyExpr;\n}(AST));\nvar ImplicitReceiver = /** @class */ (function (_super) {\n    __extends(ImplicitReceiver, _super);\n    function ImplicitReceiver() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    ImplicitReceiver.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitImplicitReceiver(this, context);\n    };\n    return ImplicitReceiver;\n}(AST));\n/**\n * Multiple expressions separated by a semicolon.\n */\nvar Chain = /** @class */ (function (_super) {\n    __extends(Chain, _super);\n    function Chain(span, expressions) {\n        var _this = _super.call(this, span) || this;\n        _this.expressions = expressions;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Chain.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitChain(this, context);\n    };\n    return Chain;\n}(AST));\nvar Conditional = /** @class */ (function (_super) {\n    __extends(Conditional, _super);\n    function Conditional(span, condition, trueExp, falseExp) {\n        var _this = _super.call(this, span) || this;\n        _this.condition = condition;\n        _this.trueExp = trueExp;\n        _this.falseExp = falseExp;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Conditional.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitConditional(this, context);\n    };\n    return Conditional;\n}(AST));\nvar PropertyRead = /** @class */ (function (_super) {\n    __extends(PropertyRead, _super);\n    function PropertyRead(span, receiver, name) {\n        var _this = _super.call(this, span) || this;\n        _this.receiver = receiver;\n        _this.name = name;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    PropertyRead.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitPropertyRead(this, context);\n    };\n    return PropertyRead;\n}(AST));\nvar PropertyWrite = /** @class */ (function (_super) {\n    __extends(PropertyWrite, _super);\n    function PropertyWrite(span, receiver, name, value) {\n        var _this = _super.call(this, span) || this;\n        _this.receiver = receiver;\n        _this.name = name;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    PropertyWrite.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitPropertyWrite(this, context);\n    };\n    return PropertyWrite;\n}(AST));\nvar SafePropertyRead = /** @class */ (function (_super) {\n    __extends(SafePropertyRead, _super);\n    function SafePropertyRead(span, receiver, name) {\n        var _this = _super.call(this, span) || this;\n        _this.receiver = receiver;\n        _this.name = name;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    SafePropertyRead.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitSafePropertyRead(this, context);\n    };\n    return SafePropertyRead;\n}(AST));\nvar KeyedRead = /** @class */ (function (_super) {\n    __extends(KeyedRead, _super);\n    function KeyedRead(span, obj, key) {\n        var _this = _super.call(this, span) || this;\n        _this.obj = obj;\n        _this.key = key;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    KeyedRead.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitKeyedRead(this, context);\n    };\n    return KeyedRead;\n}(AST));\nvar KeyedWrite = /** @class */ (function (_super) {\n    __extends(KeyedWrite, _super);\n    function KeyedWrite(span, obj, key, value) {\n        var _this = _super.call(this, span) || this;\n        _this.obj = obj;\n        _this.key = key;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    KeyedWrite.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitKeyedWrite(this, context);\n    };\n    return KeyedWrite;\n}(AST));\nvar BindingPipe = /** @class */ (function (_super) {\n    __extends(BindingPipe, _super);\n    function BindingPipe(span, exp, name, args) {\n        var _this = _super.call(this, span) || this;\n        _this.exp = exp;\n        _this.name = name;\n        _this.args = args;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    BindingPipe.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitPipe(this, context);\n    };\n    return BindingPipe;\n}(AST));\nvar LiteralPrimitive = /** @class */ (function (_super) {\n    __extends(LiteralPrimitive, _super);\n    function LiteralPrimitive(span, value) {\n        var _this = _super.call(this, span) || this;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    LiteralPrimitive.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitLiteralPrimitive(this, context);\n    };\n    return LiteralPrimitive;\n}(AST));\nvar LiteralArray = /** @class */ (function (_super) {\n    __extends(LiteralArray, _super);\n    function LiteralArray(span, expressions) {\n        var _this = _super.call(this, span) || this;\n        _this.expressions = expressions;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    LiteralArray.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitLiteralArray(this, context);\n    };\n    return LiteralArray;\n}(AST));\nvar LiteralMap = /** @class */ (function (_super) {\n    __extends(LiteralMap, _super);\n    function LiteralMap(span, keys, values) {\n        var _this = _super.call(this, span) || this;\n        _this.keys = keys;\n        _this.values = values;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    LiteralMap.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitLiteralMap(this, context);\n    };\n    return LiteralMap;\n}(AST));\nvar Interpolation = /** @class */ (function (_super) {\n    __extends(Interpolation, _super);\n    function Interpolation(span, strings, expressions) {\n        var _this = _super.call(this, span) || this;\n        _this.strings = strings;\n        _this.expressions = expressions;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Interpolation.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitInterpolation(this, context);\n    };\n    return Interpolation;\n}(AST));\nvar Binary = /** @class */ (function (_super) {\n    __extends(Binary, _super);\n    function Binary(span, operation, left, right) {\n        var _this = _super.call(this, span) || this;\n        _this.operation = operation;\n        _this.left = left;\n        _this.right = right;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Binary.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitBinary(this, context);\n    };\n    return Binary;\n}(AST));\nvar PrefixNot = /** @class */ (function (_super) {\n    __extends(PrefixNot, _super);\n    function PrefixNot(span, expression) {\n        var _this = _super.call(this, span) || this;\n        _this.expression = expression;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    PrefixNot.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitPrefixNot(this, context);\n    };\n    return PrefixNot;\n}(AST));\nvar NonNullAssert = /** @class */ (function (_super) {\n    __extends(NonNullAssert, _super);\n    function NonNullAssert(span, expression) {\n        var _this = _super.call(this, span) || this;\n        _this.expression = expression;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    NonNullAssert.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitNonNullAssert(this, context);\n    };\n    return NonNullAssert;\n}(AST));\nvar MethodCall = /** @class */ (function (_super) {\n    __extends(MethodCall, _super);\n    function MethodCall(span, receiver, name, args) {\n        var _this = _super.call(this, span) || this;\n        _this.receiver = receiver;\n        _this.name = name;\n        _this.args = args;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    MethodCall.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitMethodCall(this, context);\n    };\n    return MethodCall;\n}(AST));\nvar SafeMethodCall = /** @class */ (function (_super) {\n    __extends(SafeMethodCall, _super);\n    function SafeMethodCall(span, receiver, name, args) {\n        var _this = _super.call(this, span) || this;\n        _this.receiver = receiver;\n        _this.name = name;\n        _this.args = args;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    SafeMethodCall.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitSafeMethodCall(this, context);\n    };\n    return SafeMethodCall;\n}(AST));\nvar FunctionCall = /** @class */ (function (_super) {\n    __extends(FunctionCall, _super);\n    function FunctionCall(span, target, args) {\n        var _this = _super.call(this, span) || this;\n        _this.target = target;\n        _this.args = args;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    FunctionCall.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return visitor.visitFunctionCall(this, context);\n    };\n    return FunctionCall;\n}(AST));\nvar ASTWithSource = /** @class */ (function (_super) {\n    __extends(ASTWithSource, _super);\n    function ASTWithSource(ast, source, location, errors) {\n        var _this = _super.call(this, new ParseSpan(0, source == null ? 0 : source.length)) || this;\n        _this.ast = ast;\n        _this.source = source;\n        _this.location = location;\n        _this.errors = errors;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    ASTWithSource.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        if (context === void 0) { context = null; }\n        return this.ast.visit(visitor, context);\n    };\n    /**\n     * @return {?}\n     */\n    ASTWithSource.prototype.toString = /**\n     * @return {?}\n     */\n    function () { return this.source + \" in \" + this.location; };\n    return ASTWithSource;\n}(AST));\nvar TemplateBinding = /** @class */ (function () {\n    function TemplateBinding(span, key, keyIsVar, name, expression) {\n        this.span = span;\n        this.key = key;\n        this.keyIsVar = keyIsVar;\n        this.name = name;\n        this.expression = expression;\n    }\n    return TemplateBinding;\n}());\n/**\n * @record\n */\n\nvar NullAstVisitor = /** @class */ (function () {\n    function NullAstVisitor() {\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitBinary = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitChain = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitConditional = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitFunctionCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitImplicitReceiver = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitInterpolation = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitKeyedRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitKeyedWrite = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitLiteralArray = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitLiteralMap = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitLiteralPrimitive = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitMethodCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitPipe = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitPrefixNot = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitNonNullAssert = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitPropertyRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitPropertyWrite = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitQuote = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitSafeMethodCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    NullAstVisitor.prototype.visitSafePropertyRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    return NullAstVisitor;\n}());\nvar RecursiveAstVisitor = /** @class */ (function () {\n    function RecursiveAstVisitor() {\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitBinary = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.left.visit(this);\n        ast.right.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitChain = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return this.visitAll(ast.expressions, context); };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitConditional = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.condition.visit(this);\n        ast.trueExp.visit(this);\n        ast.falseExp.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitPipe = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.exp.visit(this);\n        this.visitAll(ast.args, context);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitFunctionCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        /** @type {?} */ ((ast.target)).visit(this);\n        this.visitAll(ast.args, context);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitImplicitReceiver = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return null; };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitInterpolation = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.visitAll(ast.expressions, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitKeyedRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.obj.visit(this);\n        ast.key.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitKeyedWrite = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.obj.visit(this);\n        ast.key.visit(this);\n        ast.value.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitLiteralArray = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.visitAll(ast.expressions, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitLiteralMap = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return this.visitAll(ast.values, context); };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitLiteralPrimitive = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return null; };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitMethodCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visit(this);\n        return this.visitAll(ast.args, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitPrefixNot = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.expression.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitNonNullAssert = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.expression.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitPropertyRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitPropertyWrite = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visit(this);\n        ast.value.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitSafePropertyRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visit(this);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitSafeMethodCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visit(this);\n        return this.visitAll(ast.args, context);\n    };\n    /**\n     * @param {?} asts\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitAll = /**\n     * @param {?} asts\n     * @param {?} context\n     * @return {?}\n     */\n    function (asts, context) {\n        var _this = this;\n        asts.forEach(function (ast) { return ast.visit(_this, context); });\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitQuote = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return null; };\n    return RecursiveAstVisitor;\n}());\nvar AstTransformer = /** @class */ (function () {\n    function AstTransformer() {\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitImplicitReceiver = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return ast; };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitInterpolation = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new Interpolation(ast.span, ast.strings, this.visitAll(ast.expressions));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitLiteralPrimitive = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new LiteralPrimitive(ast.span, ast.value);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitPropertyRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new PropertyRead(ast.span, ast.receiver.visit(this), ast.name);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitPropertyWrite = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new PropertyWrite(ast.span, ast.receiver.visit(this), ast.name, ast.value.visit(this));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitSafePropertyRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new SafePropertyRead(ast.span, ast.receiver.visit(this), ast.name);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitMethodCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new MethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitSafeMethodCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new SafeMethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitFunctionCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new FunctionCall(ast.span, /** @type {?} */ ((ast.target)).visit(this), this.visitAll(ast.args));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitLiteralArray = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new LiteralArray(ast.span, this.visitAll(ast.expressions));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitLiteralMap = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new LiteralMap(ast.span, ast.keys, this.visitAll(ast.values));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitBinary = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new Binary(ast.span, ast.operation, ast.left.visit(this), ast.right.visit(this));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitPrefixNot = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new PrefixNot(ast.span, ast.expression.visit(this));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitNonNullAssert = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new NonNullAssert(ast.span, ast.expression.visit(this));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitConditional = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new Conditional(ast.span, ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitPipe = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new BindingPipe(ast.span, ast.exp.visit(this), ast.name, this.visitAll(ast.args));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitKeyedRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new KeyedRead(ast.span, ast.obj.visit(this), ast.key.visit(this));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitKeyedWrite = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new KeyedWrite(ast.span, ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this));\n    };\n    /**\n     * @param {?} asts\n     * @return {?}\n     */\n    AstTransformer.prototype.visitAll = /**\n     * @param {?} asts\n     * @return {?}\n     */\n    function (asts) {\n        var /** @type {?} */ res = new Array(asts.length);\n        for (var /** @type {?} */ i = 0; i < asts.length; ++i) {\n            res[i] = asts[i].visit(this);\n        }\n        return res;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitChain = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new Chain(ast.span, this.visitAll(ast.expressions));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitQuote = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return new Quote(ast.span, ast.prefix, ast.uninterpretedExpression, ast.location);\n    };\n    return AstTransformer;\n}());\n/**\n * @param {?} ast\n * @param {?} visitor\n * @param {?=} context\n * @return {?}\n */\nfunction visitAstChildren(ast, visitor, context) {\n    /**\n     * @param {?} ast\n     * @return {?}\n     */\n    function visit(ast) {\n        visitor.visit && visitor.visit(ast, context) || ast.visit(visitor, context);\n    }\n    /**\n     * @template T\n     * @param {?} asts\n     * @return {?}\n     */\n    function visitAll(asts) { asts.forEach(visit); }\n    ast.visit({\n        visitBinary: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            visit(ast.left);\n            visit(ast.right);\n        },\n        visitChain: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { visitAll(ast.expressions); },\n        visitConditional: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            visit(ast.condition);\n            visit(ast.trueExp);\n            visit(ast.falseExp);\n        },\n        visitFunctionCall: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            if (ast.target) {\n                visit(ast.target);\n            }\n            visitAll(ast.args);\n        },\n        visitImplicitReceiver: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { },\n        visitInterpolation: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { visitAll(ast.expressions); },\n        visitKeyedRead: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            visit(ast.obj);\n            visit(ast.key);\n        },\n        visitKeyedWrite: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            visit(ast.obj);\n            visit(ast.key);\n            visit(ast.obj);\n        },\n        visitLiteralArray: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { visitAll(ast.expressions); },\n        visitLiteralMap: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { },\n        visitLiteralPrimitive: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { },\n        visitMethodCall: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            visit(ast.receiver);\n            visitAll(ast.args);\n        },\n        visitPipe: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            visit(ast.exp);\n            visitAll(ast.args);\n        },\n        visitPrefixNot: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { visit(ast.expression); },\n        visitNonNullAssert: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { visit(ast.expression); },\n        visitPropertyRead: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { visit(ast.receiver); },\n        visitPropertyWrite: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            visit(ast.receiver);\n            visit(ast.value);\n        },\n        visitQuote: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { },\n        visitSafeMethodCall: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) {\n            visit(ast.receiver);\n            visitAll(ast.args);\n        },\n        visitSafePropertyRead: /**\n         * @param {?} ast\n         * @return {?}\n         */\n        function (ast) { visit(ast.receiver); },\n    });\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar SplitInterpolation = /** @class */ (function () {\n    function SplitInterpolation(strings, expressions, offsets) {\n        this.strings = strings;\n        this.expressions = expressions;\n        this.offsets = offsets;\n    }\n    return SplitInterpolation;\n}());\nvar TemplateBindingParseResult = /** @class */ (function () {\n    function TemplateBindingParseResult(templateBindings, warnings, errors) {\n        this.templateBindings = templateBindings;\n        this.warnings = warnings;\n        this.errors = errors;\n    }\n    return TemplateBindingParseResult;\n}());\n/**\n * @param {?} config\n * @return {?}\n */\nfunction _createInterpolateRegExp(config) {\n    var /** @type {?} */ pattern = escapeRegExp(config.start) + '([\\\\s\\\\S]*?)' + escapeRegExp(config.end);\n    return new RegExp(pattern, 'g');\n}\nvar Parser = /** @class */ (function () {\n    function Parser(_lexer) {\n        this._lexer = _lexer;\n        this.errors = [];\n    }\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype.parseAction = /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    function (input, location, interpolationConfig) {\n        if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        this._checkNoInterpolation(input, location, interpolationConfig);\n        var /** @type {?} */ sourceToLex = this._stripComments(input);\n        var /** @type {?} */ tokens = this._lexer.tokenize(this._stripComments(input));\n        var /** @type {?} */ ast = new _ParseAST(input, location, tokens, sourceToLex.length, true, this.errors, input.length - sourceToLex.length)\n            .parseChain();\n        return new ASTWithSource(ast, input, location, this.errors);\n    };\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype.parseBinding = /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    function (input, location, interpolationConfig) {\n        if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        var /** @type {?} */ ast = this._parseBindingAst(input, location, interpolationConfig);\n        return new ASTWithSource(ast, input, location, this.errors);\n    };\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype.parseSimpleBinding = /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    function (input, location, interpolationConfig) {\n        if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        var /** @type {?} */ ast = this._parseBindingAst(input, location, interpolationConfig);\n        var /** @type {?} */ errors = SimpleExpressionChecker.check(ast);\n        if (errors.length > 0) {\n            this._reportError(\"Host binding expression cannot contain \" + errors.join(' '), input, location);\n        }\n        return new ASTWithSource(ast, input, location, this.errors);\n    };\n    /**\n     * @param {?} message\n     * @param {?} input\n     * @param {?} errLocation\n     * @param {?=} ctxLocation\n     * @return {?}\n     */\n    Parser.prototype._reportError = /**\n     * @param {?} message\n     * @param {?} input\n     * @param {?} errLocation\n     * @param {?=} ctxLocation\n     * @return {?}\n     */\n    function (message, input, errLocation, ctxLocation) {\n        this.errors.push(new ParserError(message, input, errLocation, ctxLocation));\n    };\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype._parseBindingAst = /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    function (input, location, interpolationConfig) {\n        // Quotes expressions use 3rd-party expression language. We don't want to use\n        // our lexer or parser for that, so we check for that ahead of time.\n        var /** @type {?} */ quote = this._parseQuote(input, location);\n        if (quote != null) {\n            return quote;\n        }\n        this._checkNoInterpolation(input, location, interpolationConfig);\n        var /** @type {?} */ sourceToLex = this._stripComments(input);\n        var /** @type {?} */ tokens = this._lexer.tokenize(sourceToLex);\n        return new _ParseAST(input, location, tokens, sourceToLex.length, false, this.errors, input.length - sourceToLex.length)\n            .parseChain();\n    };\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @return {?}\n     */\n    Parser.prototype._parseQuote = /**\n     * @param {?} input\n     * @param {?} location\n     * @return {?}\n     */\n    function (input, location) {\n        if (input == null)\n            return null;\n        var /** @type {?} */ prefixSeparatorIndex = input.indexOf(':');\n        if (prefixSeparatorIndex == -1)\n            return null;\n        var /** @type {?} */ prefix = input.substring(0, prefixSeparatorIndex).trim();\n        if (!isIdentifier(prefix))\n            return null;\n        var /** @type {?} */ uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);\n        return new Quote(new ParseSpan(0, input.length), prefix, uninterpretedExpression, location);\n    };\n    /**\n     * @param {?} prefixToken\n     * @param {?} input\n     * @param {?} location\n     * @return {?}\n     */\n    Parser.prototype.parseTemplateBindings = /**\n     * @param {?} prefixToken\n     * @param {?} input\n     * @param {?} location\n     * @return {?}\n     */\n    function (prefixToken, input, location) {\n        var /** @type {?} */ tokens = this._lexer.tokenize(input);\n        if (prefixToken) {\n            // Prefix the tokens with the tokens from prefixToken but have them take no space (0 index).\n            var /** @type {?} */ prefixTokens = this._lexer.tokenize(prefixToken).map(function (t) {\n                t.index = 0;\n                return t;\n            });\n            tokens.unshift.apply(tokens, prefixTokens);\n        }\n        return new _ParseAST(input, location, tokens, input.length, false, this.errors, 0)\n            .parseTemplateBindings();\n    };\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype.parseInterpolation = /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    function (input, location, interpolationConfig) {\n        if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        var /** @type {?} */ split = this.splitInterpolation(input, location, interpolationConfig);\n        if (split == null)\n            return null;\n        var /** @type {?} */ expressions = [];\n        for (var /** @type {?} */ i = 0; i < split.expressions.length; ++i) {\n            var /** @type {?} */ expressionText = split.expressions[i];\n            var /** @type {?} */ sourceToLex = this._stripComments(expressionText);\n            var /** @type {?} */ tokens = this._lexer.tokenize(sourceToLex);\n            var /** @type {?} */ ast = new _ParseAST(input, location, tokens, sourceToLex.length, false, this.errors, split.offsets[i] + (expressionText.length - sourceToLex.length))\n                .parseChain();\n            expressions.push(ast);\n        }\n        return new ASTWithSource(new Interpolation(new ParseSpan(0, input == null ? 0 : input.length), split.strings, expressions), input, location, this.errors);\n    };\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype.splitInterpolation = /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    function (input, location, interpolationConfig) {\n        if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        var /** @type {?} */ regexp = _createInterpolateRegExp(interpolationConfig);\n        var /** @type {?} */ parts = input.split(regexp);\n        if (parts.length <= 1) {\n            return null;\n        }\n        var /** @type {?} */ strings = [];\n        var /** @type {?} */ expressions = [];\n        var /** @type {?} */ offsets = [];\n        var /** @type {?} */ offset = 0;\n        for (var /** @type {?} */ i = 0; i < parts.length; i++) {\n            var /** @type {?} */ part = parts[i];\n            if (i % 2 === 0) {\n                // fixed string\n                strings.push(part);\n                offset += part.length;\n            }\n            else if (part.trim().length > 0) {\n                offset += interpolationConfig.start.length;\n                expressions.push(part);\n                offsets.push(offset);\n                offset += part.length + interpolationConfig.end.length;\n            }\n            else {\n                this._reportError('Blank expressions are not allowed in interpolated strings', input, \"at column \" + this._findInterpolationErrorColumn(parts, i, interpolationConfig) + \" in\", location);\n                expressions.push('$implict');\n                offsets.push(offset);\n            }\n        }\n        return new SplitInterpolation(strings, expressions, offsets);\n    };\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @return {?}\n     */\n    Parser.prototype.wrapLiteralPrimitive = /**\n     * @param {?} input\n     * @param {?} location\n     * @return {?}\n     */\n    function (input, location) {\n        return new ASTWithSource(new LiteralPrimitive(new ParseSpan(0, input == null ? 0 : input.length), input), input, location, this.errors);\n    };\n    /**\n     * @param {?} input\n     * @return {?}\n     */\n    Parser.prototype._stripComments = /**\n     * @param {?} input\n     * @return {?}\n     */\n    function (input) {\n        var /** @type {?} */ i = this._commentStart(input);\n        return i != null ? input.substring(0, i).trim() : input;\n    };\n    /**\n     * @param {?} input\n     * @return {?}\n     */\n    Parser.prototype._commentStart = /**\n     * @param {?} input\n     * @return {?}\n     */\n    function (input) {\n        var /** @type {?} */ outerQuote = null;\n        for (var /** @type {?} */ i = 0; i < input.length - 1; i++) {\n            var /** @type {?} */ char = input.charCodeAt(i);\n            var /** @type {?} */ nextChar = input.charCodeAt(i + 1);\n            if (char === $SLASH && nextChar == $SLASH && outerQuote == null)\n                return i;\n            if (outerQuote === char) {\n                outerQuote = null;\n            }\n            else if (outerQuote == null && isQuote(char)) {\n                outerQuote = char;\n            }\n        }\n        return null;\n    };\n    /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype._checkNoInterpolation = /**\n     * @param {?} input\n     * @param {?} location\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    function (input, location, interpolationConfig) {\n        var /** @type {?} */ regexp = _createInterpolateRegExp(interpolationConfig);\n        var /** @type {?} */ parts = input.split(regexp);\n        if (parts.length > 1) {\n            this._reportError(\"Got interpolation (\" + interpolationConfig.start + interpolationConfig.end + \") where expression was expected\", input, \"at column \" + this._findInterpolationErrorColumn(parts, 1, interpolationConfig) + \" in\", location);\n        }\n    };\n    /**\n     * @param {?} parts\n     * @param {?} partInErrIdx\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype._findInterpolationErrorColumn = /**\n     * @param {?} parts\n     * @param {?} partInErrIdx\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    function (parts, partInErrIdx, interpolationConfig) {\n        var /** @type {?} */ errLocation = '';\n        for (var /** @type {?} */ j = 0; j < partInErrIdx; j++) {\n            errLocation += j % 2 === 0 ?\n                parts[j] :\n                \"\" + interpolationConfig.start + parts[j] + interpolationConfig.end;\n        }\n        return errLocation.length;\n    };\n    return Parser;\n}());\nvar _ParseAST = /** @class */ (function () {\n    function _ParseAST(input, location, tokens, inputLength, parseAction, errors, offset) {\n        this.input = input;\n        this.location = location;\n        this.tokens = tokens;\n        this.inputLength = inputLength;\n        this.parseAction = parseAction;\n        this.errors = errors;\n        this.offset = offset;\n        this.rparensExpected = 0;\n        this.rbracketsExpected = 0;\n        this.rbracesExpected = 0;\n        this.index = 0;\n    }\n    /**\n     * @param {?} offset\n     * @return {?}\n     */\n    _ParseAST.prototype.peek = /**\n     * @param {?} offset\n     * @return {?}\n     */\n    function (offset) {\n        var /** @type {?} */ i = this.index + offset;\n        return i < this.tokens.length ? this.tokens[i] : EOF;\n    };\n    Object.defineProperty(_ParseAST.prototype, \"next\", {\n        get: /**\n         * @return {?}\n         */\n        function () { return this.peek(0); },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(_ParseAST.prototype, \"inputIndex\", {\n        get: /**\n         * @return {?}\n         */\n        function () {\n            return (this.index < this.tokens.length) ? this.next.index + this.offset :\n                this.inputLength + this.offset;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _ParseAST.prototype.span = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) { return new ParseSpan(start, this.inputIndex); };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.advance = /**\n     * @return {?}\n     */\n    function () { this.index++; };\n    /**\n     * @param {?} code\n     * @return {?}\n     */\n    _ParseAST.prototype.optionalCharacter = /**\n     * @param {?} code\n     * @return {?}\n     */\n    function (code) {\n        if (this.next.isCharacter(code)) {\n            this.advance();\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.peekKeywordLet = /**\n     * @return {?}\n     */\n    function () { return this.next.isKeywordLet(); };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.peekKeywordAs = /**\n     * @return {?}\n     */\n    function () { return this.next.isKeywordAs(); };\n    /**\n     * @param {?} code\n     * @return {?}\n     */\n    _ParseAST.prototype.expectCharacter = /**\n     * @param {?} code\n     * @return {?}\n     */\n    function (code) {\n        if (this.optionalCharacter(code))\n            return;\n        this.error(\"Missing expected \" + String.fromCharCode(code));\n    };\n    /**\n     * @param {?} op\n     * @return {?}\n     */\n    _ParseAST.prototype.optionalOperator = /**\n     * @param {?} op\n     * @return {?}\n     */\n    function (op) {\n        if (this.next.isOperator(op)) {\n            this.advance();\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    /**\n     * @param {?} operator\n     * @return {?}\n     */\n    _ParseAST.prototype.expectOperator = /**\n     * @param {?} operator\n     * @return {?}\n     */\n    function (operator) {\n        if (this.optionalOperator(operator))\n            return;\n        this.error(\"Missing expected operator \" + operator);\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.expectIdentifierOrKeyword = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ n = this.next;\n        if (!n.isIdentifier() && !n.isKeyword()) {\n            this.error(\"Unexpected token \" + n + \", expected identifier or keyword\");\n            return '';\n        }\n        this.advance();\n        return /** @type {?} */ (n.toString());\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.expectIdentifierOrKeywordOrString = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ n = this.next;\n        if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {\n            this.error(\"Unexpected token \" + n + \", expected identifier, keyword, or string\");\n            return '';\n        }\n        this.advance();\n        return /** @type {?} */ (n.toString());\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseChain = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ exprs = [];\n        var /** @type {?} */ start = this.inputIndex;\n        while (this.index < this.tokens.length) {\n            var /** @type {?} */ expr = this.parsePipe();\n            exprs.push(expr);\n            if (this.optionalCharacter($SEMICOLON)) {\n                if (!this.parseAction) {\n                    this.error('Binding expression cannot contain chained expression');\n                }\n                while (this.optionalCharacter($SEMICOLON)) {\n                } // read all semicolons\n            }\n            else if (this.index < this.tokens.length) {\n                this.error(\"Unexpected token '\" + this.next + \"'\");\n            }\n        }\n        if (exprs.length == 0)\n            return new EmptyExpr(this.span(start));\n        if (exprs.length == 1)\n            return exprs[0];\n        return new Chain(this.span(start), exprs);\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parsePipe = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ result = this.parseExpression();\n        if (this.optionalOperator('|')) {\n            if (this.parseAction) {\n                this.error('Cannot have a pipe in an action expression');\n            }\n            do {\n                var /** @type {?} */ name_1 = this.expectIdentifierOrKeyword();\n                var /** @type {?} */ args = [];\n                while (this.optionalCharacter($COLON)) {\n                    args.push(this.parseExpression());\n                }\n                result = new BindingPipe(this.span(result.span.start), result, name_1, args);\n            } while (this.optionalOperator('|'));\n        }\n        return result;\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseExpression = /**\n     * @return {?}\n     */\n    function () { return this.parseConditional(); };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseConditional = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ start = this.inputIndex;\n        var /** @type {?} */ result = this.parseLogicalOr();\n        if (this.optionalOperator('?')) {\n            var /** @type {?} */ yes = this.parsePipe();\n            var /** @type {?} */ no = void 0;\n            if (!this.optionalCharacter($COLON)) {\n                var /** @type {?} */ end = this.inputIndex;\n                var /** @type {?} */ expression = this.input.substring(start, end);\n                this.error(\"Conditional expression \" + expression + \" requires all 3 expressions\");\n                no = new EmptyExpr(this.span(start));\n            }\n            else {\n                no = this.parsePipe();\n            }\n            return new Conditional(this.span(start), result, yes, no);\n        }\n        else {\n            return result;\n        }\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseLogicalOr = /**\n     * @return {?}\n     */\n    function () {\n        // '||'\n        var /** @type {?} */ result = this.parseLogicalAnd();\n        while (this.optionalOperator('||')) {\n            var /** @type {?} */ right = this.parseLogicalAnd();\n            result = new Binary(this.span(result.span.start), '||', result, right);\n        }\n        return result;\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseLogicalAnd = /**\n     * @return {?}\n     */\n    function () {\n        // '&&'\n        var /** @type {?} */ result = this.parseEquality();\n        while (this.optionalOperator('&&')) {\n            var /** @type {?} */ right = this.parseEquality();\n            result = new Binary(this.span(result.span.start), '&&', result, right);\n        }\n        return result;\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseEquality = /**\n     * @return {?}\n     */\n    function () {\n        // '==','!=','===','!=='\n        var /** @type {?} */ result = this.parseRelational();\n        while (this.next.type == TokenType.Operator) {\n            var /** @type {?} */ operator = this.next.strValue;\n            switch (operator) {\n                case '==':\n                case '===':\n                case '!=':\n                case '!==':\n                    this.advance();\n                    var /** @type {?} */ right = this.parseRelational();\n                    result = new Binary(this.span(result.span.start), operator, result, right);\n                    continue;\n            }\n            break;\n        }\n        return result;\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseRelational = /**\n     * @return {?}\n     */\n    function () {\n        // '<', '>', '<=', '>='\n        var /** @type {?} */ result = this.parseAdditive();\n        while (this.next.type == TokenType.Operator) {\n            var /** @type {?} */ operator = this.next.strValue;\n            switch (operator) {\n                case '<':\n                case '>':\n                case '<=':\n                case '>=':\n                    this.advance();\n                    var /** @type {?} */ right = this.parseAdditive();\n                    result = new Binary(this.span(result.span.start), operator, result, right);\n                    continue;\n            }\n            break;\n        }\n        return result;\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseAdditive = /**\n     * @return {?}\n     */\n    function () {\n        // '+', '-'\n        var /** @type {?} */ result = this.parseMultiplicative();\n        while (this.next.type == TokenType.Operator) {\n            var /** @type {?} */ operator = this.next.strValue;\n            switch (operator) {\n                case '+':\n                case '-':\n                    this.advance();\n                    var /** @type {?} */ right = this.parseMultiplicative();\n                    result = new Binary(this.span(result.span.start), operator, result, right);\n                    continue;\n            }\n            break;\n        }\n        return result;\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseMultiplicative = /**\n     * @return {?}\n     */\n    function () {\n        // '*', '%', '/'\n        var /** @type {?} */ result = this.parsePrefix();\n        while (this.next.type == TokenType.Operator) {\n            var /** @type {?} */ operator = this.next.strValue;\n            switch (operator) {\n                case '*':\n                case '%':\n                case '/':\n                    this.advance();\n                    var /** @type {?} */ right = this.parsePrefix();\n                    result = new Binary(this.span(result.span.start), operator, result, right);\n                    continue;\n            }\n            break;\n        }\n        return result;\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parsePrefix = /**\n     * @return {?}\n     */\n    function () {\n        if (this.next.type == TokenType.Operator) {\n            var /** @type {?} */ start = this.inputIndex;\n            var /** @type {?} */ operator = this.next.strValue;\n            var /** @type {?} */ result = void 0;\n            switch (operator) {\n                case '+':\n                    this.advance();\n                    result = this.parsePrefix();\n                    return new Binary(this.span(start), '-', result, new LiteralPrimitive(new ParseSpan(start, start), 0));\n                case '-':\n                    this.advance();\n                    result = this.parsePrefix();\n                    return new Binary(this.span(start), operator, new LiteralPrimitive(new ParseSpan(start, start), 0), result);\n                case '!':\n                    this.advance();\n                    result = this.parsePrefix();\n                    return new PrefixNot(this.span(start), result);\n            }\n        }\n        return this.parseCallChain();\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseCallChain = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ result = this.parsePrimary();\n        while (true) {\n            if (this.optionalCharacter($PERIOD)) {\n                result = this.parseAccessMemberOrMethodCall(result, false);\n            }\n            else if (this.optionalOperator('?.')) {\n                result = this.parseAccessMemberOrMethodCall(result, true);\n            }\n            else if (this.optionalCharacter($LBRACKET)) {\n                this.rbracketsExpected++;\n                var /** @type {?} */ key = this.parsePipe();\n                this.rbracketsExpected--;\n                this.expectCharacter($RBRACKET);\n                if (this.optionalOperator('=')) {\n                    var /** @type {?} */ value = this.parseConditional();\n                    result = new KeyedWrite(this.span(result.span.start), result, key, value);\n                }\n                else {\n                    result = new KeyedRead(this.span(result.span.start), result, key);\n                }\n            }\n            else if (this.optionalCharacter($LPAREN)) {\n                this.rparensExpected++;\n                var /** @type {?} */ args = this.parseCallArguments();\n                this.rparensExpected--;\n                this.expectCharacter($RPAREN);\n                result = new FunctionCall(this.span(result.span.start), result, args);\n            }\n            else if (this.optionalOperator('!')) {\n                result = new NonNullAssert(this.span(result.span.start), result);\n            }\n            else {\n                return result;\n            }\n        }\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parsePrimary = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ start = this.inputIndex;\n        if (this.optionalCharacter($LPAREN)) {\n            this.rparensExpected++;\n            var /** @type {?} */ result = this.parsePipe();\n            this.rparensExpected--;\n            this.expectCharacter($RPAREN);\n            return result;\n        }\n        else if (this.next.isKeywordNull()) {\n            this.advance();\n            return new LiteralPrimitive(this.span(start), null);\n        }\n        else if (this.next.isKeywordUndefined()) {\n            this.advance();\n            return new LiteralPrimitive(this.span(start), void 0);\n        }\n        else if (this.next.isKeywordTrue()) {\n            this.advance();\n            return new LiteralPrimitive(this.span(start), true);\n        }\n        else if (this.next.isKeywordFalse()) {\n            this.advance();\n            return new LiteralPrimitive(this.span(start), false);\n        }\n        else if (this.next.isKeywordThis()) {\n            this.advance();\n            return new ImplicitReceiver(this.span(start));\n        }\n        else if (this.optionalCharacter($LBRACKET)) {\n            this.rbracketsExpected++;\n            var /** @type {?} */ elements = this.parseExpressionList($RBRACKET);\n            this.rbracketsExpected--;\n            this.expectCharacter($RBRACKET);\n            return new LiteralArray(this.span(start), elements);\n        }\n        else if (this.next.isCharacter($LBRACE)) {\n            return this.parseLiteralMap();\n        }\n        else if (this.next.isIdentifier()) {\n            return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start)), false);\n        }\n        else if (this.next.isNumber()) {\n            var /** @type {?} */ value = this.next.toNumber();\n            this.advance();\n            return new LiteralPrimitive(this.span(start), value);\n        }\n        else if (this.next.isString()) {\n            var /** @type {?} */ literalValue = this.next.toString();\n            this.advance();\n            return new LiteralPrimitive(this.span(start), literalValue);\n        }\n        else if (this.index >= this.tokens.length) {\n            this.error(\"Unexpected end of expression: \" + this.input);\n            return new EmptyExpr(this.span(start));\n        }\n        else {\n            this.error(\"Unexpected token \" + this.next);\n            return new EmptyExpr(this.span(start));\n        }\n    };\n    /**\n     * @param {?} terminator\n     * @return {?}\n     */\n    _ParseAST.prototype.parseExpressionList = /**\n     * @param {?} terminator\n     * @return {?}\n     */\n    function (terminator) {\n        var /** @type {?} */ result = [];\n        if (!this.next.isCharacter(terminator)) {\n            do {\n                result.push(this.parsePipe());\n            } while (this.optionalCharacter($COMMA));\n        }\n        return result;\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseLiteralMap = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ keys = [];\n        var /** @type {?} */ values = [];\n        var /** @type {?} */ start = this.inputIndex;\n        this.expectCharacter($LBRACE);\n        if (!this.optionalCharacter($RBRACE)) {\n            this.rbracesExpected++;\n            do {\n                var /** @type {?} */ quoted = this.next.isString();\n                var /** @type {?} */ key = this.expectIdentifierOrKeywordOrString();\n                keys.push({ key: key, quoted: quoted });\n                this.expectCharacter($COLON);\n                values.push(this.parsePipe());\n            } while (this.optionalCharacter($COMMA));\n            this.rbracesExpected--;\n            this.expectCharacter($RBRACE);\n        }\n        return new LiteralMap(this.span(start), keys, values);\n    };\n    /**\n     * @param {?} receiver\n     * @param {?=} isSafe\n     * @return {?}\n     */\n    _ParseAST.prototype.parseAccessMemberOrMethodCall = /**\n     * @param {?} receiver\n     * @param {?=} isSafe\n     * @return {?}\n     */\n    function (receiver, isSafe) {\n        if (isSafe === void 0) { isSafe = false; }\n        var /** @type {?} */ start = receiver.span.start;\n        var /** @type {?} */ id = this.expectIdentifierOrKeyword();\n        if (this.optionalCharacter($LPAREN)) {\n            this.rparensExpected++;\n            var /** @type {?} */ args = this.parseCallArguments();\n            this.expectCharacter($RPAREN);\n            this.rparensExpected--;\n            var /** @type {?} */ span = this.span(start);\n            return isSafe ? new SafeMethodCall(span, receiver, id, args) :\n                new MethodCall(span, receiver, id, args);\n        }\n        else {\n            if (isSafe) {\n                if (this.optionalOperator('=')) {\n                    this.error('The \\'?.\\' operator cannot be used in the assignment');\n                    return new EmptyExpr(this.span(start));\n                }\n                else {\n                    return new SafePropertyRead(this.span(start), receiver, id);\n                }\n            }\n            else {\n                if (this.optionalOperator('=')) {\n                    if (!this.parseAction) {\n                        this.error('Bindings cannot contain assignments');\n                        return new EmptyExpr(this.span(start));\n                    }\n                    var /** @type {?} */ value = this.parseConditional();\n                    return new PropertyWrite(this.span(start), receiver, id, value);\n                }\n                else {\n                    return new PropertyRead(this.span(start), receiver, id);\n                }\n            }\n        }\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseCallArguments = /**\n     * @return {?}\n     */\n    function () {\n        if (this.next.isCharacter($RPAREN))\n            return [];\n        var /** @type {?} */ positionals = [];\n        do {\n            positionals.push(this.parsePipe());\n        } while (this.optionalCharacter($COMMA));\n        return /** @type {?} */ (positionals);\n    };\n    /**\n     * An identifier, a keyword, a string with an optional `-` inbetween.\n     */\n    /**\n     * An identifier, a keyword, a string with an optional `-` inbetween.\n     * @return {?}\n     */\n    _ParseAST.prototype.expectTemplateBindingKey = /**\n     * An identifier, a keyword, a string with an optional `-` inbetween.\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ result = '';\n        var /** @type {?} */ operatorFound = false;\n        do {\n            result += this.expectIdentifierOrKeywordOrString();\n            operatorFound = this.optionalOperator('-');\n            if (operatorFound) {\n                result += '-';\n            }\n        } while (operatorFound);\n        return result.toString();\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.parseTemplateBindings = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ bindings = [];\n        var /** @type {?} */ prefix = /** @type {?} */ ((null));\n        var /** @type {?} */ warnings = [];\n        while (this.index < this.tokens.length) {\n            var /** @type {?} */ start = this.inputIndex;\n            var /** @type {?} */ keyIsVar = this.peekKeywordLet();\n            if (keyIsVar) {\n                this.advance();\n            }\n            var /** @type {?} */ rawKey = this.expectTemplateBindingKey();\n            var /** @type {?} */ key = rawKey;\n            if (!keyIsVar) {\n                if (prefix == null) {\n                    prefix = key;\n                }\n                else {\n                    key = prefix + key[0].toUpperCase() + key.substring(1);\n                }\n            }\n            this.optionalCharacter($COLON);\n            var /** @type {?} */ name_2 = /** @type {?} */ ((null));\n            var /** @type {?} */ expression = /** @type {?} */ ((null));\n            if (keyIsVar) {\n                if (this.optionalOperator('=')) {\n                    name_2 = this.expectTemplateBindingKey();\n                }\n                else {\n                    name_2 = '\\$implicit';\n                }\n            }\n            else if (this.peekKeywordAs()) {\n                var /** @type {?} */ letStart = this.inputIndex;\n                this.advance(); // consume `as`\n                name_2 = rawKey;\n                key = this.expectTemplateBindingKey(); // read local var name\n                keyIsVar = true;\n            }\n            else if (this.next !== EOF && !this.peekKeywordLet()) {\n                var /** @type {?} */ start_1 = this.inputIndex;\n                var /** @type {?} */ ast = this.parsePipe();\n                var /** @type {?} */ source = this.input.substring(start_1 - this.offset, this.inputIndex - this.offset);\n                expression = new ASTWithSource(ast, source, this.location, this.errors);\n            }\n            bindings.push(new TemplateBinding(this.span(start), key, keyIsVar, name_2, expression));\n            if (this.peekKeywordAs() && !keyIsVar) {\n                var /** @type {?} */ letStart = this.inputIndex;\n                this.advance(); // consume `as`\n                var /** @type {?} */ letName = this.expectTemplateBindingKey(); // read local var name\n                bindings.push(new TemplateBinding(this.span(letStart), letName, true, key, /** @type {?} */ ((null))));\n            }\n            if (!this.optionalCharacter($SEMICOLON)) {\n                this.optionalCharacter($COMMA);\n            }\n        }\n        return new TemplateBindingParseResult(bindings, warnings, this.errors);\n    };\n    /**\n     * @param {?} message\n     * @param {?=} index\n     * @return {?}\n     */\n    _ParseAST.prototype.error = /**\n     * @param {?} message\n     * @param {?=} index\n     * @return {?}\n     */\n    function (message, index) {\n        if (index === void 0) { index = null; }\n        this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location));\n        this.skip();\n    };\n    /**\n     * @param {?=} index\n     * @return {?}\n     */\n    _ParseAST.prototype.locationText = /**\n     * @param {?=} index\n     * @return {?}\n     */\n    function (index) {\n        if (index === void 0) { index = null; }\n        if (index == null)\n            index = this.index;\n        return (index < this.tokens.length) ? \"at column \" + (this.tokens[index].index + 1) + \" in\" :\n            \"at the end of the expression\";\n    };\n    /**\n     * @return {?}\n     */\n    _ParseAST.prototype.skip = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ n = this.next;\n        while (this.index < this.tokens.length && !n.isCharacter($SEMICOLON) &&\n            (this.rparensExpected <= 0 || !n.isCharacter($RPAREN)) &&\n            (this.rbracesExpected <= 0 || !n.isCharacter($RBRACE)) &&\n            (this.rbracketsExpected <= 0 || !n.isCharacter($RBRACKET))) {\n            if (this.next.isError()) {\n                this.errors.push(new ParserError(/** @type {?} */ ((this.next.toString())), this.input, this.locationText(), this.location));\n            }\n            this.advance();\n            n = this.next;\n        }\n    };\n    return _ParseAST;\n}());\nvar SimpleExpressionChecker = /** @class */ (function () {\n    function SimpleExpressionChecker() {\n        this.errors = [];\n    }\n    /**\n     * @param {?} ast\n     * @return {?}\n     */\n    SimpleExpressionChecker.check = /**\n     * @param {?} ast\n     * @return {?}\n     */\n    function (ast) {\n        var /** @type {?} */ s = new SimpleExpressionChecker();\n        ast.visit(s);\n        return s.errors;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitImplicitReceiver = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitInterpolation = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitLiteralPrimitive = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitPropertyRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitPropertyWrite = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitSafePropertyRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitMethodCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitSafeMethodCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitFunctionCall = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitLiteralArray = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { this.visitAll(ast.expressions); };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitLiteralMap = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { this.visitAll(ast.values); };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitBinary = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitPrefixNot = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitNonNullAssert = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitConditional = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitPipe = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { this.errors.push('pipes'); };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitKeyedRead = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitKeyedWrite = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} asts\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitAll = /**\n     * @param {?} asts\n     * @return {?}\n     */\n    function (asts) {\n        var _this = this;\n        return asts.map(function (node) { return node.visit(_this); });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitChain = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    SimpleExpressionChecker.prototype.visitQuote = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    return SimpleExpressionChecker;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\nvar ParseLocation = /** @class */ (function () {\n    function ParseLocation(file, offset, line, col) {\n        this.file = file;\n        this.offset = offset;\n        this.line = line;\n        this.col = col;\n    }\n    /**\n     * @return {?}\n     */\n    ParseLocation.prototype.toString = /**\n     * @return {?}\n     */\n    function () {\n        return this.offset != null ? this.file.url + \"@\" + this.line + \":\" + this.col : this.file.url;\n    };\n    /**\n     * @param {?} delta\n     * @return {?}\n     */\n    ParseLocation.prototype.moveBy = /**\n     * @param {?} delta\n     * @return {?}\n     */\n    function (delta) {\n        var /** @type {?} */ source = this.file.content;\n        var /** @type {?} */ len = source.length;\n        var /** @type {?} */ offset = this.offset;\n        var /** @type {?} */ line = this.line;\n        var /** @type {?} */ col = this.col;\n        while (offset > 0 && delta < 0) {\n            offset--;\n            delta++;\n            var /** @type {?} */ ch = source.charCodeAt(offset);\n            if (ch == $LF) {\n                line--;\n                var /** @type {?} */ priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode($LF));\n                col = priorLine > 0 ? offset - priorLine : offset;\n            }\n            else {\n                col--;\n            }\n        }\n        while (offset < len && delta > 0) {\n            var /** @type {?} */ ch = source.charCodeAt(offset);\n            offset++;\n            delta--;\n            if (ch == $LF) {\n                line++;\n                col = 0;\n            }\n            else {\n                col++;\n            }\n        }\n        return new ParseLocation(this.file, offset, line, col);\n    };\n    // Return the source around the location\n    // Up to `maxChars` or `maxLines` on each side of the location\n    /**\n     * @param {?} maxChars\n     * @param {?} maxLines\n     * @return {?}\n     */\n    ParseLocation.prototype.getContext = /**\n     * @param {?} maxChars\n     * @param {?} maxLines\n     * @return {?}\n     */\n    function (maxChars, maxLines) {\n        var /** @type {?} */ content = this.file.content;\n        var /** @type {?} */ startOffset = this.offset;\n        if (startOffset != null) {\n            if (startOffset > content.length - 1) {\n                startOffset = content.length - 1;\n            }\n            var /** @type {?} */ endOffset = startOffset;\n            var /** @type {?} */ ctxChars = 0;\n            var /** @type {?} */ ctxLines = 0;\n            while (ctxChars < maxChars && startOffset > 0) {\n                startOffset--;\n                ctxChars++;\n                if (content[startOffset] == '\\n') {\n                    if (++ctxLines == maxLines) {\n                        break;\n                    }\n                }\n            }\n            ctxChars = 0;\n            ctxLines = 0;\n            while (ctxChars < maxChars && endOffset < content.length - 1) {\n                endOffset++;\n                ctxChars++;\n                if (content[endOffset] == '\\n') {\n                    if (++ctxLines == maxLines) {\n                        break;\n                    }\n                }\n            }\n            return {\n                before: content.substring(startOffset, this.offset),\n                after: content.substring(this.offset, endOffset + 1),\n            };\n        }\n        return null;\n    };\n    return ParseLocation;\n}());\nvar ParseSourceFile = /** @class */ (function () {\n    function ParseSourceFile(content, url) {\n        this.content = content;\n        this.url = url;\n    }\n    return ParseSourceFile;\n}());\nvar ParseSourceSpan = /** @class */ (function () {\n    function ParseSourceSpan(start, end, details) {\n        if (details === void 0) { details = null; }\n        this.start = start;\n        this.end = end;\n        this.details = details;\n    }\n    /**\n     * @return {?}\n     */\n    ParseSourceSpan.prototype.toString = /**\n     * @return {?}\n     */\n    function () {\n        return this.start.file.content.substring(this.start.offset, this.end.offset);\n    };\n    return ParseSourceSpan;\n}());\n/** @enum {number} */\nvar ParseErrorLevel = {\n    WARNING: 0,\n    ERROR: 1,\n};\nParseErrorLevel[ParseErrorLevel.WARNING] = \"WARNING\";\nParseErrorLevel[ParseErrorLevel.ERROR] = \"ERROR\";\nvar ParseError = /** @class */ (function () {\n    function ParseError(span, msg, level) {\n        if (level === void 0) { level = ParseErrorLevel.ERROR; }\n        this.span = span;\n        this.msg = msg;\n        this.level = level;\n    }\n    /**\n     * @return {?}\n     */\n    ParseError.prototype.contextualMessage = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ ctx = this.span.start.getContext(100, 3);\n        return ctx ? this.msg + \" (\\\"\" + ctx.before + \"[\" + ParseErrorLevel[this.level] + \" ->]\" + ctx.after + \"\\\")\" :\n            this.msg;\n    };\n    /**\n     * @return {?}\n     */\n    ParseError.prototype.toString = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ details = this.span.details ? \", \" + this.span.details : '';\n        return this.contextualMessage() + \": \" + this.span.start + details;\n    };\n    return ParseError;\n}());\n/**\n * @param {?} kind\n * @param {?} type\n * @return {?}\n */\nfunction typeSourceSpan(kind, type) {\n    var /** @type {?} */ moduleUrl = identifierModuleUrl(type);\n    var /** @type {?} */ sourceFileName = moduleUrl != null ? \"in \" + kind + \" \" + identifierName(type) + \" in \" + moduleUrl :\n        \"in \" + kind + \" \" + identifierName(type);\n    var /** @type {?} */ sourceFile = new ParseSourceFile('', sourceFileName);\n    return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1));\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @enum {number} */\nvar TokenType$1 = {\n    TAG_OPEN_START: 0,\n    TAG_OPEN_END: 1,\n    TAG_OPEN_END_VOID: 2,\n    TAG_CLOSE: 3,\n    TEXT: 4,\n    ESCAPABLE_RAW_TEXT: 5,\n    RAW_TEXT: 6,\n    COMMENT_START: 7,\n    COMMENT_END: 8,\n    CDATA_START: 9,\n    CDATA_END: 10,\n    ATTR_NAME: 11,\n    ATTR_VALUE: 12,\n    DOC_TYPE: 13,\n    EXPANSION_FORM_START: 14,\n    EXPANSION_CASE_VALUE: 15,\n    EXPANSION_CASE_EXP_START: 16,\n    EXPANSION_CASE_EXP_END: 17,\n    EXPANSION_FORM_END: 18,\n    EOF: 19,\n};\nTokenType$1[TokenType$1.TAG_OPEN_START] = \"TAG_OPEN_START\";\nTokenType$1[TokenType$1.TAG_OPEN_END] = \"TAG_OPEN_END\";\nTokenType$1[TokenType$1.TAG_OPEN_END_VOID] = \"TAG_OPEN_END_VOID\";\nTokenType$1[TokenType$1.TAG_CLOSE] = \"TAG_CLOSE\";\nTokenType$1[TokenType$1.TEXT] = \"TEXT\";\nTokenType$1[TokenType$1.ESCAPABLE_RAW_TEXT] = \"ESCAPABLE_RAW_TEXT\";\nTokenType$1[TokenType$1.RAW_TEXT] = \"RAW_TEXT\";\nTokenType$1[TokenType$1.COMMENT_START] = \"COMMENT_START\";\nTokenType$1[TokenType$1.COMMENT_END] = \"COMMENT_END\";\nTokenType$1[TokenType$1.CDATA_START] = \"CDATA_START\";\nTokenType$1[TokenType$1.CDATA_END] = \"CDATA_END\";\nTokenType$1[TokenType$1.ATTR_NAME] = \"ATTR_NAME\";\nTokenType$1[TokenType$1.ATTR_VALUE] = \"ATTR_VALUE\";\nTokenType$1[TokenType$1.DOC_TYPE] = \"DOC_TYPE\";\nTokenType$1[TokenType$1.EXPANSION_FORM_START] = \"EXPANSION_FORM_START\";\nTokenType$1[TokenType$1.EXPANSION_CASE_VALUE] = \"EXPANSION_CASE_VALUE\";\nTokenType$1[TokenType$1.EXPANSION_CASE_EXP_START] = \"EXPANSION_CASE_EXP_START\";\nTokenType$1[TokenType$1.EXPANSION_CASE_EXP_END] = \"EXPANSION_CASE_EXP_END\";\nTokenType$1[TokenType$1.EXPANSION_FORM_END] = \"EXPANSION_FORM_END\";\nTokenType$1[TokenType$1.EOF] = \"EOF\";\nvar Token$1 = /** @class */ (function () {\n    function Token(type, parts, sourceSpan) {\n        this.type = type;\n        this.parts = parts;\n        this.sourceSpan = sourceSpan;\n    }\n    return Token;\n}());\nvar TokenError = /** @class */ (function (_super) {\n    __extends(TokenError, _super);\n    function TokenError(errorMsg, tokenType, span) {\n        var _this = _super.call(this, span, errorMsg) || this;\n        _this.tokenType = tokenType;\n        return _this;\n    }\n    return TokenError;\n}(ParseError));\nvar TokenizeResult = /** @class */ (function () {\n    function TokenizeResult(tokens, errors) {\n        this.tokens = tokens;\n        this.errors = errors;\n    }\n    return TokenizeResult;\n}());\n/**\n * @param {?} source\n * @param {?} url\n * @param {?} getTagDefinition\n * @param {?=} tokenizeExpansionForms\n * @param {?=} interpolationConfig\n * @return {?}\n */\nfunction tokenize(source, url, getTagDefinition, tokenizeExpansionForms, interpolationConfig) {\n    if (tokenizeExpansionForms === void 0) { tokenizeExpansionForms = false; }\n    if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n    return new _Tokenizer(new ParseSourceFile(source, url), getTagDefinition, tokenizeExpansionForms, interpolationConfig)\n        .tokenize();\n}\nvar _CR_OR_CRLF_REGEXP = /\\r\\n?/g;\n/**\n * @param {?} charCode\n * @return {?}\n */\nfunction _unexpectedCharacterErrorMsg(charCode) {\n    var /** @type {?} */ char = charCode === $EOF ? 'EOF' : String.fromCharCode(charCode);\n    return \"Unexpected character \\\"\" + char + \"\\\"\";\n}\n/**\n * @param {?} entitySrc\n * @return {?}\n */\nfunction _unknownEntityErrorMsg(entitySrc) {\n    return \"Unknown entity \\\"\" + entitySrc + \"\\\" - use the \\\"&#<decimal>;\\\" or  \\\"&#x<hex>;\\\" syntax\";\n}\nvar _ControlFlowError = /** @class */ (function () {\n    function _ControlFlowError(error) {\n        this.error = error;\n    }\n    return _ControlFlowError;\n}());\nvar _Tokenizer = /** @class */ (function () {\n    /**\n     * @param _file The html source\n     * @param _getTagDefinition\n     * @param _tokenizeIcu Whether to tokenize ICU messages (considered as text nodes when false)\n     * @param _interpolationConfig\n     */\n    function _Tokenizer(_file, _getTagDefinition, _tokenizeIcu, _interpolationConfig) {\n        if (_interpolationConfig === void 0) { _interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        this._file = _file;\n        this._getTagDefinition = _getTagDefinition;\n        this._tokenizeIcu = _tokenizeIcu;\n        this._interpolationConfig = _interpolationConfig;\n        this._peek = -1;\n        this._nextPeek = -1;\n        this._index = -1;\n        this._line = 0;\n        this._column = -1;\n        this._expansionCaseStack = [];\n        this._inInterpolation = false;\n        this.tokens = [];\n        this.errors = [];\n        this._input = _file.content;\n        this._length = _file.content.length;\n        this._advance();\n    }\n    /**\n     * @param {?} content\n     * @return {?}\n     */\n    _Tokenizer.prototype._processCarriageReturns = /**\n     * @param {?} content\n     * @return {?}\n     */\n    function (content) {\n        // http://www.w3.org/TR/html5/syntax.html#preprocessing-the-input-stream\n        // In order to keep the original position in the source, we can not\n        // pre-process it.\n        // Instead CRs are processed right before instantiating the tokens.\n        return content.replace(_CR_OR_CRLF_REGEXP, '\\n');\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype.tokenize = /**\n     * @return {?}\n     */\n    function () {\n        while (this._peek !== $EOF) {\n            var /** @type {?} */ start = this._getLocation();\n            try {\n                if (this._attemptCharCode($LT)) {\n                    if (this._attemptCharCode($BANG)) {\n                        if (this._attemptCharCode($LBRACKET)) {\n                            this._consumeCdata(start);\n                        }\n                        else if (this._attemptCharCode($MINUS)) {\n                            this._consumeComment(start);\n                        }\n                        else {\n                            this._consumeDocType(start);\n                        }\n                    }\n                    else if (this._attemptCharCode($SLASH)) {\n                        this._consumeTagClose(start);\n                    }\n                    else {\n                        this._consumeTagOpen(start);\n                    }\n                }\n                else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {\n                    this._consumeText();\n                }\n            }\n            catch (/** @type {?} */ e) {\n                if (e instanceof _ControlFlowError) {\n                    this.errors.push(e.error);\n                }\n                else {\n                    throw e;\n                }\n            }\n        }\n        this._beginToken(TokenType$1.EOF);\n        this._endToken([]);\n        return new TokenizeResult(mergeTextTokens(this.tokens), this.errors);\n    };\n    /**\n     * \\@internal\n     * @return {?} whether an ICU token has been created\n     */\n    _Tokenizer.prototype._tokenizeExpansionForm = /**\n     * \\@internal\n     * @return {?} whether an ICU token has been created\n     */\n    function () {\n        if (isExpansionFormStart(this._input, this._index, this._interpolationConfig)) {\n            this._consumeExpansionFormStart();\n            return true;\n        }\n        if (isExpansionCaseStart(this._peek) && this._isInExpansionForm()) {\n            this._consumeExpansionCaseStart();\n            return true;\n        }\n        if (this._peek === $RBRACE) {\n            if (this._isInExpansionCase()) {\n                this._consumeExpansionCaseEnd();\n                return true;\n            }\n            if (this._isInExpansionForm()) {\n                this._consumeExpansionFormEnd();\n                return true;\n            }\n        }\n        return false;\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._getLocation = /**\n     * @return {?}\n     */\n    function () {\n        return new ParseLocation(this._file, this._index, this._line, this._column);\n    };\n    /**\n     * @param {?=} start\n     * @param {?=} end\n     * @return {?}\n     */\n    _Tokenizer.prototype._getSpan = /**\n     * @param {?=} start\n     * @param {?=} end\n     * @return {?}\n     */\n    function (start, end) {\n        if (start === void 0) { start = this._getLocation(); }\n        if (end === void 0) { end = this._getLocation(); }\n        return new ParseSourceSpan(start, end);\n    };\n    /**\n     * @param {?} type\n     * @param {?=} start\n     * @return {?}\n     */\n    _Tokenizer.prototype._beginToken = /**\n     * @param {?} type\n     * @param {?=} start\n     * @return {?}\n     */\n    function (type, start) {\n        if (start === void 0) { start = this._getLocation(); }\n        this._currentTokenStart = start;\n        this._currentTokenType = type;\n    };\n    /**\n     * @param {?} parts\n     * @param {?=} end\n     * @return {?}\n     */\n    _Tokenizer.prototype._endToken = /**\n     * @param {?} parts\n     * @param {?=} end\n     * @return {?}\n     */\n    function (parts, end) {\n        if (end === void 0) { end = this._getLocation(); }\n        var /** @type {?} */ token = new Token$1(this._currentTokenType, parts, new ParseSourceSpan(this._currentTokenStart, end));\n        this.tokens.push(token);\n        this._currentTokenStart = /** @type {?} */ ((null));\n        this._currentTokenType = /** @type {?} */ ((null));\n        return token;\n    };\n    /**\n     * @param {?} msg\n     * @param {?} span\n     * @return {?}\n     */\n    _Tokenizer.prototype._createError = /**\n     * @param {?} msg\n     * @param {?} span\n     * @return {?}\n     */\n    function (msg, span) {\n        if (this._isInExpansionForm()) {\n            msg += \" (Do you have an unescaped \\\"{\\\" in your template? Use \\\"{{ '{' }}\\\") to escape it.)\";\n        }\n        var /** @type {?} */ error = new TokenError(msg, this._currentTokenType, span);\n        this._currentTokenStart = /** @type {?} */ ((null));\n        this._currentTokenType = /** @type {?} */ ((null));\n        return new _ControlFlowError(error);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._advance = /**\n     * @return {?}\n     */\n    function () {\n        if (this._index >= this._length) {\n            throw this._createError(_unexpectedCharacterErrorMsg($EOF), this._getSpan());\n        }\n        if (this._peek === $LF) {\n            this._line++;\n            this._column = 0;\n        }\n        else if (this._peek !== $LF && this._peek !== $CR) {\n            this._column++;\n        }\n        this._index++;\n        this._peek = this._index >= this._length ? $EOF : this._input.charCodeAt(this._index);\n        this._nextPeek =\n            this._index + 1 >= this._length ? $EOF : this._input.charCodeAt(this._index + 1);\n    };\n    /**\n     * @param {?} charCode\n     * @return {?}\n     */\n    _Tokenizer.prototype._attemptCharCode = /**\n     * @param {?} charCode\n     * @return {?}\n     */\n    function (charCode) {\n        if (this._peek === charCode) {\n            this._advance();\n            return true;\n        }\n        return false;\n    };\n    /**\n     * @param {?} charCode\n     * @return {?}\n     */\n    _Tokenizer.prototype._attemptCharCodeCaseInsensitive = /**\n     * @param {?} charCode\n     * @return {?}\n     */\n    function (charCode) {\n        if (compareCharCodeCaseInsensitive(this._peek, charCode)) {\n            this._advance();\n            return true;\n        }\n        return false;\n    };\n    /**\n     * @param {?} charCode\n     * @return {?}\n     */\n    _Tokenizer.prototype._requireCharCode = /**\n     * @param {?} charCode\n     * @return {?}\n     */\n    function (charCode) {\n        var /** @type {?} */ location = this._getLocation();\n        if (!this._attemptCharCode(charCode)) {\n            throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan(location, location));\n        }\n    };\n    /**\n     * @param {?} chars\n     * @return {?}\n     */\n    _Tokenizer.prototype._attemptStr = /**\n     * @param {?} chars\n     * @return {?}\n     */\n    function (chars) {\n        var /** @type {?} */ len = chars.length;\n        if (this._index + len > this._length) {\n            return false;\n        }\n        var /** @type {?} */ initialPosition = this._savePosition();\n        for (var /** @type {?} */ i = 0; i < len; i++) {\n            if (!this._attemptCharCode(chars.charCodeAt(i))) {\n                // If attempting to parse the string fails, we want to reset the parser\n                // to where it was before the attempt\n                this._restorePosition(initialPosition);\n                return false;\n            }\n        }\n        return true;\n    };\n    /**\n     * @param {?} chars\n     * @return {?}\n     */\n    _Tokenizer.prototype._attemptStrCaseInsensitive = /**\n     * @param {?} chars\n     * @return {?}\n     */\n    function (chars) {\n        for (var /** @type {?} */ i = 0; i < chars.length; i++) {\n            if (!this._attemptCharCodeCaseInsensitive(chars.charCodeAt(i))) {\n                return false;\n            }\n        }\n        return true;\n    };\n    /**\n     * @param {?} chars\n     * @return {?}\n     */\n    _Tokenizer.prototype._requireStr = /**\n     * @param {?} chars\n     * @return {?}\n     */\n    function (chars) {\n        var /** @type {?} */ location = this._getLocation();\n        if (!this._attemptStr(chars)) {\n            throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan(location));\n        }\n    };\n    /**\n     * @param {?} predicate\n     * @return {?}\n     */\n    _Tokenizer.prototype._attemptCharCodeUntilFn = /**\n     * @param {?} predicate\n     * @return {?}\n     */\n    function (predicate) {\n        while (!predicate(this._peek)) {\n            this._advance();\n        }\n    };\n    /**\n     * @param {?} predicate\n     * @param {?} len\n     * @return {?}\n     */\n    _Tokenizer.prototype._requireCharCodeUntilFn = /**\n     * @param {?} predicate\n     * @param {?} len\n     * @return {?}\n     */\n    function (predicate, len) {\n        var /** @type {?} */ start = this._getLocation();\n        this._attemptCharCodeUntilFn(predicate);\n        if (this._index - start.offset < len) {\n            throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan(start, start));\n        }\n    };\n    /**\n     * @param {?} char\n     * @return {?}\n     */\n    _Tokenizer.prototype._attemptUntilChar = /**\n     * @param {?} char\n     * @return {?}\n     */\n    function (char) {\n        while (this._peek !== char) {\n            this._advance();\n        }\n    };\n    /**\n     * @param {?} decodeEntities\n     * @return {?}\n     */\n    _Tokenizer.prototype._readChar = /**\n     * @param {?} decodeEntities\n     * @return {?}\n     */\n    function (decodeEntities) {\n        if (decodeEntities && this._peek === $AMPERSAND) {\n            return this._decodeEntity();\n        }\n        else {\n            var /** @type {?} */ index = this._index;\n            this._advance();\n            return this._input[index];\n        }\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._decodeEntity = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ start = this._getLocation();\n        this._advance();\n        if (this._attemptCharCode($HASH)) {\n            var /** @type {?} */ isHex = this._attemptCharCode($x) || this._attemptCharCode($X);\n            var /** @type {?} */ numberStart = this._getLocation().offset;\n            this._attemptCharCodeUntilFn(isDigitEntityEnd);\n            if (this._peek != $SEMICOLON) {\n                throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan());\n            }\n            this._advance();\n            var /** @type {?} */ strNum = this._input.substring(numberStart, this._index - 1);\n            try {\n                var /** @type {?} */ charCode = parseInt(strNum, isHex ? 16 : 10);\n                return String.fromCharCode(charCode);\n            }\n            catch (/** @type {?} */ e) {\n                var /** @type {?} */ entity = this._input.substring(start.offset + 1, this._index - 1);\n                throw this._createError(_unknownEntityErrorMsg(entity), this._getSpan(start));\n            }\n        }\n        else {\n            var /** @type {?} */ startPosition = this._savePosition();\n            this._attemptCharCodeUntilFn(isNamedEntityEnd);\n            if (this._peek != $SEMICOLON) {\n                this._restorePosition(startPosition);\n                return '&';\n            }\n            this._advance();\n            var /** @type {?} */ name_1 = this._input.substring(start.offset + 1, this._index - 1);\n            var /** @type {?} */ char = NAMED_ENTITIES[name_1];\n            if (!char) {\n                throw this._createError(_unknownEntityErrorMsg(name_1), this._getSpan(start));\n            }\n            return char;\n        }\n    };\n    /**\n     * @param {?} decodeEntities\n     * @param {?} firstCharOfEnd\n     * @param {?} attemptEndRest\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeRawText = /**\n     * @param {?} decodeEntities\n     * @param {?} firstCharOfEnd\n     * @param {?} attemptEndRest\n     * @return {?}\n     */\n    function (decodeEntities, firstCharOfEnd, attemptEndRest) {\n        var /** @type {?} */ tagCloseStart;\n        var /** @type {?} */ textStart = this._getLocation();\n        this._beginToken(decodeEntities ? TokenType$1.ESCAPABLE_RAW_TEXT : TokenType$1.RAW_TEXT, textStart);\n        var /** @type {?} */ parts = [];\n        while (true) {\n            tagCloseStart = this._getLocation();\n            if (this._attemptCharCode(firstCharOfEnd) && attemptEndRest()) {\n                break;\n            }\n            if (this._index > tagCloseStart.offset) {\n                // add the characters consumed by the previous if statement to the output\n                parts.push(this._input.substring(tagCloseStart.offset, this._index));\n            }\n            while (this._peek !== firstCharOfEnd) {\n                parts.push(this._readChar(decodeEntities));\n            }\n        }\n        return this._endToken([this._processCarriageReturns(parts.join(''))], tagCloseStart);\n    };\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeComment = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) {\n        var _this = this;\n        this._beginToken(TokenType$1.COMMENT_START, start);\n        this._requireCharCode($MINUS);\n        this._endToken([]);\n        var /** @type {?} */ textToken = this._consumeRawText(false, $MINUS, function () { return _this._attemptStr('->'); });\n        this._beginToken(TokenType$1.COMMENT_END, textToken.sourceSpan.end);\n        this._endToken([]);\n    };\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeCdata = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) {\n        var _this = this;\n        this._beginToken(TokenType$1.CDATA_START, start);\n        this._requireStr('CDATA[');\n        this._endToken([]);\n        var /** @type {?} */ textToken = this._consumeRawText(false, $RBRACKET, function () { return _this._attemptStr(']>'); });\n        this._beginToken(TokenType$1.CDATA_END, textToken.sourceSpan.end);\n        this._endToken([]);\n    };\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeDocType = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) {\n        this._beginToken(TokenType$1.DOC_TYPE, start);\n        this._attemptUntilChar($GT);\n        this._advance();\n        this._endToken([this._input.substring(start.offset + 2, this._index - 1)]);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumePrefixAndName = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ nameOrPrefixStart = this._index;\n        var /** @type {?} */ prefix = /** @type {?} */ ((null));\n        while (this._peek !== $COLON && !isPrefixEnd(this._peek)) {\n            this._advance();\n        }\n        var /** @type {?} */ nameStart;\n        if (this._peek === $COLON) {\n            this._advance();\n            prefix = this._input.substring(nameOrPrefixStart, this._index - 1);\n            nameStart = this._index;\n        }\n        else {\n            nameStart = nameOrPrefixStart;\n        }\n        this._requireCharCodeUntilFn(isNameEnd, this._index === nameStart ? 1 : 0);\n        var /** @type {?} */ name = this._input.substring(nameStart, this._index);\n        return [prefix, name];\n    };\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeTagOpen = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) {\n        var /** @type {?} */ savedPos = this._savePosition();\n        var /** @type {?} */ tagName;\n        var /** @type {?} */ lowercaseTagName;\n        try {\n            if (!isAsciiLetter(this._peek)) {\n                throw this._createError(_unexpectedCharacterErrorMsg(this._peek), this._getSpan());\n            }\n            var /** @type {?} */ nameStart = this._index;\n            this._consumeTagOpenStart(start);\n            tagName = this._input.substring(nameStart, this._index);\n            lowercaseTagName = tagName.toLowerCase();\n            this._attemptCharCodeUntilFn(isNotWhitespace);\n            while (this._peek !== $SLASH && this._peek !== $GT) {\n                this._consumeAttributeName();\n                this._attemptCharCodeUntilFn(isNotWhitespace);\n                if (this._attemptCharCode($EQ)) {\n                    this._attemptCharCodeUntilFn(isNotWhitespace);\n                    this._consumeAttributeValue();\n                }\n                this._attemptCharCodeUntilFn(isNotWhitespace);\n            }\n            this._consumeTagOpenEnd();\n        }\n        catch (/** @type {?} */ e) {\n            if (e instanceof _ControlFlowError) {\n                // When the start tag is invalid, assume we want a \"<\"\n                this._restorePosition(savedPos);\n                // Back to back text tokens are merged at the end\n                this._beginToken(TokenType$1.TEXT, start);\n                this._endToken(['<']);\n                return;\n            }\n            throw e;\n        }\n        var /** @type {?} */ contentTokenType = this._getTagDefinition(tagName).contentType;\n        if (contentTokenType === TagContentType.RAW_TEXT) {\n            this._consumeRawTextWithTagClose(lowercaseTagName, false);\n        }\n        else if (contentTokenType === TagContentType.ESCAPABLE_RAW_TEXT) {\n            this._consumeRawTextWithTagClose(lowercaseTagName, true);\n        }\n    };\n    /**\n     * @param {?} lowercaseTagName\n     * @param {?} decodeEntities\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeRawTextWithTagClose = /**\n     * @param {?} lowercaseTagName\n     * @param {?} decodeEntities\n     * @return {?}\n     */\n    function (lowercaseTagName, decodeEntities) {\n        var _this = this;\n        var /** @type {?} */ textToken = this._consumeRawText(decodeEntities, $LT, function () {\n            if (!_this._attemptCharCode($SLASH))\n                return false;\n            _this._attemptCharCodeUntilFn(isNotWhitespace);\n            if (!_this._attemptStrCaseInsensitive(lowercaseTagName))\n                return false;\n            _this._attemptCharCodeUntilFn(isNotWhitespace);\n            return _this._attemptCharCode($GT);\n        });\n        this._beginToken(TokenType$1.TAG_CLOSE, textToken.sourceSpan.end);\n        this._endToken([/** @type {?} */ ((null)), lowercaseTagName]);\n    };\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeTagOpenStart = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) {\n        this._beginToken(TokenType$1.TAG_OPEN_START, start);\n        var /** @type {?} */ parts = this._consumePrefixAndName();\n        this._endToken(parts);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeAttributeName = /**\n     * @return {?}\n     */\n    function () {\n        this._beginToken(TokenType$1.ATTR_NAME);\n        var /** @type {?} */ prefixAndName = this._consumePrefixAndName();\n        this._endToken(prefixAndName);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeAttributeValue = /**\n     * @return {?}\n     */\n    function () {\n        this._beginToken(TokenType$1.ATTR_VALUE);\n        var /** @type {?} */ value;\n        if (this._peek === $SQ || this._peek === $DQ) {\n            var /** @type {?} */ quoteChar = this._peek;\n            this._advance();\n            var /** @type {?} */ parts = [];\n            while (this._peek !== quoteChar) {\n                parts.push(this._readChar(true));\n            }\n            value = parts.join('');\n            this._advance();\n        }\n        else {\n            var /** @type {?} */ valueStart = this._index;\n            this._requireCharCodeUntilFn(isNameEnd, 1);\n            value = this._input.substring(valueStart, this._index);\n        }\n        this._endToken([this._processCarriageReturns(value)]);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeTagOpenEnd = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ tokenType = this._attemptCharCode($SLASH) ? TokenType$1.TAG_OPEN_END_VOID : TokenType$1.TAG_OPEN_END;\n        this._beginToken(tokenType);\n        this._requireCharCode($GT);\n        this._endToken([]);\n    };\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeTagClose = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) {\n        this._beginToken(TokenType$1.TAG_CLOSE, start);\n        this._attemptCharCodeUntilFn(isNotWhitespace);\n        var /** @type {?} */ prefixAndName = this._consumePrefixAndName();\n        this._attemptCharCodeUntilFn(isNotWhitespace);\n        this._requireCharCode($GT);\n        this._endToken(prefixAndName);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeExpansionFormStart = /**\n     * @return {?}\n     */\n    function () {\n        this._beginToken(TokenType$1.EXPANSION_FORM_START, this._getLocation());\n        this._requireCharCode($LBRACE);\n        this._endToken([]);\n        this._expansionCaseStack.push(TokenType$1.EXPANSION_FORM_START);\n        this._beginToken(TokenType$1.RAW_TEXT, this._getLocation());\n        var /** @type {?} */ condition = this._readUntil($COMMA);\n        this._endToken([condition], this._getLocation());\n        this._requireCharCode($COMMA);\n        this._attemptCharCodeUntilFn(isNotWhitespace);\n        this._beginToken(TokenType$1.RAW_TEXT, this._getLocation());\n        var /** @type {?} */ type = this._readUntil($COMMA);\n        this._endToken([type], this._getLocation());\n        this._requireCharCode($COMMA);\n        this._attemptCharCodeUntilFn(isNotWhitespace);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeExpansionCaseStart = /**\n     * @return {?}\n     */\n    function () {\n        this._beginToken(TokenType$1.EXPANSION_CASE_VALUE, this._getLocation());\n        var /** @type {?} */ value = this._readUntil($LBRACE).trim();\n        this._endToken([value], this._getLocation());\n        this._attemptCharCodeUntilFn(isNotWhitespace);\n        this._beginToken(TokenType$1.EXPANSION_CASE_EXP_START, this._getLocation());\n        this._requireCharCode($LBRACE);\n        this._endToken([], this._getLocation());\n        this._attemptCharCodeUntilFn(isNotWhitespace);\n        this._expansionCaseStack.push(TokenType$1.EXPANSION_CASE_EXP_START);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeExpansionCaseEnd = /**\n     * @return {?}\n     */\n    function () {\n        this._beginToken(TokenType$1.EXPANSION_CASE_EXP_END, this._getLocation());\n        this._requireCharCode($RBRACE);\n        this._endToken([], this._getLocation());\n        this._attemptCharCodeUntilFn(isNotWhitespace);\n        this._expansionCaseStack.pop();\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeExpansionFormEnd = /**\n     * @return {?}\n     */\n    function () {\n        this._beginToken(TokenType$1.EXPANSION_FORM_END, this._getLocation());\n        this._requireCharCode($RBRACE);\n        this._endToken([]);\n        this._expansionCaseStack.pop();\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._consumeText = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ start = this._getLocation();\n        this._beginToken(TokenType$1.TEXT, start);\n        var /** @type {?} */ parts = [];\n        do {\n            if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) {\n                parts.push(this._interpolationConfig.start);\n                this._inInterpolation = true;\n            }\n            else if (this._interpolationConfig && this._inInterpolation &&\n                this._attemptStr(this._interpolationConfig.end)) {\n                parts.push(this._interpolationConfig.end);\n                this._inInterpolation = false;\n            }\n            else {\n                parts.push(this._readChar(true));\n            }\n        } while (!this._isTextEnd());\n        this._endToken([this._processCarriageReturns(parts.join(''))]);\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._isTextEnd = /**\n     * @return {?}\n     */\n    function () {\n        if (this._peek === $LT || this._peek === $EOF) {\n            return true;\n        }\n        if (this._tokenizeIcu && !this._inInterpolation) {\n            if (isExpansionFormStart(this._input, this._index, this._interpolationConfig)) {\n                // start of an expansion form\n                return true;\n            }\n            if (this._peek === $RBRACE && this._isInExpansionCase()) {\n                // end of and expansion case\n                return true;\n            }\n        }\n        return false;\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._savePosition = /**\n     * @return {?}\n     */\n    function () {\n        return [this._peek, this._index, this._column, this._line, this.tokens.length];\n    };\n    /**\n     * @param {?} char\n     * @return {?}\n     */\n    _Tokenizer.prototype._readUntil = /**\n     * @param {?} char\n     * @return {?}\n     */\n    function (char) {\n        var /** @type {?} */ start = this._index;\n        this._attemptUntilChar(char);\n        return this._input.substring(start, this._index);\n    };\n    /**\n     * @param {?} position\n     * @return {?}\n     */\n    _Tokenizer.prototype._restorePosition = /**\n     * @param {?} position\n     * @return {?}\n     */\n    function (position) {\n        this._peek = position[0];\n        this._index = position[1];\n        this._column = position[2];\n        this._line = position[3];\n        var /** @type {?} */ nbTokens = position[4];\n        if (nbTokens < this.tokens.length) {\n            // remove any extra tokens\n            this.tokens = this.tokens.slice(0, nbTokens);\n        }\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._isInExpansionCase = /**\n     * @return {?}\n     */\n    function () {\n        return this._expansionCaseStack.length > 0 &&\n            this._expansionCaseStack[this._expansionCaseStack.length - 1] ===\n                TokenType$1.EXPANSION_CASE_EXP_START;\n    };\n    /**\n     * @return {?}\n     */\n    _Tokenizer.prototype._isInExpansionForm = /**\n     * @return {?}\n     */\n    function () {\n        return this._expansionCaseStack.length > 0 &&\n            this._expansionCaseStack[this._expansionCaseStack.length - 1] ===\n                TokenType$1.EXPANSION_FORM_START;\n    };\n    return _Tokenizer;\n}());\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isNotWhitespace(code) {\n    return !isWhitespace(code) || code === $EOF;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isNameEnd(code) {\n    return isWhitespace(code) || code === $GT || code === $SLASH ||\n        code === $SQ || code === $DQ || code === $EQ;\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isPrefixEnd(code) {\n    return (code < $a || $z < code) && (code < $A || $Z < code) &&\n        (code < $0 || code > $9);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isDigitEntityEnd(code) {\n    return code == $SEMICOLON || code == $EOF || !isAsciiHexDigit(code);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction isNamedEntityEnd(code) {\n    return code == $SEMICOLON || code == $EOF || !isAsciiLetter(code);\n}\n/**\n * @param {?} input\n * @param {?} offset\n * @param {?} interpolationConfig\n * @return {?}\n */\nfunction isExpansionFormStart(input, offset, interpolationConfig) {\n    var /** @type {?} */ isInterpolationStart = interpolationConfig ? input.indexOf(interpolationConfig.start, offset) == offset : false;\n    return input.charCodeAt(offset) == $LBRACE && !isInterpolationStart;\n}\n/**\n * @param {?} peek\n * @return {?}\n */\nfunction isExpansionCaseStart(peek) {\n    return peek === $EQ || isAsciiLetter(peek) || isDigit(peek);\n}\n/**\n * @param {?} code1\n * @param {?} code2\n * @return {?}\n */\nfunction compareCharCodeCaseInsensitive(code1, code2) {\n    return toUpperCaseCharCode(code1) == toUpperCaseCharCode(code2);\n}\n/**\n * @param {?} code\n * @return {?}\n */\nfunction toUpperCaseCharCode(code) {\n    return code >= $a && code <= $z ? code - $a + $A : code;\n}\n/**\n * @param {?} srcTokens\n * @return {?}\n */\nfunction mergeTextTokens(srcTokens) {\n    var /** @type {?} */ dstTokens = [];\n    var /** @type {?} */ lastDstToken = undefined;\n    for (var /** @type {?} */ i = 0; i < srcTokens.length; i++) {\n        var /** @type {?} */ token = srcTokens[i];\n        if (lastDstToken && lastDstToken.type == TokenType$1.TEXT && token.type == TokenType$1.TEXT) {\n            lastDstToken.parts[0] += token.parts[0];\n            lastDstToken.sourceSpan.end = token.sourceSpan.end;\n        }\n        else {\n            lastDstToken = token;\n            dstTokens.push(lastDstToken);\n        }\n    }\n    return dstTokens;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar TreeError = /** @class */ (function (_super) {\n    __extends(TreeError, _super);\n    function TreeError(elementName, span, msg) {\n        var _this = _super.call(this, span, msg) || this;\n        _this.elementName = elementName;\n        return _this;\n    }\n    /**\n     * @param {?} elementName\n     * @param {?} span\n     * @param {?} msg\n     * @return {?}\n     */\n    TreeError.create = /**\n     * @param {?} elementName\n     * @param {?} span\n     * @param {?} msg\n     * @return {?}\n     */\n    function (elementName, span, msg) {\n        return new TreeError(elementName, span, msg);\n    };\n    return TreeError;\n}(ParseError));\nvar ParseTreeResult = /** @class */ (function () {\n    function ParseTreeResult(rootNodes, errors) {\n        this.rootNodes = rootNodes;\n        this.errors = errors;\n    }\n    return ParseTreeResult;\n}());\nvar Parser$1 = /** @class */ (function () {\n    function Parser(getTagDefinition) {\n        this.getTagDefinition = getTagDefinition;\n    }\n    /**\n     * @param {?} source\n     * @param {?} url\n     * @param {?=} parseExpansionForms\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    Parser.prototype.parse = /**\n     * @param {?} source\n     * @param {?} url\n     * @param {?=} parseExpansionForms\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    function (source, url, parseExpansionForms, interpolationConfig) {\n        if (parseExpansionForms === void 0) { parseExpansionForms = false; }\n        if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        var /** @type {?} */ tokensAndErrors = tokenize(source, url, this.getTagDefinition, parseExpansionForms, interpolationConfig);\n        var /** @type {?} */ treeAndErrors = new _TreeBuilder(tokensAndErrors.tokens, this.getTagDefinition).build();\n        return new ParseTreeResult(treeAndErrors.rootNodes, (/** @type {?} */ (tokensAndErrors.errors)).concat(treeAndErrors.errors));\n    };\n    return Parser;\n}());\nvar _TreeBuilder = /** @class */ (function () {\n    function _TreeBuilder(tokens, getTagDefinition) {\n        this.tokens = tokens;\n        this.getTagDefinition = getTagDefinition;\n        this._index = -1;\n        this._rootNodes = [];\n        this._errors = [];\n        this._elementStack = [];\n        this._advance();\n    }\n    /**\n     * @return {?}\n     */\n    _TreeBuilder.prototype.build = /**\n     * @return {?}\n     */\n    function () {\n        while (this._peek.type !== TokenType$1.EOF) {\n            if (this._peek.type === TokenType$1.TAG_OPEN_START) {\n                this._consumeStartTag(this._advance());\n            }\n            else if (this._peek.type === TokenType$1.TAG_CLOSE) {\n                this._consumeEndTag(this._advance());\n            }\n            else if (this._peek.type === TokenType$1.CDATA_START) {\n                this._closeVoidElement();\n                this._consumeCdata(this._advance());\n            }\n            else if (this._peek.type === TokenType$1.COMMENT_START) {\n                this._closeVoidElement();\n                this._consumeComment(this._advance());\n            }\n            else if (this._peek.type === TokenType$1.TEXT || this._peek.type === TokenType$1.RAW_TEXT ||\n                this._peek.type === TokenType$1.ESCAPABLE_RAW_TEXT) {\n                this._closeVoidElement();\n                this._consumeText(this._advance());\n            }\n            else if (this._peek.type === TokenType$1.EXPANSION_FORM_START) {\n                this._consumeExpansion(this._advance());\n            }\n            else {\n                // Skip all other tokens...\n                this._advance();\n            }\n        }\n        return new ParseTreeResult(this._rootNodes, this._errors);\n    };\n    /**\n     * @return {?}\n     */\n    _TreeBuilder.prototype._advance = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ prev = this._peek;\n        if (this._index < this.tokens.length - 1) {\n            // Note: there is always an EOF token at the end\n            this._index++;\n        }\n        this._peek = this.tokens[this._index];\n        return prev;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    _TreeBuilder.prototype._advanceIf = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        if (this._peek.type === type) {\n            return this._advance();\n        }\n        return null;\n    };\n    /**\n     * @param {?} startToken\n     * @return {?}\n     */\n    _TreeBuilder.prototype._consumeCdata = /**\n     * @param {?} startToken\n     * @return {?}\n     */\n    function (startToken) {\n        this._consumeText(this._advance());\n        this._advanceIf(TokenType$1.CDATA_END);\n    };\n    /**\n     * @param {?} token\n     * @return {?}\n     */\n    _TreeBuilder.prototype._consumeComment = /**\n     * @param {?} token\n     * @return {?}\n     */\n    function (token) {\n        var /** @type {?} */ text = this._advanceIf(TokenType$1.RAW_TEXT);\n        this._advanceIf(TokenType$1.COMMENT_END);\n        var /** @type {?} */ value = text != null ? text.parts[0].trim() : null;\n        this._addToParent(new Comment(value, token.sourceSpan));\n    };\n    /**\n     * @param {?} token\n     * @return {?}\n     */\n    _TreeBuilder.prototype._consumeExpansion = /**\n     * @param {?} token\n     * @return {?}\n     */\n    function (token) {\n        var /** @type {?} */ switchValue = this._advance();\n        var /** @type {?} */ type = this._advance();\n        var /** @type {?} */ cases = [];\n        // read =\n        while (this._peek.type === TokenType$1.EXPANSION_CASE_VALUE) {\n            var /** @type {?} */ expCase = this._parseExpansionCase();\n            if (!expCase)\n                return; // error\n            cases.push(expCase);\n        }\n        // read the final }\n        if (this._peek.type !== TokenType$1.EXPANSION_FORM_END) {\n            this._errors.push(TreeError.create(null, this._peek.sourceSpan, \"Invalid ICU message. Missing '}'.\"));\n            return;\n        }\n        var /** @type {?} */ sourceSpan = new ParseSourceSpan(token.sourceSpan.start, this._peek.sourceSpan.end);\n        this._addToParent(new Expansion(switchValue.parts[0], type.parts[0], cases, sourceSpan, switchValue.sourceSpan));\n        this._advance();\n    };\n    /**\n     * @return {?}\n     */\n    _TreeBuilder.prototype._parseExpansionCase = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ value = this._advance();\n        // read {\n        if (this._peek.type !== TokenType$1.EXPANSION_CASE_EXP_START) {\n            this._errors.push(TreeError.create(null, this._peek.sourceSpan, \"Invalid ICU message. Missing '{'.\"));\n            return null;\n        }\n        // read until }\n        var /** @type {?} */ start = this._advance();\n        var /** @type {?} */ exp = this._collectExpansionExpTokens(start);\n        if (!exp)\n            return null;\n        var /** @type {?} */ end = this._advance();\n        exp.push(new Token$1(TokenType$1.EOF, [], end.sourceSpan));\n        // parse everything in between { and }\n        var /** @type {?} */ parsedExp = new _TreeBuilder(exp, this.getTagDefinition).build();\n        if (parsedExp.errors.length > 0) {\n            this._errors = this._errors.concat(/** @type {?} */ (parsedExp.errors));\n            return null;\n        }\n        var /** @type {?} */ sourceSpan = new ParseSourceSpan(value.sourceSpan.start, end.sourceSpan.end);\n        var /** @type {?} */ expSourceSpan = new ParseSourceSpan(start.sourceSpan.start, end.sourceSpan.end);\n        return new ExpansionCase(value.parts[0], parsedExp.rootNodes, sourceSpan, value.sourceSpan, expSourceSpan);\n    };\n    /**\n     * @param {?} start\n     * @return {?}\n     */\n    _TreeBuilder.prototype._collectExpansionExpTokens = /**\n     * @param {?} start\n     * @return {?}\n     */\n    function (start) {\n        var /** @type {?} */ exp = [];\n        var /** @type {?} */ expansionFormStack = [TokenType$1.EXPANSION_CASE_EXP_START];\n        while (true) {\n            if (this._peek.type === TokenType$1.EXPANSION_FORM_START ||\n                this._peek.type === TokenType$1.EXPANSION_CASE_EXP_START) {\n                expansionFormStack.push(this._peek.type);\n            }\n            if (this._peek.type === TokenType$1.EXPANSION_CASE_EXP_END) {\n                if (lastOnStack(expansionFormStack, TokenType$1.EXPANSION_CASE_EXP_START)) {\n                    expansionFormStack.pop();\n                    if (expansionFormStack.length == 0)\n                        return exp;\n                }\n                else {\n                    this._errors.push(TreeError.create(null, start.sourceSpan, \"Invalid ICU message. Missing '}'.\"));\n                    return null;\n                }\n            }\n            if (this._peek.type === TokenType$1.EXPANSION_FORM_END) {\n                if (lastOnStack(expansionFormStack, TokenType$1.EXPANSION_FORM_START)) {\n                    expansionFormStack.pop();\n                }\n                else {\n                    this._errors.push(TreeError.create(null, start.sourceSpan, \"Invalid ICU message. Missing '}'.\"));\n                    return null;\n                }\n            }\n            if (this._peek.type === TokenType$1.EOF) {\n                this._errors.push(TreeError.create(null, start.sourceSpan, \"Invalid ICU message. Missing '}'.\"));\n                return null;\n            }\n            exp.push(this._advance());\n        }\n    };\n    /**\n     * @param {?} token\n     * @return {?}\n     */\n    _TreeBuilder.prototype._consumeText = /**\n     * @param {?} token\n     * @return {?}\n     */\n    function (token) {\n        var /** @type {?} */ text = token.parts[0];\n        if (text.length > 0 && text[0] == '\\n') {\n            var /** @type {?} */ parent_1 = this._getParentElement();\n            if (parent_1 != null && parent_1.children.length == 0 &&\n                this.getTagDefinition(parent_1.name).ignoreFirstLf) {\n                text = text.substring(1);\n            }\n        }\n        if (text.length > 0) {\n            this._addToParent(new Text(text, token.sourceSpan));\n        }\n    };\n    /**\n     * @return {?}\n     */\n    _TreeBuilder.prototype._closeVoidElement = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ el = this._getParentElement();\n        if (el && this.getTagDefinition(el.name).isVoid) {\n            this._elementStack.pop();\n        }\n    };\n    /**\n     * @param {?} startTagToken\n     * @return {?}\n     */\n    _TreeBuilder.prototype._consumeStartTag = /**\n     * @param {?} startTagToken\n     * @return {?}\n     */\n    function (startTagToken) {\n        var /** @type {?} */ prefix = startTagToken.parts[0];\n        var /** @type {?} */ name = startTagToken.parts[1];\n        var /** @type {?} */ attrs = [];\n        while (this._peek.type === TokenType$1.ATTR_NAME) {\n            attrs.push(this._consumeAttr(this._advance()));\n        }\n        var /** @type {?} */ fullName = this._getElementFullName(prefix, name, this._getParentElement());\n        var /** @type {?} */ selfClosing = false;\n        // Note: There could have been a tokenizer error\n        // so that we don't get a token for the end tag...\n        if (this._peek.type === TokenType$1.TAG_OPEN_END_VOID) {\n            this._advance();\n            selfClosing = true;\n            var /** @type {?} */ tagDef = this.getTagDefinition(fullName);\n            if (!(tagDef.canSelfClose || getNsPrefix(fullName) !== null || tagDef.isVoid)) {\n                this._errors.push(TreeError.create(fullName, startTagToken.sourceSpan, \"Only void and foreign elements can be self closed \\\"\" + startTagToken.parts[1] + \"\\\"\"));\n            }\n        }\n        else if (this._peek.type === TokenType$1.TAG_OPEN_END) {\n            this._advance();\n            selfClosing = false;\n        }\n        var /** @type {?} */ end = this._peek.sourceSpan.start;\n        var /** @type {?} */ span = new ParseSourceSpan(startTagToken.sourceSpan.start, end);\n        var /** @type {?} */ el = new Element(fullName, attrs, [], span, span, undefined);\n        this._pushElement(el);\n        if (selfClosing) {\n            this._popElement(fullName);\n            el.endSourceSpan = span;\n        }\n    };\n    /**\n     * @param {?} el\n     * @return {?}\n     */\n    _TreeBuilder.prototype._pushElement = /**\n     * @param {?} el\n     * @return {?}\n     */\n    function (el) {\n        var /** @type {?} */ parentEl = this._getParentElement();\n        if (parentEl && this.getTagDefinition(parentEl.name).isClosedByChild(el.name)) {\n            this._elementStack.pop();\n        }\n        var /** @type {?} */ tagDef = this.getTagDefinition(el.name);\n        var _a = this._getParentElementSkippingContainers(), parent = _a.parent, container = _a.container;\n        if (parent && tagDef.requireExtraParent(parent.name)) {\n            var /** @type {?} */ newParent = new Element(tagDef.parentToAdd, [], [], el.sourceSpan, el.startSourceSpan, el.endSourceSpan);\n            this._insertBeforeContainer(parent, container, newParent);\n        }\n        this._addToParent(el);\n        this._elementStack.push(el);\n    };\n    /**\n     * @param {?} endTagToken\n     * @return {?}\n     */\n    _TreeBuilder.prototype._consumeEndTag = /**\n     * @param {?} endTagToken\n     * @return {?}\n     */\n    function (endTagToken) {\n        var /** @type {?} */ fullName = this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());\n        if (this._getParentElement()) {\n            /** @type {?} */ ((this._getParentElement())).endSourceSpan = endTagToken.sourceSpan;\n        }\n        if (this.getTagDefinition(fullName).isVoid) {\n            this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, \"Void elements do not have end tags \\\"\" + endTagToken.parts[1] + \"\\\"\"));\n        }\n        else if (!this._popElement(fullName)) {\n            var /** @type {?} */ errMsg = \"Unexpected closing tag \\\"\" + fullName + \"\\\". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags\";\n            this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, errMsg));\n        }\n    };\n    /**\n     * @param {?} fullName\n     * @return {?}\n     */\n    _TreeBuilder.prototype._popElement = /**\n     * @param {?} fullName\n     * @return {?}\n     */\n    function (fullName) {\n        for (var /** @type {?} */ stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {\n            var /** @type {?} */ el = this._elementStack[stackIndex];\n            if (el.name == fullName) {\n                this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);\n                return true;\n            }\n            if (!this.getTagDefinition(el.name).closedByParent) {\n                return false;\n            }\n        }\n        return false;\n    };\n    /**\n     * @param {?} attrName\n     * @return {?}\n     */\n    _TreeBuilder.prototype._consumeAttr = /**\n     * @param {?} attrName\n     * @return {?}\n     */\n    function (attrName) {\n        var /** @type {?} */ fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]);\n        var /** @type {?} */ end = attrName.sourceSpan.end;\n        var /** @type {?} */ value = '';\n        var /** @type {?} */ valueSpan = /** @type {?} */ ((undefined));\n        if (this._peek.type === TokenType$1.ATTR_VALUE) {\n            var /** @type {?} */ valueToken = this._advance();\n            value = valueToken.parts[0];\n            end = valueToken.sourceSpan.end;\n            valueSpan = valueToken.sourceSpan;\n        }\n        return new Attribute$1(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, end), valueSpan);\n    };\n    /**\n     * @return {?}\n     */\n    _TreeBuilder.prototype._getParentElement = /**\n     * @return {?}\n     */\n    function () {\n        return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;\n    };\n    /**\n     * Returns the parent in the DOM and the container.\n     *\n     * `<ng-container>` elements are skipped as they are not rendered as DOM element.\n     * @return {?}\n     */\n    _TreeBuilder.prototype._getParentElementSkippingContainers = /**\n     * Returns the parent in the DOM and the container.\n     *\n     * `<ng-container>` elements are skipped as they are not rendered as DOM element.\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ container = null;\n        for (var /** @type {?} */ i = this._elementStack.length - 1; i >= 0; i--) {\n            if (!isNgContainer(this._elementStack[i].name)) {\n                return { parent: this._elementStack[i], container: container };\n            }\n            container = this._elementStack[i];\n        }\n        return { parent: null, container: container };\n    };\n    /**\n     * @param {?} node\n     * @return {?}\n     */\n    _TreeBuilder.prototype._addToParent = /**\n     * @param {?} node\n     * @return {?}\n     */\n    function (node) {\n        var /** @type {?} */ parent = this._getParentElement();\n        if (parent != null) {\n            parent.children.push(node);\n        }\n        else {\n            this._rootNodes.push(node);\n        }\n    };\n    /**\n     * Insert a node between the parent and the container.\n     * When no container is given, the node is appended as a child of the parent.\n     * Also updates the element stack accordingly.\n     *\n     * \\@internal\n     * @param {?} parent\n     * @param {?} container\n     * @param {?} node\n     * @return {?}\n     */\n    _TreeBuilder.prototype._insertBeforeContainer = /**\n     * Insert a node between the parent and the container.\n     * When no container is given, the node is appended as a child of the parent.\n     * Also updates the element stack accordingly.\n     *\n     * \\@internal\n     * @param {?} parent\n     * @param {?} container\n     * @param {?} node\n     * @return {?}\n     */\n    function (parent, container, node) {\n        if (!container) {\n            this._addToParent(node);\n            this._elementStack.push(node);\n        }\n        else {\n            if (parent) {\n                // replace the container with the new node in the children\n                var /** @type {?} */ index = parent.children.indexOf(container);\n                parent.children[index] = node;\n            }\n            else {\n                this._rootNodes.push(node);\n            }\n            node.children.push(container);\n            this._elementStack.splice(this._elementStack.indexOf(container), 0, node);\n        }\n    };\n    /**\n     * @param {?} prefix\n     * @param {?} localName\n     * @param {?} parentElement\n     * @return {?}\n     */\n    _TreeBuilder.prototype._getElementFullName = /**\n     * @param {?} prefix\n     * @param {?} localName\n     * @param {?} parentElement\n     * @return {?}\n     */\n    function (prefix, localName, parentElement) {\n        if (prefix == null) {\n            prefix = /** @type {?} */ ((this.getTagDefinition(localName).implicitNamespacePrefix));\n            if (prefix == null && parentElement != null) {\n                prefix = getNsPrefix(parentElement.name);\n            }\n        }\n        return mergeNsAndName(prefix, localName);\n    };\n    return _TreeBuilder;\n}());\n/**\n * @param {?} stack\n * @param {?} element\n * @return {?}\n */\nfunction lastOnStack(stack, element) {\n    return stack.length > 0 && stack[stack.length - 1] === element;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @param {?} message\n * @return {?}\n */\nfunction digest(message) {\n    return message.id || sha1(serializeNodes(message.nodes).join('') + (\"[\" + message.meaning + \"]\"));\n}\n/**\n * @param {?} message\n * @return {?}\n */\nfunction decimalDigest(message) {\n    if (message.id) {\n        return message.id;\n    }\n    var /** @type {?} */ visitor = new _SerializerIgnoreIcuExpVisitor();\n    var /** @type {?} */ parts = message.nodes.map(function (a) { return a.visit(visitor, null); });\n    return computeMsgId(parts.join(''), message.meaning);\n}\n/**\n * Serialize the i18n ast to something xml-like in order to generate an UID.\n *\n * The visitor is also used in the i18n parser tests\n *\n * \\@internal\n */\nvar _SerializerVisitor = /** @class */ (function () {\n    function _SerializerVisitor() {\n    }\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    _SerializerVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) { return text.value; };\n    /**\n     * @param {?} container\n     * @param {?} context\n     * @return {?}\n     */\n    _SerializerVisitor.prototype.visitContainer = /**\n     * @param {?} container\n     * @param {?} context\n     * @return {?}\n     */\n    function (container, context) {\n        var _this = this;\n        return \"[\" + container.children.map(function (child) { return child.visit(_this); }).join(', ') + \"]\";\n    };\n    /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    _SerializerVisitor.prototype.visitIcu = /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        var /** @type {?} */ strCases = Object.keys(icu.cases).map(function (k) { return k + \" {\" + icu.cases[k].visit(_this) + \"}\"; });\n        return \"{\" + icu.expression + \", \" + icu.type + \", \" + strCases.join(', ') + \"}\";\n    };\n    /**\n     * @param {?} ph\n     * @param {?} context\n     * @return {?}\n     */\n    _SerializerVisitor.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var _this = this;\n        return ph.isVoid ?\n            \"<ph tag name=\\\"\" + ph.startName + \"\\\"/>\" :\n            \"<ph tag name=\\\"\" + ph.startName + \"\\\">\" + ph.children.map(function (child) { return child.visit(_this); }).join(', ') + \"</ph name=\\\"\" + ph.closeName + \"\\\">\";\n    };\n    /**\n     * @param {?} ph\n     * @param {?} context\n     * @return {?}\n     */\n    _SerializerVisitor.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?} context\n     * @return {?}\n     */\n    function (ph, context) {\n        return ph.value ? \"<ph name=\\\"\" + ph.name + \"\\\">\" + ph.value + \"</ph>\" : \"<ph name=\\\"\" + ph.name + \"\\\"/>\";\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _SerializerVisitor.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        return \"<ph icu name=\\\"\" + ph.name + \"\\\">\" + ph.value.visit(this) + \"</ph>\";\n    };\n    return _SerializerVisitor;\n}());\nvar serializerVisitor = new _SerializerVisitor();\n/**\n * @param {?} nodes\n * @return {?}\n */\nfunction serializeNodes(nodes) {\n    return nodes.map(function (a) { return a.visit(serializerVisitor, null); });\n}\n/**\n * Serialize the i18n ast to something xml-like in order to generate an UID.\n *\n * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.\n *\n * \\@internal\n */\nvar _SerializerIgnoreIcuExpVisitor = /** @class */ (function (_super) {\n    __extends(_SerializerIgnoreIcuExpVisitor, _super);\n    function _SerializerIgnoreIcuExpVisitor() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    _SerializerIgnoreIcuExpVisitor.prototype.visitIcu = /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        var /** @type {?} */ strCases = Object.keys(icu.cases).map(function (k) { return k + \" {\" + icu.cases[k].visit(_this) + \"}\"; });\n        // Do not take the expression into account\n        return \"{\" + icu.type + \", \" + strCases.join(', ') + \"}\";\n    };\n    return _SerializerIgnoreIcuExpVisitor;\n}(_SerializerVisitor));\n/**\n * Compute the SHA1 of the given string\n *\n * see http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf\n *\n * WARNING: this function has not been designed not tested with security in mind.\n *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.\n * @param {?} str\n * @return {?}\n */\nfunction sha1(str) {\n    var /** @type {?} */ utf8 = utf8Encode(str);\n    var /** @type {?} */ words32 = stringToWords32(utf8, Endian.Big);\n    var /** @type {?} */ len = utf8.length * 8;\n    var /** @type {?} */ w = new Array(80);\n    var _a = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0], a = _a[0], b = _a[1], c = _a[2], d = _a[3], e = _a[4];\n    words32[len >> 5] |= 0x80 << (24 - len % 32);\n    words32[((len + 64 >> 9) << 4) + 15] = len;\n    for (var /** @type {?} */ i = 0; i < words32.length; i += 16) {\n        var _b = [a, b, c, d, e], h0 = _b[0], h1 = _b[1], h2 = _b[2], h3 = _b[3], h4 = _b[4];\n        for (var /** @type {?} */ j = 0; j < 80; j++) {\n            if (j < 16) {\n                w[j] = words32[i + j];\n            }\n            else {\n                w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);\n            }\n            var _c = fk(j, b, c, d), f = _c[0], k = _c[1];\n            var /** @type {?} */ temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);\n            _d = [d, c, rol32(b, 30), a, temp], e = _d[0], d = _d[1], c = _d[2], b = _d[3], a = _d[4];\n        }\n        _e = [add32(a, h0), add32(b, h1), add32(c, h2), add32(d, h3), add32(e, h4)], a = _e[0], b = _e[1], c = _e[2], d = _e[3], e = _e[4];\n    }\n    return byteStringToHexString(words32ToByteString([a, b, c, d, e]));\n    var _d, _e;\n}\n/**\n * @param {?} index\n * @param {?} b\n * @param {?} c\n * @param {?} d\n * @return {?}\n */\nfunction fk(index, b, c, d) {\n    if (index < 20) {\n        return [(b & c) | (~b & d), 0x5a827999];\n    }\n    if (index < 40) {\n        return [b ^ c ^ d, 0x6ed9eba1];\n    }\n    if (index < 60) {\n        return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc];\n    }\n    return [b ^ c ^ d, 0xca62c1d6];\n}\n/**\n * Compute the fingerprint of the given string\n *\n * The output is 64 bit number encoded as a decimal string\n *\n * based on:\n * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java\n * @param {?} str\n * @return {?}\n */\nfunction fingerprint(str) {\n    var /** @type {?} */ utf8 = utf8Encode(str);\n    var _a = [hash32(utf8, 0), hash32(utf8, 102072)], hi = _a[0], lo = _a[1];\n    if (hi == 0 && (lo == 0 || lo == 1)) {\n        hi = hi ^ 0x130f9bef;\n        lo = lo ^ -0x6b5f56d8;\n    }\n    return [hi, lo];\n}\n/**\n * @param {?} msg\n * @param {?} meaning\n * @return {?}\n */\nfunction computeMsgId(msg, meaning) {\n    var _a = fingerprint(msg), hi = _a[0], lo = _a[1];\n    if (meaning) {\n        var _b = fingerprint(meaning), him = _b[0], lom = _b[1];\n        _c = add64(rol64([hi, lo], 1), [him, lom]), hi = _c[0], lo = _c[1];\n    }\n    return byteStringToDecString(words32ToByteString([hi & 0x7fffffff, lo]));\n    var _c;\n}\n/**\n * @param {?} str\n * @param {?} c\n * @return {?}\n */\nfunction hash32(str, c) {\n    var _a = [0x9e3779b9, 0x9e3779b9], a = _a[0], b = _a[1];\n    var /** @type {?} */ i;\n    var /** @type {?} */ len = str.length;\n    for (i = 0; i + 12 <= len; i += 12) {\n        a = add32(a, wordAt(str, i, Endian.Little));\n        b = add32(b, wordAt(str, i + 4, Endian.Little));\n        c = add32(c, wordAt(str, i + 8, Endian.Little));\n        _b = mix([a, b, c]), a = _b[0], b = _b[1], c = _b[2];\n    }\n    a = add32(a, wordAt(str, i, Endian.Little));\n    b = add32(b, wordAt(str, i + 4, Endian.Little));\n    // the first byte of c is reserved for the length\n    c = add32(c, len);\n    c = add32(c, wordAt(str, i + 8, Endian.Little) << 8);\n    return mix([a, b, c])[2];\n    var _b;\n}\n/**\n * @param {?} __0\n * @return {?}\n */\nfunction mix(_a) {\n    var a = _a[0], b = _a[1], c = _a[2];\n    a = sub32(a, b);\n    a = sub32(a, c);\n    a ^= c >>> 13;\n    b = sub32(b, c);\n    b = sub32(b, a);\n    b ^= a << 8;\n    c = sub32(c, a);\n    c = sub32(c, b);\n    c ^= b >>> 13;\n    a = sub32(a, b);\n    a = sub32(a, c);\n    a ^= c >>> 12;\n    b = sub32(b, c);\n    b = sub32(b, a);\n    b ^= a << 16;\n    c = sub32(c, a);\n    c = sub32(c, b);\n    c ^= b >>> 5;\n    a = sub32(a, b);\n    a = sub32(a, c);\n    a ^= c >>> 3;\n    b = sub32(b, c);\n    b = sub32(b, a);\n    b ^= a << 10;\n    c = sub32(c, a);\n    c = sub32(c, b);\n    c ^= b >>> 15;\n    return [a, b, c];\n}\n/** @enum {number} */\nvar Endian = {\n    Little: 0,\n    Big: 1,\n};\nEndian[Endian.Little] = \"Little\";\nEndian[Endian.Big] = \"Big\";\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction add32(a, b) {\n    return add32to64(a, b)[1];\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction add32to64(a, b) {\n    var /** @type {?} */ low = (a & 0xffff) + (b & 0xffff);\n    var /** @type {?} */ high = (a >>> 16) + (b >>> 16) + (low >>> 16);\n    return [high >>> 16, (high << 16) | (low & 0xffff)];\n}\n/**\n * @param {?} __0\n * @param {?} __1\n * @return {?}\n */\nfunction add64(_a, _b) {\n    var ah = _a[0], al = _a[1];\n    var bh = _b[0], bl = _b[1];\n    var _c = add32to64(al, bl), carry = _c[0], l = _c[1];\n    var /** @type {?} */ h = add32(add32(ah, bh), carry);\n    return [h, l];\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction sub32(a, b) {\n    var /** @type {?} */ low = (a & 0xffff) - (b & 0xffff);\n    var /** @type {?} */ high = (a >> 16) - (b >> 16) + (low >> 16);\n    return (high << 16) | (low & 0xffff);\n}\n/**\n * @param {?} a\n * @param {?} count\n * @return {?}\n */\nfunction rol32(a, count) {\n    return (a << count) | (a >>> (32 - count));\n}\n/**\n * @param {?} __0\n * @param {?} count\n * @return {?}\n */\nfunction rol64(_a, count) {\n    var hi = _a[0], lo = _a[1];\n    var /** @type {?} */ h = (hi << count) | (lo >>> (32 - count));\n    var /** @type {?} */ l = (lo << count) | (hi >>> (32 - count));\n    return [h, l];\n}\n/**\n * @param {?} str\n * @param {?} endian\n * @return {?}\n */\nfunction stringToWords32(str, endian) {\n    var /** @type {?} */ words32 = Array((str.length + 3) >>> 2);\n    for (var /** @type {?} */ i = 0; i < words32.length; i++) {\n        words32[i] = wordAt(str, i * 4, endian);\n    }\n    return words32;\n}\n/**\n * @param {?} str\n * @param {?} index\n * @return {?}\n */\nfunction byteAt(str, index) {\n    return index >= str.length ? 0 : str.charCodeAt(index) & 0xff;\n}\n/**\n * @param {?} str\n * @param {?} index\n * @param {?} endian\n * @return {?}\n */\nfunction wordAt(str, index, endian) {\n    var /** @type {?} */ word = 0;\n    if (endian === Endian.Big) {\n        for (var /** @type {?} */ i = 0; i < 4; i++) {\n            word += byteAt(str, index + i) << (24 - 8 * i);\n        }\n    }\n    else {\n        for (var /** @type {?} */ i = 0; i < 4; i++) {\n            word += byteAt(str, index + i) << 8 * i;\n        }\n    }\n    return word;\n}\n/**\n * @param {?} words32\n * @return {?}\n */\nfunction words32ToByteString(words32) {\n    return words32.reduce(function (str, word) { return str + word32ToByteString(word); }, '');\n}\n/**\n * @param {?} word\n * @return {?}\n */\nfunction word32ToByteString(word) {\n    var /** @type {?} */ str = '';\n    for (var /** @type {?} */ i = 0; i < 4; i++) {\n        str += String.fromCharCode((word >>> 8 * (3 - i)) & 0xff);\n    }\n    return str;\n}\n/**\n * @param {?} str\n * @return {?}\n */\nfunction byteStringToHexString(str) {\n    var /** @type {?} */ hex = '';\n    for (var /** @type {?} */ i = 0; i < str.length; i++) {\n        var /** @type {?} */ b = byteAt(str, i);\n        hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16);\n    }\n    return hex.toLowerCase();\n}\n/**\n * @param {?} str\n * @return {?}\n */\nfunction byteStringToDecString(str) {\n    var /** @type {?} */ decimal = '';\n    var /** @type {?} */ toThePower = '1';\n    for (var /** @type {?} */ i = str.length - 1; i >= 0; i--) {\n        decimal = addBigInt(decimal, numberTimesBigInt(byteAt(str, i), toThePower));\n        toThePower = numberTimesBigInt(256, toThePower);\n    }\n    return decimal.split('').reverse().join('');\n}\n/**\n * @param {?} x\n * @param {?} y\n * @return {?}\n */\nfunction addBigInt(x, y) {\n    var /** @type {?} */ sum = '';\n    var /** @type {?} */ len = Math.max(x.length, y.length);\n    for (var /** @type {?} */ i = 0, /** @type {?} */ carry = 0; i < len || carry; i++) {\n        var /** @type {?} */ tmpSum = carry + +(x[i] || 0) + +(y[i] || 0);\n        if (tmpSum >= 10) {\n            carry = 1;\n            sum += tmpSum - 10;\n        }\n        else {\n            carry = 0;\n            sum += tmpSum;\n        }\n    }\n    return sum;\n}\n/**\n * @param {?} num\n * @param {?} b\n * @return {?}\n */\nfunction numberTimesBigInt(num, b) {\n    var /** @type {?} */ product = '';\n    var /** @type {?} */ bToThePower = b;\n    for (; num !== 0; num = num >>> 1) {\n        if (num & 1)\n            product = addBigInt(product, bToThePower);\n        bToThePower = addBigInt(bToThePower, bToThePower);\n    }\n    return product;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar Message = /** @class */ (function () {\n    /**\n     * @param nodes message AST\n     * @param placeholders maps placeholder names to static content\n     * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)\n     * @param meaning\n     * @param description\n     * @param id\n     */\n    function Message(nodes, placeholders, placeholderToMessage, meaning, description, id) {\n        this.nodes = nodes;\n        this.placeholders = placeholders;\n        this.placeholderToMessage = placeholderToMessage;\n        this.meaning = meaning;\n        this.description = description;\n        this.id = id;\n        if (nodes.length) {\n            this.sources = [{\n                    filePath: nodes[0].sourceSpan.start.file.url,\n                    startLine: nodes[0].sourceSpan.start.line + 1,\n                    startCol: nodes[0].sourceSpan.start.col + 1,\n                    endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1,\n                    endCol: nodes[0].sourceSpan.start.col + 1\n                }];\n        }\n        else {\n            this.sources = [];\n        }\n    }\n    return Message;\n}());\n/**\n * @record\n */\n\n/**\n * @record\n */\n\nvar Text$1 = /** @class */ (function () {\n    function Text(value, sourceSpan) {\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Text.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitText(this, context); };\n    return Text;\n}());\nvar Container = /** @class */ (function () {\n    function Container(children, sourceSpan) {\n        this.children = children;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Container.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitContainer(this, context); };\n    return Container;\n}());\nvar Icu = /** @class */ (function () {\n    function Icu(expression, type, cases, sourceSpan) {\n        this.expression = expression;\n        this.type = type;\n        this.cases = cases;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Icu.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitIcu(this, context); };\n    return Icu;\n}());\nvar TagPlaceholder = /** @class */ (function () {\n    function TagPlaceholder(tag, attrs, startName, closeName, children, isVoid, sourceSpan) {\n        this.tag = tag;\n        this.attrs = attrs;\n        this.startName = startName;\n        this.closeName = closeName;\n        this.children = children;\n        this.isVoid = isVoid;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    TagPlaceholder.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitTagPlaceholder(this, context); };\n    return TagPlaceholder;\n}());\nvar Placeholder = /** @class */ (function () {\n    function Placeholder(value, name, sourceSpan) {\n        this.value = value;\n        this.name = name;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    Placeholder.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitPlaceholder(this, context); };\n    return Placeholder;\n}());\nvar IcuPlaceholder = /** @class */ (function () {\n    function IcuPlaceholder(value, name, sourceSpan) {\n        this.value = value;\n        this.name = name;\n        this.sourceSpan = sourceSpan;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    IcuPlaceholder.prototype.visit = /**\n     * @param {?} visitor\n     * @param {?=} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitIcuPlaceholder(this, context); };\n    return IcuPlaceholder;\n}());\n/**\n * @record\n */\n\nvar CloneVisitor = /** @class */ (function () {\n    function CloneVisitor() {\n    }\n    /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    CloneVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    function (text, context) { return new Text$1(text.value, text.sourceSpan); };\n    /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    CloneVisitor.prototype.visitContainer = /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    function (container, context) {\n        var _this = this;\n        var /** @type {?} */ children = container.children.map(function (n) { return n.visit(_this, context); });\n        return new Container(children, container.sourceSpan);\n    };\n    /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    CloneVisitor.prototype.visitIcu = /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        var /** @type {?} */ cases = {};\n        Object.keys(icu.cases).forEach(function (key) { return cases[key] = icu.cases[key].visit(_this, context); });\n        var /** @type {?} */ msg = new Icu(icu.expression, icu.type, cases, icu.sourceSpan);\n        msg.expressionPlaceholder = icu.expressionPlaceholder;\n        return msg;\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    CloneVisitor.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var _this = this;\n        var /** @type {?} */ children = ph.children.map(function (n) { return n.visit(_this, context); });\n        return new TagPlaceholder(ph.tag, ph.attrs, ph.startName, ph.closeName, children, ph.isVoid, ph.sourceSpan);\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    CloneVisitor.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        return new Placeholder(ph.value, ph.name, ph.sourceSpan);\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    CloneVisitor.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        return new IcuPlaceholder(ph.value, ph.name, ph.sourceSpan);\n    };\n    return CloneVisitor;\n}());\nvar RecurseVisitor = /** @class */ (function () {\n    function RecurseVisitor() {\n    }\n    /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    RecurseVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    function (text, context) { };\n    /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    RecurseVisitor.prototype.visitContainer = /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    function (container, context) {\n        var _this = this;\n        container.children.forEach(function (child) { return child.visit(_this); });\n    };\n    /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    RecurseVisitor.prototype.visitIcu = /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        Object.keys(icu.cases).forEach(function (k) { icu.cases[k].visit(_this); });\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    RecurseVisitor.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var _this = this;\n        ph.children.forEach(function (child) { return child.visit(_this); });\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    RecurseVisitor.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) { };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    RecurseVisitor.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) { };\n    return RecurseVisitor;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar HtmlTagDefinition = /** @class */ (function () {\n    function HtmlTagDefinition(_a) {\n        var _b = _a === void 0 ? {} : _a, closedByChildren = _b.closedByChildren, requiredParents = _b.requiredParents, implicitNamespacePrefix = _b.implicitNamespacePrefix, _c = _b.contentType, contentType = _c === void 0 ? TagContentType.PARSABLE_DATA : _c, _d = _b.closedByParent, closedByParent = _d === void 0 ? false : _d, _e = _b.isVoid, isVoid = _e === void 0 ? false : _e, _f = _b.ignoreFirstLf, ignoreFirstLf = _f === void 0 ? false : _f;\n        var _this = this;\n        this.closedByChildren = {};\n        this.closedByParent = false;\n        this.canSelfClose = false;\n        if (closedByChildren && closedByChildren.length > 0) {\n            closedByChildren.forEach(function (tagName) { return _this.closedByChildren[tagName] = true; });\n        }\n        this.isVoid = isVoid;\n        this.closedByParent = closedByParent || isVoid;\n        if (requiredParents && requiredParents.length > 0) {\n            this.requiredParents = {};\n            // The first parent is the list is automatically when none of the listed parents are present\n            this.parentToAdd = requiredParents[0];\n            requiredParents.forEach(function (tagName) { return _this.requiredParents[tagName] = true; });\n        }\n        this.implicitNamespacePrefix = implicitNamespacePrefix || null;\n        this.contentType = contentType;\n        this.ignoreFirstLf = ignoreFirstLf;\n    }\n    /**\n     * @param {?} currentParent\n     * @return {?}\n     */\n    HtmlTagDefinition.prototype.requireExtraParent = /**\n     * @param {?} currentParent\n     * @return {?}\n     */\n    function (currentParent) {\n        if (!this.requiredParents) {\n            return false;\n        }\n        if (!currentParent) {\n            return true;\n        }\n        var /** @type {?} */ lcParent = currentParent.toLowerCase();\n        var /** @type {?} */ isParentTemplate = lcParent === 'template' || currentParent === 'ng-template';\n        return !isParentTemplate && this.requiredParents[lcParent] != true;\n    };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    HtmlTagDefinition.prototype.isClosedByChild = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        return this.isVoid || name.toLowerCase() in this.closedByChildren;\n    };\n    return HtmlTagDefinition;\n}());\n// see http://www.w3.org/TR/html51/syntax.html#optional-tags\n// This implementation does not fully conform to the HTML5 spec.\nvar TAG_DEFINITIONS = {\n    'base': new HtmlTagDefinition({ isVoid: true }),\n    'meta': new HtmlTagDefinition({ isVoid: true }),\n    'area': new HtmlTagDefinition({ isVoid: true }),\n    'embed': new HtmlTagDefinition({ isVoid: true }),\n    'link': new HtmlTagDefinition({ isVoid: true }),\n    'img': new HtmlTagDefinition({ isVoid: true }),\n    'input': new HtmlTagDefinition({ isVoid: true }),\n    'param': new HtmlTagDefinition({ isVoid: true }),\n    'hr': new HtmlTagDefinition({ isVoid: true }),\n    'br': new HtmlTagDefinition({ isVoid: true }),\n    'source': new HtmlTagDefinition({ isVoid: true }),\n    'track': new HtmlTagDefinition({ isVoid: true }),\n    'wbr': new HtmlTagDefinition({ isVoid: true }),\n    'p': new HtmlTagDefinition({\n        closedByChildren: [\n            'address', 'article', 'aside', 'blockquote', 'div', 'dl', 'fieldset', 'footer', 'form',\n            'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr',\n            'main', 'nav', 'ol', 'p', 'pre', 'section', 'table', 'ul'\n        ],\n        closedByParent: true\n    }),\n    'thead': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'] }),\n    'tbody': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'], closedByParent: true }),\n    'tfoot': new HtmlTagDefinition({ closedByChildren: ['tbody'], closedByParent: true }),\n    'tr': new HtmlTagDefinition({\n        closedByChildren: ['tr'],\n        requiredParents: ['tbody', 'tfoot', 'thead'],\n        closedByParent: true\n    }),\n    'td': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),\n    'th': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),\n    'col': new HtmlTagDefinition({ requiredParents: ['colgroup'], isVoid: true }),\n    'svg': new HtmlTagDefinition({ implicitNamespacePrefix: 'svg' }),\n    'math': new HtmlTagDefinition({ implicitNamespacePrefix: 'math' }),\n    'li': new HtmlTagDefinition({ closedByChildren: ['li'], closedByParent: true }),\n    'dt': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'] }),\n    'dd': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'], closedByParent: true }),\n    'rb': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n    'rt': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n    'rtc': new HtmlTagDefinition({ closedByChildren: ['rb', 'rtc', 'rp'], closedByParent: true }),\n    'rp': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),\n    'optgroup': new HtmlTagDefinition({ closedByChildren: ['optgroup'], closedByParent: true }),\n    'option': new HtmlTagDefinition({ closedByChildren: ['option', 'optgroup'], closedByParent: true }),\n    'pre': new HtmlTagDefinition({ ignoreFirstLf: true }),\n    'listing': new HtmlTagDefinition({ ignoreFirstLf: true }),\n    'style': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),\n    'script': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),\n    'title': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT }),\n    'textarea': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),\n};\nvar _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();\n/**\n * @param {?} tagName\n * @return {?}\n */\nfunction getHtmlTagDefinition(tagName) {\n    return TAG_DEFINITIONS[tagName.toLowerCase()] || _DEFAULT_TAG_DEFINITION;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar TAG_TO_PLACEHOLDER_NAMES = {\n    'A': 'LINK',\n    'B': 'BOLD_TEXT',\n    'BR': 'LINE_BREAK',\n    'EM': 'EMPHASISED_TEXT',\n    'H1': 'HEADING_LEVEL1',\n    'H2': 'HEADING_LEVEL2',\n    'H3': 'HEADING_LEVEL3',\n    'H4': 'HEADING_LEVEL4',\n    'H5': 'HEADING_LEVEL5',\n    'H6': 'HEADING_LEVEL6',\n    'HR': 'HORIZONTAL_RULE',\n    'I': 'ITALIC_TEXT',\n    'LI': 'LIST_ITEM',\n    'LINK': 'MEDIA_LINK',\n    'OL': 'ORDERED_LIST',\n    'P': 'PARAGRAPH',\n    'Q': 'QUOTATION',\n    'S': 'STRIKETHROUGH_TEXT',\n    'SMALL': 'SMALL_TEXT',\n    'SUB': 'SUBSTRIPT',\n    'SUP': 'SUPERSCRIPT',\n    'TBODY': 'TABLE_BODY',\n    'TD': 'TABLE_CELL',\n    'TFOOT': 'TABLE_FOOTER',\n    'TH': 'TABLE_HEADER_CELL',\n    'THEAD': 'TABLE_HEADER',\n    'TR': 'TABLE_ROW',\n    'TT': 'MONOSPACED_TEXT',\n    'U': 'UNDERLINED_TEXT',\n    'UL': 'UNORDERED_LIST',\n};\n/**\n * Creates unique names for placeholder with different content.\n *\n * Returns the same placeholder name when the content is identical.\n */\nvar PlaceholderRegistry = /** @class */ (function () {\n    function PlaceholderRegistry() {\n        this._placeHolderNameCounts = {};\n        this._signatureToName = {};\n    }\n    /**\n     * @param {?} tag\n     * @param {?} attrs\n     * @param {?} isVoid\n     * @return {?}\n     */\n    PlaceholderRegistry.prototype.getStartTagPlaceholderName = /**\n     * @param {?} tag\n     * @param {?} attrs\n     * @param {?} isVoid\n     * @return {?}\n     */\n    function (tag, attrs, isVoid) {\n        var /** @type {?} */ signature = this._hashTag(tag, attrs, isVoid);\n        if (this._signatureToName[signature]) {\n            return this._signatureToName[signature];\n        }\n        var /** @type {?} */ upperTag = tag.toUpperCase();\n        var /** @type {?} */ baseName = TAG_TO_PLACEHOLDER_NAMES[upperTag] || \"TAG_\" + upperTag;\n        var /** @type {?} */ name = this._generateUniqueName(isVoid ? baseName : \"START_\" + baseName);\n        this._signatureToName[signature] = name;\n        return name;\n    };\n    /**\n     * @param {?} tag\n     * @return {?}\n     */\n    PlaceholderRegistry.prototype.getCloseTagPlaceholderName = /**\n     * @param {?} tag\n     * @return {?}\n     */\n    function (tag) {\n        var /** @type {?} */ signature = this._hashClosingTag(tag);\n        if (this._signatureToName[signature]) {\n            return this._signatureToName[signature];\n        }\n        var /** @type {?} */ upperTag = tag.toUpperCase();\n        var /** @type {?} */ baseName = TAG_TO_PLACEHOLDER_NAMES[upperTag] || \"TAG_\" + upperTag;\n        var /** @type {?} */ name = this._generateUniqueName(\"CLOSE_\" + baseName);\n        this._signatureToName[signature] = name;\n        return name;\n    };\n    /**\n     * @param {?} name\n     * @param {?} content\n     * @return {?}\n     */\n    PlaceholderRegistry.prototype.getPlaceholderName = /**\n     * @param {?} name\n     * @param {?} content\n     * @return {?}\n     */\n    function (name, content) {\n        var /** @type {?} */ upperName = name.toUpperCase();\n        var /** @type {?} */ signature = \"PH: \" + upperName + \"=\" + content;\n        if (this._signatureToName[signature]) {\n            return this._signatureToName[signature];\n        }\n        var /** @type {?} */ uniqueName = this._generateUniqueName(upperName);\n        this._signatureToName[signature] = uniqueName;\n        return uniqueName;\n    };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    PlaceholderRegistry.prototype.getUniquePlaceholder = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        return this._generateUniqueName(name.toUpperCase());\n    };\n    /**\n     * @param {?} tag\n     * @param {?} attrs\n     * @param {?} isVoid\n     * @return {?}\n     */\n    PlaceholderRegistry.prototype._hashTag = /**\n     * @param {?} tag\n     * @param {?} attrs\n     * @param {?} isVoid\n     * @return {?}\n     */\n    function (tag, attrs, isVoid) {\n        var /** @type {?} */ start = \"<\" + tag;\n        var /** @type {?} */ strAttrs = Object.keys(attrs).sort().map(function (name) { return \" \" + name + \"=\" + attrs[name]; }).join('');\n        var /** @type {?} */ end = isVoid ? '/>' : \"></\" + tag + \">\";\n        return start + strAttrs + end;\n    };\n    /**\n     * @param {?} tag\n     * @return {?}\n     */\n    PlaceholderRegistry.prototype._hashClosingTag = /**\n     * @param {?} tag\n     * @return {?}\n     */\n    function (tag) { return this._hashTag(\"/\" + tag, {}, false); };\n    /**\n     * @param {?} base\n     * @return {?}\n     */\n    PlaceholderRegistry.prototype._generateUniqueName = /**\n     * @param {?} base\n     * @return {?}\n     */\n    function (base) {\n        var /** @type {?} */ seen = this._placeHolderNameCounts.hasOwnProperty(base);\n        if (!seen) {\n            this._placeHolderNameCounts[base] = 1;\n            return base;\n        }\n        var /** @type {?} */ id = this._placeHolderNameCounts[base];\n        this._placeHolderNameCounts[base] = id + 1;\n        return base + \"_\" + id;\n    };\n    return PlaceholderRegistry;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _expParser = new Parser(new Lexer());\n/**\n * Returns a function converting html nodes to an i18n Message given an interpolationConfig\n * @param {?} interpolationConfig\n * @return {?}\n */\nfunction createI18nMessageFactory(interpolationConfig) {\n    var /** @type {?} */ visitor = new _I18nVisitor(_expParser, interpolationConfig);\n    return function (nodes, meaning, description, id) {\n        return visitor.toI18nMessage(nodes, meaning, description, id);\n    };\n}\nvar _I18nVisitor = /** @class */ (function () {\n    function _I18nVisitor(_expressionParser, _interpolationConfig) {\n        this._expressionParser = _expressionParser;\n        this._interpolationConfig = _interpolationConfig;\n    }\n    /**\n     * @param {?} nodes\n     * @param {?} meaning\n     * @param {?} description\n     * @param {?} id\n     * @return {?}\n     */\n    _I18nVisitor.prototype.toI18nMessage = /**\n     * @param {?} nodes\n     * @param {?} meaning\n     * @param {?} description\n     * @param {?} id\n     * @return {?}\n     */\n    function (nodes, meaning, description, id) {\n        this._isIcu = nodes.length == 1 && nodes[0] instanceof Expansion;\n        this._icuDepth = 0;\n        this._placeholderRegistry = new PlaceholderRegistry();\n        this._placeholderToContent = {};\n        this._placeholderToMessage = {};\n        var /** @type {?} */ i18nodes = visitAll(this, nodes, {});\n        return new Message(i18nodes, this._placeholderToContent, this._placeholderToMessage, meaning, description, id);\n    };\n    /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    _I18nVisitor.prototype.visitElement = /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    function (el, context) {\n        var /** @type {?} */ children = visitAll(this, el.children);\n        var /** @type {?} */ attrs = {};\n        el.attrs.forEach(function (attr) {\n            // Do not visit the attributes, translatable ones are top-level ASTs\n            attrs[attr.name] = attr.value;\n        });\n        var /** @type {?} */ isVoid = getHtmlTagDefinition(el.name).isVoid;\n        var /** @type {?} */ startPhName = this._placeholderRegistry.getStartTagPlaceholderName(el.name, attrs, isVoid);\n        this._placeholderToContent[startPhName] = /** @type {?} */ ((el.sourceSpan)).toString();\n        var /** @type {?} */ closePhName = '';\n        if (!isVoid) {\n            closePhName = this._placeholderRegistry.getCloseTagPlaceholderName(el.name);\n            this._placeholderToContent[closePhName] = \"</\" + el.name + \">\";\n        }\n        return new TagPlaceholder(el.name, attrs, startPhName, closePhName, children, isVoid, /** @type {?} */ ((el.sourceSpan)));\n    };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    _I18nVisitor.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) {\n        return this._visitTextWithInterpolation(attribute.value, attribute.sourceSpan);\n    };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    _I18nVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) {\n        return this._visitTextWithInterpolation(text.value, /** @type {?} */ ((text.sourceSpan)));\n    };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    _I18nVisitor.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { return null; };\n    /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    _I18nVisitor.prototype.visitExpansion = /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        this._icuDepth++;\n        var /** @type {?} */ i18nIcuCases = {};\n        var /** @type {?} */ i18nIcu = new Icu(icu.switchValue, icu.type, i18nIcuCases, icu.sourceSpan);\n        icu.cases.forEach(function (caze) {\n            i18nIcuCases[caze.value] = new Container(caze.expression.map(function (node) { return node.visit(_this, {}); }), caze.expSourceSpan);\n        });\n        this._icuDepth--;\n        if (this._isIcu || this._icuDepth > 0) {\n            // Returns an ICU node when:\n            // - the message (vs a part of the message) is an ICU message, or\n            // - the ICU message is nested.\n            var /** @type {?} */ expPh = this._placeholderRegistry.getUniquePlaceholder(\"VAR_\" + icu.type);\n            i18nIcu.expressionPlaceholder = expPh;\n            this._placeholderToContent[expPh] = icu.switchValue;\n            return i18nIcu;\n        }\n        // Else returns a placeholder\n        // ICU placeholders should not be replaced with their original content but with the their\n        // translations. We need to create a new visitor (they are not re-entrant) to compute the\n        // message id.\n        // TODO(vicb): add a html.Node -> i18n.Message cache to avoid having to re-create the msg\n        var /** @type {?} */ phName = this._placeholderRegistry.getPlaceholderName('ICU', icu.sourceSpan.toString());\n        var /** @type {?} */ visitor = new _I18nVisitor(this._expressionParser, this._interpolationConfig);\n        this._placeholderToMessage[phName] = visitor.toI18nMessage([icu], '', '', '');\n        return new IcuPlaceholder(i18nIcu, phName, icu.sourceSpan);\n    };\n    /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    _I18nVisitor.prototype.visitExpansionCase = /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (icuCase, context) {\n        throw new Error('Unreachable code');\n    };\n    /**\n     * @param {?} text\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    _I18nVisitor.prototype._visitTextWithInterpolation = /**\n     * @param {?} text\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (text, sourceSpan) {\n        var /** @type {?} */ splitInterpolation = this._expressionParser.splitInterpolation(text, sourceSpan.start.toString(), this._interpolationConfig);\n        if (!splitInterpolation) {\n            // No expression, return a single text\n            return new Text$1(text, sourceSpan);\n        }\n        // Return a group of text + expressions\n        var /** @type {?} */ nodes = [];\n        var /** @type {?} */ container = new Container(nodes, sourceSpan);\n        var _a = this._interpolationConfig, sDelimiter = _a.start, eDelimiter = _a.end;\n        for (var /** @type {?} */ i = 0; i < splitInterpolation.strings.length - 1; i++) {\n            var /** @type {?} */ expression = splitInterpolation.expressions[i];\n            var /** @type {?} */ baseName = _extractPlaceholderName(expression) || 'INTERPOLATION';\n            var /** @type {?} */ phName = this._placeholderRegistry.getPlaceholderName(baseName, expression);\n            if (splitInterpolation.strings[i].length) {\n                // No need to add empty strings\n                nodes.push(new Text$1(splitInterpolation.strings[i], sourceSpan));\n            }\n            nodes.push(new Placeholder(expression, phName, sourceSpan));\n            this._placeholderToContent[phName] = sDelimiter + expression + eDelimiter;\n        }\n        // The last index contains no expression\n        var /** @type {?} */ lastStringIdx = splitInterpolation.strings.length - 1;\n        if (splitInterpolation.strings[lastStringIdx].length) {\n            nodes.push(new Text$1(splitInterpolation.strings[lastStringIdx], sourceSpan));\n        }\n        return container;\n    };\n    return _I18nVisitor;\n}());\nvar _CUSTOM_PH_EXP = /\\/\\/[\\s\\S]*i18n[\\s\\S]*\\([\\s\\S]*ph[\\s\\S]*=[\\s\\S]*(\"|')([\\s\\S]*?)\\1[\\s\\S]*\\)/g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction _extractPlaceholderName(input) {\n    return input.split(_CUSTOM_PH_EXP)[2];\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * An i18n error.\n */\nvar I18nError = /** @class */ (function (_super) {\n    __extends(I18nError, _super);\n    function I18nError(span, msg) {\n        return _super.call(this, span, msg) || this;\n    }\n    return I18nError;\n}(ParseError));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _I18N_ATTR = 'i18n';\nvar _I18N_ATTR_PREFIX = 'i18n-';\nvar _I18N_COMMENT_PREFIX_REGEXP = /^i18n:?/;\nvar MEANING_SEPARATOR = '|';\nvar ID_SEPARATOR = '@@';\nvar i18nCommentsWarned = false;\n/**\n * Extract translatable messages from an html AST\n * @param {?} nodes\n * @param {?} interpolationConfig\n * @param {?} implicitTags\n * @param {?} implicitAttrs\n * @return {?}\n */\nfunction extractMessages(nodes, interpolationConfig, implicitTags, implicitAttrs) {\n    var /** @type {?} */ visitor = new _Visitor(implicitTags, implicitAttrs);\n    return visitor.extract(nodes, interpolationConfig);\n}\n/**\n * @param {?} nodes\n * @param {?} translations\n * @param {?} interpolationConfig\n * @param {?} implicitTags\n * @param {?} implicitAttrs\n * @return {?}\n */\nfunction mergeTranslations(nodes, translations, interpolationConfig, implicitTags, implicitAttrs) {\n    var /** @type {?} */ visitor = new _Visitor(implicitTags, implicitAttrs);\n    return visitor.merge(nodes, translations, interpolationConfig);\n}\nvar ExtractionResult = /** @class */ (function () {\n    function ExtractionResult(messages, errors) {\n        this.messages = messages;\n        this.errors = errors;\n    }\n    return ExtractionResult;\n}());\n/** @enum {number} */\nvar _VisitorMode = {\n    Extract: 0,\n    Merge: 1,\n};\n_VisitorMode[_VisitorMode.Extract] = \"Extract\";\n_VisitorMode[_VisitorMode.Merge] = \"Merge\";\n/**\n * This Visitor is used:\n * 1. to extract all the translatable strings from an html AST (see `extract()`),\n * 2. to replace the translatable strings with the actual translations (see `merge()`)\n *\n * \\@internal\n */\nvar _Visitor = /** @class */ (function () {\n    function _Visitor(_implicitTags, _implicitAttrs) {\n        this._implicitTags = _implicitTags;\n        this._implicitAttrs = _implicitAttrs;\n    }\n    /**\n     * Extracts the messages from the tree\n     */\n    /**\n     * Extracts the messages from the tree\n     * @param {?} nodes\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    _Visitor.prototype.extract = /**\n     * Extracts the messages from the tree\n     * @param {?} nodes\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    function (nodes, interpolationConfig) {\n        var _this = this;\n        this._init(_VisitorMode.Extract, interpolationConfig);\n        nodes.forEach(function (node) { return node.visit(_this, null); });\n        if (this._inI18nBlock) {\n            this._reportError(nodes[nodes.length - 1], 'Unclosed block');\n        }\n        return new ExtractionResult(this._messages, this._errors);\n    };\n    /**\n     * Returns a tree where all translatable nodes are translated\n     */\n    /**\n     * Returns a tree where all translatable nodes are translated\n     * @param {?} nodes\n     * @param {?} translations\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    _Visitor.prototype.merge = /**\n     * Returns a tree where all translatable nodes are translated\n     * @param {?} nodes\n     * @param {?} translations\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    function (nodes, translations, interpolationConfig) {\n        this._init(_VisitorMode.Merge, interpolationConfig);\n        this._translations = translations;\n        // Construct a single fake root element\n        var /** @type {?} */ wrapper = new Element('wrapper', [], nodes, /** @type {?} */ ((undefined)), undefined, undefined);\n        var /** @type {?} */ translatedNode = wrapper.visit(this, null);\n        if (this._inI18nBlock) {\n            this._reportError(nodes[nodes.length - 1], 'Unclosed block');\n        }\n        return new ParseTreeResult(translatedNode.children, this._errors);\n    };\n    /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitExpansionCase = /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (icuCase, context) {\n        // Parse cases for translatable html attributes\n        var /** @type {?} */ expression = visitAll(this, icuCase.expression, context);\n        if (this._mode === _VisitorMode.Merge) {\n            return new ExpansionCase(icuCase.value, expression, icuCase.sourceSpan, icuCase.valueSourceSpan, icuCase.expSourceSpan);\n        }\n    };\n    /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitExpansion = /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    function (icu, context) {\n        this._mayBeAddBlockChildren(icu);\n        var /** @type {?} */ wasInIcu = this._inIcu;\n        if (!this._inIcu) {\n            // nested ICU messages should not be extracted but top-level translated as a whole\n            if (this._isInTranslatableSection) {\n                this._addMessage([icu]);\n            }\n            this._inIcu = true;\n        }\n        var /** @type {?} */ cases = visitAll(this, icu.cases, context);\n        if (this._mode === _VisitorMode.Merge) {\n            icu = new Expansion(icu.switchValue, icu.type, cases, icu.sourceSpan, icu.switchValueSourceSpan);\n        }\n        this._inIcu = wasInIcu;\n        return icu;\n    };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) {\n        var /** @type {?} */ isOpening = _isOpeningComment(comment);\n        if (isOpening && this._isInTranslatableSection) {\n            this._reportError(comment, 'Could not start a block inside a translatable section');\n            return;\n        }\n        var /** @type {?} */ isClosing = _isClosingComment(comment);\n        if (isClosing && !this._inI18nBlock) {\n            this._reportError(comment, 'Trying to close an unopened block');\n            return;\n        }\n        if (!this._inI18nNode && !this._inIcu) {\n            if (!this._inI18nBlock) {\n                if (isOpening) {\n                    // deprecated from v5 you should use <ng-container i18n> instead of i18n comments\n                    if (!i18nCommentsWarned && /** @type {?} */ (console) && /** @type {?} */ (console.warn)) {\n                        i18nCommentsWarned = true;\n                        var /** @type {?} */ details = comment.sourceSpan.details ? \", \" + comment.sourceSpan.details : '';\n                        // TODO(ocombe): use a log service once there is a public one available\n                        console.warn(\"I18n comments are deprecated, use an <ng-container> element instead (\" + comment.sourceSpan.start + details + \")\");\n                    }\n                    this._inI18nBlock = true;\n                    this._blockStartDepth = this._depth;\n                    this._blockChildren = [];\n                    this._blockMeaningAndDesc = /** @type {?} */ ((comment.value)).replace(_I18N_COMMENT_PREFIX_REGEXP, '').trim();\n                    this._openTranslatableSection(comment);\n                }\n            }\n            else {\n                if (isClosing) {\n                    if (this._depth == this._blockStartDepth) {\n                        this._closeTranslatableSection(comment, this._blockChildren);\n                        this._inI18nBlock = false;\n                        var /** @type {?} */ message = /** @type {?} */ ((this._addMessage(this._blockChildren, this._blockMeaningAndDesc)));\n                        // merge attributes in sections\n                        var /** @type {?} */ nodes = this._translateMessage(comment, message);\n                        return visitAll(this, nodes);\n                    }\n                    else {\n                        this._reportError(comment, 'I18N blocks should not cross element boundaries');\n                        return;\n                    }\n                }\n            }\n        }\n    };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) {\n        if (this._isInTranslatableSection) {\n            this._mayBeAddBlockChildren(text);\n        }\n        return text;\n    };\n    /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitElement = /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    function (el, context) {\n        var _this = this;\n        this._mayBeAddBlockChildren(el);\n        this._depth++;\n        var /** @type {?} */ wasInI18nNode = this._inI18nNode;\n        var /** @type {?} */ wasInImplicitNode = this._inImplicitNode;\n        var /** @type {?} */ childNodes = [];\n        var /** @type {?} */ translatedChildNodes = /** @type {?} */ ((undefined));\n        // Extract:\n        // - top level nodes with the (implicit) \"i18n\" attribute if not already in a section\n        // - ICU messages\n        var /** @type {?} */ i18nAttr = _getI18nAttr(el);\n        var /** @type {?} */ i18nMeta = i18nAttr ? i18nAttr.value : '';\n        var /** @type {?} */ isImplicit = this._implicitTags.some(function (tag) { return el.name === tag; }) && !this._inIcu &&\n            !this._isInTranslatableSection;\n        var /** @type {?} */ isTopLevelImplicit = !wasInImplicitNode && isImplicit;\n        this._inImplicitNode = wasInImplicitNode || isImplicit;\n        if (!this._isInTranslatableSection && !this._inIcu) {\n            if (i18nAttr || isTopLevelImplicit) {\n                this._inI18nNode = true;\n                var /** @type {?} */ message = /** @type {?} */ ((this._addMessage(el.children, i18nMeta)));\n                translatedChildNodes = this._translateMessage(el, message);\n            }\n            if (this._mode == _VisitorMode.Extract) {\n                var /** @type {?} */ isTranslatable = i18nAttr || isTopLevelImplicit;\n                if (isTranslatable)\n                    this._openTranslatableSection(el);\n                visitAll(this, el.children);\n                if (isTranslatable)\n                    this._closeTranslatableSection(el, el.children);\n            }\n        }\n        else {\n            if (i18nAttr || isTopLevelImplicit) {\n                this._reportError(el, 'Could not mark an element as translatable inside a translatable section');\n            }\n            if (this._mode == _VisitorMode.Extract) {\n                // Descend into child nodes for extraction\n                visitAll(this, el.children);\n            }\n        }\n        if (this._mode === _VisitorMode.Merge) {\n            var /** @type {?} */ visitNodes = translatedChildNodes || el.children;\n            visitNodes.forEach(function (child) {\n                var /** @type {?} */ visited = child.visit(_this, context);\n                if (visited && !_this._isInTranslatableSection) {\n                    // Do not add the children from translatable sections (= i18n blocks here)\n                    // They will be added later in this loop when the block closes (i.e. on `<!-- /i18n -->`)\n                    childNodes = childNodes.concat(visited);\n                }\n            });\n        }\n        this._visitAttributesOf(el);\n        this._depth--;\n        this._inI18nNode = wasInI18nNode;\n        this._inImplicitNode = wasInImplicitNode;\n        if (this._mode === _VisitorMode.Merge) {\n            var /** @type {?} */ translatedAttrs = this._translateAttributes(el);\n            return new Element(el.name, translatedAttrs, childNodes, el.sourceSpan, el.startSourceSpan, el.endSourceSpan);\n        }\n        return null;\n    };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) {\n        throw new Error('unreachable code');\n    };\n    /**\n     * @param {?} mode\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    _Visitor.prototype._init = /**\n     * @param {?} mode\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    function (mode, interpolationConfig) {\n        this._mode = mode;\n        this._inI18nBlock = false;\n        this._inI18nNode = false;\n        this._depth = 0;\n        this._inIcu = false;\n        this._msgCountAtSectionStart = undefined;\n        this._errors = [];\n        this._messages = [];\n        this._inImplicitNode = false;\n        this._createI18nMessage = createI18nMessageFactory(interpolationConfig);\n    };\n    /**\n     * @param {?} el\n     * @return {?}\n     */\n    _Visitor.prototype._visitAttributesOf = /**\n     * @param {?} el\n     * @return {?}\n     */\n    function (el) {\n        var _this = this;\n        var /** @type {?} */ explicitAttrNameToValue = {};\n        var /** @type {?} */ implicitAttrNames = this._implicitAttrs[el.name] || [];\n        el.attrs.filter(function (attr) { return attr.name.startsWith(_I18N_ATTR_PREFIX); })\n            .forEach(function (attr) {\n            return explicitAttrNameToValue[attr.name.slice(_I18N_ATTR_PREFIX.length)] =\n                attr.value;\n        });\n        el.attrs.forEach(function (attr) {\n            if (attr.name in explicitAttrNameToValue) {\n                _this._addMessage([attr], explicitAttrNameToValue[attr.name]);\n            }\n            else if (implicitAttrNames.some(function (name) { return attr.name === name; })) {\n                _this._addMessage([attr]);\n            }\n        });\n    };\n    /**\n     * @param {?} ast\n     * @param {?=} msgMeta\n     * @return {?}\n     */\n    _Visitor.prototype._addMessage = /**\n     * @param {?} ast\n     * @param {?=} msgMeta\n     * @return {?}\n     */\n    function (ast, msgMeta) {\n        if (ast.length == 0 ||\n            ast.length == 1 && ast[0] instanceof Attribute$1 && !(/** @type {?} */ (ast[0])).value) {\n            // Do not create empty messages\n            return null;\n        }\n        var _a = _parseMessageMeta(msgMeta), meaning = _a.meaning, description = _a.description, id = _a.id;\n        var /** @type {?} */ message = this._createI18nMessage(ast, meaning, description, id);\n        this._messages.push(message);\n        return message;\n    };\n    /**\n     * @param {?} el\n     * @param {?} message\n     * @return {?}\n     */\n    _Visitor.prototype._translateMessage = /**\n     * @param {?} el\n     * @param {?} message\n     * @return {?}\n     */\n    function (el, message) {\n        if (message && this._mode === _VisitorMode.Merge) {\n            var /** @type {?} */ nodes = this._translations.get(message);\n            if (nodes) {\n                return nodes;\n            }\n            this._reportError(el, \"Translation unavailable for message id=\\\"\" + this._translations.digest(message) + \"\\\"\");\n        }\n        return [];\n    };\n    /**\n     * @param {?} el\n     * @return {?}\n     */\n    _Visitor.prototype._translateAttributes = /**\n     * @param {?} el\n     * @return {?}\n     */\n    function (el) {\n        var _this = this;\n        var /** @type {?} */ attributes = el.attrs;\n        var /** @type {?} */ i18nParsedMessageMeta = {};\n        attributes.forEach(function (attr) {\n            if (attr.name.startsWith(_I18N_ATTR_PREFIX)) {\n                i18nParsedMessageMeta[attr.name.slice(_I18N_ATTR_PREFIX.length)] =\n                    _parseMessageMeta(attr.value);\n            }\n        });\n        var /** @type {?} */ translatedAttributes = [];\n        attributes.forEach(function (attr) {\n            if (attr.name === _I18N_ATTR || attr.name.startsWith(_I18N_ATTR_PREFIX)) {\n                // strip i18n specific attributes\n                return;\n            }\n            if (attr.value && attr.value != '' && i18nParsedMessageMeta.hasOwnProperty(attr.name)) {\n                var _a = i18nParsedMessageMeta[attr.name], meaning = _a.meaning, description = _a.description, id = _a.id;\n                var /** @type {?} */ message = _this._createI18nMessage([attr], meaning, description, id);\n                var /** @type {?} */ nodes = _this._translations.get(message);\n                if (nodes) {\n                    if (nodes.length == 0) {\n                        translatedAttributes.push(new Attribute$1(attr.name, '', attr.sourceSpan));\n                    }\n                    else if (nodes[0] instanceof Text) {\n                        var /** @type {?} */ value = (/** @type {?} */ (nodes[0])).value;\n                        translatedAttributes.push(new Attribute$1(attr.name, value, attr.sourceSpan));\n                    }\n                    else {\n                        _this._reportError(el, \"Unexpected translation for attribute \\\"\" + attr.name + \"\\\" (id=\\\"\" + (id || _this._translations.digest(message)) + \"\\\")\");\n                    }\n                }\n                else {\n                    _this._reportError(el, \"Translation unavailable for attribute \\\"\" + attr.name + \"\\\" (id=\\\"\" + (id || _this._translations.digest(message)) + \"\\\")\");\n                }\n            }\n            else {\n                translatedAttributes.push(attr);\n            }\n        });\n        return translatedAttributes;\n    };\n    /**\n     * Add the node as a child of the block when:\n     * - we are in a block,\n     * - we are not inside a ICU message (those are handled separately),\n     * - the node is a \"direct child\" of the block\n     * @param {?} node\n     * @return {?}\n     */\n    _Visitor.prototype._mayBeAddBlockChildren = /**\n     * Add the node as a child of the block when:\n     * - we are in a block,\n     * - we are not inside a ICU message (those are handled separately),\n     * - the node is a \"direct child\" of the block\n     * @param {?} node\n     * @return {?}\n     */\n    function (node) {\n        if (this._inI18nBlock && !this._inIcu && this._depth == this._blockStartDepth) {\n            this._blockChildren.push(node);\n        }\n    };\n    /**\n     * Marks the start of a section, see `_closeTranslatableSection`\n     * @param {?} node\n     * @return {?}\n     */\n    _Visitor.prototype._openTranslatableSection = /**\n     * Marks the start of a section, see `_closeTranslatableSection`\n     * @param {?} node\n     * @return {?}\n     */\n    function (node) {\n        if (this._isInTranslatableSection) {\n            this._reportError(node, 'Unexpected section start');\n        }\n        else {\n            this._msgCountAtSectionStart = this._messages.length;\n        }\n    };\n    Object.defineProperty(_Visitor.prototype, \"_isInTranslatableSection\", {\n        get: /**\n         * A translatable section could be:\n         * - the content of translatable element,\n         * - nodes between `<!-- i18n -->` and `<!-- /i18n -->` comments\n         * @return {?}\n         */\n        function () {\n            return this._msgCountAtSectionStart !== void 0;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Terminates a section.\n     *\n     * If a section has only one significant children (comments not significant) then we should not\n     * keep the message from this children:\n     *\n     * `<p i18n=\"meaning|description\">{ICU message}</p>` would produce two messages:\n     * - one for the <p> content with meaning and description,\n     * - another one for the ICU message.\n     *\n     * In this case the last message is discarded as it contains less information (the AST is\n     * otherwise identical).\n     *\n     * Note that we should still keep messages extracted from attributes inside the section (ie in the\n     * ICU message here)\n     * @param {?} node\n     * @param {?} directChildren\n     * @return {?}\n     */\n    _Visitor.prototype._closeTranslatableSection = /**\n     * Terminates a section.\n     *\n     * If a section has only one significant children (comments not significant) then we should not\n     * keep the message from this children:\n     *\n     * `<p i18n=\"meaning|description\">{ICU message}</p>` would produce two messages:\n     * - one for the <p> content with meaning and description,\n     * - another one for the ICU message.\n     *\n     * In this case the last message is discarded as it contains less information (the AST is\n     * otherwise identical).\n     *\n     * Note that we should still keep messages extracted from attributes inside the section (ie in the\n     * ICU message here)\n     * @param {?} node\n     * @param {?} directChildren\n     * @return {?}\n     */\n    function (node, directChildren) {\n        if (!this._isInTranslatableSection) {\n            this._reportError(node, 'Unexpected section end');\n            return;\n        }\n        var /** @type {?} */ startIndex = this._msgCountAtSectionStart;\n        var /** @type {?} */ significantChildren = directChildren.reduce(function (count, node) { return count + (node instanceof Comment ? 0 : 1); }, 0);\n        if (significantChildren == 1) {\n            for (var /** @type {?} */ i = this._messages.length - 1; i >= /** @type {?} */ ((startIndex)); i--) {\n                var /** @type {?} */ ast = this._messages[i].nodes;\n                if (!(ast.length == 1 && ast[0] instanceof Text$1)) {\n                    this._messages.splice(i, 1);\n                    break;\n                }\n            }\n        }\n        this._msgCountAtSectionStart = undefined;\n    };\n    /**\n     * @param {?} node\n     * @param {?} msg\n     * @return {?}\n     */\n    _Visitor.prototype._reportError = /**\n     * @param {?} node\n     * @param {?} msg\n     * @return {?}\n     */\n    function (node, msg) {\n        this._errors.push(new I18nError(/** @type {?} */ ((node.sourceSpan)), msg));\n    };\n    return _Visitor;\n}());\n/**\n * @param {?} n\n * @return {?}\n */\nfunction _isOpeningComment(n) {\n    return !!(n instanceof Comment && n.value && n.value.startsWith('i18n'));\n}\n/**\n * @param {?} n\n * @return {?}\n */\nfunction _isClosingComment(n) {\n    return !!(n instanceof Comment && n.value && n.value === '/i18n');\n}\n/**\n * @param {?} p\n * @return {?}\n */\nfunction _getI18nAttr(p) {\n    return p.attrs.find(function (attr) { return attr.name === _I18N_ATTR; }) || null;\n}\n/**\n * @param {?=} i18n\n * @return {?}\n */\nfunction _parseMessageMeta(i18n) {\n    if (!i18n)\n        return { meaning: '', description: '', id: '' };\n    var /** @type {?} */ idIndex = i18n.indexOf(ID_SEPARATOR);\n    var /** @type {?} */ descIndex = i18n.indexOf(MEANING_SEPARATOR);\n    var _a = (idIndex > -1) ? [i18n.slice(0, idIndex), i18n.slice(idIndex + 2)] : [i18n, ''], meaningAndDesc = _a[0], id = _a[1];\n    var _b = (descIndex > -1) ?\n        [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] :\n        ['', meaningAndDesc], meaning = _b[0], description = _b[1];\n    return { meaning: meaning, description: description, id: id };\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar XmlTagDefinition = /** @class */ (function () {\n    function XmlTagDefinition() {\n        this.closedByParent = false;\n        this.contentType = TagContentType.PARSABLE_DATA;\n        this.isVoid = false;\n        this.ignoreFirstLf = false;\n        this.canSelfClose = true;\n    }\n    /**\n     * @param {?} currentParent\n     * @return {?}\n     */\n    XmlTagDefinition.prototype.requireExtraParent = /**\n     * @param {?} currentParent\n     * @return {?}\n     */\n    function (currentParent) { return false; };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    XmlTagDefinition.prototype.isClosedByChild = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) { return false; };\n    return XmlTagDefinition;\n}());\nvar _TAG_DEFINITION = new XmlTagDefinition();\n/**\n * @param {?} tagName\n * @return {?}\n */\nfunction getXmlTagDefinition(tagName) {\n    return _TAG_DEFINITION;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar XmlParser = /** @class */ (function (_super) {\n    __extends(XmlParser, _super);\n    function XmlParser() {\n        return _super.call(this, getXmlTagDefinition) || this;\n    }\n    /**\n     * @param {?} source\n     * @param {?} url\n     * @param {?=} parseExpansionForms\n     * @return {?}\n     */\n    XmlParser.prototype.parse = /**\n     * @param {?} source\n     * @param {?} url\n     * @param {?=} parseExpansionForms\n     * @return {?}\n     */\n    function (source, url, parseExpansionForms) {\n        if (parseExpansionForms === void 0) { parseExpansionForms = false; }\n        return _super.prototype.parse.call(this, source, url, parseExpansionForms);\n    };\n    return XmlParser;\n}(Parser$1));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @abstract\n */\nvar Serializer = /** @class */ (function () {\n    function Serializer() {\n    }\n    // Creates a name mapper, see `PlaceholderMapper`\n    // Returning `null` means that no name mapping is used.\n    /**\n     * @param {?} message\n     * @return {?}\n     */\n    Serializer.prototype.createNameMapper = /**\n     * @param {?} message\n     * @return {?}\n     */\n    function (message) { return null; };\n    return Serializer;\n}());\n/**\n * A `PlaceholderMapper` converts placeholder names from internal to serialized representation and\n * back.\n *\n * It should be used for serialization format that put constraints on the placeholder names.\n * @record\n */\n\n/**\n * A simple mapper that take a function to transform an internal name to a public name\n */\nvar SimplePlaceholderMapper = /** @class */ (function (_super) {\n    __extends(SimplePlaceholderMapper, _super);\n    // create a mapping from the message\n    function SimplePlaceholderMapper(message, mapName) {\n        var _this = _super.call(this) || this;\n        _this.mapName = mapName;\n        _this.internalToPublic = {};\n        _this.publicToNextId = {};\n        _this.publicToInternal = {};\n        message.nodes.forEach(function (node) { return node.visit(_this); });\n        return _this;\n    }\n    /**\n     * @param {?} internalName\n     * @return {?}\n     */\n    SimplePlaceholderMapper.prototype.toPublicName = /**\n     * @param {?} internalName\n     * @return {?}\n     */\n    function (internalName) {\n        return this.internalToPublic.hasOwnProperty(internalName) ?\n            this.internalToPublic[internalName] :\n            null;\n    };\n    /**\n     * @param {?} publicName\n     * @return {?}\n     */\n    SimplePlaceholderMapper.prototype.toInternalName = /**\n     * @param {?} publicName\n     * @return {?}\n     */\n    function (publicName) {\n        return this.publicToInternal.hasOwnProperty(publicName) ? this.publicToInternal[publicName] :\n            null;\n    };\n    /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    SimplePlaceholderMapper.prototype.visitText = /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    function (text, context) { return null; };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    SimplePlaceholderMapper.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        this.visitPlaceholderName(ph.startName);\n        _super.prototype.visitTagPlaceholder.call(this, ph, context);\n        this.visitPlaceholderName(ph.closeName);\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    SimplePlaceholderMapper.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) { this.visitPlaceholderName(ph.name); };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    SimplePlaceholderMapper.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        this.visitPlaceholderName(ph.name);\n    };\n    /**\n     * @param {?} internalName\n     * @return {?}\n     */\n    SimplePlaceholderMapper.prototype.visitPlaceholderName = /**\n     * @param {?} internalName\n     * @return {?}\n     */\n    function (internalName) {\n        if (!internalName || this.internalToPublic.hasOwnProperty(internalName)) {\n            return;\n        }\n        var /** @type {?} */ publicName = this.mapName(internalName);\n        if (this.publicToInternal.hasOwnProperty(publicName)) {\n            // Create a new XMB when it has already been used\n            var /** @type {?} */ nextId = this.publicToNextId[publicName];\n            this.publicToNextId[publicName] = nextId + 1;\n            publicName = publicName + \"_\" + nextId;\n        }\n        else {\n            this.publicToNextId[publicName] = 1;\n        }\n        this.internalToPublic[internalName] = publicName;\n        this.publicToInternal[publicName] = internalName;\n    };\n    return SimplePlaceholderMapper;\n}(RecurseVisitor));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @record\n */\n\nvar _Visitor$1 = /** @class */ (function () {\n    function _Visitor() {\n    }\n    /**\n     * @param {?} tag\n     * @return {?}\n     */\n    _Visitor.prototype.visitTag = /**\n     * @param {?} tag\n     * @return {?}\n     */\n    function (tag) {\n        var _this = this;\n        var /** @type {?} */ strAttrs = this._serializeAttributes(tag.attrs);\n        if (tag.children.length == 0) {\n            return \"<\" + tag.name + strAttrs + \"/>\";\n        }\n        var /** @type {?} */ strChildren = tag.children.map(function (node) { return node.visit(_this); });\n        return \"<\" + tag.name + strAttrs + \">\" + strChildren.join('') + \"</\" + tag.name + \">\";\n    };\n    /**\n     * @param {?} text\n     * @return {?}\n     */\n    _Visitor.prototype.visitText = /**\n     * @param {?} text\n     * @return {?}\n     */\n    function (text) { return text.value; };\n    /**\n     * @param {?} decl\n     * @return {?}\n     */\n    _Visitor.prototype.visitDeclaration = /**\n     * @param {?} decl\n     * @return {?}\n     */\n    function (decl) {\n        return \"<?xml\" + this._serializeAttributes(decl.attrs) + \" ?>\";\n    };\n    /**\n     * @param {?} attrs\n     * @return {?}\n     */\n    _Visitor.prototype._serializeAttributes = /**\n     * @param {?} attrs\n     * @return {?}\n     */\n    function (attrs) {\n        var /** @type {?} */ strAttrs = Object.keys(attrs).map(function (name) { return name + \"=\\\"\" + attrs[name] + \"\\\"\"; }).join(' ');\n        return strAttrs.length > 0 ? ' ' + strAttrs : '';\n    };\n    /**\n     * @param {?} doctype\n     * @return {?}\n     */\n    _Visitor.prototype.visitDoctype = /**\n     * @param {?} doctype\n     * @return {?}\n     */\n    function (doctype) {\n        return \"<!DOCTYPE \" + doctype.rootTag + \" [\\n\" + doctype.dtd + \"\\n]>\";\n    };\n    return _Visitor;\n}());\nvar _visitor = new _Visitor$1();\n/**\n * @param {?} nodes\n * @return {?}\n */\nfunction serialize(nodes) {\n    return nodes.map(function (node) { return node.visit(_visitor); }).join('');\n}\n/**\n * @record\n */\n\nvar Declaration = /** @class */ (function () {\n    function Declaration(unescapedAttrs) {\n        var _this = this;\n        this.attrs = {};\n        Object.keys(unescapedAttrs).forEach(function (k) {\n            _this.attrs[k] = escapeXml(unescapedAttrs[k]);\n        });\n    }\n    /**\n     * @param {?} visitor\n     * @return {?}\n     */\n    Declaration.prototype.visit = /**\n     * @param {?} visitor\n     * @return {?}\n     */\n    function (visitor) { return visitor.visitDeclaration(this); };\n    return Declaration;\n}());\nvar Doctype = /** @class */ (function () {\n    function Doctype(rootTag, dtd) {\n        this.rootTag = rootTag;\n        this.dtd = dtd;\n    }\n    /**\n     * @param {?} visitor\n     * @return {?}\n     */\n    Doctype.prototype.visit = /**\n     * @param {?} visitor\n     * @return {?}\n     */\n    function (visitor) { return visitor.visitDoctype(this); };\n    return Doctype;\n}());\nvar Tag = /** @class */ (function () {\n    function Tag(name, unescapedAttrs, children) {\n        if (unescapedAttrs === void 0) { unescapedAttrs = {}; }\n        if (children === void 0) { children = []; }\n        var _this = this;\n        this.name = name;\n        this.children = children;\n        this.attrs = {};\n        Object.keys(unescapedAttrs).forEach(function (k) {\n            _this.attrs[k] = escapeXml(unescapedAttrs[k]);\n        });\n    }\n    /**\n     * @param {?} visitor\n     * @return {?}\n     */\n    Tag.prototype.visit = /**\n     * @param {?} visitor\n     * @return {?}\n     */\n    function (visitor) { return visitor.visitTag(this); };\n    return Tag;\n}());\nvar Text$2 = /** @class */ (function () {\n    function Text(unescapedValue) {\n        this.value = escapeXml(unescapedValue);\n    }\n    /**\n     * @param {?} visitor\n     * @return {?}\n     */\n    Text.prototype.visit = /**\n     * @param {?} visitor\n     * @return {?}\n     */\n    function (visitor) { return visitor.visitText(this); };\n    return Text;\n}());\nvar CR = /** @class */ (function (_super) {\n    __extends(CR, _super);\n    function CR(ws) {\n        if (ws === void 0) { ws = 0; }\n        return _super.call(this, \"\\n\" + new Array(ws + 1).join(' ')) || this;\n    }\n    return CR;\n}(Text$2));\nvar _ESCAPED_CHARS = [\n    [/&/g, '&amp;'],\n    [/\"/g, '&quot;'],\n    [/'/g, '&apos;'],\n    [/</g, '&lt;'],\n    [/>/g, '&gt;'],\n];\n/**\n * @param {?} text\n * @return {?}\n */\nfunction escapeXml(text) {\n    return _ESCAPED_CHARS.reduce(function (text, entry) { return text.replace(entry[0], entry[1]); }, text);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _VERSION = '1.2';\nvar _XMLNS = 'urn:oasis:names:tc:xliff:document:1.2';\n// TODO(vicb): make this a param (s/_/-/)\nvar _DEFAULT_SOURCE_LANG = 'en';\nvar _PLACEHOLDER_TAG = 'x';\nvar _MARKER_TAG = 'mrk';\nvar _FILE_TAG = 'file';\nvar _SOURCE_TAG = 'source';\nvar _SEGMENT_SOURCE_TAG = 'seg-source';\nvar _TARGET_TAG = 'target';\nvar _UNIT_TAG = 'trans-unit';\nvar _CONTEXT_GROUP_TAG = 'context-group';\nvar _CONTEXT_TAG = 'context';\nvar Xliff = /** @class */ (function (_super) {\n    __extends(Xliff, _super);\n    function Xliff() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} messages\n     * @param {?} locale\n     * @return {?}\n     */\n    Xliff.prototype.write = /**\n     * @param {?} messages\n     * @param {?} locale\n     * @return {?}\n     */\n    function (messages, locale) {\n        var /** @type {?} */ visitor = new _WriteVisitor();\n        var /** @type {?} */ transUnits = [];\n        messages.forEach(function (message) {\n            var /** @type {?} */ contextTags = [];\n            message.sources.forEach(function (source) {\n                var /** @type {?} */ contextGroupTag = new Tag(_CONTEXT_GROUP_TAG, { purpose: 'location' });\n                contextGroupTag.children.push(new CR(10), new Tag(_CONTEXT_TAG, { 'context-type': 'sourcefile' }, [new Text$2(source.filePath)]), new CR(10), new Tag(_CONTEXT_TAG, { 'context-type': 'linenumber' }, [new Text$2(\"\" + source.startLine)]), new CR(8));\n                contextTags.push(new CR(8), contextGroupTag);\n            });\n            var /** @type {?} */ transUnit = new Tag(_UNIT_TAG, { id: message.id, datatype: 'html' });\n            (_a = transUnit.children).push.apply(_a, [new CR(8), new Tag(_SOURCE_TAG, {}, visitor.serialize(message.nodes))].concat(contextTags));\n            if (message.description) {\n                transUnit.children.push(new CR(8), new Tag('note', { priority: '1', from: 'description' }, [new Text$2(message.description)]));\n            }\n            if (message.meaning) {\n                transUnit.children.push(new CR(8), new Tag('note', { priority: '1', from: 'meaning' }, [new Text$2(message.meaning)]));\n            }\n            transUnit.children.push(new CR(6));\n            transUnits.push(new CR(6), transUnit);\n            var _a;\n        });\n        var /** @type {?} */ body = new Tag('body', {}, transUnits.concat([new CR(4)]));\n        var /** @type {?} */ file = new Tag('file', {\n            'source-language': locale || _DEFAULT_SOURCE_LANG,\n            datatype: 'plaintext',\n            original: 'ng2.template',\n        }, [new CR(4), body, new CR(2)]);\n        var /** @type {?} */ xliff = new Tag('xliff', { version: _VERSION, xmlns: _XMLNS }, [new CR(2), file, new CR()]);\n        return serialize([\n            new Declaration({ version: '1.0', encoding: 'UTF-8' }), new CR(), xliff, new CR()\n        ]);\n    };\n    /**\n     * @param {?} content\n     * @param {?} url\n     * @return {?}\n     */\n    Xliff.prototype.load = /**\n     * @param {?} content\n     * @param {?} url\n     * @return {?}\n     */\n    function (content, url) {\n        // xliff to xml nodes\n        var /** @type {?} */ xliffParser = new XliffParser();\n        var _a = xliffParser.parse(content, url), locale = _a.locale, msgIdToHtml = _a.msgIdToHtml, errors = _a.errors;\n        // xml nodes to i18n nodes\n        var /** @type {?} */ i18nNodesByMsgId = {};\n        var /** @type {?} */ converter = new XmlToI18n();\n        Object.keys(msgIdToHtml).forEach(function (msgId) {\n            var _a = converter.convert(msgIdToHtml[msgId], url), i18nNodes = _a.i18nNodes, e = _a.errors;\n            errors.push.apply(errors, e);\n            i18nNodesByMsgId[msgId] = i18nNodes;\n        });\n        if (errors.length) {\n            throw new Error(\"xliff parse errors:\\n\" + errors.join('\\n'));\n        }\n        return { locale: /** @type {?} */ ((locale)), i18nNodesByMsgId: i18nNodesByMsgId };\n    };\n    /**\n     * @param {?} message\n     * @return {?}\n     */\n    Xliff.prototype.digest = /**\n     * @param {?} message\n     * @return {?}\n     */\n    function (message) { return digest(message); };\n    return Xliff;\n}(Serializer));\nvar _WriteVisitor = /** @class */ (function () {\n    function _WriteVisitor() {\n    }\n    /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    function (text, context) { return [new Text$2(text.value)]; };\n    /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitContainer = /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    function (container, context) {\n        var _this = this;\n        var /** @type {?} */ nodes = [];\n        container.children.forEach(function (node) { return nodes.push.apply(nodes, node.visit(_this)); });\n        return nodes;\n    };\n    /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitIcu = /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        var /** @type {?} */ nodes = [new Text$2(\"{\" + icu.expressionPlaceholder + \", \" + icu.type + \", \")];\n        Object.keys(icu.cases).forEach(function (c) {\n            nodes.push.apply(nodes, [new Text$2(c + \" {\")].concat(icu.cases[c].visit(_this), [new Text$2(\"} \")]));\n        });\n        nodes.push(new Text$2(\"}\"));\n        return nodes;\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var /** @type {?} */ ctype = getCtypeForTag(ph.tag);\n        if (ph.isVoid) {\n            // void tags have no children nor closing tags\n            return [new Tag(_PLACEHOLDER_TAG, { id: ph.startName, ctype: ctype, 'equiv-text': \"<\" + ph.tag + \"/>\" })];\n        }\n        var /** @type {?} */ startTagPh = new Tag(_PLACEHOLDER_TAG, { id: ph.startName, ctype: ctype, 'equiv-text': \"<\" + ph.tag + \">\" });\n        var /** @type {?} */ closeTagPh = new Tag(_PLACEHOLDER_TAG, { id: ph.closeName, ctype: ctype, 'equiv-text': \"</\" + ph.tag + \">\" });\n        return [startTagPh].concat(this.serialize(ph.children), [closeTagPh]);\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        return [new Tag(_PLACEHOLDER_TAG, { id: ph.name, 'equiv-text': \"{{\" + ph.value + \"}}\" })];\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var /** @type {?} */ equivText = \"{\" + ph.value.expression + \", \" + ph.value.type + \", \" + Object.keys(ph.value.cases).map(function (value) { return value + ' {...}'; }).join(' ') + \"}\";\n        return [new Tag(_PLACEHOLDER_TAG, { id: ph.name, 'equiv-text': equivText })];\n    };\n    /**\n     * @param {?} nodes\n     * @return {?}\n     */\n    _WriteVisitor.prototype.serialize = /**\n     * @param {?} nodes\n     * @return {?}\n     */\n    function (nodes) {\n        var _this = this;\n        return [].concat.apply([], nodes.map(function (node) { return node.visit(_this); }));\n    };\n    return _WriteVisitor;\n}());\nvar XliffParser = /** @class */ (function () {\n    function XliffParser() {\n        this._locale = null;\n    }\n    /**\n     * @param {?} xliff\n     * @param {?} url\n     * @return {?}\n     */\n    XliffParser.prototype.parse = /**\n     * @param {?} xliff\n     * @param {?} url\n     * @return {?}\n     */\n    function (xliff, url) {\n        this._unitMlString = null;\n        this._msgIdToHtml = {};\n        var /** @type {?} */ xml = new XmlParser().parse(xliff, url, false);\n        this._errors = xml.errors;\n        visitAll(this, xml.rootNodes, null);\n        return {\n            msgIdToHtml: this._msgIdToHtml,\n            errors: this._errors,\n            locale: this._locale,\n        };\n    };\n    /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    XliffParser.prototype.visitElement = /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    function (element, context) {\n        switch (element.name) {\n            case _UNIT_TAG:\n                this._unitMlString = /** @type {?} */ ((null));\n                var /** @type {?} */ idAttr = element.attrs.find(function (attr) { return attr.name === 'id'; });\n                if (!idAttr) {\n                    this._addError(element, \"<\" + _UNIT_TAG + \"> misses the \\\"id\\\" attribute\");\n                }\n                else {\n                    var /** @type {?} */ id = idAttr.value;\n                    if (this._msgIdToHtml.hasOwnProperty(id)) {\n                        this._addError(element, \"Duplicated translations for msg \" + id);\n                    }\n                    else {\n                        visitAll(this, element.children, null);\n                        if (typeof this._unitMlString === 'string') {\n                            this._msgIdToHtml[id] = this._unitMlString;\n                        }\n                        else {\n                            this._addError(element, \"Message \" + id + \" misses a translation\");\n                        }\n                    }\n                }\n                break;\n            // ignore those tags\n            case _SOURCE_TAG:\n            case _SEGMENT_SOURCE_TAG:\n                break;\n            case _TARGET_TAG:\n                var /** @type {?} */ innerTextStart = /** @type {?} */ ((element.startSourceSpan)).end.offset;\n                var /** @type {?} */ innerTextEnd = /** @type {?} */ ((element.endSourceSpan)).start.offset;\n                var /** @type {?} */ content = /** @type {?} */ ((element.startSourceSpan)).start.file.content;\n                var /** @type {?} */ innerText = content.slice(innerTextStart, innerTextEnd);\n                this._unitMlString = innerText;\n                break;\n            case _FILE_TAG:\n                var /** @type {?} */ localeAttr = element.attrs.find(function (attr) { return attr.name === 'target-language'; });\n                if (localeAttr) {\n                    this._locale = localeAttr.value;\n                }\n                visitAll(this, element.children, null);\n                break;\n            default:\n                // TODO(vicb): assert file structure, xliff version\n                // For now only recurse on unhandled nodes\n                visitAll(this, element.children, null);\n        }\n    };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    XliffParser.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) { };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    XliffParser.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) { };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    XliffParser.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { };\n    /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    XliffParser.prototype.visitExpansion = /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansion, context) { };\n    /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    XliffParser.prototype.visitExpansionCase = /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansionCase, context) { };\n    /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    XliffParser.prototype._addError = /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    function (node, message) {\n        this._errors.push(new I18nError(/** @type {?} */ ((node.sourceSpan)), message));\n    };\n    return XliffParser;\n}());\nvar XmlToI18n = /** @class */ (function () {\n    function XmlToI18n() {\n    }\n    /**\n     * @param {?} message\n     * @param {?} url\n     * @return {?}\n     */\n    XmlToI18n.prototype.convert = /**\n     * @param {?} message\n     * @param {?} url\n     * @return {?}\n     */\n    function (message, url) {\n        var /** @type {?} */ xmlIcu = new XmlParser().parse(message, url, true);\n        this._errors = xmlIcu.errors;\n        var /** @type {?} */ i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?\n            [] : [].concat.apply([], visitAll(this, xmlIcu.rootNodes));\n        return {\n            i18nNodes: i18nNodes,\n            errors: this._errors,\n        };\n    };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) { return new Text$1(text.value, /** @type {?} */ ((text.sourceSpan))); };\n    /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitElement = /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    function (el, context) {\n        if (el.name === _PLACEHOLDER_TAG) {\n            var /** @type {?} */ nameAttr = el.attrs.find(function (attr) { return attr.name === 'id'; });\n            if (nameAttr) {\n                return new Placeholder('', nameAttr.value, /** @type {?} */ ((el.sourceSpan)));\n            }\n            this._addError(el, \"<\" + _PLACEHOLDER_TAG + \"> misses the \\\"id\\\" attribute\");\n            return null;\n        }\n        if (el.name === _MARKER_TAG) {\n            return [].concat.apply([], visitAll(this, el.children));\n        }\n        this._addError(el, \"Unexpected tag\");\n        return null;\n    };\n    /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitExpansion = /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var /** @type {?} */ caseMap = {};\n        visitAll(this, icu.cases).forEach(function (c) {\n            caseMap[c.value] = new Container(c.nodes, icu.sourceSpan);\n        });\n        return new Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);\n    };\n    /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitExpansionCase = /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (icuCase, context) {\n        return {\n            value: icuCase.value,\n            nodes: visitAll(this, icuCase.expression),\n        };\n    };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) { };\n    /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    XmlToI18n.prototype._addError = /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    function (node, message) {\n        this._errors.push(new I18nError(/** @type {?} */ ((node.sourceSpan)), message));\n    };\n    return XmlToI18n;\n}());\n/**\n * @param {?} tag\n * @return {?}\n */\nfunction getCtypeForTag(tag) {\n    switch (tag.toLowerCase()) {\n        case 'br':\n            return 'lb';\n        case 'img':\n            return 'image';\n        default:\n            return \"x-\" + tag;\n    }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _VERSION$1 = '2.0';\nvar _XMLNS$1 = 'urn:oasis:names:tc:xliff:document:2.0';\n// TODO(vicb): make this a param (s/_/-/)\nvar _DEFAULT_SOURCE_LANG$1 = 'en';\nvar _PLACEHOLDER_TAG$1 = 'ph';\nvar _PLACEHOLDER_SPANNING_TAG = 'pc';\nvar _MARKER_TAG$1 = 'mrk';\nvar _XLIFF_TAG = 'xliff';\nvar _SOURCE_TAG$1 = 'source';\nvar _TARGET_TAG$1 = 'target';\nvar _UNIT_TAG$1 = 'unit';\nvar Xliff2 = /** @class */ (function (_super) {\n    __extends(Xliff2, _super);\n    function Xliff2() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} messages\n     * @param {?} locale\n     * @return {?}\n     */\n    Xliff2.prototype.write = /**\n     * @param {?} messages\n     * @param {?} locale\n     * @return {?}\n     */\n    function (messages, locale) {\n        var /** @type {?} */ visitor = new _WriteVisitor$1();\n        var /** @type {?} */ units = [];\n        messages.forEach(function (message) {\n            var /** @type {?} */ unit = new Tag(_UNIT_TAG$1, { id: message.id });\n            var /** @type {?} */ notes = new Tag('notes');\n            if (message.description || message.meaning) {\n                if (message.description) {\n                    notes.children.push(new CR(8), new Tag('note', { category: 'description' }, [new Text$2(message.description)]));\n                }\n                if (message.meaning) {\n                    notes.children.push(new CR(8), new Tag('note', { category: 'meaning' }, [new Text$2(message.meaning)]));\n                }\n            }\n            message.sources.forEach(function (source) {\n                notes.children.push(new CR(8), new Tag('note', { category: 'location' }, [\n                    new Text$2(source.filePath + \":\" + source.startLine + (source.endLine !== source.startLine ? ',' + source.endLine : ''))\n                ]));\n            });\n            notes.children.push(new CR(6));\n            unit.children.push(new CR(6), notes);\n            var /** @type {?} */ segment = new Tag('segment');\n            segment.children.push(new CR(8), new Tag(_SOURCE_TAG$1, {}, visitor.serialize(message.nodes)), new CR(6));\n            unit.children.push(new CR(6), segment, new CR(4));\n            units.push(new CR(4), unit);\n        });\n        var /** @type {?} */ file = new Tag('file', { 'original': 'ng.template', id: 'ngi18n' }, units.concat([new CR(2)]));\n        var /** @type {?} */ xliff = new Tag(_XLIFF_TAG, { version: _VERSION$1, xmlns: _XMLNS$1, srcLang: locale || _DEFAULT_SOURCE_LANG$1 }, [new CR(2), file, new CR()]);\n        return serialize([\n            new Declaration({ version: '1.0', encoding: 'UTF-8' }), new CR(), xliff, new CR()\n        ]);\n    };\n    /**\n     * @param {?} content\n     * @param {?} url\n     * @return {?}\n     */\n    Xliff2.prototype.load = /**\n     * @param {?} content\n     * @param {?} url\n     * @return {?}\n     */\n    function (content, url) {\n        // xliff to xml nodes\n        var /** @type {?} */ xliff2Parser = new Xliff2Parser();\n        var _a = xliff2Parser.parse(content, url), locale = _a.locale, msgIdToHtml = _a.msgIdToHtml, errors = _a.errors;\n        // xml nodes to i18n nodes\n        var /** @type {?} */ i18nNodesByMsgId = {};\n        var /** @type {?} */ converter = new XmlToI18n$1();\n        Object.keys(msgIdToHtml).forEach(function (msgId) {\n            var _a = converter.convert(msgIdToHtml[msgId], url), i18nNodes = _a.i18nNodes, e = _a.errors;\n            errors.push.apply(errors, e);\n            i18nNodesByMsgId[msgId] = i18nNodes;\n        });\n        if (errors.length) {\n            throw new Error(\"xliff2 parse errors:\\n\" + errors.join('\\n'));\n        }\n        return { locale: /** @type {?} */ ((locale)), i18nNodesByMsgId: i18nNodesByMsgId };\n    };\n    /**\n     * @param {?} message\n     * @return {?}\n     */\n    Xliff2.prototype.digest = /**\n     * @param {?} message\n     * @return {?}\n     */\n    function (message) { return decimalDigest(message); };\n    return Xliff2;\n}(Serializer));\nvar _WriteVisitor$1 = /** @class */ (function () {\n    function _WriteVisitor() {\n    }\n    /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    function (text, context) { return [new Text$2(text.value)]; };\n    /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitContainer = /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    function (container, context) {\n        var _this = this;\n        var /** @type {?} */ nodes = [];\n        container.children.forEach(function (node) { return nodes.push.apply(nodes, node.visit(_this)); });\n        return nodes;\n    };\n    /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitIcu = /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        var /** @type {?} */ nodes = [new Text$2(\"{\" + icu.expressionPlaceholder + \", \" + icu.type + \", \")];\n        Object.keys(icu.cases).forEach(function (c) {\n            nodes.push.apply(nodes, [new Text$2(c + \" {\")].concat(icu.cases[c].visit(_this), [new Text$2(\"} \")]));\n        });\n        nodes.push(new Text$2(\"}\"));\n        return nodes;\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var _this = this;\n        var /** @type {?} */ type = getTypeForTag(ph.tag);\n        if (ph.isVoid) {\n            var /** @type {?} */ tagPh = new Tag(_PLACEHOLDER_TAG$1, {\n                id: (this._nextPlaceholderId++).toString(),\n                equiv: ph.startName,\n                type: type,\n                disp: \"<\" + ph.tag + \"/>\",\n            });\n            return [tagPh];\n        }\n        var /** @type {?} */ tagPc = new Tag(_PLACEHOLDER_SPANNING_TAG, {\n            id: (this._nextPlaceholderId++).toString(),\n            equivStart: ph.startName,\n            equivEnd: ph.closeName,\n            type: type,\n            dispStart: \"<\" + ph.tag + \">\",\n            dispEnd: \"</\" + ph.tag + \">\",\n        });\n        var /** @type {?} */ nodes = [].concat.apply([], ph.children.map(function (node) { return node.visit(_this); }));\n        if (nodes.length) {\n            nodes.forEach(function (node) { return tagPc.children.push(node); });\n        }\n        else {\n            tagPc.children.push(new Text$2(''));\n        }\n        return [tagPc];\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var /** @type {?} */ idStr = (this._nextPlaceholderId++).toString();\n        return [new Tag(_PLACEHOLDER_TAG$1, {\n                id: idStr,\n                equiv: ph.name,\n                disp: \"{{\" + ph.value + \"}}\",\n            })];\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _WriteVisitor.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var /** @type {?} */ cases = Object.keys(ph.value.cases).map(function (value) { return value + ' {...}'; }).join(' ');\n        var /** @type {?} */ idStr = (this._nextPlaceholderId++).toString();\n        return [new Tag(_PLACEHOLDER_TAG$1, { id: idStr, equiv: ph.name, disp: \"{\" + ph.value.expression + \", \" + ph.value.type + \", \" + cases + \"}\" })];\n    };\n    /**\n     * @param {?} nodes\n     * @return {?}\n     */\n    _WriteVisitor.prototype.serialize = /**\n     * @param {?} nodes\n     * @return {?}\n     */\n    function (nodes) {\n        var _this = this;\n        this._nextPlaceholderId = 0;\n        return [].concat.apply([], nodes.map(function (node) { return node.visit(_this); }));\n    };\n    return _WriteVisitor;\n}());\nvar Xliff2Parser = /** @class */ (function () {\n    function Xliff2Parser() {\n        this._locale = null;\n    }\n    /**\n     * @param {?} xliff\n     * @param {?} url\n     * @return {?}\n     */\n    Xliff2Parser.prototype.parse = /**\n     * @param {?} xliff\n     * @param {?} url\n     * @return {?}\n     */\n    function (xliff, url) {\n        this._unitMlString = null;\n        this._msgIdToHtml = {};\n        var /** @type {?} */ xml = new XmlParser().parse(xliff, url, false);\n        this._errors = xml.errors;\n        visitAll(this, xml.rootNodes, null);\n        return {\n            msgIdToHtml: this._msgIdToHtml,\n            errors: this._errors,\n            locale: this._locale,\n        };\n    };\n    /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    Xliff2Parser.prototype.visitElement = /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    function (element, context) {\n        switch (element.name) {\n            case _UNIT_TAG$1:\n                this._unitMlString = null;\n                var /** @type {?} */ idAttr = element.attrs.find(function (attr) { return attr.name === 'id'; });\n                if (!idAttr) {\n                    this._addError(element, \"<\" + _UNIT_TAG$1 + \"> misses the \\\"id\\\" attribute\");\n                }\n                else {\n                    var /** @type {?} */ id = idAttr.value;\n                    if (this._msgIdToHtml.hasOwnProperty(id)) {\n                        this._addError(element, \"Duplicated translations for msg \" + id);\n                    }\n                    else {\n                        visitAll(this, element.children, null);\n                        if (typeof this._unitMlString === 'string') {\n                            this._msgIdToHtml[id] = this._unitMlString;\n                        }\n                        else {\n                            this._addError(element, \"Message \" + id + \" misses a translation\");\n                        }\n                    }\n                }\n                break;\n            case _SOURCE_TAG$1:\n                // ignore source message\n                break;\n            case _TARGET_TAG$1:\n                var /** @type {?} */ innerTextStart = /** @type {?} */ ((element.startSourceSpan)).end.offset;\n                var /** @type {?} */ innerTextEnd = /** @type {?} */ ((element.endSourceSpan)).start.offset;\n                var /** @type {?} */ content = /** @type {?} */ ((element.startSourceSpan)).start.file.content;\n                var /** @type {?} */ innerText = content.slice(innerTextStart, innerTextEnd);\n                this._unitMlString = innerText;\n                break;\n            case _XLIFF_TAG:\n                var /** @type {?} */ localeAttr = element.attrs.find(function (attr) { return attr.name === 'trgLang'; });\n                if (localeAttr) {\n                    this._locale = localeAttr.value;\n                }\n                var /** @type {?} */ versionAttr = element.attrs.find(function (attr) { return attr.name === 'version'; });\n                if (versionAttr) {\n                    var /** @type {?} */ version = versionAttr.value;\n                    if (version !== '2.0') {\n                        this._addError(element, \"The XLIFF file version \" + version + \" is not compatible with XLIFF 2.0 serializer\");\n                    }\n                    else {\n                        visitAll(this, element.children, null);\n                    }\n                }\n                break;\n            default:\n                visitAll(this, element.children, null);\n        }\n    };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    Xliff2Parser.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) { };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    Xliff2Parser.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) { };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    Xliff2Parser.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { };\n    /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    Xliff2Parser.prototype.visitExpansion = /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansion, context) { };\n    /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    Xliff2Parser.prototype.visitExpansionCase = /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansionCase, context) { };\n    /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    Xliff2Parser.prototype._addError = /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    function (node, message) {\n        this._errors.push(new I18nError(node.sourceSpan, message));\n    };\n    return Xliff2Parser;\n}());\nvar XmlToI18n$1 = /** @class */ (function () {\n    function XmlToI18n() {\n    }\n    /**\n     * @param {?} message\n     * @param {?} url\n     * @return {?}\n     */\n    XmlToI18n.prototype.convert = /**\n     * @param {?} message\n     * @param {?} url\n     * @return {?}\n     */\n    function (message, url) {\n        var /** @type {?} */ xmlIcu = new XmlParser().parse(message, url, true);\n        this._errors = xmlIcu.errors;\n        var /** @type {?} */ i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?\n            [] : [].concat.apply([], visitAll(this, xmlIcu.rootNodes));\n        return {\n            i18nNodes: i18nNodes,\n            errors: this._errors,\n        };\n    };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) { return new Text$1(text.value, text.sourceSpan); };\n    /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitElement = /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    function (el, context) {\n        var _this = this;\n        switch (el.name) {\n            case _PLACEHOLDER_TAG$1:\n                var /** @type {?} */ nameAttr = el.attrs.find(function (attr) { return attr.name === 'equiv'; });\n                if (nameAttr) {\n                    return [new Placeholder('', nameAttr.value, el.sourceSpan)];\n                }\n                this._addError(el, \"<\" + _PLACEHOLDER_TAG$1 + \"> misses the \\\"equiv\\\" attribute\");\n                break;\n            case _PLACEHOLDER_SPANNING_TAG:\n                var /** @type {?} */ startAttr = el.attrs.find(function (attr) { return attr.name === 'equivStart'; });\n                var /** @type {?} */ endAttr = el.attrs.find(function (attr) { return attr.name === 'equivEnd'; });\n                if (!startAttr) {\n                    this._addError(el, \"<\" + _PLACEHOLDER_TAG$1 + \"> misses the \\\"equivStart\\\" attribute\");\n                }\n                else if (!endAttr) {\n                    this._addError(el, \"<\" + _PLACEHOLDER_TAG$1 + \"> misses the \\\"equivEnd\\\" attribute\");\n                }\n                else {\n                    var /** @type {?} */ startId = startAttr.value;\n                    var /** @type {?} */ endId = endAttr.value;\n                    var /** @type {?} */ nodes = [];\n                    return nodes.concat.apply(nodes, [new Placeholder('', startId, el.sourceSpan)].concat(el.children.map(function (node) { return node.visit(_this, null); }), [new Placeholder('', endId, el.sourceSpan)]));\n                }\n                break;\n            case _MARKER_TAG$1:\n                return [].concat.apply([], visitAll(this, el.children));\n            default:\n                this._addError(el, \"Unexpected tag\");\n        }\n        return null;\n    };\n    /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitExpansion = /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var /** @type {?} */ caseMap = {};\n        visitAll(this, icu.cases).forEach(function (c) {\n            caseMap[c.value] = new Container(c.nodes, icu.sourceSpan);\n        });\n        return new Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);\n    };\n    /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitExpansionCase = /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (icuCase, context) {\n        return {\n            value: icuCase.value,\n            nodes: [].concat.apply([], visitAll(this, icuCase.expression)),\n        };\n    };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) { };\n    /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    XmlToI18n.prototype._addError = /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    function (node, message) {\n        this._errors.push(new I18nError(node.sourceSpan, message));\n    };\n    return XmlToI18n;\n}());\n/**\n * @param {?} tag\n * @return {?}\n */\nfunction getTypeForTag(tag) {\n    switch (tag.toLowerCase()) {\n        case 'br':\n        case 'b':\n        case 'i':\n        case 'u':\n            return 'fmt';\n        case 'img':\n            return 'image';\n        case 'a':\n            return 'link';\n        default:\n            return 'other';\n    }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _MESSAGES_TAG = 'messagebundle';\nvar _MESSAGE_TAG = 'msg';\nvar _PLACEHOLDER_TAG$2 = 'ph';\nvar _EXEMPLE_TAG = 'ex';\nvar _SOURCE_TAG$2 = 'source';\nvar _DOCTYPE = \"<!ELEMENT messagebundle (msg)*>\\n<!ATTLIST messagebundle class CDATA #IMPLIED>\\n\\n<!ELEMENT msg (#PCDATA|ph|source)*>\\n<!ATTLIST msg id CDATA #IMPLIED>\\n<!ATTLIST msg seq CDATA #IMPLIED>\\n<!ATTLIST msg name CDATA #IMPLIED>\\n<!ATTLIST msg desc CDATA #IMPLIED>\\n<!ATTLIST msg meaning CDATA #IMPLIED>\\n<!ATTLIST msg obsolete (obsolete) #IMPLIED>\\n<!ATTLIST msg xml:space (default|preserve) \\\"default\\\">\\n<!ATTLIST msg is_hidden CDATA #IMPLIED>\\n\\n<!ELEMENT source (#PCDATA)>\\n\\n<!ELEMENT ph (#PCDATA|ex)*>\\n<!ATTLIST ph name CDATA #REQUIRED>\\n\\n<!ELEMENT ex (#PCDATA)>\";\nvar Xmb = /** @class */ (function (_super) {\n    __extends(Xmb, _super);\n    function Xmb() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} messages\n     * @param {?} locale\n     * @return {?}\n     */\n    Xmb.prototype.write = /**\n     * @param {?} messages\n     * @param {?} locale\n     * @return {?}\n     */\n    function (messages, locale) {\n        var /** @type {?} */ exampleVisitor = new ExampleVisitor();\n        var /** @type {?} */ visitor = new _Visitor$2();\n        var /** @type {?} */ rootNode = new Tag(_MESSAGES_TAG);\n        messages.forEach(function (message) {\n            var /** @type {?} */ attrs = { id: message.id };\n            if (message.description) {\n                attrs['desc'] = message.description;\n            }\n            if (message.meaning) {\n                attrs['meaning'] = message.meaning;\n            }\n            var /** @type {?} */ sourceTags = [];\n            message.sources.forEach(function (source) {\n                sourceTags.push(new Tag(_SOURCE_TAG$2, {}, [\n                    new Text$2(source.filePath + \":\" + source.startLine + (source.endLine !== source.startLine ? ',' + source.endLine : ''))\n                ]));\n            });\n            rootNode.children.push(new CR(2), new Tag(_MESSAGE_TAG, attrs, sourceTags.concat(visitor.serialize(message.nodes))));\n        });\n        rootNode.children.push(new CR());\n        return serialize([\n            new Declaration({ version: '1.0', encoding: 'UTF-8' }),\n            new CR(),\n            new Doctype(_MESSAGES_TAG, _DOCTYPE),\n            new CR(),\n            exampleVisitor.addDefaultExamples(rootNode),\n            new CR(),\n        ]);\n    };\n    /**\n     * @param {?} content\n     * @param {?} url\n     * @return {?}\n     */\n    Xmb.prototype.load = /**\n     * @param {?} content\n     * @param {?} url\n     * @return {?}\n     */\n    function (content, url) {\n        throw new Error('Unsupported');\n    };\n    /**\n     * @param {?} message\n     * @return {?}\n     */\n    Xmb.prototype.digest = /**\n     * @param {?} message\n     * @return {?}\n     */\n    function (message) { return digest$1(message); };\n    /**\n     * @param {?} message\n     * @return {?}\n     */\n    Xmb.prototype.createNameMapper = /**\n     * @param {?} message\n     * @return {?}\n     */\n    function (message) {\n        return new SimplePlaceholderMapper(message, toPublicName);\n    };\n    return Xmb;\n}(Serializer));\nvar _Visitor$2 = /** @class */ (function () {\n    function _Visitor() {\n    }\n    /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    function (text, context) { return [new Text$2(text.value)]; };\n    /**\n     * @param {?} container\n     * @param {?} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitContainer = /**\n     * @param {?} container\n     * @param {?} context\n     * @return {?}\n     */\n    function (container, context) {\n        var _this = this;\n        var /** @type {?} */ nodes = [];\n        container.children.forEach(function (node) { return nodes.push.apply(nodes, node.visit(_this)); });\n        return nodes;\n    };\n    /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitIcu = /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        var /** @type {?} */ nodes = [new Text$2(\"{\" + icu.expressionPlaceholder + \", \" + icu.type + \", \")];\n        Object.keys(icu.cases).forEach(function (c) {\n            nodes.push.apply(nodes, [new Text$2(c + \" {\")].concat(icu.cases[c].visit(_this), [new Text$2(\"} \")]));\n        });\n        nodes.push(new Text$2(\"}\"));\n        return nodes;\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var /** @type {?} */ startEx = new Tag(_EXEMPLE_TAG, {}, [new Text$2(\"<\" + ph.tag + \">\")]);\n        var /** @type {?} */ startTagPh = new Tag(_PLACEHOLDER_TAG$2, { name: ph.startName }, [startEx]);\n        if (ph.isVoid) {\n            // void tags have no children nor closing tags\n            return [startTagPh];\n        }\n        var /** @type {?} */ closeEx = new Tag(_EXEMPLE_TAG, {}, [new Text$2(\"</\" + ph.tag + \">\")]);\n        var /** @type {?} */ closeTagPh = new Tag(_PLACEHOLDER_TAG$2, { name: ph.closeName }, [closeEx]);\n        return [startTagPh].concat(this.serialize(ph.children), [closeTagPh]);\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var /** @type {?} */ exTag = new Tag(_EXEMPLE_TAG, {}, [new Text$2(\"{{\" + ph.value + \"}}\")]);\n        return [new Tag(_PLACEHOLDER_TAG$2, { name: ph.name }, [exTag])];\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    _Visitor.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var /** @type {?} */ exTag = new Tag(_EXEMPLE_TAG, {}, [\n            new Text$2(\"{\" + ph.value.expression + \", \" + ph.value.type + \", \" + Object.keys(ph.value.cases).map(function (value) { return value + ' {...}'; }).join(' ') + \"}\")\n        ]);\n        return [new Tag(_PLACEHOLDER_TAG$2, { name: ph.name }, [exTag])];\n    };\n    /**\n     * @param {?} nodes\n     * @return {?}\n     */\n    _Visitor.prototype.serialize = /**\n     * @param {?} nodes\n     * @return {?}\n     */\n    function (nodes) {\n        var _this = this;\n        return [].concat.apply([], nodes.map(function (node) { return node.visit(_this); }));\n    };\n    return _Visitor;\n}());\n/**\n * @param {?} message\n * @return {?}\n */\nfunction digest$1(message) {\n    return decimalDigest(message);\n}\nvar ExampleVisitor = /** @class */ (function () {\n    function ExampleVisitor() {\n    }\n    /**\n     * @param {?} node\n     * @return {?}\n     */\n    ExampleVisitor.prototype.addDefaultExamples = /**\n     * @param {?} node\n     * @return {?}\n     */\n    function (node) {\n        node.visit(this);\n        return node;\n    };\n    /**\n     * @param {?} tag\n     * @return {?}\n     */\n    ExampleVisitor.prototype.visitTag = /**\n     * @param {?} tag\n     * @return {?}\n     */\n    function (tag) {\n        var _this = this;\n        if (tag.name === _PLACEHOLDER_TAG$2) {\n            if (!tag.children || tag.children.length == 0) {\n                var /** @type {?} */ exText = new Text$2(tag.attrs['name'] || '...');\n                tag.children = [new Tag(_EXEMPLE_TAG, {}, [exText])];\n            }\n        }\n        else if (tag.children) {\n            tag.children.forEach(function (node) { return node.visit(_this); });\n        }\n    };\n    /**\n     * @param {?} text\n     * @return {?}\n     */\n    ExampleVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @return {?}\n     */\n    function (text) { };\n    /**\n     * @param {?} decl\n     * @return {?}\n     */\n    ExampleVisitor.prototype.visitDeclaration = /**\n     * @param {?} decl\n     * @return {?}\n     */\n    function (decl) { };\n    /**\n     * @param {?} doctype\n     * @return {?}\n     */\n    ExampleVisitor.prototype.visitDoctype = /**\n     * @param {?} doctype\n     * @return {?}\n     */\n    function (doctype) { };\n    return ExampleVisitor;\n}());\n/**\n * @param {?} internalName\n * @return {?}\n */\nfunction toPublicName(internalName) {\n    return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_');\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _TRANSLATIONS_TAG = 'translationbundle';\nvar _TRANSLATION_TAG = 'translation';\nvar _PLACEHOLDER_TAG$3 = 'ph';\nvar Xtb = /** @class */ (function (_super) {\n    __extends(Xtb, _super);\n    function Xtb() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} messages\n     * @param {?} locale\n     * @return {?}\n     */\n    Xtb.prototype.write = /**\n     * @param {?} messages\n     * @param {?} locale\n     * @return {?}\n     */\n    function (messages, locale) { throw new Error('Unsupported'); };\n    /**\n     * @param {?} content\n     * @param {?} url\n     * @return {?}\n     */\n    Xtb.prototype.load = /**\n     * @param {?} content\n     * @param {?} url\n     * @return {?}\n     */\n    function (content, url) {\n        // xtb to xml nodes\n        var /** @type {?} */ xtbParser = new XtbParser();\n        var _a = xtbParser.parse(content, url), locale = _a.locale, msgIdToHtml = _a.msgIdToHtml, errors = _a.errors;\n        // xml nodes to i18n nodes\n        var /** @type {?} */ i18nNodesByMsgId = {};\n        var /** @type {?} */ converter = new XmlToI18n$2();\n        // Because we should be able to load xtb files that rely on features not supported by angular,\n        // we need to delay the conversion of html to i18n nodes so that non angular messages are not\n        // converted\n        Object.keys(msgIdToHtml).forEach(function (msgId) {\n            var /** @type {?} */ valueFn = function () {\n                var _a = converter.convert(msgIdToHtml[msgId], url), i18nNodes = _a.i18nNodes, errors = _a.errors;\n                if (errors.length) {\n                    throw new Error(\"xtb parse errors:\\n\" + errors.join('\\n'));\n                }\n                return i18nNodes;\n            };\n            createLazyProperty(i18nNodesByMsgId, msgId, valueFn);\n        });\n        if (errors.length) {\n            throw new Error(\"xtb parse errors:\\n\" + errors.join('\\n'));\n        }\n        return { locale: /** @type {?} */ ((locale)), i18nNodesByMsgId: i18nNodesByMsgId };\n    };\n    /**\n     * @param {?} message\n     * @return {?}\n     */\n    Xtb.prototype.digest = /**\n     * @param {?} message\n     * @return {?}\n     */\n    function (message) { return digest$1(message); };\n    /**\n     * @param {?} message\n     * @return {?}\n     */\n    Xtb.prototype.createNameMapper = /**\n     * @param {?} message\n     * @return {?}\n     */\n    function (message) {\n        return new SimplePlaceholderMapper(message, toPublicName);\n    };\n    return Xtb;\n}(Serializer));\n/**\n * @param {?} messages\n * @param {?} id\n * @param {?} valueFn\n * @return {?}\n */\nfunction createLazyProperty(messages, id, valueFn) {\n    Object.defineProperty(messages, id, {\n        configurable: true,\n        enumerable: true,\n        get: function () {\n            var /** @type {?} */ value = valueFn();\n            Object.defineProperty(messages, id, { enumerable: true, value: value });\n            return value;\n        },\n        set: function (_) { throw new Error('Could not overwrite an XTB translation'); },\n    });\n}\nvar XtbParser = /** @class */ (function () {\n    function XtbParser() {\n        this._locale = null;\n    }\n    /**\n     * @param {?} xtb\n     * @param {?} url\n     * @return {?}\n     */\n    XtbParser.prototype.parse = /**\n     * @param {?} xtb\n     * @param {?} url\n     * @return {?}\n     */\n    function (xtb, url) {\n        this._bundleDepth = 0;\n        this._msgIdToHtml = {};\n        // We can not parse the ICU messages at this point as some messages might not originate\n        // from Angular that could not be lex'd.\n        var /** @type {?} */ xml = new XmlParser().parse(xtb, url, false);\n        this._errors = xml.errors;\n        visitAll(this, xml.rootNodes);\n        return {\n            msgIdToHtml: this._msgIdToHtml,\n            errors: this._errors,\n            locale: this._locale,\n        };\n    };\n    /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    XtbParser.prototype.visitElement = /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    function (element, context) {\n        switch (element.name) {\n            case _TRANSLATIONS_TAG:\n                this._bundleDepth++;\n                if (this._bundleDepth > 1) {\n                    this._addError(element, \"<\" + _TRANSLATIONS_TAG + \"> elements can not be nested\");\n                }\n                var /** @type {?} */ langAttr = element.attrs.find(function (attr) { return attr.name === 'lang'; });\n                if (langAttr) {\n                    this._locale = langAttr.value;\n                }\n                visitAll(this, element.children, null);\n                this._bundleDepth--;\n                break;\n            case _TRANSLATION_TAG:\n                var /** @type {?} */ idAttr = element.attrs.find(function (attr) { return attr.name === 'id'; });\n                if (!idAttr) {\n                    this._addError(element, \"<\" + _TRANSLATION_TAG + \"> misses the \\\"id\\\" attribute\");\n                }\n                else {\n                    var /** @type {?} */ id = idAttr.value;\n                    if (this._msgIdToHtml.hasOwnProperty(id)) {\n                        this._addError(element, \"Duplicated translations for msg \" + id);\n                    }\n                    else {\n                        var /** @type {?} */ innerTextStart = /** @type {?} */ ((element.startSourceSpan)).end.offset;\n                        var /** @type {?} */ innerTextEnd = /** @type {?} */ ((element.endSourceSpan)).start.offset;\n                        var /** @type {?} */ content = /** @type {?} */ ((element.startSourceSpan)).start.file.content;\n                        var /** @type {?} */ innerText = content.slice(/** @type {?} */ ((innerTextStart)), /** @type {?} */ ((innerTextEnd)));\n                        this._msgIdToHtml[id] = innerText;\n                    }\n                }\n                break;\n            default:\n                this._addError(element, 'Unexpected tag');\n        }\n    };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    XtbParser.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) { };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    XtbParser.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) { };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    XtbParser.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { };\n    /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    XtbParser.prototype.visitExpansion = /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansion, context) { };\n    /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    XtbParser.prototype.visitExpansionCase = /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansionCase, context) { };\n    /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    XtbParser.prototype._addError = /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    function (node, message) {\n        this._errors.push(new I18nError(/** @type {?} */ ((node.sourceSpan)), message));\n    };\n    return XtbParser;\n}());\nvar XmlToI18n$2 = /** @class */ (function () {\n    function XmlToI18n() {\n    }\n    /**\n     * @param {?} message\n     * @param {?} url\n     * @return {?}\n     */\n    XmlToI18n.prototype.convert = /**\n     * @param {?} message\n     * @param {?} url\n     * @return {?}\n     */\n    function (message, url) {\n        var /** @type {?} */ xmlIcu = new XmlParser().parse(message, url, true);\n        this._errors = xmlIcu.errors;\n        var /** @type {?} */ i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ?\n            [] :\n            visitAll(this, xmlIcu.rootNodes);\n        return {\n            i18nNodes: i18nNodes,\n            errors: this._errors,\n        };\n    };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) { return new Text$1(text.value, /** @type {?} */ ((text.sourceSpan))); };\n    /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitExpansion = /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var /** @type {?} */ caseMap = {};\n        visitAll(this, icu.cases).forEach(function (c) {\n            caseMap[c.value] = new Container(c.nodes, icu.sourceSpan);\n        });\n        return new Icu(icu.switchValue, icu.type, caseMap, icu.sourceSpan);\n    };\n    /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitExpansionCase = /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (icuCase, context) {\n        return {\n            value: icuCase.value,\n            nodes: visitAll(this, icuCase.expression),\n        };\n    };\n    /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitElement = /**\n     * @param {?} el\n     * @param {?} context\n     * @return {?}\n     */\n    function (el, context) {\n        if (el.name === _PLACEHOLDER_TAG$3) {\n            var /** @type {?} */ nameAttr = el.attrs.find(function (attr) { return attr.name === 'name'; });\n            if (nameAttr) {\n                return new Placeholder('', nameAttr.value, /** @type {?} */ ((el.sourceSpan)));\n            }\n            this._addError(el, \"<\" + _PLACEHOLDER_TAG$3 + \"> misses the \\\"name\\\" attribute\");\n        }\n        else {\n            this._addError(el, \"Unexpected tag\");\n        }\n        return null;\n    };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    XmlToI18n.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) { };\n    /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    XmlToI18n.prototype._addError = /**\n     * @param {?} node\n     * @param {?} message\n     * @return {?}\n     */\n    function (node, message) {\n        this._errors.push(new I18nError(/** @type {?} */ ((node.sourceSpan)), message));\n    };\n    return XmlToI18n;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar HtmlParser = /** @class */ (function (_super) {\n    __extends(HtmlParser, _super);\n    function HtmlParser() {\n        return _super.call(this, getHtmlTagDefinition) || this;\n    }\n    /**\n     * @param {?} source\n     * @param {?} url\n     * @param {?=} parseExpansionForms\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    HtmlParser.prototype.parse = /**\n     * @param {?} source\n     * @param {?} url\n     * @param {?=} parseExpansionForms\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    function (source, url, parseExpansionForms, interpolationConfig) {\n        if (parseExpansionForms === void 0) { parseExpansionForms = false; }\n        if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        return _super.prototype.parse.call(this, source, url, parseExpansionForms, interpolationConfig);\n    };\n    return HtmlParser;\n}(Parser$1));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A container for translated messages\n */\nvar TranslationBundle = /** @class */ (function () {\n    function TranslationBundle(_i18nNodesByMsgId, locale, digest, mapperFactory, missingTranslationStrategy, console) {\n        if (_i18nNodesByMsgId === void 0) { _i18nNodesByMsgId = {}; }\n        if (missingTranslationStrategy === void 0) { missingTranslationStrategy = MissingTranslationStrategy.Warning; }\n        this._i18nNodesByMsgId = _i18nNodesByMsgId;\n        this.digest = digest;\n        this.mapperFactory = mapperFactory;\n        this._i18nToHtml = new I18nToHtmlVisitor(_i18nNodesByMsgId, locale, digest, /** @type {?} */ ((mapperFactory)), missingTranslationStrategy, console);\n    }\n    // Creates a `TranslationBundle` by parsing the given `content` with the `serializer`.\n    /**\n     * @param {?} content\n     * @param {?} url\n     * @param {?} serializer\n     * @param {?} missingTranslationStrategy\n     * @param {?=} console\n     * @return {?}\n     */\n    TranslationBundle.load = /**\n     * @param {?} content\n     * @param {?} url\n     * @param {?} serializer\n     * @param {?} missingTranslationStrategy\n     * @param {?=} console\n     * @return {?}\n     */\n    function (content, url, serializer, missingTranslationStrategy, console) {\n        var _a = serializer.load(content, url), locale = _a.locale, i18nNodesByMsgId = _a.i18nNodesByMsgId;\n        var /** @type {?} */ digestFn = function (m) { return serializer.digest(m); };\n        var /** @type {?} */ mapperFactory = function (m) { return ((serializer.createNameMapper(m))); };\n        return new TranslationBundle(i18nNodesByMsgId, locale, digestFn, mapperFactory, missingTranslationStrategy, console);\n    };\n    // Returns the translation as HTML nodes from the given source message.\n    /**\n     * @param {?} srcMsg\n     * @return {?}\n     */\n    TranslationBundle.prototype.get = /**\n     * @param {?} srcMsg\n     * @return {?}\n     */\n    function (srcMsg) {\n        var /** @type {?} */ html = this._i18nToHtml.convert(srcMsg);\n        if (html.errors.length) {\n            throw new Error(html.errors.join('\\n'));\n        }\n        return html.nodes;\n    };\n    /**\n     * @param {?} srcMsg\n     * @return {?}\n     */\n    TranslationBundle.prototype.has = /**\n     * @param {?} srcMsg\n     * @return {?}\n     */\n    function (srcMsg) { return this.digest(srcMsg) in this._i18nNodesByMsgId; };\n    return TranslationBundle;\n}());\nvar I18nToHtmlVisitor = /** @class */ (function () {\n    function I18nToHtmlVisitor(_i18nNodesByMsgId, _locale, _digest, _mapperFactory, _missingTranslationStrategy, _console) {\n        if (_i18nNodesByMsgId === void 0) { _i18nNodesByMsgId = {}; }\n        this._i18nNodesByMsgId = _i18nNodesByMsgId;\n        this._locale = _locale;\n        this._digest = _digest;\n        this._mapperFactory = _mapperFactory;\n        this._missingTranslationStrategy = _missingTranslationStrategy;\n        this._console = _console;\n        this._contextStack = [];\n        this._errors = [];\n    }\n    /**\n     * @param {?} srcMsg\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype.convert = /**\n     * @param {?} srcMsg\n     * @return {?}\n     */\n    function (srcMsg) {\n        this._contextStack.length = 0;\n        this._errors.length = 0;\n        // i18n to text\n        var /** @type {?} */ text = this._convertToText(srcMsg);\n        // text to html\n        var /** @type {?} */ url = srcMsg.nodes[0].sourceSpan.start.file.url;\n        var /** @type {?} */ html = new HtmlParser().parse(text, url, true);\n        return {\n            nodes: html.rootNodes,\n            errors: this._errors.concat(html.errors),\n        };\n    };\n    /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?=} context\n     * @return {?}\n     */\n    function (text, context) {\n        // `convert()` uses an `HtmlParser` to return `html.Node`s\n        // we should then make sure that any special characters are escaped\n        return escapeXml(text.value);\n    };\n    /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype.visitContainer = /**\n     * @param {?} container\n     * @param {?=} context\n     * @return {?}\n     */\n    function (container, context) {\n        var _this = this;\n        return container.children.map(function (n) { return n.visit(_this); }).join('');\n    };\n    /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype.visitIcu = /**\n     * @param {?} icu\n     * @param {?=} context\n     * @return {?}\n     */\n    function (icu, context) {\n        var _this = this;\n        var /** @type {?} */ cases = Object.keys(icu.cases).map(function (k) { return k + \" {\" + icu.cases[k].visit(_this) + \"}\"; });\n        // TODO(vicb): Once all format switch to using expression placeholders\n        // we should throw when the placeholder is not in the source message\n        var /** @type {?} */ exp = this._srcMsg.placeholders.hasOwnProperty(icu.expression) ?\n            this._srcMsg.placeholders[icu.expression] :\n            icu.expression;\n        return \"{\" + exp + \", \" + icu.type + \", \" + cases.join(' ') + \"}\";\n    };\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var /** @type {?} */ phName = this._mapper(ph.name);\n        if (this._srcMsg.placeholders.hasOwnProperty(phName)) {\n            return this._srcMsg.placeholders[phName];\n        }\n        if (this._srcMsg.placeholderToMessage.hasOwnProperty(phName)) {\n            return this._convertToText(this._srcMsg.placeholderToMessage[phName]);\n        }\n        this._addError(ph, \"Unknown placeholder \\\"\" + ph.name + \"\\\"\");\n        return '';\n    };\n    // Loaded message contains only placeholders (vs tag and icu placeholders).\n    // However when a translation can not be found, we need to serialize the source message\n    // which can contain tag placeholders\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        var _this = this;\n        var /** @type {?} */ tag = \"\" + ph.tag;\n        var /** @type {?} */ attrs = Object.keys(ph.attrs).map(function (name) { return name + \"=\\\"\" + ph.attrs[name] + \"\\\"\"; }).join(' ');\n        if (ph.isVoid) {\n            return \"<\" + tag + \" \" + attrs + \"/>\";\n        }\n        var /** @type {?} */ children = ph.children.map(function (c) { return c.visit(_this); }).join('');\n        return \"<\" + tag + \" \" + attrs + \">\" + children + \"</\" + tag + \">\";\n    };\n    // Loaded message contains only placeholders (vs tag and icu placeholders).\n    // However when a translation can not be found, we need to serialize the source message\n    // which can contain tag placeholders\n    /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?=} context\n     * @return {?}\n     */\n    function (ph, context) {\n        // An ICU placeholder references the source message to be serialized\n        return this._convertToText(this._srcMsg.placeholderToMessage[ph.name]);\n    };\n    /**\n     * Convert a source message to a translated text string:\n     * - text nodes are replaced with their translation,\n     * - placeholders are replaced with their content,\n     * - ICU nodes are converted to ICU expressions.\n     * @param {?} srcMsg\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype._convertToText = /**\n     * Convert a source message to a translated text string:\n     * - text nodes are replaced with their translation,\n     * - placeholders are replaced with their content,\n     * - ICU nodes are converted to ICU expressions.\n     * @param {?} srcMsg\n     * @return {?}\n     */\n    function (srcMsg) {\n        var _this = this;\n        var /** @type {?} */ id = this._digest(srcMsg);\n        var /** @type {?} */ mapper = this._mapperFactory ? this._mapperFactory(srcMsg) : null;\n        var /** @type {?} */ nodes;\n        this._contextStack.push({ msg: this._srcMsg, mapper: this._mapper });\n        this._srcMsg = srcMsg;\n        if (this._i18nNodesByMsgId.hasOwnProperty(id)) {\n            // When there is a translation use its nodes as the source\n            // And create a mapper to convert serialized placeholder names to internal names\n            nodes = this._i18nNodesByMsgId[id];\n            this._mapper = function (name) { return mapper ? /** @type {?} */ ((mapper.toInternalName(name))) : name; };\n        }\n        else {\n            // When no translation has been found\n            // - report an error / a warning / nothing,\n            // - use the nodes from the original message\n            // - placeholders are already internal and need no mapper\n            if (this._missingTranslationStrategy === MissingTranslationStrategy.Error) {\n                var /** @type {?} */ ctx = this._locale ? \" for locale \\\"\" + this._locale + \"\\\"\" : '';\n                this._addError(srcMsg.nodes[0], \"Missing translation for message \\\"\" + id + \"\\\"\" + ctx);\n            }\n            else if (this._console &&\n                this._missingTranslationStrategy === MissingTranslationStrategy.Warning) {\n                var /** @type {?} */ ctx = this._locale ? \" for locale \\\"\" + this._locale + \"\\\"\" : '';\n                this._console.warn(\"Missing translation for message \\\"\" + id + \"\\\"\" + ctx);\n            }\n            nodes = srcMsg.nodes;\n            this._mapper = function (name) { return name; };\n        }\n        var /** @type {?} */ text = nodes.map(function (node) { return node.visit(_this); }).join('');\n        var /** @type {?} */ context = /** @type {?} */ ((this._contextStack.pop()));\n        this._srcMsg = context.msg;\n        this._mapper = context.mapper;\n        return text;\n    };\n    /**\n     * @param {?} el\n     * @param {?} msg\n     * @return {?}\n     */\n    I18nToHtmlVisitor.prototype._addError = /**\n     * @param {?} el\n     * @param {?} msg\n     * @return {?}\n     */\n    function (el, msg) {\n        this._errors.push(new I18nError(el.sourceSpan, msg));\n    };\n    return I18nToHtmlVisitor;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar I18NHtmlParser = /** @class */ (function () {\n    function I18NHtmlParser(_htmlParser, translations, translationsFormat, missingTranslation, console) {\n        if (missingTranslation === void 0) { missingTranslation = MissingTranslationStrategy.Warning; }\n        this._htmlParser = _htmlParser;\n        if (translations) {\n            var /** @type {?} */ serializer = createSerializer(translationsFormat);\n            this._translationBundle =\n                TranslationBundle.load(translations, 'i18n', serializer, missingTranslation, console);\n        }\n        else {\n            this._translationBundle =\n                new TranslationBundle({}, null, digest, undefined, missingTranslation, console);\n        }\n    }\n    /**\n     * @param {?} source\n     * @param {?} url\n     * @param {?=} parseExpansionForms\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    I18NHtmlParser.prototype.parse = /**\n     * @param {?} source\n     * @param {?} url\n     * @param {?=} parseExpansionForms\n     * @param {?=} interpolationConfig\n     * @return {?}\n     */\n    function (source, url, parseExpansionForms, interpolationConfig) {\n        if (parseExpansionForms === void 0) { parseExpansionForms = false; }\n        if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; }\n        var /** @type {?} */ parseResult = this._htmlParser.parse(source, url, parseExpansionForms, interpolationConfig);\n        if (parseResult.errors.length) {\n            return new ParseTreeResult(parseResult.rootNodes, parseResult.errors);\n        }\n        return mergeTranslations(parseResult.rootNodes, this._translationBundle, interpolationConfig, [], {});\n    };\n    return I18NHtmlParser;\n}());\n/**\n * @param {?=} format\n * @return {?}\n */\nfunction createSerializer(format) {\n    format = (format || 'xlf').toLowerCase();\n    switch (format) {\n        case 'xmb':\n            return new Xmb();\n        case 'xtb':\n            return new Xtb();\n        case 'xliff2':\n        case 'xlf2':\n            return new Xliff2();\n        case 'xliff':\n        case 'xlf':\n        default:\n            return new Xliff();\n    }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar STRIP_SRC_FILE_SUFFIXES = /(\\.ts|\\.d\\.ts|\\.js|\\.jsx|\\.tsx)$/;\nvar GENERATED_FILE = /\\.ngfactory\\.|\\.ngsummary\\./;\nvar JIT_SUMMARY_FILE = /\\.ngsummary\\./;\nvar JIT_SUMMARY_NAME = /NgSummary$/;\n/**\n * @param {?} filePath\n * @param {?=} forceSourceFile\n * @return {?}\n */\nfunction ngfactoryFilePath(filePath, forceSourceFile) {\n    if (forceSourceFile === void 0) { forceSourceFile = false; }\n    var /** @type {?} */ urlWithSuffix = splitTypescriptSuffix(filePath, forceSourceFile);\n    return urlWithSuffix[0] + \".ngfactory\" + normalizeGenFileSuffix(urlWithSuffix[1]);\n}\n/**\n * @param {?} filePath\n * @return {?}\n */\nfunction stripGeneratedFileSuffix(filePath) {\n    return filePath.replace(GENERATED_FILE, '.');\n}\n/**\n * @param {?} filePath\n * @return {?}\n */\nfunction isGeneratedFile(filePath) {\n    return GENERATED_FILE.test(filePath);\n}\n/**\n * @param {?} path\n * @param {?=} forceSourceFile\n * @return {?}\n */\nfunction splitTypescriptSuffix(path, forceSourceFile) {\n    if (forceSourceFile === void 0) { forceSourceFile = false; }\n    if (path.endsWith('.d.ts')) {\n        return [path.slice(0, -5), forceSourceFile ? '.ts' : '.d.ts'];\n    }\n    var /** @type {?} */ lastDot = path.lastIndexOf('.');\n    if (lastDot !== -1) {\n        return [path.substring(0, lastDot), path.substring(lastDot)];\n    }\n    return [path, ''];\n}\n/**\n * @param {?} srcFileSuffix\n * @return {?}\n */\nfunction normalizeGenFileSuffix(srcFileSuffix) {\n    return srcFileSuffix === '.tsx' ? '.ts' : srcFileSuffix;\n}\n/**\n * @param {?} fileName\n * @return {?}\n */\nfunction summaryFileName(fileName) {\n    var /** @type {?} */ fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, '');\n    return fileNameWithoutSuffix + \".ngsummary.json\";\n}\n/**\n * @param {?} fileName\n * @param {?=} forceSourceFile\n * @return {?}\n */\nfunction summaryForJitFileName(fileName, forceSourceFile) {\n    if (forceSourceFile === void 0) { forceSourceFile = false; }\n    var /** @type {?} */ urlWithSuffix = splitTypescriptSuffix(stripGeneratedFileSuffix(fileName), forceSourceFile);\n    return urlWithSuffix[0] + \".ngsummary\" + urlWithSuffix[1];\n}\n/**\n * @param {?} filePath\n * @return {?}\n */\nfunction stripSummaryForJitFileSuffix(filePath) {\n    return filePath.replace(JIT_SUMMARY_FILE, '.');\n}\n/**\n * @param {?} symbolName\n * @return {?}\n */\nfunction summaryForJitName(symbolName) {\n    return symbolName + \"NgSummary\";\n}\n/**\n * @param {?} symbolName\n * @return {?}\n */\nfunction stripSummaryForJitNameSuffix(symbolName) {\n    return symbolName.replace(JIT_SUMMARY_NAME, '');\n}\nvar LOWERED_SYMBOL = /\\u0275\\d+/;\n/**\n * @param {?} name\n * @return {?}\n */\nfunction isLoweredSymbol(name) {\n    return LOWERED_SYMBOL.test(name);\n}\n/**\n * @param {?} id\n * @return {?}\n */\nfunction createLoweredSymbol(id) {\n    return \"\\u0275\" + id;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar CORE = '@angular/core';\nvar Identifiers = /** @class */ (function () {\n    function Identifiers() {\n    }\n    Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS = {\n        name: 'ANALYZE_FOR_ENTRY_COMPONENTS',\n        moduleName: CORE,\n    };\n    Identifiers.ElementRef = { name: 'ElementRef', moduleName: CORE };\n    Identifiers.NgModuleRef = { name: 'NgModuleRef', moduleName: CORE };\n    Identifiers.ViewContainerRef = { name: 'ViewContainerRef', moduleName: CORE };\n    Identifiers.ChangeDetectorRef = {\n        name: 'ChangeDetectorRef',\n        moduleName: CORE,\n    };\n    Identifiers.QueryList = { name: 'QueryList', moduleName: CORE };\n    Identifiers.TemplateRef = { name: 'TemplateRef', moduleName: CORE };\n    Identifiers.CodegenComponentFactoryResolver = {\n        name: 'ɵCodegenComponentFactoryResolver',\n        moduleName: CORE,\n    };\n    Identifiers.ComponentFactoryResolver = {\n        name: 'ComponentFactoryResolver',\n        moduleName: CORE,\n    };\n    Identifiers.ComponentFactory = { name: 'ComponentFactory', moduleName: CORE };\n    Identifiers.ComponentRef = { name: 'ComponentRef', moduleName: CORE };\n    Identifiers.NgModuleFactory = { name: 'NgModuleFactory', moduleName: CORE };\n    Identifiers.createModuleFactory = {\n        name: 'ɵcmf',\n        moduleName: CORE,\n    };\n    Identifiers.moduleDef = {\n        name: 'ɵmod',\n        moduleName: CORE,\n    };\n    Identifiers.moduleProviderDef = {\n        name: 'ɵmpd',\n        moduleName: CORE,\n    };\n    Identifiers.RegisterModuleFactoryFn = {\n        name: 'ɵregisterModuleFactory',\n        moduleName: CORE,\n    };\n    Identifiers.Injector = { name: 'Injector', moduleName: CORE };\n    Identifiers.ViewEncapsulation = {\n        name: 'ViewEncapsulation',\n        moduleName: CORE,\n    };\n    Identifiers.ChangeDetectionStrategy = {\n        name: 'ChangeDetectionStrategy',\n        moduleName: CORE,\n    };\n    Identifiers.SecurityContext = {\n        name: 'SecurityContext',\n        moduleName: CORE,\n    };\n    Identifiers.LOCALE_ID = { name: 'LOCALE_ID', moduleName: CORE };\n    Identifiers.TRANSLATIONS_FORMAT = {\n        name: 'TRANSLATIONS_FORMAT',\n        moduleName: CORE,\n    };\n    Identifiers.inlineInterpolate = {\n        name: 'ɵinlineInterpolate',\n        moduleName: CORE,\n    };\n    Identifiers.interpolate = { name: 'ɵinterpolate', moduleName: CORE };\n    Identifiers.EMPTY_ARRAY = { name: 'ɵEMPTY_ARRAY', moduleName: CORE };\n    Identifiers.EMPTY_MAP = { name: 'ɵEMPTY_MAP', moduleName: CORE };\n    Identifiers.Renderer = { name: 'Renderer', moduleName: CORE };\n    Identifiers.viewDef = { name: 'ɵvid', moduleName: CORE };\n    Identifiers.elementDef = { name: 'ɵeld', moduleName: CORE };\n    Identifiers.anchorDef = { name: 'ɵand', moduleName: CORE };\n    Identifiers.textDef = { name: 'ɵted', moduleName: CORE };\n    Identifiers.directiveDef = { name: 'ɵdid', moduleName: CORE };\n    Identifiers.providerDef = { name: 'ɵprd', moduleName: CORE };\n    Identifiers.queryDef = { name: 'ɵqud', moduleName: CORE };\n    Identifiers.pureArrayDef = { name: 'ɵpad', moduleName: CORE };\n    Identifiers.pureObjectDef = { name: 'ɵpod', moduleName: CORE };\n    Identifiers.purePipeDef = { name: 'ɵppd', moduleName: CORE };\n    Identifiers.pipeDef = { name: 'ɵpid', moduleName: CORE };\n    Identifiers.nodeValue = { name: 'ɵnov', moduleName: CORE };\n    Identifiers.ngContentDef = { name: 'ɵncd', moduleName: CORE };\n    Identifiers.unwrapValue = { name: 'ɵunv', moduleName: CORE };\n    Identifiers.createRendererType2 = { name: 'ɵcrt', moduleName: CORE };\n    // type only\n    Identifiers.RendererType2 = {\n        name: 'RendererType2',\n        moduleName: CORE,\n    };\n    // type only\n    Identifiers.ViewDefinition = {\n        name: 'ɵViewDefinition',\n        moduleName: CORE,\n    };\n    Identifiers.createComponentFactory = { name: 'ɵccf', moduleName: CORE };\n    return Identifiers;\n}());\n/**\n * @param {?} reference\n * @return {?}\n */\nfunction createTokenForReference(reference) {\n    return { identifier: { reference: reference } };\n}\n/**\n * @param {?} reflector\n * @param {?} reference\n * @return {?}\n */\nfunction createTokenForExternalReference(reflector, reference) {\n    return createTokenForReference(reflector.resolveExternalReference(reference));\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @enum {number} */\nvar LifecycleHooks = {\n    OnInit: 0,\n    OnDestroy: 1,\n    DoCheck: 2,\n    OnChanges: 3,\n    AfterContentInit: 4,\n    AfterContentChecked: 5,\n    AfterViewInit: 6,\n    AfterViewChecked: 7,\n};\nLifecycleHooks[LifecycleHooks.OnInit] = \"OnInit\";\nLifecycleHooks[LifecycleHooks.OnDestroy] = \"OnDestroy\";\nLifecycleHooks[LifecycleHooks.DoCheck] = \"DoCheck\";\nLifecycleHooks[LifecycleHooks.OnChanges] = \"OnChanges\";\nLifecycleHooks[LifecycleHooks.AfterContentInit] = \"AfterContentInit\";\nLifecycleHooks[LifecycleHooks.AfterContentChecked] = \"AfterContentChecked\";\nLifecycleHooks[LifecycleHooks.AfterViewInit] = \"AfterViewInit\";\nLifecycleHooks[LifecycleHooks.AfterViewChecked] = \"AfterViewChecked\";\nvar LIFECYCLE_HOOKS_VALUES = [\n    LifecycleHooks.OnInit, LifecycleHooks.OnDestroy, LifecycleHooks.DoCheck, LifecycleHooks.OnChanges,\n    LifecycleHooks.AfterContentInit, LifecycleHooks.AfterContentChecked, LifecycleHooks.AfterViewInit,\n    LifecycleHooks.AfterViewChecked\n];\n/**\n * @param {?} reflector\n * @param {?} hook\n * @param {?} token\n * @return {?}\n */\nfunction hasLifecycleHook(reflector, hook, token) {\n    return reflector.hasLifecycleHook(token, getHookName(hook));\n}\n/**\n * @param {?} reflector\n * @param {?} token\n * @return {?}\n */\nfunction getAllLifecycleHooks(reflector, token) {\n    return LIFECYCLE_HOOKS_VALUES.filter(function (hook) { return hasLifecycleHook(reflector, hook, token); });\n}\n/**\n * @param {?} hook\n * @return {?}\n */\nfunction getHookName(hook) {\n    switch (hook) {\n        case LifecycleHooks.OnInit:\n            return 'ngOnInit';\n        case LifecycleHooks.OnDestroy:\n            return 'ngOnDestroy';\n        case LifecycleHooks.DoCheck:\n            return 'ngDoCheck';\n        case LifecycleHooks.OnChanges:\n            return 'ngOnChanges';\n        case LifecycleHooks.AfterContentInit:\n            return 'ngAfterContentInit';\n        case LifecycleHooks.AfterContentChecked:\n            return 'ngAfterContentChecked';\n        case LifecycleHooks.AfterViewInit:\n            return 'ngAfterViewInit';\n        case LifecycleHooks.AfterViewChecked:\n            return 'ngAfterViewChecked';\n    }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _SELECTOR_REGEXP = new RegExp('(\\\\:not\\\\()|' + //\":not(\"\n    '([-\\\\w]+)|' + // \"tag\"\n    '(?:\\\\.([-\\\\w]+))|' + // \".class\"\n    '(?:\\\\[([-.\\\\w*]+)(?:=([\\\"\\']?)([^\\\\]\\\"\\']*)\\\\5)?\\\\])|' + // \"[name]\", \"[name=value]\",\n    '(\\\\))|' + // \")\"\n    '(\\\\s*,\\\\s*)', // \",\"\n'g');\n/**\n * A css selector contains an element name,\n * css classes and attribute/value pairs with the purpose\n * of selecting subsets out of them.\n */\nvar CssSelector = /** @class */ (function () {\n    function CssSelector() {\n        this.element = null;\n        this.classNames = [];\n        this.attrs = [];\n        this.notSelectors = [];\n    }\n    /**\n     * @param {?} selector\n     * @return {?}\n     */\n    CssSelector.parse = /**\n     * @param {?} selector\n     * @return {?}\n     */\n    function (selector) {\n        var /** @type {?} */ results = [];\n        var /** @type {?} */ _addResult = function (res, cssSel) {\n            if (cssSel.notSelectors.length > 0 && !cssSel.element && cssSel.classNames.length == 0 &&\n                cssSel.attrs.length == 0) {\n                cssSel.element = '*';\n            }\n            res.push(cssSel);\n        };\n        var /** @type {?} */ cssSelector = new CssSelector();\n        var /** @type {?} */ match;\n        var /** @type {?} */ current = cssSelector;\n        var /** @type {?} */ inNot = false;\n        _SELECTOR_REGEXP.lastIndex = 0;\n        while (match = _SELECTOR_REGEXP.exec(selector)) {\n            if (match[1]) {\n                if (inNot) {\n                    throw new Error('Nesting :not is not allowed in a selector');\n                }\n                inNot = true;\n                current = new CssSelector();\n                cssSelector.notSelectors.push(current);\n            }\n            if (match[2]) {\n                current.setElement(match[2]);\n            }\n            if (match[3]) {\n                current.addClassName(match[3]);\n            }\n            if (match[4]) {\n                current.addAttribute(match[4], match[6]);\n            }\n            if (match[7]) {\n                inNot = false;\n                current = cssSelector;\n            }\n            if (match[8]) {\n                if (inNot) {\n                    throw new Error('Multiple selectors in :not are not supported');\n                }\n                _addResult(results, cssSelector);\n                cssSelector = current = new CssSelector();\n            }\n        }\n        _addResult(results, cssSelector);\n        return results;\n    };\n    /**\n     * @return {?}\n     */\n    CssSelector.prototype.isElementSelector = /**\n     * @return {?}\n     */\n    function () {\n        return this.hasElementSelector() && this.classNames.length == 0 && this.attrs.length == 0 &&\n            this.notSelectors.length === 0;\n    };\n    /**\n     * @return {?}\n     */\n    CssSelector.prototype.hasElementSelector = /**\n     * @return {?}\n     */\n    function () { return !!this.element; };\n    /**\n     * @param {?=} element\n     * @return {?}\n     */\n    CssSelector.prototype.setElement = /**\n     * @param {?=} element\n     * @return {?}\n     */\n    function (element) {\n        if (element === void 0) { element = null; }\n        this.element = element;\n    };\n    /** Gets a template string for an element that matches the selector. */\n    /**\n     * Gets a template string for an element that matches the selector.\n     * @return {?}\n     */\n    CssSelector.prototype.getMatchingElementTemplate = /**\n     * Gets a template string for an element that matches the selector.\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ tagName = this.element || 'div';\n        var /** @type {?} */ classAttr = this.classNames.length > 0 ? \" class=\\\"\" + this.classNames.join(' ') + \"\\\"\" : '';\n        var /** @type {?} */ attrs = '';\n        for (var /** @type {?} */ i = 0; i < this.attrs.length; i += 2) {\n            var /** @type {?} */ attrName = this.attrs[i];\n            var /** @type {?} */ attrValue = this.attrs[i + 1] !== '' ? \"=\\\"\" + this.attrs[i + 1] + \"\\\"\" : '';\n            attrs += \" \" + attrName + attrValue;\n        }\n        return getHtmlTagDefinition(tagName).isVoid ? \"<\" + tagName + classAttr + attrs + \"/>\" :\n            \"<\" + tagName + classAttr + attrs + \"></\" + tagName + \">\";\n    };\n    /**\n     * @param {?} name\n     * @param {?=} value\n     * @return {?}\n     */\n    CssSelector.prototype.addAttribute = /**\n     * @param {?} name\n     * @param {?=} value\n     * @return {?}\n     */\n    function (name, value) {\n        if (value === void 0) { value = ''; }\n        this.attrs.push(name, value && value.toLowerCase() || '');\n    };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    CssSelector.prototype.addClassName = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) { this.classNames.push(name.toLowerCase()); };\n    /**\n     * @return {?}\n     */\n    CssSelector.prototype.toString = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ res = this.element || '';\n        if (this.classNames) {\n            this.classNames.forEach(function (klass) { return res += \".\" + klass; });\n        }\n        if (this.attrs) {\n            for (var /** @type {?} */ i = 0; i < this.attrs.length; i += 2) {\n                var /** @type {?} */ name_1 = this.attrs[i];\n                var /** @type {?} */ value = this.attrs[i + 1];\n                res += \"[\" + name_1 + (value ? '=' + value : '') + \"]\";\n            }\n        }\n        this.notSelectors.forEach(function (notSelector) { return res += \":not(\" + notSelector + \")\"; });\n        return res;\n    };\n    return CssSelector;\n}());\n/**\n * Reads a list of CssSelectors and allows to calculate which ones\n * are contained in a given CssSelector.\n */\nvar SelectorMatcher = /** @class */ (function () {\n    function SelectorMatcher() {\n        this._elementMap = new Map();\n        this._elementPartialMap = new Map();\n        this._classMap = new Map();\n        this._classPartialMap = new Map();\n        this._attrValueMap = new Map();\n        this._attrValuePartialMap = new Map();\n        this._listContexts = [];\n    }\n    /**\n     * @param {?} notSelectors\n     * @return {?}\n     */\n    SelectorMatcher.createNotMatcher = /**\n     * @param {?} notSelectors\n     * @return {?}\n     */\n    function (notSelectors) {\n        var /** @type {?} */ notMatcher = new SelectorMatcher();\n        notMatcher.addSelectables(notSelectors, null);\n        return notMatcher;\n    };\n    /**\n     * @param {?} cssSelectors\n     * @param {?=} callbackCtxt\n     * @return {?}\n     */\n    SelectorMatcher.prototype.addSelectables = /**\n     * @param {?} cssSelectors\n     * @param {?=} callbackCtxt\n     * @return {?}\n     */\n    function (cssSelectors, callbackCtxt) {\n        var /** @type {?} */ listContext = /** @type {?} */ ((null));\n        if (cssSelectors.length > 1) {\n            listContext = new SelectorListContext(cssSelectors);\n            this._listContexts.push(listContext);\n        }\n        for (var /** @type {?} */ i = 0; i < cssSelectors.length; i++) {\n            this._addSelectable(cssSelectors[i], callbackCtxt, listContext);\n        }\n    };\n    /**\n     * Add an object that can be found later on by calling `match`.\n     * @param {?} cssSelector A css selector\n     * @param {?} callbackCtxt An opaque object that will be given to the callback of the `match` function\n     * @param {?} listContext\n     * @return {?}\n     */\n    SelectorMatcher.prototype._addSelectable = /**\n     * Add an object that can be found later on by calling `match`.\n     * @param {?} cssSelector A css selector\n     * @param {?} callbackCtxt An opaque object that will be given to the callback of the `match` function\n     * @param {?} listContext\n     * @return {?}\n     */\n    function (cssSelector, callbackCtxt, listContext) {\n        var /** @type {?} */ matcher = this;\n        var /** @type {?} */ element = cssSelector.element;\n        var /** @type {?} */ classNames = cssSelector.classNames;\n        var /** @type {?} */ attrs = cssSelector.attrs;\n        var /** @type {?} */ selectable = new SelectorContext(cssSelector, callbackCtxt, listContext);\n        if (element) {\n            var /** @type {?} */ isTerminal = attrs.length === 0 && classNames.length === 0;\n            if (isTerminal) {\n                this._addTerminal(matcher._elementMap, element, selectable);\n            }\n            else {\n                matcher = this._addPartial(matcher._elementPartialMap, element);\n            }\n        }\n        if (classNames) {\n            for (var /** @type {?} */ i = 0; i < classNames.length; i++) {\n                var /** @type {?} */ isTerminal = attrs.length === 0 && i === classNames.length - 1;\n                var /** @type {?} */ className = classNames[i];\n                if (isTerminal) {\n                    this._addTerminal(matcher._classMap, className, selectable);\n                }\n                else {\n                    matcher = this._addPartial(matcher._classPartialMap, className);\n                }\n            }\n        }\n        if (attrs) {\n            for (var /** @type {?} */ i = 0; i < attrs.length; i += 2) {\n                var /** @type {?} */ isTerminal = i === attrs.length - 2;\n                var /** @type {?} */ name_2 = attrs[i];\n                var /** @type {?} */ value = attrs[i + 1];\n                if (isTerminal) {\n                    var /** @type {?} */ terminalMap = matcher._attrValueMap;\n                    var /** @type {?} */ terminalValuesMap = terminalMap.get(name_2);\n                    if (!terminalValuesMap) {\n                        terminalValuesMap = new Map();\n                        terminalMap.set(name_2, terminalValuesMap);\n                    }\n                    this._addTerminal(terminalValuesMap, value, selectable);\n                }\n                else {\n                    var /** @type {?} */ partialMap = matcher._attrValuePartialMap;\n                    var /** @type {?} */ partialValuesMap = partialMap.get(name_2);\n                    if (!partialValuesMap) {\n                        partialValuesMap = new Map();\n                        partialMap.set(name_2, partialValuesMap);\n                    }\n                    matcher = this._addPartial(partialValuesMap, value);\n                }\n            }\n        }\n    };\n    /**\n     * @param {?} map\n     * @param {?} name\n     * @param {?} selectable\n     * @return {?}\n     */\n    SelectorMatcher.prototype._addTerminal = /**\n     * @param {?} map\n     * @param {?} name\n     * @param {?} selectable\n     * @return {?}\n     */\n    function (map, name, selectable) {\n        var /** @type {?} */ terminalList = map.get(name);\n        if (!terminalList) {\n            terminalList = [];\n            map.set(name, terminalList);\n        }\n        terminalList.push(selectable);\n    };\n    /**\n     * @param {?} map\n     * @param {?} name\n     * @return {?}\n     */\n    SelectorMatcher.prototype._addPartial = /**\n     * @param {?} map\n     * @param {?} name\n     * @return {?}\n     */\n    function (map, name) {\n        var /** @type {?} */ matcher = map.get(name);\n        if (!matcher) {\n            matcher = new SelectorMatcher();\n            map.set(name, matcher);\n        }\n        return matcher;\n    };\n    /**\n     * Find the objects that have been added via `addSelectable`\n     * whose css selector is contained in the given css selector.\n     * @param cssSelector A css selector\n     * @param matchedCallback This callback will be called with the object handed into `addSelectable`\n     * @return boolean true if a match was found\n    */\n    /**\n     * Find the objects that have been added via `addSelectable`\n     * whose css selector is contained in the given css selector.\n     * @param {?} cssSelector A css selector\n     * @param {?} matchedCallback This callback will be called with the object handed into `addSelectable`\n     * @return {?} boolean true if a match was found\n     */\n    SelectorMatcher.prototype.match = /**\n     * Find the objects that have been added via `addSelectable`\n     * whose css selector is contained in the given css selector.\n     * @param {?} cssSelector A css selector\n     * @param {?} matchedCallback This callback will be called with the object handed into `addSelectable`\n     * @return {?} boolean true if a match was found\n     */\n    function (cssSelector, matchedCallback) {\n        var /** @type {?} */ result = false;\n        var /** @type {?} */ element = /** @type {?} */ ((cssSelector.element));\n        var /** @type {?} */ classNames = cssSelector.classNames;\n        var /** @type {?} */ attrs = cssSelector.attrs;\n        for (var /** @type {?} */ i = 0; i < this._listContexts.length; i++) {\n            this._listContexts[i].alreadyMatched = false;\n        }\n        result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result;\n        result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) ||\n            result;\n        if (classNames) {\n            for (var /** @type {?} */ i = 0; i < classNames.length; i++) {\n                var /** @type {?} */ className = classNames[i];\n                result =\n                    this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result;\n                result =\n                    this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) ||\n                        result;\n            }\n        }\n        if (attrs) {\n            for (var /** @type {?} */ i = 0; i < attrs.length; i += 2) {\n                var /** @type {?} */ name_3 = attrs[i];\n                var /** @type {?} */ value = attrs[i + 1];\n                var /** @type {?} */ terminalValuesMap = /** @type {?} */ ((this._attrValueMap.get(name_3)));\n                if (value) {\n                    result =\n                        this._matchTerminal(terminalValuesMap, '', cssSelector, matchedCallback) || result;\n                }\n                result =\n                    this._matchTerminal(terminalValuesMap, value, cssSelector, matchedCallback) || result;\n                var /** @type {?} */ partialValuesMap = /** @type {?} */ ((this._attrValuePartialMap.get(name_3)));\n                if (value) {\n                    result = this._matchPartial(partialValuesMap, '', cssSelector, matchedCallback) || result;\n                }\n                result =\n                    this._matchPartial(partialValuesMap, value, cssSelector, matchedCallback) || result;\n            }\n        }\n        return result;\n    };\n    /** @internal */\n    /**\n     * \\@internal\n     * @param {?} map\n     * @param {?} name\n     * @param {?} cssSelector\n     * @param {?} matchedCallback\n     * @return {?}\n     */\n    SelectorMatcher.prototype._matchTerminal = /**\n     * \\@internal\n     * @param {?} map\n     * @param {?} name\n     * @param {?} cssSelector\n     * @param {?} matchedCallback\n     * @return {?}\n     */\n    function (map, name, cssSelector, matchedCallback) {\n        if (!map || typeof name !== 'string') {\n            return false;\n        }\n        var /** @type {?} */ selectables = map.get(name) || [];\n        var /** @type {?} */ starSelectables = /** @type {?} */ ((map.get('*')));\n        if (starSelectables) {\n            selectables = selectables.concat(starSelectables);\n        }\n        if (selectables.length === 0) {\n            return false;\n        }\n        var /** @type {?} */ selectable;\n        var /** @type {?} */ result = false;\n        for (var /** @type {?} */ i = 0; i < selectables.length; i++) {\n            selectable = selectables[i];\n            result = selectable.finalize(cssSelector, matchedCallback) || result;\n        }\n        return result;\n    };\n    /** @internal */\n    /**\n     * \\@internal\n     * @param {?} map\n     * @param {?} name\n     * @param {?} cssSelector\n     * @param {?} matchedCallback\n     * @return {?}\n     */\n    SelectorMatcher.prototype._matchPartial = /**\n     * \\@internal\n     * @param {?} map\n     * @param {?} name\n     * @param {?} cssSelector\n     * @param {?} matchedCallback\n     * @return {?}\n     */\n    function (map, name, cssSelector, matchedCallback) {\n        if (!map || typeof name !== 'string') {\n            return false;\n        }\n        var /** @type {?} */ nestedSelector = map.get(name);\n        if (!nestedSelector) {\n            return false;\n        }\n        // TODO(perf): get rid of recursion and measure again\n        // TODO(perf): don't pass the whole selector into the recursion,\n        // but only the not processed parts\n        return nestedSelector.match(cssSelector, matchedCallback);\n    };\n    return SelectorMatcher;\n}());\nvar SelectorListContext = /** @class */ (function () {\n    function SelectorListContext(selectors) {\n        this.selectors = selectors;\n        this.alreadyMatched = false;\n    }\n    return SelectorListContext;\n}());\nvar SelectorContext = /** @class */ (function () {\n    function SelectorContext(selector, cbContext, listContext) {\n        this.selector = selector;\n        this.cbContext = cbContext;\n        this.listContext = listContext;\n        this.notSelectors = selector.notSelectors;\n    }\n    /**\n     * @param {?} cssSelector\n     * @param {?} callback\n     * @return {?}\n     */\n    SelectorContext.prototype.finalize = /**\n     * @param {?} cssSelector\n     * @param {?} callback\n     * @return {?}\n     */\n    function (cssSelector, callback) {\n        var /** @type {?} */ result = true;\n        if (this.notSelectors.length > 0 && (!this.listContext || !this.listContext.alreadyMatched)) {\n            var /** @type {?} */ notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors);\n            result = !notMatcher.match(cssSelector, null);\n        }\n        if (result && callback && (!this.listContext || !this.listContext.alreadyMatched)) {\n            if (this.listContext) {\n                this.listContext.alreadyMatched = true;\n            }\n            callback(this.selector, this.cbContext);\n        }\n        return result;\n    };\n    return SelectorContext;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ERROR_COMPONENT_TYPE = 'ngComponentType';\nvar CompileMetadataResolver = /** @class */ (function () {\n    function CompileMetadataResolver(_config, _htmlParser, _ngModuleResolver, _directiveResolver, _pipeResolver, _summaryResolver, _schemaRegistry, _directiveNormalizer, _console, _staticSymbolCache, _reflector, _errorCollector) {\n        this._config = _config;\n        this._htmlParser = _htmlParser;\n        this._ngModuleResolver = _ngModuleResolver;\n        this._directiveResolver = _directiveResolver;\n        this._pipeResolver = _pipeResolver;\n        this._summaryResolver = _summaryResolver;\n        this._schemaRegistry = _schemaRegistry;\n        this._directiveNormalizer = _directiveNormalizer;\n        this._console = _console;\n        this._staticSymbolCache = _staticSymbolCache;\n        this._reflector = _reflector;\n        this._errorCollector = _errorCollector;\n        this._nonNormalizedDirectiveCache = new Map();\n        this._directiveCache = new Map();\n        this._summaryCache = new Map();\n        this._pipeCache = new Map();\n        this._ngModuleCache = new Map();\n        this._ngModuleOfTypes = new Map();\n    }\n    /**\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getReflector = /**\n     * @return {?}\n     */\n    function () { return this._reflector; };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.clearCacheFor = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ dirMeta = this._directiveCache.get(type);\n        this._directiveCache.delete(type);\n        this._nonNormalizedDirectiveCache.delete(type);\n        this._summaryCache.delete(type);\n        this._pipeCache.delete(type);\n        this._ngModuleOfTypes.delete(type);\n        // Clear all of the NgModule as they contain transitive information!\n        this._ngModuleCache.clear();\n        if (dirMeta) {\n            this._directiveNormalizer.clearCacheFor(dirMeta);\n        }\n    };\n    /**\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.clearCache = /**\n     * @return {?}\n     */\n    function () {\n        this._directiveCache.clear();\n        this._nonNormalizedDirectiveCache.clear();\n        this._summaryCache.clear();\n        this._pipeCache.clear();\n        this._ngModuleCache.clear();\n        this._ngModuleOfTypes.clear();\n        this._directiveNormalizer.clearCache();\n    };\n    /**\n     * @param {?} baseType\n     * @param {?} name\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._createProxyClass = /**\n     * @param {?} baseType\n     * @param {?} name\n     * @return {?}\n     */\n    function (baseType, name) {\n        var /** @type {?} */ delegate = null;\n        var /** @type {?} */ proxyClass = /** @type {?} */ (function () {\n            if (!delegate) {\n                throw new Error(\"Illegal state: Class \" + name + \" for type \" + stringify(baseType) + \" is not compiled yet!\");\n            }\n            return delegate.apply(this, arguments);\n        });\n        proxyClass.setDelegate = function (d) {\n            delegate = d;\n            (/** @type {?} */ (proxyClass)).prototype = d.prototype;\n        };\n        // Make stringify work correctly\n        (/** @type {?} */ (proxyClass)).overriddenName = name;\n        return proxyClass;\n    };\n    /**\n     * @param {?} dirType\n     * @param {?} name\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getGeneratedClass = /**\n     * @param {?} dirType\n     * @param {?} name\n     * @return {?}\n     */\n    function (dirType, name) {\n        if (dirType instanceof StaticSymbol) {\n            return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), name);\n        }\n        else {\n            return this._createProxyClass(dirType, name);\n        }\n    };\n    /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getComponentViewClass = /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    function (dirType) {\n        return this.getGeneratedClass(dirType, viewClassName(dirType, 0));\n    };\n    /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getHostComponentViewClass = /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    function (dirType) {\n        return this.getGeneratedClass(dirType, hostViewClassName(dirType));\n    };\n    /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getHostComponentType = /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    function (dirType) {\n        var /** @type {?} */ name = identifierName({ reference: dirType }) + \"_Host\";\n        if (dirType instanceof StaticSymbol) {\n            return this._staticSymbolCache.get(dirType.filePath, name);\n        }\n        else {\n            var /** @type {?} */ HostClass = /** @type {?} */ (function HostClass() { });\n            HostClass.overriddenName = name;\n            return HostClass;\n        }\n    };\n    /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getRendererType = /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    function (dirType) {\n        if (dirType instanceof StaticSymbol) {\n            return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), rendererTypeName(dirType));\n        }\n        else {\n            // returning an object as proxy,\n            // that we fill later during runtime compilation.\n            return /** @type {?} */ ({});\n        }\n    };\n    /**\n     * @param {?} selector\n     * @param {?} dirType\n     * @param {?} inputs\n     * @param {?} outputs\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getComponentFactory = /**\n     * @param {?} selector\n     * @param {?} dirType\n     * @param {?} inputs\n     * @param {?} outputs\n     * @return {?}\n     */\n    function (selector, dirType, inputs, outputs) {\n        if (dirType instanceof StaticSymbol) {\n            return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), componentFactoryName(dirType));\n        }\n        else {\n            var /** @type {?} */ hostView = this.getHostComponentViewClass(dirType);\n            // Note: ngContentSelectors will be filled later once the template is\n            // loaded.\n            var /** @type {?} */ createComponentFactory = this._reflector.resolveExternalReference(Identifiers.createComponentFactory);\n            return createComponentFactory(selector, dirType, /** @type {?} */ (hostView), inputs, outputs, []);\n        }\n    };\n    /**\n     * @param {?} factory\n     * @param {?} ngContentSelectors\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.initComponentFactory = /**\n     * @param {?} factory\n     * @param {?} ngContentSelectors\n     * @return {?}\n     */\n    function (factory, ngContentSelectors) {\n        if (!(factory instanceof StaticSymbol)) {\n            (_a = (/** @type {?} */ (factory)).ngContentSelectors).push.apply(_a, ngContentSelectors);\n        }\n        var _a;\n    };\n    /**\n     * @param {?} type\n     * @param {?} kind\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._loadSummary = /**\n     * @param {?} type\n     * @param {?} kind\n     * @return {?}\n     */\n    function (type, kind) {\n        var /** @type {?} */ typeSummary = this._summaryCache.get(type);\n        if (!typeSummary) {\n            var /** @type {?} */ summary = this._summaryResolver.resolveSummary(type);\n            typeSummary = summary ? summary.type : null;\n            this._summaryCache.set(type, typeSummary || null);\n        }\n        return typeSummary && typeSummary.summaryKind === kind ? typeSummary : null;\n    };\n    /**\n     * @param {?} compMeta\n     * @param {?=} hostViewType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getHostComponentMetadata = /**\n     * @param {?} compMeta\n     * @param {?=} hostViewType\n     * @return {?}\n     */\n    function (compMeta, hostViewType) {\n        var /** @type {?} */ hostType = this.getHostComponentType(compMeta.type.reference);\n        if (!hostViewType) {\n            hostViewType = this.getHostComponentViewClass(hostType);\n        }\n        // Note: ! is ok here as this method should only be called with normalized directive\n        // metadata, which always fills in the selector.\n        var /** @type {?} */ template = CssSelector.parse(/** @type {?} */ ((compMeta.selector)))[0].getMatchingElementTemplate();\n        var /** @type {?} */ templateUrl = '';\n        var /** @type {?} */ htmlAst = this._htmlParser.parse(template, templateUrl);\n        return CompileDirectiveMetadata.create({\n            isHost: true,\n            type: { reference: hostType, diDeps: [], lifecycleHooks: [] },\n            template: new CompileTemplateMetadata({\n                encapsulation: ViewEncapsulation.None,\n                template: template,\n                templateUrl: templateUrl,\n                htmlAst: htmlAst,\n                styles: [],\n                styleUrls: [],\n                ngContentSelectors: [],\n                animations: [],\n                isInline: true,\n                externalStylesheets: [],\n                interpolation: null,\n                preserveWhitespaces: false,\n            }),\n            exportAs: null,\n            changeDetection: ChangeDetectionStrategy.Default,\n            inputs: [],\n            outputs: [],\n            host: {},\n            isComponent: true,\n            selector: '*',\n            providers: [],\n            viewProviders: [],\n            queries: [],\n            guards: {},\n            viewQueries: [],\n            componentViewType: hostViewType,\n            rendererType: /** @type {?} */ ({ id: '__Host__', encapsulation: ViewEncapsulation.None, styles: [], data: {} }),\n            entryComponents: [],\n            componentFactory: null\n        });\n    };\n    /**\n     * @param {?} ngModuleType\n     * @param {?} directiveType\n     * @param {?} isSync\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.loadDirectiveMetadata = /**\n     * @param {?} ngModuleType\n     * @param {?} directiveType\n     * @param {?} isSync\n     * @return {?}\n     */\n    function (ngModuleType, directiveType, isSync) {\n        var _this = this;\n        if (this._directiveCache.has(directiveType)) {\n            return null;\n        }\n        directiveType = resolveForwardRef(directiveType);\n        var _a = /** @type {?} */ ((this.getNonNormalizedDirectiveMetadata(directiveType))), annotation = _a.annotation, metadata = _a.metadata;\n        var /** @type {?} */ createDirectiveMetadata = function (templateMetadata) {\n            var /** @type {?} */ normalizedDirMeta = new CompileDirectiveMetadata({\n                isHost: false,\n                type: metadata.type,\n                isComponent: metadata.isComponent,\n                selector: metadata.selector,\n                exportAs: metadata.exportAs,\n                changeDetection: metadata.changeDetection,\n                inputs: metadata.inputs,\n                outputs: metadata.outputs,\n                hostListeners: metadata.hostListeners,\n                hostProperties: metadata.hostProperties,\n                hostAttributes: metadata.hostAttributes,\n                providers: metadata.providers,\n                viewProviders: metadata.viewProviders,\n                queries: metadata.queries,\n                guards: metadata.guards,\n                viewQueries: metadata.viewQueries,\n                entryComponents: metadata.entryComponents,\n                componentViewType: metadata.componentViewType,\n                rendererType: metadata.rendererType,\n                componentFactory: metadata.componentFactory,\n                template: templateMetadata\n            });\n            if (templateMetadata) {\n                _this.initComponentFactory(/** @type {?} */ ((metadata.componentFactory)), templateMetadata.ngContentSelectors);\n            }\n            _this._directiveCache.set(directiveType, normalizedDirMeta);\n            _this._summaryCache.set(directiveType, normalizedDirMeta.toSummary());\n            return null;\n        };\n        if (metadata.isComponent) {\n            var /** @type {?} */ template = /** @type {?} */ ((metadata.template));\n            var /** @type {?} */ templateMeta = this._directiveNormalizer.normalizeTemplate({\n                ngModuleType: ngModuleType,\n                componentType: directiveType,\n                moduleUrl: this._reflector.componentModuleUrl(directiveType, annotation),\n                encapsulation: template.encapsulation,\n                template: template.template,\n                templateUrl: template.templateUrl,\n                styles: template.styles,\n                styleUrls: template.styleUrls,\n                animations: template.animations,\n                interpolation: template.interpolation,\n                preserveWhitespaces: template.preserveWhitespaces\n            });\n            if (isPromise(templateMeta) && isSync) {\n                this._reportError(componentStillLoadingError(directiveType), directiveType);\n                return null;\n            }\n            return SyncAsync.then(templateMeta, createDirectiveMetadata);\n        }\n        else {\n            // directive\n            createDirectiveMetadata(null);\n            return null;\n        }\n    };\n    /**\n     * @param {?} directiveType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getNonNormalizedDirectiveMetadata = /**\n     * @param {?} directiveType\n     * @return {?}\n     */\n    function (directiveType) {\n        var _this = this;\n        directiveType = resolveForwardRef(directiveType);\n        if (!directiveType) {\n            return null;\n        }\n        var /** @type {?} */ cacheEntry = this._nonNormalizedDirectiveCache.get(directiveType);\n        if (cacheEntry) {\n            return cacheEntry;\n        }\n        var /** @type {?} */ dirMeta = this._directiveResolver.resolve(directiveType, false);\n        if (!dirMeta) {\n            return null;\n        }\n        var /** @type {?} */ nonNormalizedTemplateMetadata = /** @type {?} */ ((undefined));\n        if (createComponent.isTypeOf(dirMeta)) {\n            // component\n            var /** @type {?} */ compMeta = /** @type {?} */ (dirMeta);\n            assertArrayOfStrings('styles', compMeta.styles);\n            assertArrayOfStrings('styleUrls', compMeta.styleUrls);\n            assertInterpolationSymbols('interpolation', compMeta.interpolation);\n            var /** @type {?} */ animations = compMeta.animations;\n            nonNormalizedTemplateMetadata = new CompileTemplateMetadata({\n                encapsulation: noUndefined(compMeta.encapsulation),\n                template: noUndefined(compMeta.template),\n                templateUrl: noUndefined(compMeta.templateUrl),\n                htmlAst: null,\n                styles: compMeta.styles || [],\n                styleUrls: compMeta.styleUrls || [],\n                animations: animations || [],\n                interpolation: noUndefined(compMeta.interpolation),\n                isInline: !!compMeta.template,\n                externalStylesheets: [],\n                ngContentSelectors: [],\n                preserveWhitespaces: noUndefined(dirMeta.preserveWhitespaces),\n            });\n        }\n        var /** @type {?} */ changeDetectionStrategy = /** @type {?} */ ((null));\n        var /** @type {?} */ viewProviders = [];\n        var /** @type {?} */ entryComponentMetadata = [];\n        var /** @type {?} */ selector = dirMeta.selector;\n        if (createComponent.isTypeOf(dirMeta)) {\n            // Component\n            var /** @type {?} */ compMeta = /** @type {?} */ (dirMeta);\n            changeDetectionStrategy = /** @type {?} */ ((compMeta.changeDetection));\n            if (compMeta.viewProviders) {\n                viewProviders = this._getProvidersMetadata(compMeta.viewProviders, entryComponentMetadata, \"viewProviders for \\\"\" + stringifyType(directiveType) + \"\\\"\", [], directiveType);\n            }\n            if (compMeta.entryComponents) {\n                entryComponentMetadata = flattenAndDedupeArray(compMeta.entryComponents)\n                    .map(function (type) { return ((_this._getEntryComponentMetadata(type))); })\n                    .concat(entryComponentMetadata);\n            }\n            if (!selector) {\n                selector = this._schemaRegistry.getDefaultComponentElementName();\n            }\n        }\n        else {\n            // Directive\n            if (!selector) {\n                this._reportError(syntaxError(\"Directive \" + stringifyType(directiveType) + \" has no selector, please add it!\"), directiveType);\n                selector = 'error';\n            }\n        }\n        var /** @type {?} */ providers = [];\n        if (dirMeta.providers != null) {\n            providers = this._getProvidersMetadata(dirMeta.providers, entryComponentMetadata, \"providers for \\\"\" + stringifyType(directiveType) + \"\\\"\", [], directiveType);\n        }\n        var /** @type {?} */ queries = [];\n        var /** @type {?} */ viewQueries = [];\n        if (dirMeta.queries != null) {\n            queries = this._getQueriesMetadata(dirMeta.queries, false, directiveType);\n            viewQueries = this._getQueriesMetadata(dirMeta.queries, true, directiveType);\n        }\n        var /** @type {?} */ metadata = CompileDirectiveMetadata.create({\n            isHost: false,\n            selector: selector,\n            exportAs: noUndefined(dirMeta.exportAs),\n            isComponent: !!nonNormalizedTemplateMetadata,\n            type: this._getTypeMetadata(directiveType),\n            template: nonNormalizedTemplateMetadata,\n            changeDetection: changeDetectionStrategy,\n            inputs: dirMeta.inputs || [],\n            outputs: dirMeta.outputs || [],\n            host: dirMeta.host || {},\n            providers: providers || [],\n            viewProviders: viewProviders || [],\n            queries: queries || [],\n            guards: dirMeta.guards || {},\n            viewQueries: viewQueries || [],\n            entryComponents: entryComponentMetadata,\n            componentViewType: nonNormalizedTemplateMetadata ? this.getComponentViewClass(directiveType) :\n                null,\n            rendererType: nonNormalizedTemplateMetadata ? this.getRendererType(directiveType) : null,\n            componentFactory: null\n        });\n        if (nonNormalizedTemplateMetadata) {\n            metadata.componentFactory =\n                this.getComponentFactory(selector, directiveType, metadata.inputs, metadata.outputs);\n        }\n        cacheEntry = { metadata: metadata, annotation: dirMeta };\n        this._nonNormalizedDirectiveCache.set(directiveType, cacheEntry);\n        return cacheEntry;\n    };\n    /**\n     * Gets the metadata for the given directive.\n     * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.\n     */\n    /**\n     * Gets the metadata for the given directive.\n     * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.\n     * @param {?} directiveType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getDirectiveMetadata = /**\n     * Gets the metadata for the given directive.\n     * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.\n     * @param {?} directiveType\n     * @return {?}\n     */\n    function (directiveType) {\n        var /** @type {?} */ dirMeta = /** @type {?} */ ((this._directiveCache.get(directiveType)));\n        if (!dirMeta) {\n            this._reportError(syntaxError(\"Illegal state: getDirectiveMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Directive \" + stringifyType(directiveType) + \".\"), directiveType);\n        }\n        return dirMeta;\n    };\n    /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getDirectiveSummary = /**\n     * @param {?} dirType\n     * @return {?}\n     */\n    function (dirType) {\n        var /** @type {?} */ dirSummary = /** @type {?} */ (this._loadSummary(dirType, CompileSummaryKind.Directive));\n        if (!dirSummary) {\n            this._reportError(syntaxError(\"Illegal state: Could not load the summary for directive \" + stringifyType(dirType) + \".\"), dirType);\n        }\n        return dirSummary;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.isDirective = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        return !!this._loadSummary(type, CompileSummaryKind.Directive) ||\n            this._directiveResolver.isDirective(type);\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.isPipe = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        return !!this._loadSummary(type, CompileSummaryKind.Pipe) ||\n            this._pipeResolver.isPipe(type);\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.isNgModule = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        return !!this._loadSummary(type, CompileSummaryKind.NgModule) ||\n            this._ngModuleResolver.isNgModule(type);\n    };\n    /**\n     * @param {?} moduleType\n     * @param {?=} alreadyCollecting\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getNgModuleSummary = /**\n     * @param {?} moduleType\n     * @param {?=} alreadyCollecting\n     * @return {?}\n     */\n    function (moduleType, alreadyCollecting) {\n        if (alreadyCollecting === void 0) { alreadyCollecting = null; }\n        var /** @type {?} */ moduleSummary = /** @type {?} */ (this._loadSummary(moduleType, CompileSummaryKind.NgModule));\n        if (!moduleSummary) {\n            var /** @type {?} */ moduleMeta = this.getNgModuleMetadata(moduleType, false, alreadyCollecting);\n            moduleSummary = moduleMeta ? moduleMeta.toSummary() : null;\n            if (moduleSummary) {\n                this._summaryCache.set(moduleType, moduleSummary);\n            }\n        }\n        return moduleSummary;\n    };\n    /**\n     * Loads the declared directives and pipes of an NgModule.\n     */\n    /**\n     * Loads the declared directives and pipes of an NgModule.\n     * @param {?} moduleType\n     * @param {?} isSync\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.loadNgModuleDirectiveAndPipeMetadata = /**\n     * Loads the declared directives and pipes of an NgModule.\n     * @param {?} moduleType\n     * @param {?} isSync\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    function (moduleType, isSync, throwIfNotFound) {\n        var _this = this;\n        if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n        var /** @type {?} */ ngModule = this.getNgModuleMetadata(moduleType, throwIfNotFound);\n        var /** @type {?} */ loading = [];\n        if (ngModule) {\n            ngModule.declaredDirectives.forEach(function (id) {\n                var /** @type {?} */ promise = _this.loadDirectiveMetadata(moduleType, id.reference, isSync);\n                if (promise) {\n                    loading.push(promise);\n                }\n            });\n            ngModule.declaredPipes.forEach(function (id) { return _this._loadPipeMetadata(id.reference); });\n        }\n        return Promise.all(loading);\n    };\n    /**\n     * @param {?} moduleType\n     * @param {?=} throwIfNotFound\n     * @param {?=} alreadyCollecting\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getNgModuleMetadata = /**\n     * @param {?} moduleType\n     * @param {?=} throwIfNotFound\n     * @param {?=} alreadyCollecting\n     * @return {?}\n     */\n    function (moduleType, throwIfNotFound, alreadyCollecting) {\n        var _this = this;\n        if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n        if (alreadyCollecting === void 0) { alreadyCollecting = null; }\n        moduleType = resolveForwardRef(moduleType);\n        var /** @type {?} */ compileMeta = this._ngModuleCache.get(moduleType);\n        if (compileMeta) {\n            return compileMeta;\n        }\n        var /** @type {?} */ meta = this._ngModuleResolver.resolve(moduleType, throwIfNotFound);\n        if (!meta) {\n            return null;\n        }\n        var /** @type {?} */ declaredDirectives = [];\n        var /** @type {?} */ exportedNonModuleIdentifiers = [];\n        var /** @type {?} */ declaredPipes = [];\n        var /** @type {?} */ importedModules = [];\n        var /** @type {?} */ exportedModules = [];\n        var /** @type {?} */ providers = [];\n        var /** @type {?} */ entryComponents = [];\n        var /** @type {?} */ bootstrapComponents = [];\n        var /** @type {?} */ schemas = [];\n        if (meta.imports) {\n            flattenAndDedupeArray(meta.imports).forEach(function (importedType) {\n                var /** @type {?} */ importedModuleType = /** @type {?} */ ((undefined));\n                if (isValidType(importedType)) {\n                    importedModuleType = importedType;\n                }\n                else if (importedType && importedType.ngModule) {\n                    var /** @type {?} */ moduleWithProviders = importedType;\n                    importedModuleType = moduleWithProviders.ngModule;\n                    if (moduleWithProviders.providers) {\n                        providers.push.apply(providers, _this._getProvidersMetadata(moduleWithProviders.providers, entryComponents, \"provider for the NgModule '\" + stringifyType(importedModuleType) + \"'\", [], importedType));\n                    }\n                }\n                if (importedModuleType) {\n                    if (_this._checkSelfImport(moduleType, importedModuleType))\n                        return;\n                    if (!alreadyCollecting)\n                        alreadyCollecting = new Set();\n                    if (alreadyCollecting.has(importedModuleType)) {\n                        _this._reportError(syntaxError(_this._getTypeDescriptor(importedModuleType) + \" '\" + stringifyType(importedType) + \"' is imported recursively by the module '\" + stringifyType(moduleType) + \"'.\"), moduleType);\n                        return;\n                    }\n                    alreadyCollecting.add(importedModuleType);\n                    var /** @type {?} */ importedModuleSummary = _this.getNgModuleSummary(importedModuleType, alreadyCollecting);\n                    alreadyCollecting.delete(importedModuleType);\n                    if (!importedModuleSummary) {\n                        _this._reportError(syntaxError(\"Unexpected \" + _this._getTypeDescriptor(importedType) + \" '\" + stringifyType(importedType) + \"' imported by the module '\" + stringifyType(moduleType) + \"'. Please add a @NgModule annotation.\"), moduleType);\n                        return;\n                    }\n                    importedModules.push(importedModuleSummary);\n                }\n                else {\n                    _this._reportError(syntaxError(\"Unexpected value '\" + stringifyType(importedType) + \"' imported by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n                    return;\n                }\n            });\n        }\n        if (meta.exports) {\n            flattenAndDedupeArray(meta.exports).forEach(function (exportedType) {\n                if (!isValidType(exportedType)) {\n                    _this._reportError(syntaxError(\"Unexpected value '\" + stringifyType(exportedType) + \"' exported by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n                    return;\n                }\n                if (!alreadyCollecting)\n                    alreadyCollecting = new Set();\n                if (alreadyCollecting.has(exportedType)) {\n                    _this._reportError(syntaxError(_this._getTypeDescriptor(exportedType) + \" '\" + stringify(exportedType) + \"' is exported recursively by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n                    return;\n                }\n                alreadyCollecting.add(exportedType);\n                var /** @type {?} */ exportedModuleSummary = _this.getNgModuleSummary(exportedType, alreadyCollecting);\n                alreadyCollecting.delete(exportedType);\n                if (exportedModuleSummary) {\n                    exportedModules.push(exportedModuleSummary);\n                }\n                else {\n                    exportedNonModuleIdentifiers.push(_this._getIdentifierMetadata(exportedType));\n                }\n            });\n        }\n        // Note: This will be modified later, so we rely on\n        // getting a new instance every time!\n        var /** @type {?} */ transitiveModule = this._getTransitiveNgModuleMetadata(importedModules, exportedModules);\n        if (meta.declarations) {\n            flattenAndDedupeArray(meta.declarations).forEach(function (declaredType) {\n                if (!isValidType(declaredType)) {\n                    _this._reportError(syntaxError(\"Unexpected value '\" + stringifyType(declaredType) + \"' declared by the module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n                    return;\n                }\n                var /** @type {?} */ declaredIdentifier = _this._getIdentifierMetadata(declaredType);\n                if (_this.isDirective(declaredType)) {\n                    transitiveModule.addDirective(declaredIdentifier);\n                    declaredDirectives.push(declaredIdentifier);\n                    _this._addTypeToModule(declaredType, moduleType);\n                }\n                else if (_this.isPipe(declaredType)) {\n                    transitiveModule.addPipe(declaredIdentifier);\n                    transitiveModule.pipes.push(declaredIdentifier);\n                    declaredPipes.push(declaredIdentifier);\n                    _this._addTypeToModule(declaredType, moduleType);\n                }\n                else {\n                    _this._reportError(syntaxError(\"Unexpected \" + _this._getTypeDescriptor(declaredType) + \" '\" + stringifyType(declaredType) + \"' declared by the module '\" + stringifyType(moduleType) + \"'. Please add a @Pipe/@Directive/@Component annotation.\"), moduleType);\n                    return;\n                }\n            });\n        }\n        var /** @type {?} */ exportedDirectives = [];\n        var /** @type {?} */ exportedPipes = [];\n        exportedNonModuleIdentifiers.forEach(function (exportedId) {\n            if (transitiveModule.directivesSet.has(exportedId.reference)) {\n                exportedDirectives.push(exportedId);\n                transitiveModule.addExportedDirective(exportedId);\n            }\n            else if (transitiveModule.pipesSet.has(exportedId.reference)) {\n                exportedPipes.push(exportedId);\n                transitiveModule.addExportedPipe(exportedId);\n            }\n            else {\n                _this._reportError(syntaxError(\"Can't export \" + _this._getTypeDescriptor(exportedId.reference) + \" \" + stringifyType(exportedId.reference) + \" from \" + stringifyType(moduleType) + \" as it was neither declared nor imported!\"), moduleType);\n                return;\n            }\n        });\n        // The providers of the module have to go last\n        // so that they overwrite any other provider we already added.\n        if (meta.providers) {\n            providers.push.apply(providers, this._getProvidersMetadata(meta.providers, entryComponents, \"provider for the NgModule '\" + stringifyType(moduleType) + \"'\", [], moduleType));\n        }\n        if (meta.entryComponents) {\n            entryComponents.push.apply(entryComponents, flattenAndDedupeArray(meta.entryComponents)\n                .map(function (type) { return ((_this._getEntryComponentMetadata(type))); }));\n        }\n        if (meta.bootstrap) {\n            flattenAndDedupeArray(meta.bootstrap).forEach(function (type) {\n                if (!isValidType(type)) {\n                    _this._reportError(syntaxError(\"Unexpected value '\" + stringifyType(type) + \"' used in the bootstrap property of module '\" + stringifyType(moduleType) + \"'\"), moduleType);\n                    return;\n                }\n                bootstrapComponents.push(_this._getIdentifierMetadata(type));\n            });\n        }\n        entryComponents.push.apply(entryComponents, bootstrapComponents.map(function (type) { return ((_this._getEntryComponentMetadata(type.reference))); }));\n        if (meta.schemas) {\n            schemas.push.apply(schemas, flattenAndDedupeArray(meta.schemas));\n        }\n        compileMeta = new CompileNgModuleMetadata({\n            type: this._getTypeMetadata(moduleType),\n            providers: providers,\n            entryComponents: entryComponents,\n            bootstrapComponents: bootstrapComponents,\n            schemas: schemas,\n            declaredDirectives: declaredDirectives,\n            exportedDirectives: exportedDirectives,\n            declaredPipes: declaredPipes,\n            exportedPipes: exportedPipes,\n            importedModules: importedModules,\n            exportedModules: exportedModules,\n            transitiveModule: transitiveModule,\n            id: meta.id || null,\n        });\n        entryComponents.forEach(function (id) { return transitiveModule.addEntryComponent(id); });\n        providers.forEach(function (provider) { return transitiveModule.addProvider(provider, /** @type {?} */ ((compileMeta)).type); });\n        transitiveModule.addModule(compileMeta.type);\n        this._ngModuleCache.set(moduleType, compileMeta);\n        return compileMeta;\n    };\n    /**\n     * @param {?} moduleType\n     * @param {?} importedModuleType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._checkSelfImport = /**\n     * @param {?} moduleType\n     * @param {?} importedModuleType\n     * @return {?}\n     */\n    function (moduleType, importedModuleType) {\n        if (moduleType === importedModuleType) {\n            this._reportError(syntaxError(\"'\" + stringifyType(moduleType) + \"' module can't import itself\"), moduleType);\n            return true;\n        }\n        return false;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getTypeDescriptor = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        if (isValidType(type)) {\n            if (this.isDirective(type)) {\n                return 'directive';\n            }\n            if (this.isPipe(type)) {\n                return 'pipe';\n            }\n            if (this.isNgModule(type)) {\n                return 'module';\n            }\n        }\n        if ((/** @type {?} */ (type)).provide) {\n            return 'provider';\n        }\n        return 'value';\n    };\n    /**\n     * @param {?} type\n     * @param {?} moduleType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._addTypeToModule = /**\n     * @param {?} type\n     * @param {?} moduleType\n     * @return {?}\n     */\n    function (type, moduleType) {\n        var /** @type {?} */ oldModule = this._ngModuleOfTypes.get(type);\n        if (oldModule && oldModule !== moduleType) {\n            this._reportError(syntaxError(\"Type \" + stringifyType(type) + \" is part of the declarations of 2 modules: \" + stringifyType(oldModule) + \" and \" + stringifyType(moduleType) + \"! \" +\n                (\"Please consider moving \" + stringifyType(type) + \" to a higher module that imports \" + stringifyType(oldModule) + \" and \" + stringifyType(moduleType) + \". \") +\n                (\"You can also create a new NgModule that exports and includes \" + stringifyType(type) + \" then import that NgModule in \" + stringifyType(oldModule) + \" and \" + stringifyType(moduleType) + \".\")), moduleType);\n            return;\n        }\n        this._ngModuleOfTypes.set(type, moduleType);\n    };\n    /**\n     * @param {?} importedModules\n     * @param {?} exportedModules\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getTransitiveNgModuleMetadata = /**\n     * @param {?} importedModules\n     * @param {?} exportedModules\n     * @return {?}\n     */\n    function (importedModules, exportedModules) {\n        // collect `providers` / `entryComponents` from all imported and all exported modules\n        var /** @type {?} */ result = new TransitiveCompileNgModuleMetadata();\n        var /** @type {?} */ modulesByToken = new Map();\n        importedModules.concat(exportedModules).forEach(function (modSummary) {\n            modSummary.modules.forEach(function (mod) { return result.addModule(mod); });\n            modSummary.entryComponents.forEach(function (comp) { return result.addEntryComponent(comp); });\n            var /** @type {?} */ addedTokens = new Set();\n            modSummary.providers.forEach(function (entry) {\n                var /** @type {?} */ tokenRef = tokenReference(entry.provider.token);\n                var /** @type {?} */ prevModules = modulesByToken.get(tokenRef);\n                if (!prevModules) {\n                    prevModules = new Set();\n                    modulesByToken.set(tokenRef, prevModules);\n                }\n                var /** @type {?} */ moduleRef = entry.module.reference;\n                // Note: the providers of one module may still contain multiple providers\n                // per token (e.g. for multi providers), and we need to preserve these.\n                if (addedTokens.has(tokenRef) || !prevModules.has(moduleRef)) {\n                    prevModules.add(moduleRef);\n                    addedTokens.add(tokenRef);\n                    result.addProvider(entry.provider, entry.module);\n                }\n            });\n        });\n        exportedModules.forEach(function (modSummary) {\n            modSummary.exportedDirectives.forEach(function (id) { return result.addExportedDirective(id); });\n            modSummary.exportedPipes.forEach(function (id) { return result.addExportedPipe(id); });\n        });\n        importedModules.forEach(function (modSummary) {\n            modSummary.exportedDirectives.forEach(function (id) { return result.addDirective(id); });\n            modSummary.exportedPipes.forEach(function (id) { return result.addPipe(id); });\n        });\n        return result;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getIdentifierMetadata = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        type = resolveForwardRef(type);\n        return { reference: type };\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.isInjectable = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ annotations = this._reflector.annotations(type);\n        return annotations.some(function (ann) { return createInjectable.isTypeOf(ann); });\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getInjectableSummary = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        return {\n            summaryKind: CompileSummaryKind.Injectable,\n            type: this._getTypeMetadata(type, null, false)\n        };\n    };\n    /**\n     * @param {?} type\n     * @param {?=} dependencies\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getInjectableMetadata = /**\n     * @param {?} type\n     * @param {?=} dependencies\n     * @return {?}\n     */\n    function (type, dependencies) {\n        if (dependencies === void 0) { dependencies = null; }\n        var /** @type {?} */ typeSummary = this._loadSummary(type, CompileSummaryKind.Injectable);\n        if (typeSummary) {\n            return typeSummary.type;\n        }\n        return this._getTypeMetadata(type, dependencies);\n    };\n    /**\n     * @param {?} type\n     * @param {?=} dependencies\n     * @param {?=} throwOnUnknownDeps\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getTypeMetadata = /**\n     * @param {?} type\n     * @param {?=} dependencies\n     * @param {?=} throwOnUnknownDeps\n     * @return {?}\n     */\n    function (type, dependencies, throwOnUnknownDeps) {\n        if (dependencies === void 0) { dependencies = null; }\n        if (throwOnUnknownDeps === void 0) { throwOnUnknownDeps = true; }\n        var /** @type {?} */ identifier = this._getIdentifierMetadata(type);\n        return {\n            reference: identifier.reference,\n            diDeps: this._getDependenciesMetadata(identifier.reference, dependencies, throwOnUnknownDeps),\n            lifecycleHooks: getAllLifecycleHooks(this._reflector, identifier.reference),\n        };\n    };\n    /**\n     * @param {?} factory\n     * @param {?=} dependencies\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getFactoryMetadata = /**\n     * @param {?} factory\n     * @param {?=} dependencies\n     * @return {?}\n     */\n    function (factory, dependencies) {\n        if (dependencies === void 0) { dependencies = null; }\n        factory = resolveForwardRef(factory);\n        return { reference: factory, diDeps: this._getDependenciesMetadata(factory, dependencies) };\n    };\n    /**\n     * Gets the metadata for the given pipe.\n     * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.\n     */\n    /**\n     * Gets the metadata for the given pipe.\n     * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.\n     * @param {?} pipeType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getPipeMetadata = /**\n     * Gets the metadata for the given pipe.\n     * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first.\n     * @param {?} pipeType\n     * @return {?}\n     */\n    function (pipeType) {\n        var /** @type {?} */ pipeMeta = this._pipeCache.get(pipeType);\n        if (!pipeMeta) {\n            this._reportError(syntaxError(\"Illegal state: getPipeMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Pipe \" + stringifyType(pipeType) + \".\"), pipeType);\n        }\n        return pipeMeta || null;\n    };\n    /**\n     * @param {?} pipeType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getPipeSummary = /**\n     * @param {?} pipeType\n     * @return {?}\n     */\n    function (pipeType) {\n        var /** @type {?} */ pipeSummary = /** @type {?} */ (this._loadSummary(pipeType, CompileSummaryKind.Pipe));\n        if (!pipeSummary) {\n            this._reportError(syntaxError(\"Illegal state: Could not load the summary for pipe \" + stringifyType(pipeType) + \".\"), pipeType);\n        }\n        return pipeSummary;\n    };\n    /**\n     * @param {?} pipeType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getOrLoadPipeMetadata = /**\n     * @param {?} pipeType\n     * @return {?}\n     */\n    function (pipeType) {\n        var /** @type {?} */ pipeMeta = this._pipeCache.get(pipeType);\n        if (!pipeMeta) {\n            pipeMeta = this._loadPipeMetadata(pipeType);\n        }\n        return pipeMeta;\n    };\n    /**\n     * @param {?} pipeType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._loadPipeMetadata = /**\n     * @param {?} pipeType\n     * @return {?}\n     */\n    function (pipeType) {\n        pipeType = resolveForwardRef(pipeType);\n        var /** @type {?} */ pipeAnnotation = /** @type {?} */ ((this._pipeResolver.resolve(pipeType)));\n        var /** @type {?} */ pipeMeta = new CompilePipeMetadata({\n            type: this._getTypeMetadata(pipeType),\n            name: pipeAnnotation.name,\n            pure: !!pipeAnnotation.pure\n        });\n        this._pipeCache.set(pipeType, pipeMeta);\n        this._summaryCache.set(pipeType, pipeMeta.toSummary());\n        return pipeMeta;\n    };\n    /**\n     * @param {?} typeOrFunc\n     * @param {?} dependencies\n     * @param {?=} throwOnUnknownDeps\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getDependenciesMetadata = /**\n     * @param {?} typeOrFunc\n     * @param {?} dependencies\n     * @param {?=} throwOnUnknownDeps\n     * @return {?}\n     */\n    function (typeOrFunc, dependencies, throwOnUnknownDeps) {\n        var _this = this;\n        if (throwOnUnknownDeps === void 0) { throwOnUnknownDeps = true; }\n        var /** @type {?} */ hasUnknownDeps = false;\n        var /** @type {?} */ params = dependencies || this._reflector.parameters(typeOrFunc) || [];\n        var /** @type {?} */ dependenciesMetadata = params.map(function (param) {\n            var /** @type {?} */ isAttribute = false;\n            var /** @type {?} */ isHost = false;\n            var /** @type {?} */ isSelf = false;\n            var /** @type {?} */ isSkipSelf = false;\n            var /** @type {?} */ isOptional = false;\n            var /** @type {?} */ token = null;\n            if (Array.isArray(param)) {\n                param.forEach(function (paramEntry) {\n                    if (createHost.isTypeOf(paramEntry)) {\n                        isHost = true;\n                    }\n                    else if (createSelf.isTypeOf(paramEntry)) {\n                        isSelf = true;\n                    }\n                    else if (createSkipSelf.isTypeOf(paramEntry)) {\n                        isSkipSelf = true;\n                    }\n                    else if (createOptional.isTypeOf(paramEntry)) {\n                        isOptional = true;\n                    }\n                    else if (createAttribute.isTypeOf(paramEntry)) {\n                        isAttribute = true;\n                        token = paramEntry.attributeName;\n                    }\n                    else if (createInject.isTypeOf(paramEntry)) {\n                        token = paramEntry.token;\n                    }\n                    else if (createInjectionToken.isTypeOf(paramEntry) || paramEntry instanceof StaticSymbol) {\n                        token = paramEntry;\n                    }\n                    else if (isValidType(paramEntry) && token == null) {\n                        token = paramEntry;\n                    }\n                });\n            }\n            else {\n                token = param;\n            }\n            if (token == null) {\n                hasUnknownDeps = true;\n                return /** @type {?} */ ((null));\n            }\n            return {\n                isAttribute: isAttribute,\n                isHost: isHost,\n                isSelf: isSelf,\n                isSkipSelf: isSkipSelf,\n                isOptional: isOptional,\n                token: _this._getTokenMetadata(token)\n            };\n        });\n        if (hasUnknownDeps) {\n            var /** @type {?} */ depsTokens = dependenciesMetadata.map(function (dep) { return dep ? stringifyType(dep.token) : '?'; }).join(', ');\n            var /** @type {?} */ message = \"Can't resolve all parameters for \" + stringifyType(typeOrFunc) + \": (\" + depsTokens + \").\";\n            if (throwOnUnknownDeps || this._config.strictInjectionParameters) {\n                this._reportError(syntaxError(message), typeOrFunc);\n            }\n            else {\n                this._console.warn(\"Warning: \" + message + \" This will become an error in Angular v6.x\");\n            }\n        }\n        return dependenciesMetadata;\n    };\n    /**\n     * @param {?} token\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getTokenMetadata = /**\n     * @param {?} token\n     * @return {?}\n     */\n    function (token) {\n        token = resolveForwardRef(token);\n        var /** @type {?} */ compileToken;\n        if (typeof token === 'string') {\n            compileToken = { value: token };\n        }\n        else {\n            compileToken = { identifier: { reference: token } };\n        }\n        return compileToken;\n    };\n    /**\n     * @param {?} providers\n     * @param {?} targetEntryComponents\n     * @param {?=} debugInfo\n     * @param {?=} compileProviders\n     * @param {?=} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getProvidersMetadata = /**\n     * @param {?} providers\n     * @param {?} targetEntryComponents\n     * @param {?=} debugInfo\n     * @param {?=} compileProviders\n     * @param {?=} type\n     * @return {?}\n     */\n    function (providers, targetEntryComponents, debugInfo, compileProviders, type) {\n        var _this = this;\n        if (compileProviders === void 0) { compileProviders = []; }\n        providers.forEach(function (provider, providerIdx) {\n            if (Array.isArray(provider)) {\n                _this._getProvidersMetadata(provider, targetEntryComponents, debugInfo, compileProviders);\n            }\n            else {\n                provider = resolveForwardRef(provider);\n                var /** @type {?} */ providerMeta = /** @type {?} */ ((undefined));\n                if (provider && typeof provider === 'object' && provider.hasOwnProperty('provide')) {\n                    _this._validateProvider(provider);\n                    providerMeta = new ProviderMeta(provider.provide, provider);\n                }\n                else if (isValidType(provider)) {\n                    providerMeta = new ProviderMeta(provider, { useClass: provider });\n                }\n                else if (provider === void 0) {\n                    _this._reportError(syntaxError(\"Encountered undefined provider! Usually this means you have a circular dependencies (might be caused by using 'barrel' index.ts files.\"));\n                    return;\n                }\n                else {\n                    var /** @type {?} */ providersInfo = (/** @type {?} */ (providers.reduce(function (soFar, seenProvider, seenProviderIdx) {\n                        if (seenProviderIdx < providerIdx) {\n                            soFar.push(\"\" + stringifyType(seenProvider));\n                        }\n                        else if (seenProviderIdx == providerIdx) {\n                            soFar.push(\"?\" + stringifyType(seenProvider) + \"?\");\n                        }\n                        else if (seenProviderIdx == providerIdx + 1) {\n                            soFar.push('...');\n                        }\n                        return soFar;\n                    }, [])))\n                        .join(', ');\n                    _this._reportError(syntaxError(\"Invalid \" + (debugInfo ? debugInfo : 'provider') + \" - only instances of Provider and Type are allowed, got: [\" + providersInfo + \"]\"), type);\n                    return;\n                }\n                if (providerMeta.token ===\n                    _this._reflector.resolveExternalReference(Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS)) {\n                    targetEntryComponents.push.apply(targetEntryComponents, _this._getEntryComponentsFromProvider(providerMeta, type));\n                }\n                else {\n                    compileProviders.push(_this.getProviderMetadata(providerMeta));\n                }\n            }\n        });\n        return compileProviders;\n    };\n    /**\n     * @param {?} provider\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._validateProvider = /**\n     * @param {?} provider\n     * @return {?}\n     */\n    function (provider) {\n        if (provider.hasOwnProperty('useClass') && provider.useClass == null) {\n            this._reportError(syntaxError(\"Invalid provider for \" + stringifyType(provider.provide) + \". useClass cannot be \" + provider.useClass + \".\\n           Usually it happens when:\\n           1. There's a circular dependency (might be caused by using index.ts (barrel) files).\\n           2. Class was used before it was declared. Use forwardRef in this case.\"));\n        }\n    };\n    /**\n     * @param {?} provider\n     * @param {?=} type\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getEntryComponentsFromProvider = /**\n     * @param {?} provider\n     * @param {?=} type\n     * @return {?}\n     */\n    function (provider, type) {\n        var _this = this;\n        var /** @type {?} */ components = [];\n        var /** @type {?} */ collectedIdentifiers = [];\n        if (provider.useFactory || provider.useExisting || provider.useClass) {\n            this._reportError(syntaxError(\"The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!\"), type);\n            return [];\n        }\n        if (!provider.multi) {\n            this._reportError(syntaxError(\"The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!\"), type);\n            return [];\n        }\n        extractIdentifiers(provider.useValue, collectedIdentifiers);\n        collectedIdentifiers.forEach(function (identifier) {\n            var /** @type {?} */ entry = _this._getEntryComponentMetadata(identifier.reference, false);\n            if (entry) {\n                components.push(entry);\n            }\n        });\n        return components;\n    };\n    /**\n     * @param {?} dirType\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getEntryComponentMetadata = /**\n     * @param {?} dirType\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    function (dirType, throwIfNotFound) {\n        if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n        var /** @type {?} */ dirMeta = this.getNonNormalizedDirectiveMetadata(dirType);\n        if (dirMeta && dirMeta.metadata.isComponent) {\n            return { componentType: dirType, componentFactory: /** @type {?} */ ((dirMeta.metadata.componentFactory)) };\n        }\n        var /** @type {?} */ dirSummary = /** @type {?} */ (this._loadSummary(dirType, CompileSummaryKind.Directive));\n        if (dirSummary && dirSummary.isComponent) {\n            return { componentType: dirType, componentFactory: /** @type {?} */ ((dirSummary.componentFactory)) };\n        }\n        if (throwIfNotFound) {\n            throw syntaxError(dirType.name + \" cannot be used as an entry component.\");\n        }\n        return null;\n    };\n    /**\n     * @param {?} provider\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype.getProviderMetadata = /**\n     * @param {?} provider\n     * @return {?}\n     */\n    function (provider) {\n        var /** @type {?} */ compileDeps = /** @type {?} */ ((undefined));\n        var /** @type {?} */ compileTypeMetadata = /** @type {?} */ ((null));\n        var /** @type {?} */ compileFactoryMetadata = /** @type {?} */ ((null));\n        var /** @type {?} */ token = this._getTokenMetadata(provider.token);\n        if (provider.useClass) {\n            compileTypeMetadata = this._getInjectableMetadata(provider.useClass, provider.dependencies);\n            compileDeps = compileTypeMetadata.diDeps;\n            if (provider.token === provider.useClass) {\n                // use the compileTypeMetadata as it contains information about lifecycleHooks...\n                token = { identifier: compileTypeMetadata };\n            }\n        }\n        else if (provider.useFactory) {\n            compileFactoryMetadata = this._getFactoryMetadata(provider.useFactory, provider.dependencies);\n            compileDeps = compileFactoryMetadata.diDeps;\n        }\n        return {\n            token: token,\n            useClass: compileTypeMetadata,\n            useValue: provider.useValue,\n            useFactory: compileFactoryMetadata,\n            useExisting: provider.useExisting ? this._getTokenMetadata(provider.useExisting) : undefined,\n            deps: compileDeps,\n            multi: provider.multi\n        };\n    };\n    /**\n     * @param {?} queries\n     * @param {?} isViewQuery\n     * @param {?} directiveType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getQueriesMetadata = /**\n     * @param {?} queries\n     * @param {?} isViewQuery\n     * @param {?} directiveType\n     * @return {?}\n     */\n    function (queries, isViewQuery, directiveType) {\n        var _this = this;\n        var /** @type {?} */ res = [];\n        Object.keys(queries).forEach(function (propertyName) {\n            var /** @type {?} */ query = queries[propertyName];\n            if (query.isViewQuery === isViewQuery) {\n                res.push(_this._getQueryMetadata(query, propertyName, directiveType));\n            }\n        });\n        return res;\n    };\n    /**\n     * @param {?} selector\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._queryVarBindings = /**\n     * @param {?} selector\n     * @return {?}\n     */\n    function (selector) { return selector.split(/\\s*,\\s*/); };\n    /**\n     * @param {?} q\n     * @param {?} propertyName\n     * @param {?} typeOrFunc\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._getQueryMetadata = /**\n     * @param {?} q\n     * @param {?} propertyName\n     * @param {?} typeOrFunc\n     * @return {?}\n     */\n    function (q, propertyName, typeOrFunc) {\n        var _this = this;\n        var /** @type {?} */ selectors;\n        if (typeof q.selector === 'string') {\n            selectors =\n                this._queryVarBindings(q.selector).map(function (varName) { return _this._getTokenMetadata(varName); });\n        }\n        else {\n            if (!q.selector) {\n                this._reportError(syntaxError(\"Can't construct a query for the property \\\"\" + propertyName + \"\\\" of \\\"\" + stringifyType(typeOrFunc) + \"\\\" since the query selector wasn't defined.\"), typeOrFunc);\n                selectors = [];\n            }\n            else {\n                selectors = [this._getTokenMetadata(q.selector)];\n            }\n        }\n        return {\n            selectors: selectors,\n            first: q.first,\n            descendants: q.descendants, propertyName: propertyName,\n            read: q.read ? this._getTokenMetadata(q.read) : /** @type {?} */ ((null))\n        };\n    };\n    /**\n     * @param {?} error\n     * @param {?=} type\n     * @param {?=} otherType\n     * @return {?}\n     */\n    CompileMetadataResolver.prototype._reportError = /**\n     * @param {?} error\n     * @param {?=} type\n     * @param {?=} otherType\n     * @return {?}\n     */\n    function (error, type, otherType) {\n        if (this._errorCollector) {\n            this._errorCollector(error, type);\n            if (otherType) {\n                this._errorCollector(error, otherType);\n            }\n        }\n        else {\n            throw error;\n        }\n    };\n    return CompileMetadataResolver;\n}());\n/**\n * @param {?} tree\n * @param {?=} out\n * @return {?}\n */\nfunction flattenArray(tree, out) {\n    if (out === void 0) { out = []; }\n    if (tree) {\n        for (var /** @type {?} */ i = 0; i < tree.length; i++) {\n            var /** @type {?} */ item = resolveForwardRef(tree[i]);\n            if (Array.isArray(item)) {\n                flattenArray(item, out);\n            }\n            else {\n                out.push(item);\n            }\n        }\n    }\n    return out;\n}\n/**\n * @param {?} array\n * @return {?}\n */\nfunction dedupeArray(array) {\n    if (array) {\n        return Array.from(new Set(array));\n    }\n    return [];\n}\n/**\n * @param {?} tree\n * @return {?}\n */\nfunction flattenAndDedupeArray(tree) {\n    return dedupeArray(flattenArray(tree));\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isValidType(value) {\n    return (value instanceof StaticSymbol) || (value instanceof Type);\n}\n/**\n * @param {?} value\n * @param {?} targetIdentifiers\n * @return {?}\n */\nfunction extractIdentifiers(value, targetIdentifiers) {\n    visitValue(value, new _CompileValueConverter(), targetIdentifiers);\n}\nvar _CompileValueConverter = /** @class */ (function (_super) {\n    __extends(_CompileValueConverter, _super);\n    function _CompileValueConverter() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} value\n     * @param {?} targetIdentifiers\n     * @return {?}\n     */\n    _CompileValueConverter.prototype.visitOther = /**\n     * @param {?} value\n     * @param {?} targetIdentifiers\n     * @return {?}\n     */\n    function (value, targetIdentifiers) {\n        targetIdentifiers.push({ reference: value });\n    };\n    return _CompileValueConverter;\n}(ValueTransformer));\n/**\n * @param {?} type\n * @return {?}\n */\nfunction stringifyType(type) {\n    if (type instanceof StaticSymbol) {\n        return type.name + \" in \" + type.filePath;\n    }\n    else {\n        return stringify(type);\n    }\n}\n/**\n * Indicates that a component is still being loaded in a synchronous compile.\n * @param {?} compType\n * @return {?}\n */\nfunction componentStillLoadingError(compType) {\n    var /** @type {?} */ error = Error(\"Can't compile synchronously as \" + stringify(compType) + \" is still being loaded!\");\n    (/** @type {?} */ (error))[ERROR_COMPONENT_TYPE] = compType;\n    return error;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @enum {number} */\nvar TypeModifier = {\n    Const: 0,\n};\nTypeModifier[TypeModifier.Const] = \"Const\";\n/**\n * @abstract\n */\nvar Type$1 = /** @class */ (function () {\n    function Type(modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        this.modifiers = modifiers;\n        if (!modifiers) {\n            this.modifiers = [];\n        }\n    }\n    /**\n     * @param {?} modifier\n     * @return {?}\n     */\n    Type.prototype.hasModifier = /**\n     * @param {?} modifier\n     * @return {?}\n     */\n    function (modifier) { return /** @type {?} */ ((this.modifiers)).indexOf(modifier) !== -1; };\n    return Type;\n}());\n/** @enum {number} */\nvar BuiltinTypeName = {\n    Dynamic: 0,\n    Bool: 1,\n    String: 2,\n    Int: 3,\n    Number: 4,\n    Function: 5,\n    Inferred: 6,\n};\nBuiltinTypeName[BuiltinTypeName.Dynamic] = \"Dynamic\";\nBuiltinTypeName[BuiltinTypeName.Bool] = \"Bool\";\nBuiltinTypeName[BuiltinTypeName.String] = \"String\";\nBuiltinTypeName[BuiltinTypeName.Int] = \"Int\";\nBuiltinTypeName[BuiltinTypeName.Number] = \"Number\";\nBuiltinTypeName[BuiltinTypeName.Function] = \"Function\";\nBuiltinTypeName[BuiltinTypeName.Inferred] = \"Inferred\";\nvar BuiltinType = /** @class */ (function (_super) {\n    __extends(BuiltinType, _super);\n    function BuiltinType(name, modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, modifiers) || this;\n        _this.name = name;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    BuiltinType.prototype.visitType = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitBuiltintType(this, context);\n    };\n    return BuiltinType;\n}(Type$1));\nvar ExpressionType = /** @class */ (function (_super) {\n    __extends(ExpressionType, _super);\n    function ExpressionType(value, modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, modifiers) || this;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ExpressionType.prototype.visitType = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitExpressionType(this, context);\n    };\n    return ExpressionType;\n}(Type$1));\nvar ArrayType = /** @class */ (function (_super) {\n    __extends(ArrayType, _super);\n    function ArrayType(of, modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, modifiers) || this;\n        _this.of = of;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ArrayType.prototype.visitType = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitArrayType(this, context);\n    };\n    return ArrayType;\n}(Type$1));\nvar MapType = /** @class */ (function (_super) {\n    __extends(MapType, _super);\n    function MapType(valueType, modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, modifiers) || this;\n        _this.valueType = valueType || null;\n        return _this;\n    }\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    MapType.prototype.visitType = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) { return visitor.visitMapType(this, context); };\n    return MapType;\n}(Type$1));\nvar DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);\nvar INFERRED_TYPE = new BuiltinType(BuiltinTypeName.Inferred);\nvar BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);\nvar INT_TYPE = new BuiltinType(BuiltinTypeName.Int);\nvar NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);\nvar STRING_TYPE = new BuiltinType(BuiltinTypeName.String);\nvar FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);\n/**\n * @record\n */\n\n/** @enum {number} */\nvar BinaryOperator = {\n    Equals: 0,\n    NotEquals: 1,\n    Identical: 2,\n    NotIdentical: 3,\n    Minus: 4,\n    Plus: 5,\n    Divide: 6,\n    Multiply: 7,\n    Modulo: 8,\n    And: 9,\n    Or: 10,\n    Lower: 11,\n    LowerEquals: 12,\n    Bigger: 13,\n    BiggerEquals: 14,\n};\nBinaryOperator[BinaryOperator.Equals] = \"Equals\";\nBinaryOperator[BinaryOperator.NotEquals] = \"NotEquals\";\nBinaryOperator[BinaryOperator.Identical] = \"Identical\";\nBinaryOperator[BinaryOperator.NotIdentical] = \"NotIdentical\";\nBinaryOperator[BinaryOperator.Minus] = \"Minus\";\nBinaryOperator[BinaryOperator.Plus] = \"Plus\";\nBinaryOperator[BinaryOperator.Divide] = \"Divide\";\nBinaryOperator[BinaryOperator.Multiply] = \"Multiply\";\nBinaryOperator[BinaryOperator.Modulo] = \"Modulo\";\nBinaryOperator[BinaryOperator.And] = \"And\";\nBinaryOperator[BinaryOperator.Or] = \"Or\";\nBinaryOperator[BinaryOperator.Lower] = \"Lower\";\nBinaryOperator[BinaryOperator.LowerEquals] = \"LowerEquals\";\nBinaryOperator[BinaryOperator.Bigger] = \"Bigger\";\nBinaryOperator[BinaryOperator.BiggerEquals] = \"BiggerEquals\";\n/**\n * @template T\n * @param {?} base\n * @param {?} other\n * @return {?}\n */\nfunction nullSafeIsEquivalent(base, other) {\n    if (base == null || other == null) {\n        return base == other;\n    }\n    return base.isEquivalent(other);\n}\n/**\n * @template T\n * @param {?} base\n * @param {?} other\n * @return {?}\n */\nfunction areAllEquivalent(base, other) {\n    var /** @type {?} */ len = base.length;\n    if (len !== other.length) {\n        return false;\n    }\n    for (var /** @type {?} */ i = 0; i < len; i++) {\n        if (!base[i].isEquivalent(other[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * @abstract\n */\nvar Expression = /** @class */ (function () {\n    function Expression(type, sourceSpan) {\n        this.type = type || null;\n        this.sourceSpan = sourceSpan || null;\n    }\n    /**\n     * @param {?} name\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.prop = /**\n     * @param {?} name\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (name, sourceSpan) {\n        return new ReadPropExpr(this, name, null, sourceSpan);\n    };\n    /**\n     * @param {?} index\n     * @param {?=} type\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.key = /**\n     * @param {?} index\n     * @param {?=} type\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (index, type, sourceSpan) {\n        return new ReadKeyExpr(this, index, type, sourceSpan);\n    };\n    /**\n     * @param {?} name\n     * @param {?} params\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.callMethod = /**\n     * @param {?} name\n     * @param {?} params\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (name, params, sourceSpan) {\n        return new InvokeMethodExpr(this, name, params, null, sourceSpan);\n    };\n    /**\n     * @param {?} params\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.callFn = /**\n     * @param {?} params\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (params, sourceSpan) {\n        return new InvokeFunctionExpr(this, params, null, sourceSpan);\n    };\n    /**\n     * @param {?} params\n     * @param {?=} type\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.instantiate = /**\n     * @param {?} params\n     * @param {?=} type\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (params, type, sourceSpan) {\n        return new InstantiateExpr(this, params, type, sourceSpan);\n    };\n    /**\n     * @param {?} trueCase\n     * @param {?=} falseCase\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.conditional = /**\n     * @param {?} trueCase\n     * @param {?=} falseCase\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (trueCase, falseCase, sourceSpan) {\n        if (falseCase === void 0) { falseCase = null; }\n        return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.equals = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.notEquals = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.identical = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.notIdentical = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.minus = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.plus = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.divide = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.multiply = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.modulo = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.and = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.or = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.lower = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.lowerEquals = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.bigger = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.biggerEquals = /**\n     * @param {?} rhs\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (rhs, sourceSpan) {\n        return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan);\n    };\n    /**\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.isBlank = /**\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (sourceSpan) {\n        // Note: We use equals by purpose here to compare to null and undefined in JS.\n        // We use the typed null to allow strictNullChecks to narrow types.\n        return this.equals(TYPED_NULL_EXPR, sourceSpan);\n    };\n    /**\n     * @param {?} type\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    Expression.prototype.cast = /**\n     * @param {?} type\n     * @param {?=} sourceSpan\n     * @return {?}\n     */\n    function (type, sourceSpan) {\n        return new CastExpr(this, type, sourceSpan);\n    };\n    /**\n     * @return {?}\n     */\n    Expression.prototype.toStmt = /**\n     * @return {?}\n     */\n    function () { return new ExpressionStatement(this, null); };\n    return Expression;\n}());\n/** @enum {number} */\nvar BuiltinVar = {\n    This: 0,\n    Super: 1,\n    CatchError: 2,\n    CatchStack: 3,\n};\nBuiltinVar[BuiltinVar.This] = \"This\";\nBuiltinVar[BuiltinVar.Super] = \"Super\";\nBuiltinVar[BuiltinVar.CatchError] = \"CatchError\";\nBuiltinVar[BuiltinVar.CatchStack] = \"CatchStack\";\nvar ReadVarExpr = /** @class */ (function (_super) {\n    __extends(ReadVarExpr, _super);\n    function ReadVarExpr(name, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        if (typeof name === 'string') {\n            _this.name = name;\n            _this.builtin = null;\n        }\n        else {\n            _this.name = null;\n            _this.builtin = /** @type {?} */ (name);\n        }\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    ReadVarExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof ReadVarExpr && this.name === e.name && this.builtin === e.builtin;\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ReadVarExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitReadVarExpr(this, context);\n    };\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    ReadVarExpr.prototype.set = /**\n     * @param {?} value\n     * @return {?}\n     */\n    function (value) {\n        if (!this.name) {\n            throw new Error(\"Built in variable \" + this.builtin + \" can not be assigned to.\");\n        }\n        return new WriteVarExpr(this.name, value, null, this.sourceSpan);\n    };\n    return ReadVarExpr;\n}(Expression));\nvar WriteVarExpr = /** @class */ (function (_super) {\n    __extends(WriteVarExpr, _super);\n    function WriteVarExpr(name, value, type, sourceSpan) {\n        var _this = _super.call(this, type || value.type, sourceSpan) || this;\n        _this.name = name;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    WriteVarExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof WriteVarExpr && this.name === e.name && this.value.isEquivalent(e.value);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    WriteVarExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitWriteVarExpr(this, context);\n    };\n    /**\n     * @param {?=} type\n     * @param {?=} modifiers\n     * @return {?}\n     */\n    WriteVarExpr.prototype.toDeclStmt = /**\n     * @param {?=} type\n     * @param {?=} modifiers\n     * @return {?}\n     */\n    function (type, modifiers) {\n        return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);\n    };\n    return WriteVarExpr;\n}(Expression));\nvar WriteKeyExpr = /** @class */ (function (_super) {\n    __extends(WriteKeyExpr, _super);\n    function WriteKeyExpr(receiver, index, value, type, sourceSpan) {\n        var _this = _super.call(this, type || value.type, sourceSpan) || this;\n        _this.receiver = receiver;\n        _this.index = index;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    WriteKeyExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof WriteKeyExpr && this.receiver.isEquivalent(e.receiver) &&\n            this.index.isEquivalent(e.index) && this.value.isEquivalent(e.value);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    WriteKeyExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitWriteKeyExpr(this, context);\n    };\n    return WriteKeyExpr;\n}(Expression));\nvar WritePropExpr = /** @class */ (function (_super) {\n    __extends(WritePropExpr, _super);\n    function WritePropExpr(receiver, name, value, type, sourceSpan) {\n        var _this = _super.call(this, type || value.type, sourceSpan) || this;\n        _this.receiver = receiver;\n        _this.name = name;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    WritePropExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof WritePropExpr && this.receiver.isEquivalent(e.receiver) &&\n            this.name === e.name && this.value.isEquivalent(e.value);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    WritePropExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitWritePropExpr(this, context);\n    };\n    return WritePropExpr;\n}(Expression));\n/** @enum {number} */\nvar BuiltinMethod = {\n    ConcatArray: 0,\n    SubscribeObservable: 1,\n    Bind: 2,\n};\nBuiltinMethod[BuiltinMethod.ConcatArray] = \"ConcatArray\";\nBuiltinMethod[BuiltinMethod.SubscribeObservable] = \"SubscribeObservable\";\nBuiltinMethod[BuiltinMethod.Bind] = \"Bind\";\nvar InvokeMethodExpr = /** @class */ (function (_super) {\n    __extends(InvokeMethodExpr, _super);\n    function InvokeMethodExpr(receiver, method, args, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.receiver = receiver;\n        _this.args = args;\n        if (typeof method === 'string') {\n            _this.name = method;\n            _this.builtin = null;\n        }\n        else {\n            _this.name = null;\n            _this.builtin = /** @type {?} */ (method);\n        }\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    InvokeMethodExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof InvokeMethodExpr && this.receiver.isEquivalent(e.receiver) &&\n            this.name === e.name && this.builtin === e.builtin && areAllEquivalent(this.args, e.args);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    InvokeMethodExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitInvokeMethodExpr(this, context);\n    };\n    return InvokeMethodExpr;\n}(Expression));\nvar InvokeFunctionExpr = /** @class */ (function (_super) {\n    __extends(InvokeFunctionExpr, _super);\n    function InvokeFunctionExpr(fn, args, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.fn = fn;\n        _this.args = args;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    InvokeFunctionExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof InvokeFunctionExpr && this.fn.isEquivalent(e.fn) &&\n            areAllEquivalent(this.args, e.args);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    InvokeFunctionExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitInvokeFunctionExpr(this, context);\n    };\n    return InvokeFunctionExpr;\n}(Expression));\nvar InstantiateExpr = /** @class */ (function (_super) {\n    __extends(InstantiateExpr, _super);\n    function InstantiateExpr(classExpr, args, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.classExpr = classExpr;\n        _this.args = args;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    InstantiateExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof InstantiateExpr && this.classExpr.isEquivalent(e.classExpr) &&\n            areAllEquivalent(this.args, e.args);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    InstantiateExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitInstantiateExpr(this, context);\n    };\n    return InstantiateExpr;\n}(Expression));\nvar LiteralExpr = /** @class */ (function (_super) {\n    __extends(LiteralExpr, _super);\n    function LiteralExpr(value, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    LiteralExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof LiteralExpr && this.value === e.value;\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    LiteralExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitLiteralExpr(this, context);\n    };\n    return LiteralExpr;\n}(Expression));\nvar ExternalExpr = /** @class */ (function (_super) {\n    __extends(ExternalExpr, _super);\n    function ExternalExpr(value, type, typeParams, sourceSpan) {\n        if (typeParams === void 0) { typeParams = null; }\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.value = value;\n        _this.typeParams = typeParams;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    ExternalExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof ExternalExpr && this.value.name === e.value.name &&\n            this.value.moduleName === e.value.moduleName && this.value.runtime === e.value.runtime;\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ExternalExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitExternalExpr(this, context);\n    };\n    return ExternalExpr;\n}(Expression));\nvar ExternalReference = /** @class */ (function () {\n    function ExternalReference(moduleName, name, runtime) {\n        this.moduleName = moduleName;\n        this.name = name;\n        this.runtime = runtime;\n    }\n    return ExternalReference;\n}());\nvar ConditionalExpr = /** @class */ (function (_super) {\n    __extends(ConditionalExpr, _super);\n    function ConditionalExpr(condition, trueCase, falseCase, type, sourceSpan) {\n        if (falseCase === void 0) { falseCase = null; }\n        var _this = _super.call(this, type || trueCase.type, sourceSpan) || this;\n        _this.condition = condition;\n        _this.falseCase = falseCase;\n        _this.trueCase = trueCase;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    ConditionalExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof ConditionalExpr && this.condition.isEquivalent(e.condition) &&\n            this.trueCase.isEquivalent(e.trueCase) && nullSafeIsEquivalent(this.falseCase, e.falseCase);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ConditionalExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitConditionalExpr(this, context);\n    };\n    return ConditionalExpr;\n}(Expression));\nvar NotExpr = /** @class */ (function (_super) {\n    __extends(NotExpr, _super);\n    function NotExpr(condition, sourceSpan) {\n        var _this = _super.call(this, BOOL_TYPE, sourceSpan) || this;\n        _this.condition = condition;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    NotExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof NotExpr && this.condition.isEquivalent(e.condition);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    NotExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitNotExpr(this, context);\n    };\n    return NotExpr;\n}(Expression));\nvar AssertNotNull = /** @class */ (function (_super) {\n    __extends(AssertNotNull, _super);\n    function AssertNotNull(condition, sourceSpan) {\n        var _this = _super.call(this, condition.type, sourceSpan) || this;\n        _this.condition = condition;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    AssertNotNull.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof AssertNotNull && this.condition.isEquivalent(e.condition);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    AssertNotNull.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitAssertNotNullExpr(this, context);\n    };\n    return AssertNotNull;\n}(Expression));\nvar CastExpr = /** @class */ (function (_super) {\n    __extends(CastExpr, _super);\n    function CastExpr(value, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    CastExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof CastExpr && this.value.isEquivalent(e.value);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    CastExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitCastExpr(this, context);\n    };\n    return CastExpr;\n}(Expression));\nvar FnParam = /** @class */ (function () {\n    function FnParam(name, type) {\n        if (type === void 0) { type = null; }\n        this.name = name;\n        this.type = type;\n    }\n    /**\n     * @param {?} param\n     * @return {?}\n     */\n    FnParam.prototype.isEquivalent = /**\n     * @param {?} param\n     * @return {?}\n     */\n    function (param) { return this.name === param.name; };\n    return FnParam;\n}());\nvar FunctionExpr = /** @class */ (function (_super) {\n    __extends(FunctionExpr, _super);\n    function FunctionExpr(params, statements, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.params = params;\n        _this.statements = statements;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    FunctionExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof FunctionExpr && areAllEquivalent(this.params, e.params) &&\n            areAllEquivalent(this.statements, e.statements);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    FunctionExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitFunctionExpr(this, context);\n    };\n    /**\n     * @param {?} name\n     * @param {?=} modifiers\n     * @return {?}\n     */\n    FunctionExpr.prototype.toDeclStmt = /**\n     * @param {?} name\n     * @param {?=} modifiers\n     * @return {?}\n     */\n    function (name, modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan);\n    };\n    return FunctionExpr;\n}(Expression));\nvar BinaryOperatorExpr = /** @class */ (function (_super) {\n    __extends(BinaryOperatorExpr, _super);\n    function BinaryOperatorExpr(operator, lhs, rhs, type, sourceSpan) {\n        var _this = _super.call(this, type || lhs.type, sourceSpan) || this;\n        _this.operator = operator;\n        _this.rhs = rhs;\n        _this.lhs = lhs;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    BinaryOperatorExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof BinaryOperatorExpr && this.operator === e.operator &&\n            this.lhs.isEquivalent(e.lhs) && this.rhs.isEquivalent(e.rhs);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    BinaryOperatorExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitBinaryOperatorExpr(this, context);\n    };\n    return BinaryOperatorExpr;\n}(Expression));\nvar ReadPropExpr = /** @class */ (function (_super) {\n    __extends(ReadPropExpr, _super);\n    function ReadPropExpr(receiver, name, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.receiver = receiver;\n        _this.name = name;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    ReadPropExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof ReadPropExpr && this.receiver.isEquivalent(e.receiver) &&\n            this.name === e.name;\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ReadPropExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitReadPropExpr(this, context);\n    };\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    ReadPropExpr.prototype.set = /**\n     * @param {?} value\n     * @return {?}\n     */\n    function (value) {\n        return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);\n    };\n    return ReadPropExpr;\n}(Expression));\nvar ReadKeyExpr = /** @class */ (function (_super) {\n    __extends(ReadKeyExpr, _super);\n    function ReadKeyExpr(receiver, index, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.receiver = receiver;\n        _this.index = index;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    ReadKeyExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof ReadKeyExpr && this.receiver.isEquivalent(e.receiver) &&\n            this.index.isEquivalent(e.index);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ReadKeyExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitReadKeyExpr(this, context);\n    };\n    /**\n     * @param {?} value\n     * @return {?}\n     */\n    ReadKeyExpr.prototype.set = /**\n     * @param {?} value\n     * @return {?}\n     */\n    function (value) {\n        return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);\n    };\n    return ReadKeyExpr;\n}(Expression));\nvar LiteralArrayExpr = /** @class */ (function (_super) {\n    __extends(LiteralArrayExpr, _super);\n    function LiteralArrayExpr(entries, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.entries = entries;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    LiteralArrayExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof LiteralArrayExpr && areAllEquivalent(this.entries, e.entries);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    LiteralArrayExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitLiteralArrayExpr(this, context);\n    };\n    return LiteralArrayExpr;\n}(Expression));\nvar LiteralMapEntry = /** @class */ (function () {\n    function LiteralMapEntry(key, value, quoted) {\n        this.key = key;\n        this.value = value;\n        this.quoted = quoted;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    LiteralMapEntry.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return this.key === e.key && this.value.isEquivalent(e.value);\n    };\n    return LiteralMapEntry;\n}());\nvar LiteralMapExpr = /** @class */ (function (_super) {\n    __extends(LiteralMapExpr, _super);\n    function LiteralMapExpr(entries, type, sourceSpan) {\n        var _this = _super.call(this, type, sourceSpan) || this;\n        _this.entries = entries;\n        _this.valueType = null;\n        if (type) {\n            _this.valueType = type.valueType;\n        }\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    LiteralMapExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof LiteralMapExpr && areAllEquivalent(this.entries, e.entries);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    LiteralMapExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitLiteralMapExpr(this, context);\n    };\n    return LiteralMapExpr;\n}(Expression));\nvar CommaExpr = /** @class */ (function (_super) {\n    __extends(CommaExpr, _super);\n    function CommaExpr(parts, sourceSpan) {\n        var _this = _super.call(this, parts[parts.length - 1].type, sourceSpan) || this;\n        _this.parts = parts;\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @return {?}\n     */\n    CommaExpr.prototype.isEquivalent = /**\n     * @param {?} e\n     * @return {?}\n     */\n    function (e) {\n        return e instanceof CommaExpr && areAllEquivalent(this.parts, e.parts);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    CommaExpr.prototype.visitExpression = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitCommaExpr(this, context);\n    };\n    return CommaExpr;\n}(Expression));\n/**\n * @record\n */\n\nvar THIS_EXPR = new ReadVarExpr(BuiltinVar.This, null, null);\nvar SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super, null, null);\nvar CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError, null, null);\nvar CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack, null, null);\nvar NULL_EXPR = new LiteralExpr(null, null, null);\nvar TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);\n/** @enum {number} */\nvar StmtModifier = {\n    Final: 0,\n    Private: 1,\n    Exported: 2,\n};\nStmtModifier[StmtModifier.Final] = \"Final\";\nStmtModifier[StmtModifier.Private] = \"Private\";\nStmtModifier[StmtModifier.Exported] = \"Exported\";\n/**\n * @abstract\n */\nvar Statement = /** @class */ (function () {\n    function Statement(modifiers, sourceSpan) {\n        this.modifiers = modifiers || [];\n        this.sourceSpan = sourceSpan || null;\n    }\n    /**\n     * @param {?} modifier\n     * @return {?}\n     */\n    Statement.prototype.hasModifier = /**\n     * @param {?} modifier\n     * @return {?}\n     */\n    function (modifier) { return /** @type {?} */ ((this.modifiers)).indexOf(modifier) !== -1; };\n    return Statement;\n}());\nvar DeclareVarStmt = /** @class */ (function (_super) {\n    __extends(DeclareVarStmt, _super);\n    function DeclareVarStmt(name, value, type, modifiers, sourceSpan) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, modifiers, sourceSpan) || this;\n        _this.name = name;\n        _this.value = value;\n        _this.type = type || value.type;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    DeclareVarStmt.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) {\n        return stmt instanceof DeclareVarStmt && this.name === stmt.name &&\n            this.value.isEquivalent(stmt.value);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    DeclareVarStmt.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitDeclareVarStmt(this, context);\n    };\n    return DeclareVarStmt;\n}(Statement));\nvar DeclareFunctionStmt = /** @class */ (function (_super) {\n    __extends(DeclareFunctionStmt, _super);\n    function DeclareFunctionStmt(name, params, statements, type, modifiers, sourceSpan) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, modifiers, sourceSpan) || this;\n        _this.name = name;\n        _this.params = params;\n        _this.statements = statements;\n        _this.type = type || null;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    DeclareFunctionStmt.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) {\n        return stmt instanceof DeclareFunctionStmt && areAllEquivalent(this.params, stmt.params) &&\n            areAllEquivalent(this.statements, stmt.statements);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    DeclareFunctionStmt.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitDeclareFunctionStmt(this, context);\n    };\n    return DeclareFunctionStmt;\n}(Statement));\nvar ExpressionStatement = /** @class */ (function (_super) {\n    __extends(ExpressionStatement, _super);\n    function ExpressionStatement(expr, sourceSpan) {\n        var _this = _super.call(this, null, sourceSpan) || this;\n        _this.expr = expr;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    ExpressionStatement.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) {\n        return stmt instanceof ExpressionStatement && this.expr.isEquivalent(stmt.expr);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ExpressionStatement.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitExpressionStmt(this, context);\n    };\n    return ExpressionStatement;\n}(Statement));\nvar ReturnStatement = /** @class */ (function (_super) {\n    __extends(ReturnStatement, _super);\n    function ReturnStatement(value, sourceSpan) {\n        var _this = _super.call(this, null, sourceSpan) || this;\n        _this.value = value;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    ReturnStatement.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) {\n        return stmt instanceof ReturnStatement && this.value.isEquivalent(stmt.value);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ReturnStatement.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitReturnStmt(this, context);\n    };\n    return ReturnStatement;\n}(Statement));\nvar AbstractClassPart = /** @class */ (function () {\n    function AbstractClassPart(type, modifiers) {\n        this.modifiers = modifiers;\n        if (!modifiers) {\n            this.modifiers = [];\n        }\n        this.type = type || null;\n    }\n    /**\n     * @param {?} modifier\n     * @return {?}\n     */\n    AbstractClassPart.prototype.hasModifier = /**\n     * @param {?} modifier\n     * @return {?}\n     */\n    function (modifier) { return /** @type {?} */ ((this.modifiers)).indexOf(modifier) !== -1; };\n    return AbstractClassPart;\n}());\nvar ClassField = /** @class */ (function (_super) {\n    __extends(ClassField, _super);\n    function ClassField(name, type, modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, type, modifiers) || this;\n        _this.name = name;\n        return _this;\n    }\n    /**\n     * @param {?} f\n     * @return {?}\n     */\n    ClassField.prototype.isEquivalent = /**\n     * @param {?} f\n     * @return {?}\n     */\n    function (f) { return this.name === f.name; };\n    return ClassField;\n}(AbstractClassPart));\nvar ClassMethod = /** @class */ (function (_super) {\n    __extends(ClassMethod, _super);\n    function ClassMethod(name, params, body, type, modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, type, modifiers) || this;\n        _this.name = name;\n        _this.params = params;\n        _this.body = body;\n        return _this;\n    }\n    /**\n     * @param {?} m\n     * @return {?}\n     */\n    ClassMethod.prototype.isEquivalent = /**\n     * @param {?} m\n     * @return {?}\n     */\n    function (m) {\n        return this.name === m.name && areAllEquivalent(this.body, m.body);\n    };\n    return ClassMethod;\n}(AbstractClassPart));\nvar ClassGetter = /** @class */ (function (_super) {\n    __extends(ClassGetter, _super);\n    function ClassGetter(name, body, type, modifiers) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, type, modifiers) || this;\n        _this.name = name;\n        _this.body = body;\n        return _this;\n    }\n    /**\n     * @param {?} m\n     * @return {?}\n     */\n    ClassGetter.prototype.isEquivalent = /**\n     * @param {?} m\n     * @return {?}\n     */\n    function (m) {\n        return this.name === m.name && areAllEquivalent(this.body, m.body);\n    };\n    return ClassGetter;\n}(AbstractClassPart));\nvar ClassStmt = /** @class */ (function (_super) {\n    __extends(ClassStmt, _super);\n    function ClassStmt(name, parent, fields, getters, constructorMethod, methods, modifiers, sourceSpan) {\n        if (modifiers === void 0) { modifiers = null; }\n        var _this = _super.call(this, modifiers, sourceSpan) || this;\n        _this.name = name;\n        _this.parent = parent;\n        _this.fields = fields;\n        _this.getters = getters;\n        _this.constructorMethod = constructorMethod;\n        _this.methods = methods;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    ClassStmt.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) {\n        return stmt instanceof ClassStmt && this.name === stmt.name &&\n            nullSafeIsEquivalent(this.parent, stmt.parent) &&\n            areAllEquivalent(this.fields, stmt.fields) &&\n            areAllEquivalent(this.getters, stmt.getters) &&\n            this.constructorMethod.isEquivalent(stmt.constructorMethod) &&\n            areAllEquivalent(this.methods, stmt.methods);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ClassStmt.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitDeclareClassStmt(this, context);\n    };\n    return ClassStmt;\n}(Statement));\nvar IfStmt = /** @class */ (function (_super) {\n    __extends(IfStmt, _super);\n    function IfStmt(condition, trueCase, falseCase, sourceSpan) {\n        if (falseCase === void 0) { falseCase = []; }\n        var _this = _super.call(this, null, sourceSpan) || this;\n        _this.condition = condition;\n        _this.trueCase = trueCase;\n        _this.falseCase = falseCase;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    IfStmt.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) {\n        return stmt instanceof IfStmt && this.condition.isEquivalent(stmt.condition) &&\n            areAllEquivalent(this.trueCase, stmt.trueCase) &&\n            areAllEquivalent(this.falseCase, stmt.falseCase);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    IfStmt.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitIfStmt(this, context);\n    };\n    return IfStmt;\n}(Statement));\nvar CommentStmt = /** @class */ (function (_super) {\n    __extends(CommentStmt, _super);\n    function CommentStmt(comment, sourceSpan) {\n        var _this = _super.call(this, null, sourceSpan) || this;\n        _this.comment = comment;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    CommentStmt.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) { return stmt instanceof CommentStmt; };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    CommentStmt.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitCommentStmt(this, context);\n    };\n    return CommentStmt;\n}(Statement));\nvar TryCatchStmt = /** @class */ (function (_super) {\n    __extends(TryCatchStmt, _super);\n    function TryCatchStmt(bodyStmts, catchStmts, sourceSpan) {\n        var _this = _super.call(this, null, sourceSpan) || this;\n        _this.bodyStmts = bodyStmts;\n        _this.catchStmts = catchStmts;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    TryCatchStmt.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) {\n        return stmt instanceof TryCatchStmt && areAllEquivalent(this.bodyStmts, stmt.bodyStmts) &&\n            areAllEquivalent(this.catchStmts, stmt.catchStmts);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    TryCatchStmt.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitTryCatchStmt(this, context);\n    };\n    return TryCatchStmt;\n}(Statement));\nvar ThrowStmt = /** @class */ (function (_super) {\n    __extends(ThrowStmt, _super);\n    function ThrowStmt(error, sourceSpan) {\n        var _this = _super.call(this, null, sourceSpan) || this;\n        _this.error = error;\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    ThrowStmt.prototype.isEquivalent = /**\n     * @param {?} stmt\n     * @return {?}\n     */\n    function (stmt) {\n        return stmt instanceof TryCatchStmt && this.error.isEquivalent(stmt.error);\n    };\n    /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    ThrowStmt.prototype.visitStatement = /**\n     * @param {?} visitor\n     * @param {?} context\n     * @return {?}\n     */\n    function (visitor, context) {\n        return visitor.visitThrowStmt(this, context);\n    };\n    return ThrowStmt;\n}(Statement));\n/**\n * @record\n */\n\nvar AstTransformer$1 = /** @class */ (function () {\n    function AstTransformer() {\n    }\n    /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.transformExpr = /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    function (expr, context) { return expr; };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.transformStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) { return stmt; };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitReadVarExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return this.transformExpr(ast, context); };\n    /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitWriteVarExpr = /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    function (expr, context) {\n        return this.transformExpr(new WriteVarExpr(expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context);\n    };\n    /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitWriteKeyExpr = /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    function (expr, context) {\n        return this.transformExpr(new WriteKeyExpr(expr.receiver.visitExpression(this, context), expr.index.visitExpression(this, context), expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context);\n    };\n    /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitWritePropExpr = /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    function (expr, context) {\n        return this.transformExpr(new WritePropExpr(expr.receiver.visitExpression(this, context), expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitInvokeMethodExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var /** @type {?} */ method = ast.builtin || ast.name;\n        return this.transformExpr(new InvokeMethodExpr(ast.receiver.visitExpression(this, context), /** @type {?} */ ((method)), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitInvokeFunctionExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new InvokeFunctionExpr(ast.fn.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitInstantiateExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new InstantiateExpr(ast.classExpr.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitLiteralExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return this.transformExpr(ast, context); };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitExternalExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitConditionalExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new ConditionalExpr(ast.condition.visitExpression(this, context), ast.trueCase.visitExpression(this, context), /** @type {?} */ ((ast.falseCase)).visitExpression(this, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitNotExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new NotExpr(ast.condition.visitExpression(this, context), ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitAssertNotNullExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new AssertNotNull(ast.condition.visitExpression(this, context), ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitCastExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new CastExpr(ast.value.visitExpression(this, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitFunctionExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new FunctionExpr(ast.params, this.visitAllStatements(ast.statements, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitBinaryOperatorExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new BinaryOperatorExpr(ast.operator, ast.lhs.visitExpression(this, context), ast.rhs.visitExpression(this, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitReadPropExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new ReadPropExpr(ast.receiver.visitExpression(this, context), ast.name, ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitReadKeyExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new ReadKeyExpr(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitLiteralArrayExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new LiteralArrayExpr(this.visitAllExpressions(ast.entries, context), ast.type, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitLiteralMapExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        var /** @type {?} */ entries = ast.entries.map(function (entry) {\n            return new LiteralMapEntry(entry.key, entry.value.visitExpression(_this, context), entry.quoted);\n        });\n        var /** @type {?} */ mapType = new MapType(ast.valueType, null);\n        return this.transformExpr(new LiteralMapExpr(entries, mapType, ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitCommaExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.transformExpr(new CommaExpr(this.visitAllExpressions(ast.parts, context), ast.sourceSpan), context);\n    };\n    /**\n     * @param {?} exprs\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitAllExpressions = /**\n     * @param {?} exprs\n     * @param {?} context\n     * @return {?}\n     */\n    function (exprs, context) {\n        var _this = this;\n        return exprs.map(function (expr) { return expr.visitExpression(_this, context); });\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitDeclareVarStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        return this.transformStmt(new DeclareVarStmt(stmt.name, stmt.value.visitExpression(this, context), stmt.type, stmt.modifiers, stmt.sourceSpan), context);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitDeclareFunctionStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        return this.transformStmt(new DeclareFunctionStmt(stmt.name, stmt.params, this.visitAllStatements(stmt.statements, context), stmt.type, stmt.modifiers, stmt.sourceSpan), context);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitExpressionStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        return this.transformStmt(new ExpressionStatement(stmt.expr.visitExpression(this, context), stmt.sourceSpan), context);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitReturnStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        return this.transformStmt(new ReturnStatement(stmt.value.visitExpression(this, context), stmt.sourceSpan), context);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitDeclareClassStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        var _this = this;\n        var /** @type {?} */ parent = /** @type {?} */ ((stmt.parent)).visitExpression(this, context);\n        var /** @type {?} */ getters = stmt.getters.map(function (getter) {\n            return new ClassGetter(getter.name, _this.visitAllStatements(getter.body, context), getter.type, getter.modifiers);\n        });\n        var /** @type {?} */ ctorMethod = stmt.constructorMethod &&\n            new ClassMethod(stmt.constructorMethod.name, stmt.constructorMethod.params, this.visitAllStatements(stmt.constructorMethod.body, context), stmt.constructorMethod.type, stmt.constructorMethod.modifiers);\n        var /** @type {?} */ methods = stmt.methods.map(function (method) {\n            return new ClassMethod(method.name, method.params, _this.visitAllStatements(method.body, context), method.type, method.modifiers);\n        });\n        return this.transformStmt(new ClassStmt(stmt.name, parent, stmt.fields, getters, ctorMethod, methods, stmt.modifiers, stmt.sourceSpan), context);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitIfStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        return this.transformStmt(new IfStmt(stmt.condition.visitExpression(this, context), this.visitAllStatements(stmt.trueCase, context), this.visitAllStatements(stmt.falseCase, context), stmt.sourceSpan), context);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitTryCatchStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        return this.transformStmt(new TryCatchStmt(this.visitAllStatements(stmt.bodyStmts, context), this.visitAllStatements(stmt.catchStmts, context), stmt.sourceSpan), context);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitThrowStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        return this.transformStmt(new ThrowStmt(stmt.error.visitExpression(this, context), stmt.sourceSpan), context);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitCommentStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        return this.transformStmt(stmt, context);\n    };\n    /**\n     * @param {?} stmts\n     * @param {?} context\n     * @return {?}\n     */\n    AstTransformer.prototype.visitAllStatements = /**\n     * @param {?} stmts\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmts, context) {\n        var _this = this;\n        return stmts.map(function (stmt) { return stmt.visitStatement(_this, context); });\n    };\n    return AstTransformer;\n}());\nvar RecursiveAstVisitor$1 = /** @class */ (function () {\n    function RecursiveAstVisitor() {\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitType = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { return ast; };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitExpression = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        if (ast.type) {\n            ast.type.visitType(this, context);\n        }\n        return ast;\n    };\n    /**\n     * @param {?} type\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitBuiltintType = /**\n     * @param {?} type\n     * @param {?} context\n     * @return {?}\n     */\n    function (type, context) { return this.visitType(type, context); };\n    /**\n     * @param {?} type\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitExpressionType = /**\n     * @param {?} type\n     * @param {?} context\n     * @return {?}\n     */\n    function (type, context) {\n        type.value.visitExpression(this, context);\n        return this.visitType(type, context);\n    };\n    /**\n     * @param {?} type\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitArrayType = /**\n     * @param {?} type\n     * @param {?} context\n     * @return {?}\n     */\n    function (type, context) { return this.visitType(type, context); };\n    /**\n     * @param {?} type\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitMapType = /**\n     * @param {?} type\n     * @param {?} context\n     * @return {?}\n     */\n    function (type, context) { return this.visitType(type, context); };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitReadVarExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitWriteVarExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.value.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitWriteKeyExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visitExpression(this, context);\n        ast.index.visitExpression(this, context);\n        ast.value.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitWritePropExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visitExpression(this, context);\n        ast.value.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitInvokeMethodExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visitExpression(this, context);\n        this.visitAllExpressions(ast.args, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitInvokeFunctionExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.fn.visitExpression(this, context);\n        this.visitAllExpressions(ast.args, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitInstantiateExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.classExpr.visitExpression(this, context);\n        this.visitAllExpressions(ast.args, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitLiteralExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitExternalExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        if (ast.typeParams) {\n            ast.typeParams.forEach(function (type) { return type.visitType(_this, context); });\n        }\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitConditionalExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.condition.visitExpression(this, context);\n        ast.trueCase.visitExpression(this, context); /** @type {?} */\n        ((ast.falseCase)).visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitNotExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.condition.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitAssertNotNullExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.condition.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitCastExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.value.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitFunctionExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        this.visitAllStatements(ast.statements, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitBinaryOperatorExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.lhs.visitExpression(this, context);\n        ast.rhs.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitReadPropExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitReadKeyExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        ast.receiver.visitExpression(this, context);\n        ast.index.visitExpression(this, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitLiteralArrayExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        this.visitAllExpressions(ast.entries, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitLiteralMapExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        ast.entries.forEach(function (entry) { return entry.value.visitExpression(_this, context); });\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitCommaExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        this.visitAllExpressions(ast.parts, context);\n        return this.visitExpression(ast, context);\n    };\n    /**\n     * @param {?} exprs\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitAllExpressions = /**\n     * @param {?} exprs\n     * @param {?} context\n     * @return {?}\n     */\n    function (exprs, context) {\n        var _this = this;\n        exprs.forEach(function (expr) { return expr.visitExpression(_this, context); });\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitDeclareVarStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        stmt.value.visitExpression(this, context);\n        if (stmt.type) {\n            stmt.type.visitType(this, context);\n        }\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitDeclareFunctionStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        this.visitAllStatements(stmt.statements, context);\n        if (stmt.type) {\n            stmt.type.visitType(this, context);\n        }\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitExpressionStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        stmt.expr.visitExpression(this, context);\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitReturnStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        stmt.value.visitExpression(this, context);\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitDeclareClassStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        var _this = this;\n        /** @type {?} */ ((stmt.parent)).visitExpression(this, context);\n        stmt.getters.forEach(function (getter) { return _this.visitAllStatements(getter.body, context); });\n        if (stmt.constructorMethod) {\n            this.visitAllStatements(stmt.constructorMethod.body, context);\n        }\n        stmt.methods.forEach(function (method) { return _this.visitAllStatements(method.body, context); });\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitIfStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        stmt.condition.visitExpression(this, context);\n        this.visitAllStatements(stmt.trueCase, context);\n        this.visitAllStatements(stmt.falseCase, context);\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitTryCatchStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        this.visitAllStatements(stmt.bodyStmts, context);\n        this.visitAllStatements(stmt.catchStmts, context);\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitThrowStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        stmt.error.visitExpression(this, context);\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitCommentStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) { return stmt; };\n    /**\n     * @param {?} stmts\n     * @param {?} context\n     * @return {?}\n     */\n    RecursiveAstVisitor.prototype.visitAllStatements = /**\n     * @param {?} stmts\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmts, context) {\n        var _this = this;\n        stmts.forEach(function (stmt) { return stmt.visitStatement(_this, context); });\n    };\n    return RecursiveAstVisitor;\n}());\n/**\n * @param {?} stmts\n * @return {?}\n */\nfunction findReadVarNames(stmts) {\n    var /** @type {?} */ visitor = new _ReadVarVisitor();\n    visitor.visitAllStatements(stmts, null);\n    return visitor.varNames;\n}\nvar _ReadVarVisitor = /** @class */ (function (_super) {\n    __extends(_ReadVarVisitor, _super);\n    function _ReadVarVisitor() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.varNames = new Set();\n        return _this;\n    }\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    _ReadVarVisitor.prototype.visitDeclareFunctionStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        // Don't descend into nested functions\n        return stmt;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    _ReadVarVisitor.prototype.visitDeclareClassStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        // Don't descend into nested classes\n        return stmt;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    _ReadVarVisitor.prototype.visitReadVarExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        if (ast.name) {\n            this.varNames.add(ast.name);\n        }\n        return null;\n    };\n    return _ReadVarVisitor;\n}(RecursiveAstVisitor$1));\n/**\n * @param {?} stmts\n * @return {?}\n */\nfunction collectExternalReferences(stmts) {\n    var /** @type {?} */ visitor = new _FindExternalReferencesVisitor();\n    visitor.visitAllStatements(stmts, null);\n    return visitor.externalReferences;\n}\nvar _FindExternalReferencesVisitor = /** @class */ (function (_super) {\n    __extends(_FindExternalReferencesVisitor, _super);\n    function _FindExternalReferencesVisitor() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.externalReferences = [];\n        return _this;\n    }\n    /**\n     * @param {?} e\n     * @param {?} context\n     * @return {?}\n     */\n    _FindExternalReferencesVisitor.prototype.visitExternalExpr = /**\n     * @param {?} e\n     * @param {?} context\n     * @return {?}\n     */\n    function (e, context) {\n        this.externalReferences.push(e.value);\n        return _super.prototype.visitExternalExpr.call(this, e, context);\n    };\n    return _FindExternalReferencesVisitor;\n}(RecursiveAstVisitor$1));\n/**\n * @param {?} stmt\n * @param {?} sourceSpan\n * @return {?}\n */\nfunction applySourceSpanToStatementIfNeeded(stmt, sourceSpan) {\n    if (!sourceSpan) {\n        return stmt;\n    }\n    var /** @type {?} */ transformer = new _ApplySourceSpanTransformer(sourceSpan);\n    return stmt.visitStatement(transformer, null);\n}\n/**\n * @param {?} expr\n * @param {?} sourceSpan\n * @return {?}\n */\nfunction applySourceSpanToExpressionIfNeeded(expr, sourceSpan) {\n    if (!sourceSpan) {\n        return expr;\n    }\n    var /** @type {?} */ transformer = new _ApplySourceSpanTransformer(sourceSpan);\n    return expr.visitExpression(transformer, null);\n}\nvar _ApplySourceSpanTransformer = /** @class */ (function (_super) {\n    __extends(_ApplySourceSpanTransformer, _super);\n    function _ApplySourceSpanTransformer(sourceSpan) {\n        var _this = _super.call(this) || this;\n        _this.sourceSpan = sourceSpan;\n        return _this;\n    }\n    /**\n     * @param {?} obj\n     * @return {?}\n     */\n    _ApplySourceSpanTransformer.prototype._clone = /**\n     * @param {?} obj\n     * @return {?}\n     */\n    function (obj) {\n        var /** @type {?} */ clone = Object.create(obj.constructor.prototype);\n        for (var /** @type {?} */ prop in obj) {\n            clone[prop] = obj[prop];\n        }\n        return clone;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    _ApplySourceSpanTransformer.prototype.transformExpr = /**\n     * @param {?} expr\n     * @param {?} context\n     * @return {?}\n     */\n    function (expr, context) {\n        if (!expr.sourceSpan) {\n            expr = this._clone(expr);\n            expr.sourceSpan = this.sourceSpan;\n        }\n        return expr;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    _ApplySourceSpanTransformer.prototype.transformStmt = /**\n     * @param {?} stmt\n     * @param {?} context\n     * @return {?}\n     */\n    function (stmt, context) {\n        if (!stmt.sourceSpan) {\n            stmt = this._clone(stmt);\n            stmt.sourceSpan = this.sourceSpan;\n        }\n        return stmt;\n    };\n    return _ApplySourceSpanTransformer;\n}(AstTransformer$1));\n/**\n * @param {?} name\n * @param {?=} type\n * @param {?=} sourceSpan\n * @return {?}\n */\nfunction variable(name, type, sourceSpan) {\n    return new ReadVarExpr(name, type, sourceSpan);\n}\n/**\n * @param {?} id\n * @param {?=} typeParams\n * @param {?=} sourceSpan\n * @return {?}\n */\nfunction importExpr(id, typeParams, sourceSpan) {\n    if (typeParams === void 0) { typeParams = null; }\n    return new ExternalExpr(id, null, typeParams, sourceSpan);\n}\n/**\n * @param {?} id\n * @param {?=} typeParams\n * @param {?=} typeModifiers\n * @return {?}\n */\nfunction importType(id, typeParams, typeModifiers) {\n    if (typeParams === void 0) { typeParams = null; }\n    if (typeModifiers === void 0) { typeModifiers = null; }\n    return id != null ? expressionType(importExpr(id, typeParams, null), typeModifiers) : null;\n}\n/**\n * @param {?} expr\n * @param {?=} typeModifiers\n * @return {?}\n */\nfunction expressionType(expr, typeModifiers) {\n    if (typeModifiers === void 0) { typeModifiers = null; }\n    return new ExpressionType(expr, typeModifiers);\n}\n/**\n * @param {?} values\n * @param {?=} type\n * @param {?=} sourceSpan\n * @return {?}\n */\nfunction literalArr(values, type, sourceSpan) {\n    return new LiteralArrayExpr(values, type, sourceSpan);\n}\n/**\n * @param {?} values\n * @param {?=} type\n * @return {?}\n */\nfunction literalMap(values, type) {\n    if (type === void 0) { type = null; }\n    return new LiteralMapExpr(values.map(function (e) { return new LiteralMapEntry(e.key, e.value, e.quoted); }), type, null);\n}\n/**\n * @param {?} expr\n * @param {?=} sourceSpan\n * @return {?}\n */\nfunction not(expr, sourceSpan) {\n    return new NotExpr(expr, sourceSpan);\n}\n/**\n * @param {?} expr\n * @param {?=} sourceSpan\n * @return {?}\n */\nfunction assertNotNull(expr, sourceSpan) {\n    return new AssertNotNull(expr, sourceSpan);\n}\n/**\n * @param {?} params\n * @param {?} body\n * @param {?=} type\n * @param {?=} sourceSpan\n * @return {?}\n */\nfunction fn(params, body, type, sourceSpan) {\n    return new FunctionExpr(params, body, type, sourceSpan);\n}\n/**\n * @param {?} value\n * @param {?=} type\n * @param {?=} sourceSpan\n * @return {?}\n */\nfunction literal(value, type, sourceSpan) {\n    return new LiteralExpr(value, type, sourceSpan);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ProviderError = /** @class */ (function (_super) {\n    __extends(ProviderError, _super);\n    function ProviderError(message, span) {\n        return _super.call(this, span, message) || this;\n    }\n    return ProviderError;\n}(ParseError));\n/**\n * @record\n */\n\nvar ProviderViewContext = /** @class */ (function () {\n    function ProviderViewContext(reflector, component) {\n        var _this = this;\n        this.reflector = reflector;\n        this.component = component;\n        this.errors = [];\n        this.viewQueries = _getViewQueries(component);\n        this.viewProviders = new Map();\n        component.viewProviders.forEach(function (provider) {\n            if (_this.viewProviders.get(tokenReference(provider.token)) == null) {\n                _this.viewProviders.set(tokenReference(provider.token), true);\n            }\n        });\n    }\n    return ProviderViewContext;\n}());\nvar ProviderElementContext = /** @class */ (function () {\n    function ProviderElementContext(viewContext, _parent, _isViewRoot, _directiveAsts, attrs, refs, isTemplate, contentQueryStartId, _sourceSpan) {\n        var _this = this;\n        this.viewContext = viewContext;\n        this._parent = _parent;\n        this._isViewRoot = _isViewRoot;\n        this._directiveAsts = _directiveAsts;\n        this._sourceSpan = _sourceSpan;\n        this._transformedProviders = new Map();\n        this._seenProviders = new Map();\n        this._queriedTokens = new Map();\n        this.transformedHasViewContainer = false;\n        this._attrs = {};\n        attrs.forEach(function (attrAst) { return _this._attrs[attrAst.name] = attrAst.value; });\n        var /** @type {?} */ directivesMeta = _directiveAsts.map(function (directiveAst) { return directiveAst.directive; });\n        this._allProviders =\n            _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, viewContext.errors);\n        this._contentQueries = _getContentQueries(contentQueryStartId, directivesMeta);\n        Array.from(this._allProviders.values()).forEach(function (provider) {\n            _this._addQueryReadsTo(provider.token, provider.token, _this._queriedTokens);\n        });\n        if (isTemplate) {\n            var /** @type {?} */ templateRefId = createTokenForExternalReference(this.viewContext.reflector, Identifiers.TemplateRef);\n            this._addQueryReadsTo(templateRefId, templateRefId, this._queriedTokens);\n        }\n        refs.forEach(function (refAst) {\n            var /** @type {?} */ defaultQueryValue = refAst.value ||\n                createTokenForExternalReference(_this.viewContext.reflector, Identifiers.ElementRef);\n            _this._addQueryReadsTo({ value: refAst.name }, defaultQueryValue, _this._queriedTokens);\n        });\n        if (this._queriedTokens.get(this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef))) {\n            this.transformedHasViewContainer = true;\n        }\n        // create the providers that we know are eager first\n        Array.from(this._allProviders.values()).forEach(function (provider) {\n            var /** @type {?} */ eager = provider.eager || _this._queriedTokens.get(tokenReference(provider.token));\n            if (eager) {\n                _this._getOrCreateLocalProvider(provider.providerType, provider.token, true);\n            }\n        });\n    }\n    /**\n     * @return {?}\n     */\n    ProviderElementContext.prototype.afterElement = /**\n     * @return {?}\n     */\n    function () {\n        var _this = this;\n        // collect lazy providers\n        Array.from(this._allProviders.values()).forEach(function (provider) {\n            _this._getOrCreateLocalProvider(provider.providerType, provider.token, false);\n        });\n    };\n    Object.defineProperty(ProviderElementContext.prototype, \"transformProviders\", {\n        get: /**\n         * @return {?}\n         */\n        function () {\n            // Note: Maps keep their insertion order.\n            var /** @type {?} */ lazyProviders = [];\n            var /** @type {?} */ eagerProviders = [];\n            this._transformedProviders.forEach(function (provider) {\n                if (provider.eager) {\n                    eagerProviders.push(provider);\n                }\n                else {\n                    lazyProviders.push(provider);\n                }\n            });\n            return lazyProviders.concat(eagerProviders);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ProviderElementContext.prototype, \"transformedDirectiveAsts\", {\n        get: /**\n         * @return {?}\n         */\n        function () {\n            var /** @type {?} */ sortedProviderTypes = this.transformProviders.map(function (provider) { return provider.token.identifier; });\n            var /** @type {?} */ sortedDirectives = this._directiveAsts.slice();\n            sortedDirectives.sort(function (dir1, dir2) {\n                return sortedProviderTypes.indexOf(dir1.directive.type) -\n                    sortedProviderTypes.indexOf(dir2.directive.type);\n            });\n            return sortedDirectives;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ProviderElementContext.prototype, \"queryMatches\", {\n        get: /**\n         * @return {?}\n         */\n        function () {\n            var /** @type {?} */ allMatches = [];\n            this._queriedTokens.forEach(function (matches) { allMatches.push.apply(allMatches, matches); });\n            return allMatches;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * @param {?} token\n     * @param {?} defaultValue\n     * @param {?} queryReadTokens\n     * @return {?}\n     */\n    ProviderElementContext.prototype._addQueryReadsTo = /**\n     * @param {?} token\n     * @param {?} defaultValue\n     * @param {?} queryReadTokens\n     * @return {?}\n     */\n    function (token, defaultValue, queryReadTokens) {\n        this._getQueriesFor(token).forEach(function (query) {\n            var /** @type {?} */ queryValue = query.meta.read || defaultValue;\n            var /** @type {?} */ tokenRef = tokenReference(queryValue);\n            var /** @type {?} */ queryMatches = queryReadTokens.get(tokenRef);\n            if (!queryMatches) {\n                queryMatches = [];\n                queryReadTokens.set(tokenRef, queryMatches);\n            }\n            queryMatches.push({ queryId: query.queryId, value: queryValue });\n        });\n    };\n    /**\n     * @param {?} token\n     * @return {?}\n     */\n    ProviderElementContext.prototype._getQueriesFor = /**\n     * @param {?} token\n     * @return {?}\n     */\n    function (token) {\n        var /** @type {?} */ result = [];\n        var /** @type {?} */ currentEl = this;\n        var /** @type {?} */ distance = 0;\n        var /** @type {?} */ queries;\n        while (currentEl !== null) {\n            queries = currentEl._contentQueries.get(tokenReference(token));\n            if (queries) {\n                result.push.apply(result, queries.filter(function (query) { return query.meta.descendants || distance <= 1; }));\n            }\n            if (currentEl._directiveAsts.length > 0) {\n                distance++;\n            }\n            currentEl = currentEl._parent;\n        }\n        queries = this.viewContext.viewQueries.get(tokenReference(token));\n        if (queries) {\n            result.push.apply(result, queries);\n        }\n        return result;\n    };\n    /**\n     * @param {?} requestingProviderType\n     * @param {?} token\n     * @param {?} eager\n     * @return {?}\n     */\n    ProviderElementContext.prototype._getOrCreateLocalProvider = /**\n     * @param {?} requestingProviderType\n     * @param {?} token\n     * @param {?} eager\n     * @return {?}\n     */\n    function (requestingProviderType, token, eager) {\n        var _this = this;\n        var /** @type {?} */ resolvedProvider = this._allProviders.get(tokenReference(token));\n        if (!resolvedProvider || ((requestingProviderType === ProviderAstType.Directive ||\n            requestingProviderType === ProviderAstType.PublicService) &&\n            resolvedProvider.providerType === ProviderAstType.PrivateService) ||\n            ((requestingProviderType === ProviderAstType.PrivateService ||\n                requestingProviderType === ProviderAstType.PublicService) &&\n                resolvedProvider.providerType === ProviderAstType.Builtin)) {\n            return null;\n        }\n        var /** @type {?} */ transformedProviderAst = this._transformedProviders.get(tokenReference(token));\n        if (transformedProviderAst) {\n            return transformedProviderAst;\n        }\n        if (this._seenProviders.get(tokenReference(token)) != null) {\n            this.viewContext.errors.push(new ProviderError(\"Cannot instantiate cyclic dependency! \" + tokenName(token), this._sourceSpan));\n            return null;\n        }\n        this._seenProviders.set(tokenReference(token), true);\n        var /** @type {?} */ transformedProviders = resolvedProvider.providers.map(function (provider) {\n            var /** @type {?} */ transformedUseValue = provider.useValue;\n            var /** @type {?} */ transformedUseExisting = /** @type {?} */ ((provider.useExisting));\n            var /** @type {?} */ transformedDeps = /** @type {?} */ ((undefined));\n            if (provider.useExisting != null) {\n                var /** @type {?} */ existingDiDep = /** @type {?} */ ((_this._getDependency(resolvedProvider.providerType, { token: provider.useExisting }, eager)));\n                if (existingDiDep.token != null) {\n                    transformedUseExisting = existingDiDep.token;\n                }\n                else {\n                    transformedUseExisting = /** @type {?} */ ((null));\n                    transformedUseValue = existingDiDep.value;\n                }\n            }\n            else if (provider.useFactory) {\n                var /** @type {?} */ deps = provider.deps || provider.useFactory.diDeps;\n                transformedDeps =\n                    deps.map(function (dep) { return ((_this._getDependency(resolvedProvider.providerType, dep, eager))); });\n            }\n            else if (provider.useClass) {\n                var /** @type {?} */ deps = provider.deps || provider.useClass.diDeps;\n                transformedDeps =\n                    deps.map(function (dep) { return ((_this._getDependency(resolvedProvider.providerType, dep, eager))); });\n            }\n            return _transformProvider(provider, {\n                useExisting: transformedUseExisting,\n                useValue: transformedUseValue,\n                deps: transformedDeps\n            });\n        });\n        transformedProviderAst =\n            _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders });\n        this._transformedProviders.set(tokenReference(token), transformedProviderAst);\n        return transformedProviderAst;\n    };\n    /**\n     * @param {?} requestingProviderType\n     * @param {?} dep\n     * @param {?=} eager\n     * @return {?}\n     */\n    ProviderElementContext.prototype._getLocalDependency = /**\n     * @param {?} requestingProviderType\n     * @param {?} dep\n     * @param {?=} eager\n     * @return {?}\n     */\n    function (requestingProviderType, dep, eager) {\n        if (eager === void 0) { eager = false; }\n        if (dep.isAttribute) {\n            var /** @type {?} */ attrValue = this._attrs[/** @type {?} */ ((dep.token)).value];\n            return { isValue: true, value: attrValue == null ? null : attrValue };\n        }\n        if (dep.token != null) {\n            // access builtints\n            if ((requestingProviderType === ProviderAstType.Directive ||\n                requestingProviderType === ProviderAstType.Component)) {\n                if (tokenReference(dep.token) ===\n                    this.viewContext.reflector.resolveExternalReference(Identifiers.Renderer) ||\n                    tokenReference(dep.token) ===\n                        this.viewContext.reflector.resolveExternalReference(Identifiers.ElementRef) ||\n                    tokenReference(dep.token) ===\n                        this.viewContext.reflector.resolveExternalReference(Identifiers.ChangeDetectorRef) ||\n                    tokenReference(dep.token) ===\n                        this.viewContext.reflector.resolveExternalReference(Identifiers.TemplateRef)) {\n                    return dep;\n                }\n                if (tokenReference(dep.token) ===\n                    this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) {\n                    (/** @type {?} */ (this)).transformedHasViewContainer = true;\n                }\n            }\n            // access the injector\n            if (tokenReference(dep.token) ===\n                this.viewContext.reflector.resolveExternalReference(Identifiers.Injector)) {\n                return dep;\n            }\n            // access providers\n            if (this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager) != null) {\n                return dep;\n            }\n        }\n        return null;\n    };\n    /**\n     * @param {?} requestingProviderType\n     * @param {?} dep\n     * @param {?=} eager\n     * @return {?}\n     */\n    ProviderElementContext.prototype._getDependency = /**\n     * @param {?} requestingProviderType\n     * @param {?} dep\n     * @param {?=} eager\n     * @return {?}\n     */\n    function (requestingProviderType, dep, eager) {\n        if (eager === void 0) { eager = false; }\n        var /** @type {?} */ currElement = this;\n        var /** @type {?} */ currEager = eager;\n        var /** @type {?} */ result = null;\n        if (!dep.isSkipSelf) {\n            result = this._getLocalDependency(requestingProviderType, dep, eager);\n        }\n        if (dep.isSelf) {\n            if (!result && dep.isOptional) {\n                result = { isValue: true, value: null };\n            }\n        }\n        else {\n            // check parent elements\n            while (!result && currElement._parent) {\n                var /** @type {?} */ prevElement = currElement;\n                currElement = currElement._parent;\n                if (prevElement._isViewRoot) {\n                    currEager = false;\n                }\n                result = currElement._getLocalDependency(ProviderAstType.PublicService, dep, currEager);\n            }\n            // check @Host restriction\n            if (!result) {\n                if (!dep.isHost || this.viewContext.component.isHost ||\n                    this.viewContext.component.type.reference === tokenReference(/** @type {?} */ ((dep.token))) ||\n                    this.viewContext.viewProviders.get(tokenReference(/** @type {?} */ ((dep.token)))) != null) {\n                    result = dep;\n                }\n                else {\n                    result = dep.isOptional ? result = { isValue: true, value: null } : null;\n                }\n            }\n        }\n        if (!result) {\n            this.viewContext.errors.push(new ProviderError(\"No provider for \" + tokenName((/** @type {?} */ ((dep.token)))), this._sourceSpan));\n        }\n        return result;\n    };\n    return ProviderElementContext;\n}());\nvar NgModuleProviderAnalyzer = /** @class */ (function () {\n    function NgModuleProviderAnalyzer(reflector, ngModule, extraProviders, sourceSpan) {\n        var _this = this;\n        this.reflector = reflector;\n        this._transformedProviders = new Map();\n        this._seenProviders = new Map();\n        this._errors = [];\n        this._allProviders = new Map();\n        ngModule.transitiveModule.modules.forEach(function (ngModuleType) {\n            var /** @type {?} */ ngModuleProvider = { token: { identifier: ngModuleType }, useClass: ngModuleType };\n            _resolveProviders([ngModuleProvider], ProviderAstType.PublicService, true, sourceSpan, _this._errors, _this._allProviders);\n        });\n        _resolveProviders(ngModule.transitiveModule.providers.map(function (entry) { return entry.provider; }).concat(extraProviders), ProviderAstType.PublicService, false, sourceSpan, this._errors, this._allProviders);\n    }\n    /**\n     * @return {?}\n     */\n    NgModuleProviderAnalyzer.prototype.parse = /**\n     * @return {?}\n     */\n    function () {\n        var _this = this;\n        Array.from(this._allProviders.values()).forEach(function (provider) {\n            _this._getOrCreateLocalProvider(provider.token, provider.eager);\n        });\n        if (this._errors.length > 0) {\n            var /** @type {?} */ errorString = this._errors.join('\\n');\n            throw new Error(\"Provider parse errors:\\n\" + errorString);\n        }\n        // Note: Maps keep their insertion order.\n        var /** @type {?} */ lazyProviders = [];\n        var /** @type {?} */ eagerProviders = [];\n        this._transformedProviders.forEach(function (provider) {\n            if (provider.eager) {\n                eagerProviders.push(provider);\n            }\n            else {\n                lazyProviders.push(provider);\n            }\n        });\n        return lazyProviders.concat(eagerProviders);\n    };\n    /**\n     * @param {?} token\n     * @param {?} eager\n     * @return {?}\n     */\n    NgModuleProviderAnalyzer.prototype._getOrCreateLocalProvider = /**\n     * @param {?} token\n     * @param {?} eager\n     * @return {?}\n     */\n    function (token, eager) {\n        var _this = this;\n        var /** @type {?} */ resolvedProvider = this._allProviders.get(tokenReference(token));\n        if (!resolvedProvider) {\n            return null;\n        }\n        var /** @type {?} */ transformedProviderAst = this._transformedProviders.get(tokenReference(token));\n        if (transformedProviderAst) {\n            return transformedProviderAst;\n        }\n        if (this._seenProviders.get(tokenReference(token)) != null) {\n            this._errors.push(new ProviderError(\"Cannot instantiate cyclic dependency! \" + tokenName(token), resolvedProvider.sourceSpan));\n            return null;\n        }\n        this._seenProviders.set(tokenReference(token), true);\n        var /** @type {?} */ transformedProviders = resolvedProvider.providers.map(function (provider) {\n            var /** @type {?} */ transformedUseValue = provider.useValue;\n            var /** @type {?} */ transformedUseExisting = /** @type {?} */ ((provider.useExisting));\n            var /** @type {?} */ transformedDeps = /** @type {?} */ ((undefined));\n            if (provider.useExisting != null) {\n                var /** @type {?} */ existingDiDep = _this._getDependency({ token: provider.useExisting }, eager, resolvedProvider.sourceSpan);\n                if (existingDiDep.token != null) {\n                    transformedUseExisting = existingDiDep.token;\n                }\n                else {\n                    transformedUseExisting = /** @type {?} */ ((null));\n                    transformedUseValue = existingDiDep.value;\n                }\n            }\n            else if (provider.useFactory) {\n                var /** @type {?} */ deps = provider.deps || provider.useFactory.diDeps;\n                transformedDeps =\n                    deps.map(function (dep) { return _this._getDependency(dep, eager, resolvedProvider.sourceSpan); });\n            }\n            else if (provider.useClass) {\n                var /** @type {?} */ deps = provider.deps || provider.useClass.diDeps;\n                transformedDeps =\n                    deps.map(function (dep) { return _this._getDependency(dep, eager, resolvedProvider.sourceSpan); });\n            }\n            return _transformProvider(provider, {\n                useExisting: transformedUseExisting,\n                useValue: transformedUseValue,\n                deps: transformedDeps\n            });\n        });\n        transformedProviderAst =\n            _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders });\n        this._transformedProviders.set(tokenReference(token), transformedProviderAst);\n        return transformedProviderAst;\n    };\n    /**\n     * @param {?} dep\n     * @param {?=} eager\n     * @param {?=} requestorSourceSpan\n     * @return {?}\n     */\n    NgModuleProviderAnalyzer.prototype._getDependency = /**\n     * @param {?} dep\n     * @param {?=} eager\n     * @param {?=} requestorSourceSpan\n     * @return {?}\n     */\n    function (dep, eager, requestorSourceSpan) {\n        if (eager === void 0) { eager = false; }\n        var /** @type {?} */ foundLocal = false;\n        if (!dep.isSkipSelf && dep.token != null) {\n            // access the injector\n            if (tokenReference(dep.token) ===\n                this.reflector.resolveExternalReference(Identifiers.Injector) ||\n                tokenReference(dep.token) ===\n                    this.reflector.resolveExternalReference(Identifiers.ComponentFactoryResolver)) {\n                foundLocal = true;\n                // access providers\n            }\n            else if (this._getOrCreateLocalProvider(dep.token, eager) != null) {\n                foundLocal = true;\n            }\n        }\n        var /** @type {?} */ result = dep;\n        if (dep.isSelf && !foundLocal) {\n            if (dep.isOptional) {\n                result = { isValue: true, value: null };\n            }\n            else {\n                this._errors.push(new ProviderError(\"No provider for \" + tokenName((/** @type {?} */ ((dep.token)))), requestorSourceSpan));\n            }\n        }\n        return result;\n    };\n    return NgModuleProviderAnalyzer;\n}());\n/**\n * @param {?} provider\n * @param {?} __1\n * @return {?}\n */\nfunction _transformProvider(provider, _a) {\n    var useExisting = _a.useExisting, useValue = _a.useValue, deps = _a.deps;\n    return {\n        token: provider.token,\n        useClass: provider.useClass,\n        useExisting: useExisting,\n        useFactory: provider.useFactory,\n        useValue: useValue,\n        deps: deps,\n        multi: provider.multi\n    };\n}\n/**\n * @param {?} provider\n * @param {?} __1\n * @return {?}\n */\nfunction _transformProviderAst(provider, _a) {\n    var eager = _a.eager, providers = _a.providers;\n    return new ProviderAst(provider.token, provider.multiProvider, provider.eager || eager, providers, provider.providerType, provider.lifecycleHooks, provider.sourceSpan);\n}\n/**\n * @param {?} directives\n * @param {?} sourceSpan\n * @param {?} targetErrors\n * @return {?}\n */\nfunction _resolveProvidersFromDirectives(directives, sourceSpan, targetErrors) {\n    var /** @type {?} */ providersByToken = new Map();\n    directives.forEach(function (directive) {\n        var /** @type {?} */ dirProvider = { token: { identifier: directive.type }, useClass: directive.type };\n        _resolveProviders([dirProvider], directive.isComponent ? ProviderAstType.Component : ProviderAstType.Directive, true, sourceSpan, targetErrors, providersByToken);\n    });\n    // Note: directives need to be able to overwrite providers of a component!\n    var /** @type {?} */ directivesWithComponentFirst = directives.filter(function (dir) { return dir.isComponent; }).concat(directives.filter(function (dir) { return !dir.isComponent; }));\n    directivesWithComponentFirst.forEach(function (directive) {\n        _resolveProviders(directive.providers, ProviderAstType.PublicService, false, sourceSpan, targetErrors, providersByToken);\n        _resolveProviders(directive.viewProviders, ProviderAstType.PrivateService, false, sourceSpan, targetErrors, providersByToken);\n    });\n    return providersByToken;\n}\n/**\n * @param {?} providers\n * @param {?} providerType\n * @param {?} eager\n * @param {?} sourceSpan\n * @param {?} targetErrors\n * @param {?} targetProvidersByToken\n * @return {?}\n */\nfunction _resolveProviders(providers, providerType, eager, sourceSpan, targetErrors, targetProvidersByToken) {\n    providers.forEach(function (provider) {\n        var /** @type {?} */ resolvedProvider = targetProvidersByToken.get(tokenReference(provider.token));\n        if (resolvedProvider != null && !!resolvedProvider.multiProvider !== !!provider.multi) {\n            targetErrors.push(new ProviderError(\"Mixing multi and non multi provider is not possible for token \" + tokenName(resolvedProvider.token), sourceSpan));\n        }\n        if (!resolvedProvider) {\n            var /** @type {?} */ lifecycleHooks = provider.token.identifier &&\n                (/** @type {?} */ (provider.token.identifier)).lifecycleHooks ?\n                (/** @type {?} */ (provider.token.identifier)).lifecycleHooks :\n                [];\n            var /** @type {?} */ isUseValue = !(provider.useClass || provider.useExisting || provider.useFactory);\n            resolvedProvider = new ProviderAst(provider.token, !!provider.multi, eager || isUseValue, [provider], providerType, lifecycleHooks, sourceSpan);\n            targetProvidersByToken.set(tokenReference(provider.token), resolvedProvider);\n        }\n        else {\n            if (!provider.multi) {\n                resolvedProvider.providers.length = 0;\n            }\n            resolvedProvider.providers.push(provider);\n        }\n    });\n}\n/**\n * @param {?} component\n * @return {?}\n */\nfunction _getViewQueries(component) {\n    // Note: queries start with id 1 so we can use the number in a Bloom filter!\n    var /** @type {?} */ viewQueryId = 1;\n    var /** @type {?} */ viewQueries = new Map();\n    if (component.viewQueries) {\n        component.viewQueries.forEach(function (query) { return _addQueryToTokenMap(viewQueries, { meta: query, queryId: viewQueryId++ }); });\n    }\n    return viewQueries;\n}\n/**\n * @param {?} contentQueryStartId\n * @param {?} directives\n * @return {?}\n */\nfunction _getContentQueries(contentQueryStartId, directives) {\n    var /** @type {?} */ contentQueryId = contentQueryStartId;\n    var /** @type {?} */ contentQueries = new Map();\n    directives.forEach(function (directive, directiveIndex) {\n        if (directive.queries) {\n            directive.queries.forEach(function (query) { return _addQueryToTokenMap(contentQueries, { meta: query, queryId: contentQueryId++ }); });\n        }\n    });\n    return contentQueries;\n}\n/**\n * @param {?} map\n * @param {?} query\n * @return {?}\n */\nfunction _addQueryToTokenMap(map, query) {\n    query.meta.selectors.forEach(function (token) {\n        var /** @type {?} */ entry = map.get(tokenReference(token));\n        if (!entry) {\n            entry = [];\n            map.set(tokenReference(token), entry);\n        }\n        entry.push(query);\n    });\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar QUOTED_KEYS = '$quoted$';\n/**\n * @param {?} ctx\n * @param {?} value\n * @param {?=} type\n * @return {?}\n */\nfunction convertValueToOutputAst(ctx, value, type) {\n    if (type === void 0) { type = null; }\n    return visitValue(value, new _ValueOutputAstTransformer(ctx), type);\n}\nvar _ValueOutputAstTransformer = /** @class */ (function () {\n    function _ValueOutputAstTransformer(ctx) {\n        this.ctx = ctx;\n    }\n    /**\n     * @param {?} arr\n     * @param {?} type\n     * @return {?}\n     */\n    _ValueOutputAstTransformer.prototype.visitArray = /**\n     * @param {?} arr\n     * @param {?} type\n     * @return {?}\n     */\n    function (arr, type) {\n        var _this = this;\n        return literalArr(arr.map(function (value) { return visitValue(value, _this, null); }), type);\n    };\n    /**\n     * @param {?} map\n     * @param {?} type\n     * @return {?}\n     */\n    _ValueOutputAstTransformer.prototype.visitStringMap = /**\n     * @param {?} map\n     * @param {?} type\n     * @return {?}\n     */\n    function (map, type) {\n        var _this = this;\n        var /** @type {?} */ entries = [];\n        var /** @type {?} */ quotedSet = new Set(map && map[QUOTED_KEYS]);\n        Object.keys(map).forEach(function (key) {\n            entries.push(new LiteralMapEntry(key, visitValue(map[key], _this, null), quotedSet.has(key)));\n        });\n        return new LiteralMapExpr(entries, type);\n    };\n    /**\n     * @param {?} value\n     * @param {?} type\n     * @return {?}\n     */\n    _ValueOutputAstTransformer.prototype.visitPrimitive = /**\n     * @param {?} value\n     * @param {?} type\n     * @return {?}\n     */\n    function (value, type) { return literal(value, type); };\n    /**\n     * @param {?} value\n     * @param {?} type\n     * @return {?}\n     */\n    _ValueOutputAstTransformer.prototype.visitOther = /**\n     * @param {?} value\n     * @param {?} type\n     * @return {?}\n     */\n    function (value, type) {\n        if (value instanceof Expression) {\n            return value;\n        }\n        else {\n            return this.ctx.importExpr(value);\n        }\n    };\n    return _ValueOutputAstTransformer;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @param {?} ctx\n * @param {?} providerAst\n * @return {?}\n */\nfunction providerDef(ctx, providerAst) {\n    var /** @type {?} */ flags = 0;\n    if (!providerAst.eager) {\n        flags |= 4096 /* LazyProvider */;\n    }\n    if (providerAst.providerType === ProviderAstType.PrivateService) {\n        flags |= 8192 /* PrivateProvider */;\n    }\n    providerAst.lifecycleHooks.forEach(function (lifecycleHook) {\n        // for regular providers, we only support ngOnDestroy\n        if (lifecycleHook === LifecycleHooks.OnDestroy ||\n            providerAst.providerType === ProviderAstType.Directive ||\n            providerAst.providerType === ProviderAstType.Component) {\n            flags |= lifecycleHookToNodeFlag(lifecycleHook);\n        }\n    });\n    var _a = providerAst.multiProvider ?\n        multiProviderDef(ctx, flags, providerAst.providers) :\n        singleProviderDef(ctx, flags, providerAst.providerType, providerAst.providers[0]), providerExpr = _a.providerExpr, providerFlags = _a.flags, depsExpr = _a.depsExpr;\n    return {\n        providerExpr: providerExpr,\n        flags: providerFlags, depsExpr: depsExpr,\n        tokenExpr: tokenExpr(ctx, providerAst.token),\n    };\n}\n/**\n * @param {?} ctx\n * @param {?} flags\n * @param {?} providers\n * @return {?}\n */\nfunction multiProviderDef(ctx, flags, providers) {\n    var /** @type {?} */ allDepDefs = [];\n    var /** @type {?} */ allParams = [];\n    var /** @type {?} */ exprs = providers.map(function (provider, providerIndex) {\n        var /** @type {?} */ expr;\n        if (provider.useClass) {\n            var /** @type {?} */ depExprs = convertDeps(providerIndex, provider.deps || provider.useClass.diDeps);\n            expr = ctx.importExpr(provider.useClass.reference).instantiate(depExprs);\n        }\n        else if (provider.useFactory) {\n            var /** @type {?} */ depExprs = convertDeps(providerIndex, provider.deps || provider.useFactory.diDeps);\n            expr = ctx.importExpr(provider.useFactory.reference).callFn(depExprs);\n        }\n        else if (provider.useExisting) {\n            var /** @type {?} */ depExprs = convertDeps(providerIndex, [{ token: provider.useExisting }]);\n            expr = depExprs[0];\n        }\n        else {\n            expr = convertValueToOutputAst(ctx, provider.useValue);\n        }\n        return expr;\n    });\n    var /** @type {?} */ providerExpr = fn(allParams, [new ReturnStatement(literalArr(exprs))], INFERRED_TYPE);\n    return {\n        providerExpr: providerExpr,\n        flags: flags | 1024 /* TypeFactoryProvider */,\n        depsExpr: literalArr(allDepDefs)\n    };\n    /**\n     * @param {?} providerIndex\n     * @param {?} deps\n     * @return {?}\n     */\n    function convertDeps(providerIndex, deps) {\n        return deps.map(function (dep, depIndex) {\n            var /** @type {?} */ paramName = \"p\" + providerIndex + \"_\" + depIndex;\n            allParams.push(new FnParam(paramName, DYNAMIC_TYPE));\n            allDepDefs.push(depDef(ctx, dep));\n            return variable(paramName);\n        });\n    }\n}\n/**\n * @param {?} ctx\n * @param {?} flags\n * @param {?} providerType\n * @param {?} providerMeta\n * @return {?}\n */\nfunction singleProviderDef(ctx, flags, providerType, providerMeta) {\n    var /** @type {?} */ providerExpr;\n    var /** @type {?} */ deps;\n    if (providerType === ProviderAstType.Directive || providerType === ProviderAstType.Component) {\n        providerExpr = ctx.importExpr(/** @type {?} */ ((providerMeta.useClass)).reference);\n        flags |= 16384 /* TypeDirective */;\n        deps = providerMeta.deps || /** @type {?} */ ((providerMeta.useClass)).diDeps;\n    }\n    else {\n        if (providerMeta.useClass) {\n            providerExpr = ctx.importExpr(providerMeta.useClass.reference);\n            flags |= 512 /* TypeClassProvider */;\n            deps = providerMeta.deps || providerMeta.useClass.diDeps;\n        }\n        else if (providerMeta.useFactory) {\n            providerExpr = ctx.importExpr(providerMeta.useFactory.reference);\n            flags |= 1024 /* TypeFactoryProvider */;\n            deps = providerMeta.deps || providerMeta.useFactory.diDeps;\n        }\n        else if (providerMeta.useExisting) {\n            providerExpr = NULL_EXPR;\n            flags |= 2048 /* TypeUseExistingProvider */;\n            deps = [{ token: providerMeta.useExisting }];\n        }\n        else {\n            providerExpr = convertValueToOutputAst(ctx, providerMeta.useValue);\n            flags |= 256 /* TypeValueProvider */;\n            deps = [];\n        }\n    }\n    var /** @type {?} */ depsExpr = literalArr(deps.map(function (dep) { return depDef(ctx, dep); }));\n    return { providerExpr: providerExpr, flags: flags, depsExpr: depsExpr };\n}\n/**\n * @param {?} ctx\n * @param {?} tokenMeta\n * @return {?}\n */\nfunction tokenExpr(ctx, tokenMeta) {\n    return tokenMeta.identifier ? ctx.importExpr(tokenMeta.identifier.reference) :\n        literal(tokenMeta.value);\n}\n/**\n * @param {?} ctx\n * @param {?} dep\n * @return {?}\n */\nfunction depDef(ctx, dep) {\n    // Note: the following fields have already been normalized out by provider_analyzer:\n    // - isAttribute, isSelf, isHost\n    var /** @type {?} */ expr = dep.isValue ? convertValueToOutputAst(ctx, dep.value) : tokenExpr(ctx, /** @type {?} */ ((dep.token)));\n    var /** @type {?} */ flags = 0;\n    if (dep.isSkipSelf) {\n        flags |= 1 /* SkipSelf */;\n    }\n    if (dep.isOptional) {\n        flags |= 2 /* Optional */;\n    }\n    if (dep.isValue) {\n        flags |= 8 /* Value */;\n    }\n    return flags === 0 /* None */ ? expr : literalArr([literal(flags), expr]);\n}\n/**\n * @param {?} lifecycleHook\n * @return {?}\n */\nfunction lifecycleHookToNodeFlag(lifecycleHook) {\n    var /** @type {?} */ nodeFlag = 0;\n    switch (lifecycleHook) {\n        case LifecycleHooks.AfterContentChecked:\n            nodeFlag = 2097152 /* AfterContentChecked */;\n            break;\n        case LifecycleHooks.AfterContentInit:\n            nodeFlag = 1048576 /* AfterContentInit */;\n            break;\n        case LifecycleHooks.AfterViewChecked:\n            nodeFlag = 8388608 /* AfterViewChecked */;\n            break;\n        case LifecycleHooks.AfterViewInit:\n            nodeFlag = 4194304 /* AfterViewInit */;\n            break;\n        case LifecycleHooks.DoCheck:\n            nodeFlag = 262144 /* DoCheck */;\n            break;\n        case LifecycleHooks.OnChanges:\n            nodeFlag = 524288 /* OnChanges */;\n            break;\n        case LifecycleHooks.OnDestroy:\n            nodeFlag = 131072 /* OnDestroy */;\n            break;\n        case LifecycleHooks.OnInit:\n            nodeFlag = 65536 /* OnInit */;\n            break;\n    }\n    return nodeFlag;\n}\n/**\n * @param {?} reflector\n * @param {?} ctx\n * @param {?} flags\n * @param {?} entryComponents\n * @return {?}\n */\nfunction componentFactoryResolverProviderDef(reflector, ctx, flags, entryComponents) {\n    var /** @type {?} */ entryComponentFactories = entryComponents.map(function (entryComponent) { return ctx.importExpr(entryComponent.componentFactory); });\n    var /** @type {?} */ token = createTokenForExternalReference(reflector, Identifiers.ComponentFactoryResolver);\n    var /** @type {?} */ classMeta = {\n        diDeps: [\n            { isValue: true, value: literalArr(entryComponentFactories) },\n            { token: token, isSkipSelf: true, isOptional: true },\n            { token: createTokenForExternalReference(reflector, Identifiers.NgModuleRef) },\n        ],\n        lifecycleHooks: [],\n        reference: reflector.resolveExternalReference(Identifiers.CodegenComponentFactoryResolver)\n    };\n    var _a = singleProviderDef(ctx, flags, ProviderAstType.PrivateService, {\n        token: token,\n        multi: false,\n        useClass: classMeta,\n    }), providerExpr = _a.providerExpr, providerFlags = _a.flags, depsExpr = _a.depsExpr;\n    return { providerExpr: providerExpr, flags: providerFlags, depsExpr: depsExpr, tokenExpr: tokenExpr(ctx, token) };\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar NgModuleCompileResult = /** @class */ (function () {\n    function NgModuleCompileResult(ngModuleFactoryVar) {\n        this.ngModuleFactoryVar = ngModuleFactoryVar;\n    }\n    return NgModuleCompileResult;\n}());\nvar LOG_VAR = variable('_l');\nvar NgModuleCompiler = /** @class */ (function () {\n    function NgModuleCompiler(reflector) {\n        this.reflector = reflector;\n    }\n    /**\n     * @param {?} ctx\n     * @param {?} ngModuleMeta\n     * @param {?} extraProviders\n     * @return {?}\n     */\n    NgModuleCompiler.prototype.compile = /**\n     * @param {?} ctx\n     * @param {?} ngModuleMeta\n     * @param {?} extraProviders\n     * @return {?}\n     */\n    function (ctx, ngModuleMeta, extraProviders) {\n        var /** @type {?} */ sourceSpan = typeSourceSpan('NgModule', ngModuleMeta.type);\n        var /** @type {?} */ entryComponentFactories = ngModuleMeta.transitiveModule.entryComponents;\n        var /** @type {?} */ bootstrapComponents = ngModuleMeta.bootstrapComponents;\n        var /** @type {?} */ providerParser = new NgModuleProviderAnalyzer(this.reflector, ngModuleMeta, extraProviders, sourceSpan);\n        var /** @type {?} */ providerDefs = [componentFactoryResolverProviderDef(this.reflector, ctx, 0 /* None */, entryComponentFactories)]\n            .concat(providerParser.parse().map(function (provider) { return providerDef(ctx, provider); }))\n            .map(function (_a) {\n            var providerExpr = _a.providerExpr, depsExpr = _a.depsExpr, flags = _a.flags, tokenExpr = _a.tokenExpr;\n            return importExpr(Identifiers.moduleProviderDef).callFn([\n                literal(flags), tokenExpr, providerExpr, depsExpr\n            ]);\n        });\n        var /** @type {?} */ ngModuleDef = importExpr(Identifiers.moduleDef).callFn([literalArr(providerDefs)]);\n        var /** @type {?} */ ngModuleDefFactory = fn([new FnParam(/** @type {?} */ ((LOG_VAR.name)))], [new ReturnStatement(ngModuleDef)], INFERRED_TYPE);\n        var /** @type {?} */ ngModuleFactoryVar = identifierName(ngModuleMeta.type) + \"NgFactory\";\n        this._createNgModuleFactory(ctx, ngModuleMeta.type.reference, importExpr(Identifiers.createModuleFactory).callFn([\n            ctx.importExpr(ngModuleMeta.type.reference),\n            literalArr(bootstrapComponents.map(function (id) { return ctx.importExpr(id.reference); })),\n            ngModuleDefFactory\n        ]));\n        if (ngModuleMeta.id) {\n            var /** @type {?} */ registerFactoryStmt = importExpr(Identifiers.RegisterModuleFactoryFn)\n                .callFn([literal(ngModuleMeta.id), variable(ngModuleFactoryVar)])\n                .toStmt();\n            ctx.statements.push(registerFactoryStmt);\n        }\n        return new NgModuleCompileResult(ngModuleFactoryVar);\n    };\n    /**\n     * @param {?} ctx\n     * @param {?} ngModuleReference\n     * @return {?}\n     */\n    NgModuleCompiler.prototype.createStub = /**\n     * @param {?} ctx\n     * @param {?} ngModuleReference\n     * @return {?}\n     */\n    function (ctx, ngModuleReference) {\n        this._createNgModuleFactory(ctx, ngModuleReference, NULL_EXPR);\n    };\n    /**\n     * @param {?} ctx\n     * @param {?} reference\n     * @param {?} value\n     * @return {?}\n     */\n    NgModuleCompiler.prototype._createNgModuleFactory = /**\n     * @param {?} ctx\n     * @param {?} reference\n     * @param {?} value\n     * @return {?}\n     */\n    function (ctx, reference, value) {\n        var /** @type {?} */ ngModuleFactoryVar = identifierName({ reference: reference }) + \"NgFactory\";\n        var /** @type {?} */ ngModuleFactoryStmt = variable(ngModuleFactoryVar)\n            .set(value)\n            .toDeclStmt(importType(Identifiers.NgModuleFactory, [/** @type {?} */ ((expressionType(ctx.importExpr(reference))))], [TypeModifier.Const]), [StmtModifier.Final, StmtModifier.Exported]);\n        ctx.statements.push(ngModuleFactoryStmt);\n    };\n    return NgModuleCompiler;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Resolves types to {\\@link NgModule}.\n */\nvar NgModuleResolver = /** @class */ (function () {\n    function NgModuleResolver(_reflector) {\n        this._reflector = _reflector;\n    }\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    NgModuleResolver.prototype.isNgModule = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) { return this._reflector.annotations(type).some(createNgModule.isTypeOf); };\n    /**\n     * @param {?} type\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    NgModuleResolver.prototype.resolve = /**\n     * @param {?} type\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    function (type, throwIfNotFound) {\n        if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n        var /** @type {?} */ ngModuleMeta = findLast(this._reflector.annotations(type), createNgModule.isTypeOf);\n        if (ngModuleMeta) {\n            return ngModuleMeta;\n        }\n        else {\n            if (throwIfNotFound) {\n                throw new Error(\"No NgModule metadata found for '\" + stringify(type) + \"'.\");\n            }\n            return null;\n        }\n    };\n    return NgModuleResolver;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit\nvar VERSION$1 = 3;\nvar JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,';\nvar SourceMapGenerator = /** @class */ (function () {\n    function SourceMapGenerator(file) {\n        if (file === void 0) { file = null; }\n        this.file = file;\n        this.sourcesContent = new Map();\n        this.lines = [];\n        this.lastCol0 = 0;\n        this.hasMappings = false;\n    }\n    // The content is `null` when the content is expected to be loaded using the URL\n    /**\n     * @param {?} url\n     * @param {?=} content\n     * @return {?}\n     */\n    SourceMapGenerator.prototype.addSource = /**\n     * @param {?} url\n     * @param {?=} content\n     * @return {?}\n     */\n    function (url, content) {\n        if (content === void 0) { content = null; }\n        if (!this.sourcesContent.has(url)) {\n            this.sourcesContent.set(url, content);\n        }\n        return this;\n    };\n    /**\n     * @return {?}\n     */\n    SourceMapGenerator.prototype.addLine = /**\n     * @return {?}\n     */\n    function () {\n        this.lines.push([]);\n        this.lastCol0 = 0;\n        return this;\n    };\n    /**\n     * @param {?} col0\n     * @param {?=} sourceUrl\n     * @param {?=} sourceLine0\n     * @param {?=} sourceCol0\n     * @return {?}\n     */\n    SourceMapGenerator.prototype.addMapping = /**\n     * @param {?} col0\n     * @param {?=} sourceUrl\n     * @param {?=} sourceLine0\n     * @param {?=} sourceCol0\n     * @return {?}\n     */\n    function (col0, sourceUrl, sourceLine0, sourceCol0) {\n        if (!this.currentLine) {\n            throw new Error(\"A line must be added before mappings can be added\");\n        }\n        if (sourceUrl != null && !this.sourcesContent.has(sourceUrl)) {\n            throw new Error(\"Unknown source file \\\"\" + sourceUrl + \"\\\"\");\n        }\n        if (col0 == null) {\n            throw new Error(\"The column in the generated code must be provided\");\n        }\n        if (col0 < this.lastCol0) {\n            throw new Error(\"Mapping should be added in output order\");\n        }\n        if (sourceUrl && (sourceLine0 == null || sourceCol0 == null)) {\n            throw new Error(\"The source location must be provided when a source url is provided\");\n        }\n        this.hasMappings = true;\n        this.lastCol0 = col0;\n        this.currentLine.push({ col0: col0, sourceUrl: sourceUrl, sourceLine0: sourceLine0, sourceCol0: sourceCol0 });\n        return this;\n    };\n    Object.defineProperty(SourceMapGenerator.prototype, \"currentLine\", {\n        get: /**\n         * @return {?}\n         */\n        function () { return this.lines.slice(-1)[0]; },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * @return {?}\n     */\n    SourceMapGenerator.prototype.toJSON = /**\n     * @return {?}\n     */\n    function () {\n        var _this = this;\n        if (!this.hasMappings) {\n            return null;\n        }\n        var /** @type {?} */ sourcesIndex = new Map();\n        var /** @type {?} */ sources = [];\n        var /** @type {?} */ sourcesContent = [];\n        Array.from(this.sourcesContent.keys()).forEach(function (url, i) {\n            sourcesIndex.set(url, i);\n            sources.push(url);\n            sourcesContent.push(_this.sourcesContent.get(url) || null);\n        });\n        var /** @type {?} */ mappings = '';\n        var /** @type {?} */ lastCol0 = 0;\n        var /** @type {?} */ lastSourceIndex = 0;\n        var /** @type {?} */ lastSourceLine0 = 0;\n        var /** @type {?} */ lastSourceCol0 = 0;\n        this.lines.forEach(function (segments) {\n            lastCol0 = 0;\n            mappings += segments\n                .map(function (segment) {\n                // zero-based starting column of the line in the generated code\n                var /** @type {?} */ segAsStr = toBase64VLQ(segment.col0 - lastCol0);\n                lastCol0 = segment.col0;\n                if (segment.sourceUrl != null) {\n                    // zero-based index into the “sources” list\n                    segAsStr +=\n                        toBase64VLQ(/** @type {?} */ ((sourcesIndex.get(segment.sourceUrl))) - lastSourceIndex);\n                    lastSourceIndex = /** @type {?} */ ((sourcesIndex.get(segment.sourceUrl)));\n                    // the zero-based starting line in the original source\n                    segAsStr += toBase64VLQ(/** @type {?} */ ((segment.sourceLine0)) - lastSourceLine0);\n                    lastSourceLine0 = /** @type {?} */ ((segment.sourceLine0));\n                    // the zero-based starting column in the original source\n                    segAsStr += toBase64VLQ(/** @type {?} */ ((segment.sourceCol0)) - lastSourceCol0);\n                    lastSourceCol0 = /** @type {?} */ ((segment.sourceCol0));\n                }\n                return segAsStr;\n            })\n                .join(',');\n            mappings += ';';\n        });\n        mappings = mappings.slice(0, -1);\n        return {\n            'file': this.file || '',\n            'version': VERSION$1,\n            'sourceRoot': '',\n            'sources': sources,\n            'sourcesContent': sourcesContent,\n            'mappings': mappings,\n        };\n    };\n    /**\n     * @return {?}\n     */\n    SourceMapGenerator.prototype.toJsComment = /**\n     * @return {?}\n     */\n    function () {\n        return this.hasMappings ? '//' + JS_B64_PREFIX + toBase64String(JSON.stringify(this, null, 0)) :\n            '';\n    };\n    return SourceMapGenerator;\n}());\n/**\n * @param {?} value\n * @return {?}\n */\nfunction toBase64String(value) {\n    var /** @type {?} */ b64 = '';\n    value = utf8Encode(value);\n    for (var /** @type {?} */ i = 0; i < value.length;) {\n        var /** @type {?} */ i1 = value.charCodeAt(i++);\n        var /** @type {?} */ i2 = value.charCodeAt(i++);\n        var /** @type {?} */ i3 = value.charCodeAt(i++);\n        b64 += toBase64Digit(i1 >> 2);\n        b64 += toBase64Digit(((i1 & 3) << 4) | (isNaN(i2) ? 0 : i2 >> 4));\n        b64 += isNaN(i2) ? '=' : toBase64Digit(((i2 & 15) << 2) | (i3 >> 6));\n        b64 += isNaN(i2) || isNaN(i3) ? '=' : toBase64Digit(i3 & 63);\n    }\n    return b64;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction toBase64VLQ(value) {\n    value = value < 0 ? ((-value) << 1) + 1 : value << 1;\n    var /** @type {?} */ out = '';\n    do {\n        var /** @type {?} */ digit = value & 31;\n        value = value >> 5;\n        if (value > 0) {\n            digit = digit | 32;\n        }\n        out += toBase64Digit(digit);\n    } while (value > 0);\n    return out;\n}\nvar B64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n/**\n * @param {?} value\n * @return {?}\n */\nfunction toBase64Digit(value) {\n    if (value < 0 || value >= 64) {\n        throw new Error(\"Can only encode value in the range [0, 63]\");\n    }\n    return B64_DIGITS[value];\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\\\|\\n|\\r|\\$/g;\nvar _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i;\nvar _INDENT_WITH = '  ';\nvar CATCH_ERROR_VAR$1 = variable('error', null, null);\nvar CATCH_STACK_VAR$1 = variable('stack', null, null);\n/**\n * @record\n */\n\nvar _EmittedLine = /** @class */ (function () {\n    function _EmittedLine(indent) {\n        this.indent = indent;\n        this.partsLength = 0;\n        this.parts = [];\n        this.srcSpans = [];\n    }\n    return _EmittedLine;\n}());\nvar EmitterVisitorContext = /** @class */ (function () {\n    function EmitterVisitorContext(_indent) {\n        this._indent = _indent;\n        this._classes = [];\n        this._preambleLineCount = 0;\n        this._lines = [new _EmittedLine(_indent)];\n    }\n    /**\n     * @return {?}\n     */\n    EmitterVisitorContext.createRoot = /**\n     * @return {?}\n     */\n    function () { return new EmitterVisitorContext(0); };\n    Object.defineProperty(EmitterVisitorContext.prototype, \"_currentLine\", {\n        get: /**\n         * @return {?}\n         */\n        function () { return this._lines[this._lines.length - 1]; },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * @param {?=} from\n     * @param {?=} lastPart\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.println = /**\n     * @param {?=} from\n     * @param {?=} lastPart\n     * @return {?}\n     */\n    function (from, lastPart) {\n        if (lastPart === void 0) { lastPart = ''; }\n        this.print(from || null, lastPart, true);\n    };\n    /**\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.lineIsEmpty = /**\n     * @return {?}\n     */\n    function () { return this._currentLine.parts.length === 0; };\n    /**\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.lineLength = /**\n     * @return {?}\n     */\n    function () {\n        return this._currentLine.indent * _INDENT_WITH.length + this._currentLine.partsLength;\n    };\n    /**\n     * @param {?} from\n     * @param {?} part\n     * @param {?=} newLine\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.print = /**\n     * @param {?} from\n     * @param {?} part\n     * @param {?=} newLine\n     * @return {?}\n     */\n    function (from, part, newLine) {\n        if (newLine === void 0) { newLine = false; }\n        if (part.length > 0) {\n            this._currentLine.parts.push(part);\n            this._currentLine.partsLength += part.length;\n            this._currentLine.srcSpans.push(from && from.sourceSpan || null);\n        }\n        if (newLine) {\n            this._lines.push(new _EmittedLine(this._indent));\n        }\n    };\n    /**\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.removeEmptyLastLine = /**\n     * @return {?}\n     */\n    function () {\n        if (this.lineIsEmpty()) {\n            this._lines.pop();\n        }\n    };\n    /**\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.incIndent = /**\n     * @return {?}\n     */\n    function () {\n        this._indent++;\n        if (this.lineIsEmpty()) {\n            this._currentLine.indent = this._indent;\n        }\n    };\n    /**\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.decIndent = /**\n     * @return {?}\n     */\n    function () {\n        this._indent--;\n        if (this.lineIsEmpty()) {\n            this._currentLine.indent = this._indent;\n        }\n    };\n    /**\n     * @param {?} clazz\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.pushClass = /**\n     * @param {?} clazz\n     * @return {?}\n     */\n    function (clazz) { this._classes.push(clazz); };\n    /**\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.popClass = /**\n     * @return {?}\n     */\n    function () { return /** @type {?} */ ((this._classes.pop())); };\n    Object.defineProperty(EmitterVisitorContext.prototype, \"currentClass\", {\n        get: /**\n         * @return {?}\n         */\n        function () {\n            return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.toSource = /**\n     * @return {?}\n     */\n    function () {\n        return this.sourceLines\n            .map(function (l) { return l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : ''; })\n            .join('\\n');\n    };\n    /**\n     * @param {?} genFilePath\n     * @param {?=} startsAtLine\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.toSourceMapGenerator = /**\n     * @param {?} genFilePath\n     * @param {?=} startsAtLine\n     * @return {?}\n     */\n    function (genFilePath, startsAtLine) {\n        if (startsAtLine === void 0) { startsAtLine = 0; }\n        var /** @type {?} */ map = new SourceMapGenerator(genFilePath);\n        var /** @type {?} */ firstOffsetMapped = false;\n        var /** @type {?} */ mapFirstOffsetIfNeeded = function () {\n            if (!firstOffsetMapped) {\n                // Add a single space so that tools won't try to load the file from disk.\n                // Note: We are using virtual urls like `ng:///`, so we have to\n                // provide a content here.\n                map.addSource(genFilePath, ' ').addMapping(0, genFilePath, 0, 0);\n                firstOffsetMapped = true;\n            }\n        };\n        for (var /** @type {?} */ i = 0; i < startsAtLine; i++) {\n            map.addLine();\n            mapFirstOffsetIfNeeded();\n        }\n        this.sourceLines.forEach(function (line, lineIdx) {\n            map.addLine();\n            var /** @type {?} */ spans = line.srcSpans;\n            var /** @type {?} */ parts = line.parts;\n            var /** @type {?} */ col0 = line.indent * _INDENT_WITH.length;\n            var /** @type {?} */ spanIdx = 0;\n            // skip leading parts without source spans\n            while (spanIdx < spans.length && !spans[spanIdx]) {\n                col0 += parts[spanIdx].length;\n                spanIdx++;\n            }\n            if (spanIdx < spans.length && lineIdx === 0 && col0 === 0) {\n                firstOffsetMapped = true;\n            }\n            else {\n                mapFirstOffsetIfNeeded();\n            }\n            while (spanIdx < spans.length) {\n                var /** @type {?} */ span = /** @type {?} */ ((spans[spanIdx]));\n                var /** @type {?} */ source = span.start.file;\n                var /** @type {?} */ sourceLine = span.start.line;\n                var /** @type {?} */ sourceCol = span.start.col;\n                map.addSource(source.url, source.content)\n                    .addMapping(col0, source.url, sourceLine, sourceCol);\n                col0 += parts[spanIdx].length;\n                spanIdx++;\n                // assign parts without span or the same span to the previous segment\n                while (spanIdx < spans.length && (span === spans[spanIdx] || !spans[spanIdx])) {\n                    col0 += parts[spanIdx].length;\n                    spanIdx++;\n                }\n            }\n        });\n        return map;\n    };\n    /**\n     * @param {?} count\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.setPreambleLineCount = /**\n     * @param {?} count\n     * @return {?}\n     */\n    function (count) { return this._preambleLineCount = count; };\n    /**\n     * @param {?} line\n     * @param {?} column\n     * @return {?}\n     */\n    EmitterVisitorContext.prototype.spanOf = /**\n     * @param {?} line\n     * @param {?} column\n     * @return {?}\n     */\n    function (line, column) {\n        var /** @type {?} */ emittedLine = this._lines[line - this._preambleLineCount];\n        if (emittedLine) {\n            var /** @type {?} */ columnsLeft = column - _createIndent(emittedLine.indent).length;\n            for (var /** @type {?} */ partIndex = 0; partIndex < emittedLine.parts.length; partIndex++) {\n                var /** @type {?} */ part = emittedLine.parts[partIndex];\n                if (part.length > columnsLeft) {\n                    return emittedLine.srcSpans[partIndex];\n                }\n                columnsLeft -= part.length;\n            }\n        }\n        return null;\n    };\n    Object.defineProperty(EmitterVisitorContext.prototype, \"sourceLines\", {\n        get: /**\n         * @return {?}\n         */\n        function () {\n            if (this._lines.length && this._lines[this._lines.length - 1].parts.length === 0) {\n                return this._lines.slice(0, -1);\n            }\n            return this._lines;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return EmitterVisitorContext;\n}());\n/**\n * @abstract\n */\nvar AbstractEmitterVisitor = /** @class */ (function () {\n    function AbstractEmitterVisitor(_escapeDollarInStrings) {\n        this._escapeDollarInStrings = _escapeDollarInStrings;\n    }\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitExpressionStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        stmt.expr.visitExpression(this, ctx);\n        ctx.println(stmt, ';');\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitReturnStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.print(stmt, \"return \");\n        stmt.value.visitExpression(this, ctx);\n        ctx.println(stmt, ';');\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitIfStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.print(stmt, \"if (\");\n        stmt.condition.visitExpression(this, ctx);\n        ctx.print(stmt, \") {\");\n        var /** @type {?} */ hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0;\n        if (stmt.trueCase.length <= 1 && !hasElseCase) {\n            ctx.print(stmt, \" \");\n            this.visitAllStatements(stmt.trueCase, ctx);\n            ctx.removeEmptyLastLine();\n            ctx.print(stmt, \" \");\n        }\n        else {\n            ctx.println();\n            ctx.incIndent();\n            this.visitAllStatements(stmt.trueCase, ctx);\n            ctx.decIndent();\n            if (hasElseCase) {\n                ctx.println(stmt, \"} else {\");\n                ctx.incIndent();\n                this.visitAllStatements(stmt.falseCase, ctx);\n                ctx.decIndent();\n            }\n        }\n        ctx.println(stmt, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitThrowStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.print(stmt, \"throw \");\n        stmt.error.visitExpression(this, ctx);\n        ctx.println(stmt, \";\");\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitCommentStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        var /** @type {?} */ lines = stmt.comment.split('\\n');\n        lines.forEach(function (line) { ctx.println(stmt, \"// \" + line); });\n        return null;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitWriteVarExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        var /** @type {?} */ lineWasEmpty = ctx.lineIsEmpty();\n        if (!lineWasEmpty) {\n            ctx.print(expr, '(');\n        }\n        ctx.print(expr, expr.name + \" = \");\n        expr.value.visitExpression(this, ctx);\n        if (!lineWasEmpty) {\n            ctx.print(expr, ')');\n        }\n        return null;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitWriteKeyExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        var /** @type {?} */ lineWasEmpty = ctx.lineIsEmpty();\n        if (!lineWasEmpty) {\n            ctx.print(expr, '(');\n        }\n        expr.receiver.visitExpression(this, ctx);\n        ctx.print(expr, \"[\");\n        expr.index.visitExpression(this, ctx);\n        ctx.print(expr, \"] = \");\n        expr.value.visitExpression(this, ctx);\n        if (!lineWasEmpty) {\n            ctx.print(expr, ')');\n        }\n        return null;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitWritePropExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        var /** @type {?} */ lineWasEmpty = ctx.lineIsEmpty();\n        if (!lineWasEmpty) {\n            ctx.print(expr, '(');\n        }\n        expr.receiver.visitExpression(this, ctx);\n        ctx.print(expr, \".\" + expr.name + \" = \");\n        expr.value.visitExpression(this, ctx);\n        if (!lineWasEmpty) {\n            ctx.print(expr, ')');\n        }\n        return null;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitInvokeMethodExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        expr.receiver.visitExpression(this, ctx);\n        var /** @type {?} */ name = expr.name;\n        if (expr.builtin != null) {\n            name = this.getBuiltinMethodName(expr.builtin);\n            if (name == null) {\n                // some builtins just mean to skip the call.\n                return null;\n            }\n        }\n        ctx.print(expr, \".\" + name + \"(\");\n        this.visitAllExpressions(expr.args, ctx, \",\");\n        ctx.print(expr, \")\");\n        return null;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitInvokeFunctionExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        expr.fn.visitExpression(this, ctx);\n        ctx.print(expr, \"(\");\n        this.visitAllExpressions(expr.args, ctx, ',');\n        ctx.print(expr, \")\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitReadVarExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ varName = /** @type {?} */ ((ast.name));\n        if (ast.builtin != null) {\n            switch (ast.builtin) {\n                case BuiltinVar.Super:\n                    varName = 'super';\n                    break;\n                case BuiltinVar.This:\n                    varName = 'this';\n                    break;\n                case BuiltinVar.CatchError:\n                    varName = /** @type {?} */ ((CATCH_ERROR_VAR$1.name));\n                    break;\n                case BuiltinVar.CatchStack:\n                    varName = /** @type {?} */ ((CATCH_STACK_VAR$1.name));\n                    break;\n                default:\n                    throw new Error(\"Unknown builtin variable \" + ast.builtin);\n            }\n        }\n        ctx.print(ast, varName);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitInstantiateExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, \"new \");\n        ast.classExpr.visitExpression(this, ctx);\n        ctx.print(ast, \"(\");\n        this.visitAllExpressions(ast.args, ctx, ',');\n        ctx.print(ast, \")\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitLiteralExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ value = ast.value;\n        if (typeof value === 'string') {\n            ctx.print(ast, escapeIdentifier(value, this._escapeDollarInStrings));\n        }\n        else {\n            ctx.print(ast, \"\" + value);\n        }\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitConditionalExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, \"(\");\n        ast.condition.visitExpression(this, ctx);\n        ctx.print(ast, '? ');\n        ast.trueCase.visitExpression(this, ctx);\n        ctx.print(ast, ': '); /** @type {?} */\n        ((ast.falseCase)).visitExpression(this, ctx);\n        ctx.print(ast, \")\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitNotExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, '!');\n        ast.condition.visitExpression(this, ctx);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitAssertNotNullExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ast.condition.visitExpression(this, ctx);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitBinaryOperatorExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ opStr;\n        switch (ast.operator) {\n            case BinaryOperator.Equals:\n                opStr = '==';\n                break;\n            case BinaryOperator.Identical:\n                opStr = '===';\n                break;\n            case BinaryOperator.NotEquals:\n                opStr = '!=';\n                break;\n            case BinaryOperator.NotIdentical:\n                opStr = '!==';\n                break;\n            case BinaryOperator.And:\n                opStr = '&&';\n                break;\n            case BinaryOperator.Or:\n                opStr = '||';\n                break;\n            case BinaryOperator.Plus:\n                opStr = '+';\n                break;\n            case BinaryOperator.Minus:\n                opStr = '-';\n                break;\n            case BinaryOperator.Divide:\n                opStr = '/';\n                break;\n            case BinaryOperator.Multiply:\n                opStr = '*';\n                break;\n            case BinaryOperator.Modulo:\n                opStr = '%';\n                break;\n            case BinaryOperator.Lower:\n                opStr = '<';\n                break;\n            case BinaryOperator.LowerEquals:\n                opStr = '<=';\n                break;\n            case BinaryOperator.Bigger:\n                opStr = '>';\n                break;\n            case BinaryOperator.BiggerEquals:\n                opStr = '>=';\n                break;\n            default:\n                throw new Error(\"Unknown operator \" + ast.operator);\n        }\n        ctx.print(ast, \"(\");\n        ast.lhs.visitExpression(this, ctx);\n        ctx.print(ast, \" \" + opStr + \" \");\n        ast.rhs.visitExpression(this, ctx);\n        ctx.print(ast, \")\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitReadPropExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ast.receiver.visitExpression(this, ctx);\n        ctx.print(ast, \".\");\n        ctx.print(ast, ast.name);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitReadKeyExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ast.receiver.visitExpression(this, ctx);\n        ctx.print(ast, \"[\");\n        ast.index.visitExpression(this, ctx);\n        ctx.print(ast, \"]\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitLiteralArrayExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, \"[\");\n        this.visitAllExpressions(ast.entries, ctx, ',');\n        ctx.print(ast, \"]\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitLiteralMapExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var _this = this;\n        ctx.print(ast, \"{\");\n        this.visitAllObjects(function (entry) {\n            ctx.print(ast, escapeIdentifier(entry.key, _this._escapeDollarInStrings, entry.quoted) + \":\");\n            entry.value.visitExpression(_this, ctx);\n        }, ast.entries, ctx, ',');\n        ctx.print(ast, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitCommaExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, '(');\n        this.visitAllExpressions(ast.parts, ctx, ',');\n        ctx.print(ast, ')');\n        return null;\n    };\n    /**\n     * @param {?} expressions\n     * @param {?} ctx\n     * @param {?} separator\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitAllExpressions = /**\n     * @param {?} expressions\n     * @param {?} ctx\n     * @param {?} separator\n     * @return {?}\n     */\n    function (expressions, ctx, separator) {\n        var _this = this;\n        this.visitAllObjects(function (expr) { return expr.visitExpression(_this, ctx); }, expressions, ctx, separator);\n    };\n    /**\n     * @template T\n     * @param {?} handler\n     * @param {?} expressions\n     * @param {?} ctx\n     * @param {?} separator\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitAllObjects = /**\n     * @template T\n     * @param {?} handler\n     * @param {?} expressions\n     * @param {?} ctx\n     * @param {?} separator\n     * @return {?}\n     */\n    function (handler, expressions, ctx, separator) {\n        var /** @type {?} */ incrementedIndent = false;\n        for (var /** @type {?} */ i = 0; i < expressions.length; i++) {\n            if (i > 0) {\n                if (ctx.lineLength() > 80) {\n                    ctx.print(null, separator, true);\n                    if (!incrementedIndent) {\n                        // continuation are marked with double indent.\n                        ctx.incIndent();\n                        ctx.incIndent();\n                        incrementedIndent = true;\n                    }\n                }\n                else {\n                    ctx.print(null, separator, false);\n                }\n            }\n            handler(expressions[i]);\n        }\n        if (incrementedIndent) {\n            // continuation are marked with double indent.\n            ctx.decIndent();\n            ctx.decIndent();\n        }\n    };\n    /**\n     * @param {?} statements\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractEmitterVisitor.prototype.visitAllStatements = /**\n     * @param {?} statements\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (statements, ctx) {\n        var _this = this;\n        statements.forEach(function (stmt) { return stmt.visitStatement(_this, ctx); });\n    };\n    return AbstractEmitterVisitor;\n}());\n/**\n * @param {?} input\n * @param {?} escapeDollar\n * @param {?=} alwaysQuote\n * @return {?}\n */\nfunction escapeIdentifier(input, escapeDollar, alwaysQuote) {\n    if (alwaysQuote === void 0) { alwaysQuote = true; }\n    if (input == null) {\n        return null;\n    }\n    var /** @type {?} */ body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, function () {\n        var match = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            match[_i] = arguments[_i];\n        }\n        if (match[0] == '$') {\n            return escapeDollar ? '\\\\$' : '$';\n        }\n        else if (match[0] == '\\n') {\n            return '\\\\n';\n        }\n        else if (match[0] == '\\r') {\n            return '\\\\r';\n        }\n        else {\n            return \"\\\\\" + match[0];\n        }\n    });\n    var /** @type {?} */ requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body);\n    return requiresQuotes ? \"'\" + body + \"'\" : body;\n}\n/**\n * @param {?} count\n * @return {?}\n */\nfunction _createIndent(count) {\n    var /** @type {?} */ res = '';\n    for (var /** @type {?} */ i = 0; i < count; i++) {\n        res += _INDENT_WITH;\n    }\n    return res;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @param {?} ast\n * @return {?}\n */\nfunction debugOutputAstAsTypeScript(ast) {\n    var /** @type {?} */ converter = new _TsEmitterVisitor();\n    var /** @type {?} */ ctx = EmitterVisitorContext.createRoot();\n    var /** @type {?} */ asts = Array.isArray(ast) ? ast : [ast];\n    asts.forEach(function (ast) {\n        if (ast instanceof Statement) {\n            ast.visitStatement(converter, ctx);\n        }\n        else if (ast instanceof Expression) {\n            ast.visitExpression(converter, ctx);\n        }\n        else if (ast instanceof Type$1) {\n            ast.visitType(converter, ctx);\n        }\n        else {\n            throw new Error(\"Don't know how to print debug info for \" + ast);\n        }\n    });\n    return ctx.toSource();\n}\nvar TypeScriptEmitter = /** @class */ (function () {\n    function TypeScriptEmitter() {\n    }\n    /**\n     * @param {?} genFilePath\n     * @param {?} stmts\n     * @param {?=} preamble\n     * @param {?=} emitSourceMaps\n     * @param {?=} referenceFilter\n     * @return {?}\n     */\n    TypeScriptEmitter.prototype.emitStatementsAndContext = /**\n     * @param {?} genFilePath\n     * @param {?} stmts\n     * @param {?=} preamble\n     * @param {?=} emitSourceMaps\n     * @param {?=} referenceFilter\n     * @return {?}\n     */\n    function (genFilePath, stmts, preamble, emitSourceMaps, referenceFilter) {\n        if (preamble === void 0) { preamble = ''; }\n        if (emitSourceMaps === void 0) { emitSourceMaps = true; }\n        var /** @type {?} */ converter = new _TsEmitterVisitor(referenceFilter);\n        var /** @type {?} */ ctx = EmitterVisitorContext.createRoot();\n        converter.visitAllStatements(stmts, ctx);\n        var /** @type {?} */ preambleLines = preamble ? preamble.split('\\n') : [];\n        converter.reexports.forEach(function (reexports, exportedModuleName) {\n            var /** @type {?} */ reexportsCode = reexports.map(function (reexport) { return reexport.name + \" as \" + reexport.as; }).join(',');\n            preambleLines.push(\"export {\" + reexportsCode + \"} from '\" + exportedModuleName + \"';\");\n        });\n        converter.importsWithPrefixes.forEach(function (prefix, importedModuleName) {\n            // Note: can't write the real word for import as it screws up system.js auto detection...\n            preambleLines.push(\"imp\" +\n                (\"ort * as \" + prefix + \" from '\" + importedModuleName + \"';\"));\n        });\n        var /** @type {?} */ sm = emitSourceMaps ?\n            ctx.toSourceMapGenerator(genFilePath, preambleLines.length).toJsComment() :\n            '';\n        var /** @type {?} */ lines = preambleLines.concat([ctx.toSource(), sm]);\n        if (sm) {\n            // always add a newline at the end, as some tools have bugs without it.\n            lines.push('');\n        }\n        ctx.setPreambleLineCount(preambleLines.length);\n        return { sourceText: lines.join('\\n'), context: ctx };\n    };\n    /**\n     * @param {?} genFilePath\n     * @param {?} stmts\n     * @param {?=} preamble\n     * @return {?}\n     */\n    TypeScriptEmitter.prototype.emitStatements = /**\n     * @param {?} genFilePath\n     * @param {?} stmts\n     * @param {?=} preamble\n     * @return {?}\n     */\n    function (genFilePath, stmts, preamble) {\n        if (preamble === void 0) { preamble = ''; }\n        return this.emitStatementsAndContext(genFilePath, stmts, preamble).sourceText;\n    };\n    return TypeScriptEmitter;\n}());\nvar _TsEmitterVisitor = /** @class */ (function (_super) {\n    __extends(_TsEmitterVisitor, _super);\n    function _TsEmitterVisitor(referenceFilter) {\n        var _this = _super.call(this, false) || this;\n        _this.referenceFilter = referenceFilter;\n        _this.typeExpression = 0;\n        _this.importsWithPrefixes = new Map();\n        _this.reexports = new Map();\n        return _this;\n    }\n    /**\n     * @param {?} t\n     * @param {?} ctx\n     * @param {?=} defaultType\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitType = /**\n     * @param {?} t\n     * @param {?} ctx\n     * @param {?=} defaultType\n     * @return {?}\n     */\n    function (t, ctx, defaultType) {\n        if (defaultType === void 0) { defaultType = 'any'; }\n        if (t) {\n            this.typeExpression++;\n            t.visitType(this, ctx);\n            this.typeExpression--;\n        }\n        else {\n            ctx.print(null, defaultType);\n        }\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitLiteralExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ value = ast.value;\n        if (value == null && ast.type != INFERRED_TYPE) {\n            ctx.print(ast, \"(\" + value + \" as any)\");\n            return null;\n        }\n        return _super.prototype.visitLiteralExpr.call(this, ast, ctx);\n    };\n    // Temporary workaround to support strictNullCheck enabled consumers of ngc emit.\n    // In SNC mode, [] have the type never[], so we cast here to any[].\n    // TODO: narrow the cast to a more explicit type, or use a pattern that does not\n    // start with [].concat. see https://github.com/angular/angular/pull/11846\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitLiteralArrayExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        if (ast.entries.length === 0) {\n            ctx.print(ast, '(');\n        }\n        var /** @type {?} */ result = _super.prototype.visitLiteralArrayExpr.call(this, ast, ctx);\n        if (ast.entries.length === 0) {\n            ctx.print(ast, ' as any[])');\n        }\n        return result;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitExternalExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        this._visitIdentifier(ast.value, ast.typeParams, ctx);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitAssertNotNullExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ result = _super.prototype.visitAssertNotNullExpr.call(this, ast, ctx);\n        ctx.print(ast, '!');\n        return result;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitDeclareVarStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        if (stmt.hasModifier(StmtModifier.Exported) && stmt.value instanceof ExternalExpr &&\n            !stmt.type) {\n            // check for a reexport\n            var _a = stmt.value.value, name_1 = _a.name, moduleName = _a.moduleName;\n            if (moduleName) {\n                var /** @type {?} */ reexports = this.reexports.get(moduleName);\n                if (!reexports) {\n                    reexports = [];\n                    this.reexports.set(moduleName, reexports);\n                }\n                reexports.push({ name: /** @type {?} */ ((name_1)), as: stmt.name });\n                return null;\n            }\n        }\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            ctx.print(stmt, \"export \");\n        }\n        if (stmt.hasModifier(StmtModifier.Final)) {\n            ctx.print(stmt, \"const\");\n        }\n        else {\n            ctx.print(stmt, \"var\");\n        }\n        ctx.print(stmt, \" \" + stmt.name);\n        this._printColonType(stmt.type, ctx);\n        ctx.print(stmt, \" = \");\n        stmt.value.visitExpression(this, ctx);\n        ctx.println(stmt, \";\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitCastExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, \"(<\"); /** @type {?} */\n        ((ast.type)).visitType(this, ctx);\n        ctx.print(ast, \">\");\n        ast.value.visitExpression(this, ctx);\n        ctx.print(ast, \")\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitInstantiateExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, \"new \");\n        this.typeExpression++;\n        ast.classExpr.visitExpression(this, ctx);\n        this.typeExpression--;\n        ctx.print(ast, \"(\");\n        this.visitAllExpressions(ast.args, ctx, ',');\n        ctx.print(ast, \")\");\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitDeclareClassStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        var _this = this;\n        ctx.pushClass(stmt);\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            ctx.print(stmt, \"export \");\n        }\n        ctx.print(stmt, \"class \" + stmt.name);\n        if (stmt.parent != null) {\n            ctx.print(stmt, \" extends \");\n            this.typeExpression++;\n            stmt.parent.visitExpression(this, ctx);\n            this.typeExpression--;\n        }\n        ctx.println(stmt, \" {\");\n        ctx.incIndent();\n        stmt.fields.forEach(function (field) { return _this._visitClassField(field, ctx); });\n        if (stmt.constructorMethod != null) {\n            this._visitClassConstructor(stmt, ctx);\n        }\n        stmt.getters.forEach(function (getter) { return _this._visitClassGetter(getter, ctx); });\n        stmt.methods.forEach(function (method) { return _this._visitClassMethod(method, ctx); });\n        ctx.decIndent();\n        ctx.println(stmt, \"}\");\n        ctx.popClass();\n        return null;\n    };\n    /**\n     * @param {?} field\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype._visitClassField = /**\n     * @param {?} field\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (field, ctx) {\n        if (field.hasModifier(StmtModifier.Private)) {\n            // comment out as a workaround for #10967\n            ctx.print(null, \"/*private*/ \");\n        }\n        ctx.print(null, field.name);\n        this._printColonType(field.type, ctx);\n        ctx.println(null, \";\");\n    };\n    /**\n     * @param {?} getter\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype._visitClassGetter = /**\n     * @param {?} getter\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (getter, ctx) {\n        if (getter.hasModifier(StmtModifier.Private)) {\n            ctx.print(null, \"private \");\n        }\n        ctx.print(null, \"get \" + getter.name + \"()\");\n        this._printColonType(getter.type, ctx);\n        ctx.println(null, \" {\");\n        ctx.incIndent();\n        this.visitAllStatements(getter.body, ctx);\n        ctx.decIndent();\n        ctx.println(null, \"}\");\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype._visitClassConstructor = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.print(stmt, \"constructor(\");\n        this._visitParams(stmt.constructorMethod.params, ctx);\n        ctx.println(stmt, \") {\");\n        ctx.incIndent();\n        this.visitAllStatements(stmt.constructorMethod.body, ctx);\n        ctx.decIndent();\n        ctx.println(stmt, \"}\");\n    };\n    /**\n     * @param {?} method\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype._visitClassMethod = /**\n     * @param {?} method\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (method, ctx) {\n        if (method.hasModifier(StmtModifier.Private)) {\n            ctx.print(null, \"private \");\n        }\n        ctx.print(null, method.name + \"(\");\n        this._visitParams(method.params, ctx);\n        ctx.print(null, \")\");\n        this._printColonType(method.type, ctx, 'void');\n        ctx.println(null, \" {\");\n        ctx.incIndent();\n        this.visitAllStatements(method.body, ctx);\n        ctx.decIndent();\n        ctx.println(null, \"}\");\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitFunctionExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, \"(\");\n        this._visitParams(ast.params, ctx);\n        ctx.print(ast, \")\");\n        this._printColonType(ast.type, ctx, 'void');\n        ctx.println(ast, \" => {\");\n        ctx.incIndent();\n        this.visitAllStatements(ast.statements, ctx);\n        ctx.decIndent();\n        ctx.print(ast, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitDeclareFunctionStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            ctx.print(stmt, \"export \");\n        }\n        ctx.print(stmt, \"function \" + stmt.name + \"(\");\n        this._visitParams(stmt.params, ctx);\n        ctx.print(stmt, \")\");\n        this._printColonType(stmt.type, ctx, 'void');\n        ctx.println(stmt, \" {\");\n        ctx.incIndent();\n        this.visitAllStatements(stmt.statements, ctx);\n        ctx.decIndent();\n        ctx.println(stmt, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitTryCatchStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.println(stmt, \"try {\");\n        ctx.incIndent();\n        this.visitAllStatements(stmt.bodyStmts, ctx);\n        ctx.decIndent();\n        ctx.println(stmt, \"} catch (\" + CATCH_ERROR_VAR$1.name + \") {\");\n        ctx.incIndent();\n        var /** @type {?} */ catchStmts = [/** @type {?} */ (CATCH_STACK_VAR$1.set(CATCH_ERROR_VAR$1.prop('stack', null)).toDeclStmt(null, [\n                StmtModifier.Final\n            ]))].concat(stmt.catchStmts);\n        this.visitAllStatements(catchStmts, ctx);\n        ctx.decIndent();\n        ctx.println(stmt, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} type\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitBuiltintType = /**\n     * @param {?} type\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (type, ctx) {\n        var /** @type {?} */ typeStr;\n        switch (type.name) {\n            case BuiltinTypeName.Bool:\n                typeStr = 'boolean';\n                break;\n            case BuiltinTypeName.Dynamic:\n                typeStr = 'any';\n                break;\n            case BuiltinTypeName.Function:\n                typeStr = 'Function';\n                break;\n            case BuiltinTypeName.Number:\n                typeStr = 'number';\n                break;\n            case BuiltinTypeName.Int:\n                typeStr = 'number';\n                break;\n            case BuiltinTypeName.String:\n                typeStr = 'string';\n                break;\n            default:\n                throw new Error(\"Unsupported builtin type \" + type.name);\n        }\n        ctx.print(null, typeStr);\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitExpressionType = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ast.value.visitExpression(this, ctx);\n        return null;\n    };\n    /**\n     * @param {?} type\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitArrayType = /**\n     * @param {?} type\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (type, ctx) {\n        this.visitType(type.of, ctx);\n        ctx.print(null, \"[]\");\n        return null;\n    };\n    /**\n     * @param {?} type\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.visitMapType = /**\n     * @param {?} type\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (type, ctx) {\n        ctx.print(null, \"{[key: string]:\");\n        this.visitType(type.valueType, ctx);\n        ctx.print(null, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} method\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype.getBuiltinMethodName = /**\n     * @param {?} method\n     * @return {?}\n     */\n    function (method) {\n        var /** @type {?} */ name;\n        switch (method) {\n            case BuiltinMethod.ConcatArray:\n                name = 'concat';\n                break;\n            case BuiltinMethod.SubscribeObservable:\n                name = 'subscribe';\n                break;\n            case BuiltinMethod.Bind:\n                name = 'bind';\n                break;\n            default:\n                throw new Error(\"Unknown builtin method: \" + method);\n        }\n        return name;\n    };\n    /**\n     * @param {?} params\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype._visitParams = /**\n     * @param {?} params\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (params, ctx) {\n        var _this = this;\n        this.visitAllObjects(function (param) {\n            ctx.print(null, param.name);\n            _this._printColonType(param.type, ctx);\n        }, params, ctx, ',');\n    };\n    /**\n     * @param {?} value\n     * @param {?} typeParams\n     * @param {?} ctx\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype._visitIdentifier = /**\n     * @param {?} value\n     * @param {?} typeParams\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (value, typeParams, ctx) {\n        var _this = this;\n        var name = value.name, moduleName = value.moduleName;\n        if (this.referenceFilter && this.referenceFilter(value)) {\n            ctx.print(null, '(null as any)');\n            return;\n        }\n        if (moduleName) {\n            var /** @type {?} */ prefix = this.importsWithPrefixes.get(moduleName);\n            if (prefix == null) {\n                prefix = \"i\" + this.importsWithPrefixes.size;\n                this.importsWithPrefixes.set(moduleName, prefix);\n            }\n            ctx.print(null, prefix + \".\");\n        }\n        ctx.print(null, /** @type {?} */ ((name)));\n        if (this.typeExpression > 0) {\n            // If we are in a type expression that refers to a generic type then supply\n            // the required type parameters. If there were not enough type parameters\n            // supplied, supply any as the type. Outside a type expression the reference\n            // should not supply type parameters and be treated as a simple value reference\n            // to the constructor function itself.\n            var /** @type {?} */ suppliedParameters = typeParams || [];\n            if (suppliedParameters.length > 0) {\n                ctx.print(null, \"<\");\n                this.visitAllObjects(function (type) { return type.visitType(_this, ctx); }, /** @type {?} */ ((typeParams)), ctx, ',');\n                ctx.print(null, \">\");\n            }\n        }\n    };\n    /**\n     * @param {?} type\n     * @param {?} ctx\n     * @param {?=} defaultType\n     * @return {?}\n     */\n    _TsEmitterVisitor.prototype._printColonType = /**\n     * @param {?} type\n     * @param {?} ctx\n     * @param {?=} defaultType\n     * @return {?}\n     */\n    function (type, ctx, defaultType) {\n        if (type !== INFERRED_TYPE) {\n            ctx.print(null, ':');\n            this.visitType(type, ctx, defaultType);\n        }\n    };\n    return _TsEmitterVisitor;\n}(AbstractEmitterVisitor));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Resolve a `Type` for {\\@link Pipe}.\n *\n * This interface can be overridden by the application developer to create custom behavior.\n *\n * See {\\@link Compiler}\n */\nvar PipeResolver = /** @class */ (function () {\n    function PipeResolver(_reflector) {\n        this._reflector = _reflector;\n    }\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    PipeResolver.prototype.isPipe = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ typeMetadata = this._reflector.annotations(resolveForwardRef(type));\n        return typeMetadata && typeMetadata.some(createPipe.isTypeOf);\n    };\n    /**\n     * Return {@link Pipe} for a given `Type`.\n     */\n    /**\n     * Return {\\@link Pipe} for a given `Type`.\n     * @param {?} type\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    PipeResolver.prototype.resolve = /**\n     * Return {\\@link Pipe} for a given `Type`.\n     * @param {?} type\n     * @param {?=} throwIfNotFound\n     * @return {?}\n     */\n    function (type, throwIfNotFound) {\n        if (throwIfNotFound === void 0) { throwIfNotFound = true; }\n        var /** @type {?} */ metas = this._reflector.annotations(resolveForwardRef(type));\n        if (metas) {\n            var /** @type {?} */ annotation = findLast(metas, createPipe.isTypeOf);\n            if (annotation) {\n                return annotation;\n            }\n        }\n        if (throwIfNotFound) {\n            throw new Error(\"No Pipe decorator found on \" + stringify(type));\n        }\n        return null;\n    };\n    return PipeResolver;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Map from tagName|propertyName SecurityContext. Properties applying to all tags use '*'.\n */\nvar SECURITY_SCHEMA = {};\n/**\n * @param {?} ctx\n * @param {?} specs\n * @return {?}\n */\nfunction registerContext(ctx, specs) {\n    for (var _i = 0, specs_1 = specs; _i < specs_1.length; _i++) {\n        var spec = specs_1[_i];\n        SECURITY_SCHEMA[spec.toLowerCase()] = ctx;\n    }\n}\n// Case is insignificant below, all element and attribute names are lower-cased for lookup.\nregisterContext(SecurityContext.HTML, [\n    'iframe|srcdoc',\n    '*|innerHTML',\n    '*|outerHTML',\n]);\nregisterContext(SecurityContext.STYLE, ['*|style']);\n// NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.\nregisterContext(SecurityContext.URL, [\n    '*|formAction', 'area|href', 'area|ping', 'audio|src', 'a|href',\n    'a|ping', 'blockquote|cite', 'body|background', 'del|cite', 'form|action',\n    'img|src', 'img|srcset', 'input|src', 'ins|cite', 'q|cite',\n    'source|src', 'source|srcset', 'track|src', 'video|poster', 'video|src',\n]);\nregisterContext(SecurityContext.RESOURCE_URL, [\n    'applet|code',\n    'applet|codebase',\n    'base|href',\n    'embed|src',\n    'frame|src',\n    'head|profile',\n    'html|manifest',\n    'iframe|src',\n    'link|href',\n    'media|src',\n    'object|codebase',\n    'object|data',\n    'script|src',\n]);\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @abstract\n */\nvar ElementSchemaRegistry = /** @class */ (function () {\n    function ElementSchemaRegistry() {\n    }\n    return ElementSchemaRegistry;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar BOOLEAN = 'boolean';\nvar NUMBER = 'number';\nvar STRING = 'string';\nvar OBJECT = 'object';\n/**\n * This array represents the DOM schema. It encodes inheritance, properties, and events.\n *\n * ## Overview\n *\n * Each line represents one kind of element. The `element_inheritance` and properties are joined\n * using `element_inheritance|properties` syntax.\n *\n * ## Element Inheritance\n *\n * The `element_inheritance` can be further subdivided as `element1,element2,...^parentElement`.\n * Here the individual elements are separated by `,` (commas). Every element in the list\n * has identical properties.\n *\n * An `element` may inherit additional properties from `parentElement` If no `^parentElement` is\n * specified then `\"\"` (blank) element is assumed.\n *\n * NOTE: The blank element inherits from root `[Element]` element, the super element of all\n * elements.\n *\n * NOTE an element prefix such as `:svg:` has no special meaning to the schema.\n *\n * ## Properties\n *\n * Each element has a set of properties separated by `,` (commas). Each property can be prefixed\n * by a special character designating its type:\n *\n * - (no prefix): property is a string.\n * - `*`: property represents an event.\n * - `!`: property is a boolean.\n * - `#`: property is a number.\n * - `%`: property is an object.\n *\n * ## Query\n *\n * The class creates an internal squas representation which allows to easily answer the query of\n * if a given property exist on a given element.\n *\n * NOTE: We don't yet support querying for types or events.\n * NOTE: This schema is auto extracted from `schema_extractor.ts` located in the test folder,\n *       see dom_element_schema_registry_spec.ts\n */\nvar SCHEMA = [\n    '[Element]|textContent,%classList,className,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*copy,*cut,*paste,*search,*selectstart,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerHTML,#scrollLeft,#scrollTop,slot' +\n        ',*message,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored',\n    '[HTMLElement]^[Element]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate',\n    'abbr,address,article,aside,b,bdi,bdo,cite,code,dd,dfn,dt,em,figcaption,figure,footer,header,i,kbd,main,mark,nav,noscript,rb,rp,rt,rtc,ruby,s,samp,section,small,strong,sub,sup,u,var,wbr^[HTMLElement]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate',\n    'media^[HTMLElement]|!autoplay,!controls,%controlsList,%crossOrigin,#currentTime,!defaultMuted,#defaultPlaybackRate,!disableRemotePlayback,!loop,!muted,*encrypted,*waitingforkey,#playbackRate,preload,src,%srcObject,#volume',\n    ':svg:^[HTMLElement]|*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,%style,#tabIndex',\n    ':svg:graphics^:svg:|',\n    ':svg:animation^:svg:|*begin,*end,*repeat',\n    ':svg:geometry^:svg:|',\n    ':svg:componentTransferFunction^:svg:|',\n    ':svg:gradient^:svg:|',\n    ':svg:textContent^:svg:graphics|',\n    ':svg:textPositioning^:svg:textContent|',\n    'a^[HTMLElement]|charset,coords,download,hash,host,hostname,href,hreflang,name,password,pathname,ping,port,protocol,referrerPolicy,rel,rev,search,shape,target,text,type,username',\n    'area^[HTMLElement]|alt,coords,download,hash,host,hostname,href,!noHref,password,pathname,ping,port,protocol,referrerPolicy,rel,search,shape,target,username',\n    'audio^media|',\n    'br^[HTMLElement]|clear',\n    'base^[HTMLElement]|href,target',\n    'body^[HTMLElement]|aLink,background,bgColor,link,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,text,vLink',\n    'button^[HTMLElement]|!autofocus,!disabled,formAction,formEnctype,formMethod,!formNoValidate,formTarget,name,type,value',\n    'canvas^[HTMLElement]|#height,#width',\n    'content^[HTMLElement]|select',\n    'dl^[HTMLElement]|!compact',\n    'datalist^[HTMLElement]|',\n    'details^[HTMLElement]|!open',\n    'dialog^[HTMLElement]|!open,returnValue',\n    'dir^[HTMLElement]|!compact',\n    'div^[HTMLElement]|align',\n    'embed^[HTMLElement]|align,height,name,src,type,width',\n    'fieldset^[HTMLElement]|!disabled,name',\n    'font^[HTMLElement]|color,face,size',\n    'form^[HTMLElement]|acceptCharset,action,autocomplete,encoding,enctype,method,name,!noValidate,target',\n    'frame^[HTMLElement]|frameBorder,longDesc,marginHeight,marginWidth,name,!noResize,scrolling,src',\n    'frameset^[HTMLElement]|cols,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,rows',\n    'hr^[HTMLElement]|align,color,!noShade,size,width',\n    'head^[HTMLElement]|',\n    'h1,h2,h3,h4,h5,h6^[HTMLElement]|align',\n    'html^[HTMLElement]|version',\n    'iframe^[HTMLElement]|align,!allowFullscreen,frameBorder,height,longDesc,marginHeight,marginWidth,name,referrerPolicy,%sandbox,scrolling,src,srcdoc,width',\n    'img^[HTMLElement]|align,alt,border,%crossOrigin,#height,#hspace,!isMap,longDesc,lowsrc,name,referrerPolicy,sizes,src,srcset,useMap,#vspace,#width',\n    'input^[HTMLElement]|accept,align,alt,autocapitalize,autocomplete,!autofocus,!checked,!defaultChecked,defaultValue,dirName,!disabled,%files,formAction,formEnctype,formMethod,!formNoValidate,formTarget,#height,!incremental,!indeterminate,max,#maxLength,min,#minLength,!multiple,name,pattern,placeholder,!readOnly,!required,selectionDirection,#selectionEnd,#selectionStart,#size,src,step,type,useMap,value,%valueAsDate,#valueAsNumber,#width',\n    'li^[HTMLElement]|type,#value',\n    'label^[HTMLElement]|htmlFor',\n    'legend^[HTMLElement]|align',\n    'link^[HTMLElement]|as,charset,%crossOrigin,!disabled,href,hreflang,integrity,media,referrerPolicy,rel,%relList,rev,%sizes,target,type',\n    'map^[HTMLElement]|name',\n    'marquee^[HTMLElement]|behavior,bgColor,direction,height,#hspace,#loop,#scrollAmount,#scrollDelay,!trueSpeed,#vspace,width',\n    'menu^[HTMLElement]|!compact',\n    'meta^[HTMLElement]|content,httpEquiv,name,scheme',\n    'meter^[HTMLElement]|#high,#low,#max,#min,#optimum,#value',\n    'ins,del^[HTMLElement]|cite,dateTime',\n    'ol^[HTMLElement]|!compact,!reversed,#start,type',\n    'object^[HTMLElement]|align,archive,border,code,codeBase,codeType,data,!declare,height,#hspace,name,standby,type,useMap,#vspace,width',\n    'optgroup^[HTMLElement]|!disabled,label',\n    'option^[HTMLElement]|!defaultSelected,!disabled,label,!selected,text,value',\n    'output^[HTMLElement]|defaultValue,%htmlFor,name,value',\n    'p^[HTMLElement]|align',\n    'param^[HTMLElement]|name,type,value,valueType',\n    'picture^[HTMLElement]|',\n    'pre^[HTMLElement]|#width',\n    'progress^[HTMLElement]|#max,#value',\n    'q,blockquote,cite^[HTMLElement]|',\n    'script^[HTMLElement]|!async,charset,%crossOrigin,!defer,event,htmlFor,integrity,src,text,type',\n    'select^[HTMLElement]|!autofocus,!disabled,#length,!multiple,name,!required,#selectedIndex,#size,value',\n    'shadow^[HTMLElement]|',\n    'slot^[HTMLElement]|name',\n    'source^[HTMLElement]|media,sizes,src,srcset,type',\n    'span^[HTMLElement]|',\n    'style^[HTMLElement]|!disabled,media,type',\n    'caption^[HTMLElement]|align',\n    'th,td^[HTMLElement]|abbr,align,axis,bgColor,ch,chOff,#colSpan,headers,height,!noWrap,#rowSpan,scope,vAlign,width',\n    'col,colgroup^[HTMLElement]|align,ch,chOff,#span,vAlign,width',\n    'table^[HTMLElement]|align,bgColor,border,%caption,cellPadding,cellSpacing,frame,rules,summary,%tFoot,%tHead,width',\n    'tr^[HTMLElement]|align,bgColor,ch,chOff,vAlign',\n    'tfoot,thead,tbody^[HTMLElement]|align,ch,chOff,vAlign',\n    'template^[HTMLElement]|',\n    'textarea^[HTMLElement]|autocapitalize,!autofocus,#cols,defaultValue,dirName,!disabled,#maxLength,#minLength,name,placeholder,!readOnly,!required,#rows,selectionDirection,#selectionEnd,#selectionStart,value,wrap',\n    'title^[HTMLElement]|text',\n    'track^[HTMLElement]|!default,kind,label,src,srclang',\n    'ul^[HTMLElement]|!compact,type',\n    'unknown^[HTMLElement]|',\n    'video^media|#height,poster,#width',\n    ':svg:a^:svg:graphics|',\n    ':svg:animate^:svg:animation|',\n    ':svg:animateMotion^:svg:animation|',\n    ':svg:animateTransform^:svg:animation|',\n    ':svg:circle^:svg:geometry|',\n    ':svg:clipPath^:svg:graphics|',\n    ':svg:defs^:svg:graphics|',\n    ':svg:desc^:svg:|',\n    ':svg:discard^:svg:|',\n    ':svg:ellipse^:svg:geometry|',\n    ':svg:feBlend^:svg:|',\n    ':svg:feColorMatrix^:svg:|',\n    ':svg:feComponentTransfer^:svg:|',\n    ':svg:feComposite^:svg:|',\n    ':svg:feConvolveMatrix^:svg:|',\n    ':svg:feDiffuseLighting^:svg:|',\n    ':svg:feDisplacementMap^:svg:|',\n    ':svg:feDistantLight^:svg:|',\n    ':svg:feDropShadow^:svg:|',\n    ':svg:feFlood^:svg:|',\n    ':svg:feFuncA^:svg:componentTransferFunction|',\n    ':svg:feFuncB^:svg:componentTransferFunction|',\n    ':svg:feFuncG^:svg:componentTransferFunction|',\n    ':svg:feFuncR^:svg:componentTransferFunction|',\n    ':svg:feGaussianBlur^:svg:|',\n    ':svg:feImage^:svg:|',\n    ':svg:feMerge^:svg:|',\n    ':svg:feMergeNode^:svg:|',\n    ':svg:feMorphology^:svg:|',\n    ':svg:feOffset^:svg:|',\n    ':svg:fePointLight^:svg:|',\n    ':svg:feSpecularLighting^:svg:|',\n    ':svg:feSpotLight^:svg:|',\n    ':svg:feTile^:svg:|',\n    ':svg:feTurbulence^:svg:|',\n    ':svg:filter^:svg:|',\n    ':svg:foreignObject^:svg:graphics|',\n    ':svg:g^:svg:graphics|',\n    ':svg:image^:svg:graphics|',\n    ':svg:line^:svg:geometry|',\n    ':svg:linearGradient^:svg:gradient|',\n    ':svg:mpath^:svg:|',\n    ':svg:marker^:svg:|',\n    ':svg:mask^:svg:|',\n    ':svg:metadata^:svg:|',\n    ':svg:path^:svg:geometry|',\n    ':svg:pattern^:svg:|',\n    ':svg:polygon^:svg:geometry|',\n    ':svg:polyline^:svg:geometry|',\n    ':svg:radialGradient^:svg:gradient|',\n    ':svg:rect^:svg:geometry|',\n    ':svg:svg^:svg:graphics|#currentScale,#zoomAndPan',\n    ':svg:script^:svg:|type',\n    ':svg:set^:svg:animation|',\n    ':svg:stop^:svg:|',\n    ':svg:style^:svg:|!disabled,media,title,type',\n    ':svg:switch^:svg:graphics|',\n    ':svg:symbol^:svg:|',\n    ':svg:tspan^:svg:textPositioning|',\n    ':svg:text^:svg:textPositioning|',\n    ':svg:textPath^:svg:textContent|',\n    ':svg:title^:svg:|',\n    ':svg:use^:svg:graphics|',\n    ':svg:view^:svg:|#zoomAndPan',\n    'data^[HTMLElement]|value',\n    'keygen^[HTMLElement]|!autofocus,challenge,!disabled,form,keytype,name',\n    'menuitem^[HTMLElement]|type,label,icon,!disabled,!checked,radiogroup,!default',\n    'summary^[HTMLElement]|',\n    'time^[HTMLElement]|dateTime',\n    ':svg:cursor^:svg:|',\n];\nvar _ATTR_TO_PROP = {\n    'class': 'className',\n    'for': 'htmlFor',\n    'formaction': 'formAction',\n    'innerHtml': 'innerHTML',\n    'readonly': 'readOnly',\n    'tabindex': 'tabIndex',\n};\nvar DomElementSchemaRegistry = /** @class */ (function (_super) {\n    __extends(DomElementSchemaRegistry, _super);\n    function DomElementSchemaRegistry() {\n        var _this = _super.call(this) || this;\n        _this._schema = {};\n        SCHEMA.forEach(function (encodedType) {\n            var /** @type {?} */ type = {};\n            var _a = encodedType.split('|'), strType = _a[0], strProperties = _a[1];\n            var /** @type {?} */ properties = strProperties.split(',');\n            var _b = strType.split('^'), typeNames = _b[0], superName = _b[1];\n            typeNames.split(',').forEach(function (tag) { return _this._schema[tag.toLowerCase()] = type; });\n            var /** @type {?} */ superType = superName && _this._schema[superName.toLowerCase()];\n            if (superType) {\n                Object.keys(superType).forEach(function (prop) { type[prop] = superType[prop]; });\n            }\n            properties.forEach(function (property) {\n                if (property.length > 0) {\n                    switch (property[0]) {\n                        case '*':\n                            // We don't yet support events.\n                            // If ever allowing to bind to events, GO THROUGH A SECURITY REVIEW, allowing events\n                            // will\n                            // almost certainly introduce bad XSS vulnerabilities.\n                            // type[property.substring(1)] = EVENT;\n                            break;\n                        case '!':\n                            type[property.substring(1)] = BOOLEAN;\n                            break;\n                        case '#':\n                            type[property.substring(1)] = NUMBER;\n                            break;\n                        case '%':\n                            type[property.substring(1)] = OBJECT;\n                            break;\n                        default:\n                            type[property] = STRING;\n                    }\n                }\n            });\n        });\n        return _this;\n    }\n    /**\n     * @param {?} tagName\n     * @param {?} propName\n     * @param {?} schemaMetas\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.hasProperty = /**\n     * @param {?} tagName\n     * @param {?} propName\n     * @param {?} schemaMetas\n     * @return {?}\n     */\n    function (tagName, propName, schemaMetas) {\n        if (schemaMetas.some(function (schema) { return schema.name === NO_ERRORS_SCHEMA.name; })) {\n            return true;\n        }\n        if (tagName.indexOf('-') > -1) {\n            if (isNgContainer(tagName) || isNgContent(tagName)) {\n                return false;\n            }\n            if (schemaMetas.some(function (schema) { return schema.name === CUSTOM_ELEMENTS_SCHEMA.name; })) {\n                // Can't tell now as we don't know which properties a custom element will get\n                // once it is instantiated\n                return true;\n            }\n        }\n        var /** @type {?} */ elementProperties = this._schema[tagName.toLowerCase()] || this._schema['unknown'];\n        return !!elementProperties[propName];\n    };\n    /**\n     * @param {?} tagName\n     * @param {?} schemaMetas\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.hasElement = /**\n     * @param {?} tagName\n     * @param {?} schemaMetas\n     * @return {?}\n     */\n    function (tagName, schemaMetas) {\n        if (schemaMetas.some(function (schema) { return schema.name === NO_ERRORS_SCHEMA.name; })) {\n            return true;\n        }\n        if (tagName.indexOf('-') > -1) {\n            if (isNgContainer(tagName) || isNgContent(tagName)) {\n                return true;\n            }\n            if (schemaMetas.some(function (schema) { return schema.name === CUSTOM_ELEMENTS_SCHEMA.name; })) {\n                // Allow any custom elements\n                return true;\n            }\n        }\n        return !!this._schema[tagName.toLowerCase()];\n    };\n    /**\n     * securityContext returns the security context for the given property on the given DOM tag.\n     *\n     * Tag and property name are statically known and cannot change at runtime, i.e. it is not\n     * possible to bind a value into a changing attribute or tag name.\n     *\n     * The filtering is white list based. All attributes in the schema above are assumed to have the\n     * 'NONE' security context, i.e. that they are safe inert string values. Only specific well known\n     * attack vectors are assigned their appropriate context.\n     */\n    /**\n     * securityContext returns the security context for the given property on the given DOM tag.\n     *\n     * Tag and property name are statically known and cannot change at runtime, i.e. it is not\n     * possible to bind a value into a changing attribute or tag name.\n     *\n     * The filtering is white list based. All attributes in the schema above are assumed to have the\n     * 'NONE' security context, i.e. that they are safe inert string values. Only specific well known\n     * attack vectors are assigned their appropriate context.\n     * @param {?} tagName\n     * @param {?} propName\n     * @param {?} isAttribute\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.securityContext = /**\n     * securityContext returns the security context for the given property on the given DOM tag.\n     *\n     * Tag and property name are statically known and cannot change at runtime, i.e. it is not\n     * possible to bind a value into a changing attribute or tag name.\n     *\n     * The filtering is white list based. All attributes in the schema above are assumed to have the\n     * 'NONE' security context, i.e. that they are safe inert string values. Only specific well known\n     * attack vectors are assigned their appropriate context.\n     * @param {?} tagName\n     * @param {?} propName\n     * @param {?} isAttribute\n     * @return {?}\n     */\n    function (tagName, propName, isAttribute) {\n        if (isAttribute) {\n            // NB: For security purposes, use the mapped property name, not the attribute name.\n            propName = this.getMappedPropName(propName);\n        }\n        // Make sure comparisons are case insensitive, so that case differences between attribute and\n        // property names do not have a security impact.\n        tagName = tagName.toLowerCase();\n        propName = propName.toLowerCase();\n        var /** @type {?} */ ctx = SECURITY_SCHEMA[tagName + '|' + propName];\n        if (ctx) {\n            return ctx;\n        }\n        ctx = SECURITY_SCHEMA['*|' + propName];\n        return ctx ? ctx : SecurityContext.NONE;\n    };\n    /**\n     * @param {?} propName\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.getMappedPropName = /**\n     * @param {?} propName\n     * @return {?}\n     */\n    function (propName) { return _ATTR_TO_PROP[propName] || propName; };\n    /**\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.getDefaultComponentElementName = /**\n     * @return {?}\n     */\n    function () { return 'ng-component'; };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.validateProperty = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        if (name.toLowerCase().startsWith('on')) {\n            var /** @type {?} */ msg = \"Binding to event property '\" + name + \"' is disallowed for security reasons, \" +\n                (\"please use (\" + name.slice(2) + \")=...\") +\n                (\"\\nIf '\" + name + \"' is a directive input, make sure the directive is imported by the\") +\n                \" current module.\";\n            return { error: true, msg: msg };\n        }\n        else {\n            return { error: false };\n        }\n    };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.validateAttribute = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        if (name.toLowerCase().startsWith('on')) {\n            var /** @type {?} */ msg = \"Binding to event attribute '\" + name + \"' is disallowed for security reasons, \" +\n                (\"please use (\" + name.slice(2) + \")=...\");\n            return { error: true, msg: msg };\n        }\n        else {\n            return { error: false };\n        }\n    };\n    /**\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.allKnownElementNames = /**\n     * @return {?}\n     */\n    function () { return Object.keys(this._schema); };\n    /**\n     * @param {?} propName\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.normalizeAnimationStyleProperty = /**\n     * @param {?} propName\n     * @return {?}\n     */\n    function (propName) {\n        return dashCaseToCamelCase(propName);\n    };\n    /**\n     * @param {?} camelCaseProp\n     * @param {?} userProvidedProp\n     * @param {?} val\n     * @return {?}\n     */\n    DomElementSchemaRegistry.prototype.normalizeAnimationStyleValue = /**\n     * @param {?} camelCaseProp\n     * @param {?} userProvidedProp\n     * @param {?} val\n     * @return {?}\n     */\n    function (camelCaseProp, userProvidedProp, val) {\n        var /** @type {?} */ unit = '';\n        var /** @type {?} */ strVal = val.toString().trim();\n        var /** @type {?} */ errorMsg = /** @type {?} */ ((null));\n        if (_isPixelDimensionStyle(camelCaseProp) && val !== 0 && val !== '0') {\n            if (typeof val === 'number') {\n                unit = 'px';\n            }\n            else {\n                var /** @type {?} */ valAndSuffixMatch = val.match(/^[+-]?[\\d\\.]+([a-z]*)$/);\n                if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {\n                    errorMsg = \"Please provide a CSS unit value for \" + userProvidedProp + \":\" + val;\n                }\n            }\n        }\n        return { error: errorMsg, value: strVal + unit };\n    };\n    return DomElementSchemaRegistry;\n}(ElementSchemaRegistry));\n/**\n * @param {?} prop\n * @return {?}\n */\nfunction _isPixelDimensionStyle(prop) {\n    switch (prop) {\n        case 'width':\n        case 'height':\n        case 'minWidth':\n        case 'minHeight':\n        case 'maxWidth':\n        case 'maxHeight':\n        case 'left':\n        case 'top':\n        case 'bottom':\n        case 'right':\n        case 'fontSize':\n        case 'outlineWidth':\n        case 'outlineOffset':\n        case 'paddingTop':\n        case 'paddingLeft':\n        case 'paddingBottom':\n        case 'paddingRight':\n        case 'marginTop':\n        case 'marginLeft':\n        case 'marginBottom':\n        case 'marginRight':\n        case 'borderRadius':\n        case 'borderWidth':\n        case 'borderTopWidth':\n        case 'borderLeftWidth':\n        case 'borderRightWidth':\n        case 'borderBottomWidth':\n        case 'textIndent':\n            return true;\n        default:\n            return false;\n    }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * This file is a port of shadowCSS from webcomponents.js to TypeScript.\n *\n * Please make sure to keep to edits in sync with the source file.\n *\n * Source:\n * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js\n *\n * The original file level comment is reproduced below\n */\n/*\n  This is a limited shim for ShadowDOM css styling.\n  https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles\n\n  The intention here is to support only the styling features which can be\n  relatively simply implemented. The goal is to allow users to avoid the\n  most obvious pitfalls and do so without compromising performance significantly.\n  For ShadowDOM styling that's not covered here, a set of best practices\n  can be provided that should allow users to accomplish more complex styling.\n\n  The following is a list of specific ShadowDOM styling features and a brief\n  discussion of the approach used to shim.\n\n  Shimmed features:\n\n  * :host, :host-context: ShadowDOM allows styling of the shadowRoot's host\n  element using the :host rule. To shim this feature, the :host styles are\n  reformatted and prefixed with a given scope name and promoted to a\n  document level stylesheet.\n  For example, given a scope name of .foo, a rule like this:\n\n    :host {\n        background: red;\n      }\n    }\n\n  becomes:\n\n    .foo {\n      background: red;\n    }\n\n  * encapsulation: Styles defined within ShadowDOM, apply only to\n  dom inside the ShadowDOM. Polymer uses one of two techniques to implement\n  this feature.\n\n  By default, rules are prefixed with the host element tag name\n  as a descendant selector. This ensures styling does not leak out of the 'top'\n  of the element's ShadowDOM. For example,\n\n  div {\n      font-weight: bold;\n    }\n\n  becomes:\n\n  x-foo div {\n      font-weight: bold;\n    }\n\n  becomes:\n\n\n  Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then\n  selectors are scoped by adding an attribute selector suffix to each\n  simple selector that contains the host element tag name. Each element\n  in the element's ShadowDOM template is also given the scope attribute.\n  Thus, these rules match only elements that have the scope attribute.\n  For example, given a scope name of x-foo, a rule like this:\n\n    div {\n      font-weight: bold;\n    }\n\n  becomes:\n\n    div[x-foo] {\n      font-weight: bold;\n    }\n\n  Note that elements that are dynamically added to a scope must have the scope\n  selector added to them manually.\n\n  * upper/lower bound encapsulation: Styles which are defined outside a\n  shadowRoot should not cross the ShadowDOM boundary and should not apply\n  inside a shadowRoot.\n\n  This styling behavior is not emulated. Some possible ways to do this that\n  were rejected due to complexity and/or performance concerns include: (1) reset\n  every possible property for every possible selector for a given scope name;\n  (2) re-implement css in javascript.\n\n  As an alternative, users should make sure to use selectors\n  specific to the scope in which they are working.\n\n  * ::distributed: This behavior is not emulated. It's often not necessary\n  to style the contents of a specific insertion point and instead, descendants\n  of the host element can be styled selectively. Users can also create an\n  extra node around an insertion point and style that node's contents\n  via descendent selectors. For example, with a shadowRoot like this:\n\n    <style>\n      ::content(div) {\n        background: red;\n      }\n    </style>\n    <content></content>\n\n  could become:\n\n    <style>\n      / *@polyfill .content-container div * /\n      ::content(div) {\n        background: red;\n      }\n    </style>\n    <div class=\"content-container\">\n      <content></content>\n    </div>\n\n  Note the use of @polyfill in the comment above a ShadowDOM specific style\n  declaration. This is a directive to the styling shim to use the selector\n  in comments in lieu of the next selector when running under polyfill.\n*/\nvar ShadowCss = /** @class */ (function () {\n    function ShadowCss() {\n        this.strictStyling = true;\n    }\n    /*\n    * Shim some cssText with the given selector. Returns cssText that can\n    * be included in the document via WebComponents.ShadowCSS.addCssToDocument(css).\n    *\n    * When strictStyling is true:\n    * - selector is the attribute added to all elements inside the host,\n    * - hostSelector is the attribute added to the host itself.\n    */\n    /**\n     * @param {?} cssText\n     * @param {?} selector\n     * @param {?=} hostSelector\n     * @return {?}\n     */\n    ShadowCss.prototype.shimCssText = /**\n     * @param {?} cssText\n     * @param {?} selector\n     * @param {?=} hostSelector\n     * @return {?}\n     */\n    function (cssText, selector, hostSelector) {\n        if (hostSelector === void 0) { hostSelector = ''; }\n        var /** @type {?} */ commentsWithHash = extractCommentsWithHash(cssText);\n        cssText = stripComments(cssText);\n        cssText = this._insertDirectives(cssText);\n        var /** @type {?} */ scopedCssText = this._scopeCssText(cssText, selector, hostSelector);\n        return [scopedCssText].concat(commentsWithHash).join('\\n');\n    };\n    /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    ShadowCss.prototype._insertDirectives = /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    function (cssText) {\n        cssText = this._insertPolyfillDirectivesInCssText(cssText);\n        return this._insertPolyfillRulesInCssText(cssText);\n    };\n    /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    ShadowCss.prototype._insertPolyfillDirectivesInCssText = /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    function (cssText) {\n        // Difference with webcomponents.js: does not handle comments\n        return cssText.replace(_cssContentNextSelectorRe, function () {\n            var m = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                m[_i] = arguments[_i];\n            }\n            return m[2] + '{';\n        });\n    };\n    /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    ShadowCss.prototype._insertPolyfillRulesInCssText = /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    function (cssText) {\n        // Difference with webcomponents.js: does not handle comments\n        return cssText.replace(_cssContentRuleRe, function () {\n            var m = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                m[_i] = arguments[_i];\n            }\n            var /** @type {?} */ rule = m[0].replace(m[1], '').replace(m[2], '');\n            return m[4] + rule;\n        });\n    };\n    /**\n     * @param {?} cssText\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    ShadowCss.prototype._scopeCssText = /**\n     * @param {?} cssText\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    function (cssText, scopeSelector, hostSelector) {\n        var /** @type {?} */ unscopedRules = this._extractUnscopedRulesFromCssText(cssText);\n        // replace :host and :host-context -shadowcsshost and -shadowcsshost respectively\n        cssText = this._insertPolyfillHostInCssText(cssText);\n        cssText = this._convertColonHost(cssText);\n        cssText = this._convertColonHostContext(cssText);\n        cssText = this._convertShadowDOMSelectors(cssText);\n        if (scopeSelector) {\n            cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector);\n        }\n        cssText = cssText + '\\n' + unscopedRules;\n        return cssText.trim();\n    };\n    /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    ShadowCss.prototype._extractUnscopedRulesFromCssText = /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    function (cssText) {\n        // Difference with webcomponents.js: does not handle comments\n        var /** @type {?} */ r = '';\n        var /** @type {?} */ m;\n        _cssContentUnscopedRuleRe.lastIndex = 0;\n        while ((m = _cssContentUnscopedRuleRe.exec(cssText)) !== null) {\n            var /** @type {?} */ rule = m[0].replace(m[2], '').replace(m[1], m[4]);\n            r += rule + '\\n\\n';\n        }\n        return r;\n    };\n    /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    ShadowCss.prototype._convertColonHost = /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    function (cssText) {\n        return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);\n    };\n    /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    ShadowCss.prototype._convertColonHostContext = /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    function (cssText) {\n        return this._convertColonRule(cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);\n    };\n    /**\n     * @param {?} cssText\n     * @param {?} regExp\n     * @param {?} partReplacer\n     * @return {?}\n     */\n    ShadowCss.prototype._convertColonRule = /**\n     * @param {?} cssText\n     * @param {?} regExp\n     * @param {?} partReplacer\n     * @return {?}\n     */\n    function (cssText, regExp, partReplacer) {\n        // m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule\n        return cssText.replace(regExp, function () {\n            var m = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                m[_i] = arguments[_i];\n            }\n            if (m[2]) {\n                var /** @type {?} */ parts = m[2].split(',');\n                var /** @type {?} */ r = [];\n                for (var /** @type {?} */ i = 0; i < parts.length; i++) {\n                    var /** @type {?} */ p = parts[i].trim();\n                    if (!p)\n                        break;\n                    r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));\n                }\n                return r.join(',');\n            }\n            else {\n                return _polyfillHostNoCombinator + m[3];\n            }\n        });\n    };\n    /**\n     * @param {?} host\n     * @param {?} part\n     * @param {?} suffix\n     * @return {?}\n     */\n    ShadowCss.prototype._colonHostContextPartReplacer = /**\n     * @param {?} host\n     * @param {?} part\n     * @param {?} suffix\n     * @return {?}\n     */\n    function (host, part, suffix) {\n        if (part.indexOf(_polyfillHost) > -1) {\n            return this._colonHostPartReplacer(host, part, suffix);\n        }\n        else {\n            return host + part + suffix + ', ' + part + ' ' + host + suffix;\n        }\n    };\n    /**\n     * @param {?} host\n     * @param {?} part\n     * @param {?} suffix\n     * @return {?}\n     */\n    ShadowCss.prototype._colonHostPartReplacer = /**\n     * @param {?} host\n     * @param {?} part\n     * @param {?} suffix\n     * @return {?}\n     */\n    function (host, part, suffix) {\n        return host + part.replace(_polyfillHost, '') + suffix;\n    };\n    /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    ShadowCss.prototype._convertShadowDOMSelectors = /**\n     * @param {?} cssText\n     * @return {?}\n     */\n    function (cssText) {\n        return _shadowDOMSelectorsRe.reduce(function (result, pattern) { return result.replace(pattern, ' '); }, cssText);\n    };\n    /**\n     * @param {?} cssText\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    ShadowCss.prototype._scopeSelectors = /**\n     * @param {?} cssText\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    function (cssText, scopeSelector, hostSelector) {\n        var _this = this;\n        return processRules(cssText, function (rule) {\n            var /** @type {?} */ selector = rule.selector;\n            var /** @type {?} */ content = rule.content;\n            if (rule.selector[0] != '@') {\n                selector =\n                    _this._scopeSelector(rule.selector, scopeSelector, hostSelector, _this.strictStyling);\n            }\n            else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||\n                rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {\n                content = _this._scopeSelectors(rule.content, scopeSelector, hostSelector);\n            }\n            return new CssRule(selector, content);\n        });\n    };\n    /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @param {?} strict\n     * @return {?}\n     */\n    ShadowCss.prototype._scopeSelector = /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @param {?} strict\n     * @return {?}\n     */\n    function (selector, scopeSelector, hostSelector, strict) {\n        var _this = this;\n        return selector.split(',')\n            .map(function (part) { return part.trim().split(_shadowDeepSelectors); })\n            .map(function (deepParts) {\n            var shallowPart = deepParts[0], otherParts = deepParts.slice(1);\n            var /** @type {?} */ applyScope = function (shallowPart) {\n                if (_this._selectorNeedsScoping(shallowPart, scopeSelector)) {\n                    return strict ?\n                        _this._applyStrictSelectorScope(shallowPart, scopeSelector, hostSelector) :\n                        _this._applySelectorScope(shallowPart, scopeSelector, hostSelector);\n                }\n                else {\n                    return shallowPart;\n                }\n            };\n            return [applyScope(shallowPart)].concat(otherParts).join(' ');\n        })\n            .join(', ');\n    };\n    /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @return {?}\n     */\n    ShadowCss.prototype._selectorNeedsScoping = /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @return {?}\n     */\n    function (selector, scopeSelector) {\n        var /** @type {?} */ re = this._makeScopeMatcher(scopeSelector);\n        return !re.test(selector);\n    };\n    /**\n     * @param {?} scopeSelector\n     * @return {?}\n     */\n    ShadowCss.prototype._makeScopeMatcher = /**\n     * @param {?} scopeSelector\n     * @return {?}\n     */\n    function (scopeSelector) {\n        var /** @type {?} */ lre = /\\[/g;\n        var /** @type {?} */ rre = /\\]/g;\n        scopeSelector = scopeSelector.replace(lre, '\\\\[').replace(rre, '\\\\]');\n        return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');\n    };\n    /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    ShadowCss.prototype._applySelectorScope = /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    function (selector, scopeSelector, hostSelector) {\n        // Difference from webcomponents.js: scopeSelector could not be an array\n        return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);\n    };\n    /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    ShadowCss.prototype._applySimpleSelectorScope = /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    function (selector, scopeSelector, hostSelector) {\n        // In Android browser, the lastIndex is not reset when the regex is used in String.replace()\n        _polyfillHostRe.lastIndex = 0;\n        if (_polyfillHostRe.test(selector)) {\n            var /** @type {?} */ replaceBy_1 = this.strictStyling ? \"[\" + hostSelector + \"]\" : scopeSelector;\n            return selector\n                .replace(_polyfillHostNoCombinatorRe, function (hnc, selector) {\n                return selector.replace(/([^:]*)(:*)(.*)/, function (_, before, colon, after) {\n                    return before + replaceBy_1 + colon + after;\n                });\n            })\n                .replace(_polyfillHostRe, replaceBy_1 + ' ');\n        }\n        return scopeSelector + ' ' + selector;\n    };\n    /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    ShadowCss.prototype._applyStrictSelectorScope = /**\n     * @param {?} selector\n     * @param {?} scopeSelector\n     * @param {?} hostSelector\n     * @return {?}\n     */\n    function (selector, scopeSelector, hostSelector) {\n        var _this = this;\n        var /** @type {?} */ isRe = /\\[is=([^\\]]*)\\]/g;\n        scopeSelector = scopeSelector.replace(isRe, function (_) {\n            var parts = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                parts[_i - 1] = arguments[_i];\n            }\n            return parts[0];\n        });\n        var /** @type {?} */ attrName = '[' + scopeSelector + ']';\n        var /** @type {?} */ _scopeSelectorPart = function (p) {\n            var /** @type {?} */ scopedP = p.trim();\n            if (!scopedP) {\n                return '';\n            }\n            if (p.indexOf(_polyfillHostNoCombinator) > -1) {\n                scopedP = _this._applySimpleSelectorScope(p, scopeSelector, hostSelector);\n            }\n            else {\n                // remove :host since it should be unnecessary\n                var /** @type {?} */ t = p.replace(_polyfillHostRe, '');\n                if (t.length > 0) {\n                    var /** @type {?} */ matches = t.match(/([^:]*)(:*)(.*)/);\n                    if (matches) {\n                        scopedP = matches[1] + attrName + matches[2] + matches[3];\n                    }\n                }\n            }\n            return scopedP;\n        };\n        var /** @type {?} */ safeContent = new SafeSelector(selector);\n        selector = safeContent.content();\n        var /** @type {?} */ scopedSelector = '';\n        var /** @type {?} */ startIndex = 0;\n        var /** @type {?} */ res;\n        var /** @type {?} */ sep = /( |>|\\+|~(?!=))\\s*/g;\n        // If a selector appears before :host it should not be shimmed as it\n        // matches on ancestor elements and not on elements in the host's shadow\n        // `:host-context(div)` is transformed to\n        // `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator`\n        // the `div` is not part of the component in the 2nd selectors and should not be scoped.\n        // Historically `component-tag:host` was matching the component so we also want to preserve\n        // this behavior to avoid breaking legacy apps (it should not match).\n        // The behavior should be:\n        // - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything)\n        // - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a\n        //   `:host-context(tag)`)\n        var /** @type {?} */ hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1;\n        // Only scope parts after the first `-shadowcsshost-no-combinator` when it is present\n        var /** @type {?} */ shouldScope = !hasHost;\n        while ((res = sep.exec(selector)) !== null) {\n            var /** @type {?} */ separator = res[1];\n            var /** @type {?} */ part_1 = selector.slice(startIndex, res.index).trim();\n            shouldScope = shouldScope || part_1.indexOf(_polyfillHostNoCombinator) > -1;\n            var /** @type {?} */ scopedPart = shouldScope ? _scopeSelectorPart(part_1) : part_1;\n            scopedSelector += scopedPart + \" \" + separator + \" \";\n            startIndex = sep.lastIndex;\n        }\n        var /** @type {?} */ part = selector.substring(startIndex);\n        shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;\n        scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;\n        // replace the placeholders with their original values\n        return safeContent.restore(scopedSelector);\n    };\n    /**\n     * @param {?} selector\n     * @return {?}\n     */\n    ShadowCss.prototype._insertPolyfillHostInCssText = /**\n     * @param {?} selector\n     * @return {?}\n     */\n    function (selector) {\n        return selector.replace(_colonHostContextRe, _polyfillHostContext)\n            .replace(_colonHostRe, _polyfillHost);\n    };\n    return ShadowCss;\n}());\nvar SafeSelector = /** @class */ (function () {\n    function SafeSelector(selector) {\n        var _this = this;\n        this.placeholders = [];\n        this.index = 0;\n        // Replaces attribute selectors with placeholders.\n        // The WS in [attr=\"va lue\"] would otherwise be interpreted as a selector separator.\n        selector = selector.replace(/(\\[[^\\]]*\\])/g, function (_, keep) {\n            var /** @type {?} */ replaceBy = \"__ph-\" + _this.index + \"__\";\n            _this.placeholders.push(keep);\n            _this.index++;\n            return replaceBy;\n        });\n        // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.\n        // WS and \"+\" would otherwise be interpreted as selector separators.\n        this._content = selector.replace(/(:nth-[-\\w]+)(\\([^)]+\\))/g, function (_, pseudo, exp) {\n            var /** @type {?} */ replaceBy = \"__ph-\" + _this.index + \"__\";\n            _this.placeholders.push(exp);\n            _this.index++;\n            return pseudo + replaceBy;\n        });\n    }\n    /**\n     * @param {?} content\n     * @return {?}\n     */\n    SafeSelector.prototype.restore = /**\n     * @param {?} content\n     * @return {?}\n     */\n    function (content) {\n        var _this = this;\n        return content.replace(/__ph-(\\d+)__/g, function (ph, index) { return _this.placeholders[+index]; });\n    };\n    /**\n     * @return {?}\n     */\n    SafeSelector.prototype.content = /**\n     * @return {?}\n     */\n    function () { return this._content; };\n    return SafeSelector;\n}());\nvar _cssContentNextSelectorRe = /polyfill-next-selector[^}]*content:[\\s]*?(['\"])(.*?)\\1[;\\s]*}([^{]*?){/gim;\nvar _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\\s]*(['\"])(.*?)\\3)[;\\s]*[^}]*}/gim;\nvar _cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content:[\\s]*(['\"])(.*?)\\3)[;\\s]*[^}]*}/gim;\nvar _polyfillHost = '-shadowcsshost';\n// note: :host-context pre-processed to -shadowcsshostcontext.\nvar _polyfillHostContext = '-shadowcsscontext';\nvar _parenSuffix = ')(?:\\\\((' +\n    '(?:\\\\([^)(]*\\\\)|[^)(]*)+?' +\n    ')\\\\))?([^,{]*)';\nvar _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');\nvar _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');\nvar _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';\nvar _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\\s]*)/;\nvar _shadowDOMSelectorsRe = [\n    /::shadow/g,\n    /::content/g,\n    /\\/shadow-deep\\//g,\n    /\\/shadow\\//g,\n];\n// The deep combinator is deprecated in the CSS spec\n// Support for `>>>`, `deep`, `::ng-deep` is then also deprecated and will be removed in the future.\n// see https://github.com/angular/angular/pull/17677\nvar _shadowDeepSelectors = /(?:>>>)|(?:\\/deep\\/)|(?:::ng-deep)/g;\nvar _selectorReSuffix = '([>\\\\s~+\\[.,{:][\\\\s\\\\S]*)?$';\nvar _polyfillHostRe = /-shadowcsshost/gim;\nvar _colonHostRe = /:host/gim;\nvar _colonHostContextRe = /:host-context/gim;\nvar _commentRe = /\\/\\*\\s*[\\s\\S]*?\\*\\//g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction stripComments(input) {\n    return input.replace(_commentRe, '');\n}\nvar _commentWithHashRe = /\\/\\*\\s*#\\s*source(Mapping)?URL=[\\s\\S]+?\\*\\//g;\n/**\n * @param {?} input\n * @return {?}\n */\nfunction extractCommentsWithHash(input) {\n    return input.match(_commentWithHashRe) || [];\n}\nvar _ruleRe = /(\\s*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))/g;\nvar _curlyRe = /([{}])/g;\nvar OPEN_CURLY = '{';\nvar CLOSE_CURLY = '}';\nvar BLOCK_PLACEHOLDER = '%BLOCK%';\nvar CssRule = /** @class */ (function () {\n    function CssRule(selector, content) {\n        this.selector = selector;\n        this.content = content;\n    }\n    return CssRule;\n}());\n/**\n * @param {?} input\n * @param {?} ruleCallback\n * @return {?}\n */\nfunction processRules(input, ruleCallback) {\n    var /** @type {?} */ inputWithEscapedBlocks = escapeBlocks(input);\n    var /** @type {?} */ nextBlockIndex = 0;\n    return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function () {\n        var m = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            m[_i] = arguments[_i];\n        }\n        var /** @type {?} */ selector = m[2];\n        var /** @type {?} */ content = '';\n        var /** @type {?} */ suffix = m[4];\n        var /** @type {?} */ contentPrefix = '';\n        if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {\n            content = inputWithEscapedBlocks.blocks[nextBlockIndex++];\n            suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);\n            contentPrefix = '{';\n        }\n        var /** @type {?} */ rule = ruleCallback(new CssRule(selector, content));\n        return \"\" + m[1] + rule.selector + m[3] + contentPrefix + rule.content + suffix;\n    });\n}\nvar StringWithEscapedBlocks = /** @class */ (function () {\n    function StringWithEscapedBlocks(escapedString, blocks) {\n        this.escapedString = escapedString;\n        this.blocks = blocks;\n    }\n    return StringWithEscapedBlocks;\n}());\n/**\n * @param {?} input\n * @return {?}\n */\nfunction escapeBlocks(input) {\n    var /** @type {?} */ inputParts = input.split(_curlyRe);\n    var /** @type {?} */ resultParts = [];\n    var /** @type {?} */ escapedBlocks = [];\n    var /** @type {?} */ bracketCount = 0;\n    var /** @type {?} */ currentBlockParts = [];\n    for (var /** @type {?} */ partIndex = 0; partIndex < inputParts.length; partIndex++) {\n        var /** @type {?} */ part = inputParts[partIndex];\n        if (part == CLOSE_CURLY) {\n            bracketCount--;\n        }\n        if (bracketCount > 0) {\n            currentBlockParts.push(part);\n        }\n        else {\n            if (currentBlockParts.length > 0) {\n                escapedBlocks.push(currentBlockParts.join(''));\n                resultParts.push(BLOCK_PLACEHOLDER);\n                currentBlockParts = [];\n            }\n            resultParts.push(part);\n        }\n        if (part == OPEN_CURLY) {\n            bracketCount++;\n        }\n    }\n    if (currentBlockParts.length > 0) {\n        escapedBlocks.push(currentBlockParts.join(''));\n        resultParts.push(BLOCK_PLACEHOLDER);\n    }\n    return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar COMPONENT_VARIABLE = '%COMP%';\nvar HOST_ATTR = \"_nghost-\" + COMPONENT_VARIABLE;\nvar CONTENT_ATTR = \"_ngcontent-\" + COMPONENT_VARIABLE;\nvar StylesCompileDependency = /** @class */ (function () {\n    function StylesCompileDependency(name, moduleUrl, setValue) {\n        this.name = name;\n        this.moduleUrl = moduleUrl;\n        this.setValue = setValue;\n    }\n    return StylesCompileDependency;\n}());\nvar CompiledStylesheet = /** @class */ (function () {\n    function CompiledStylesheet(outputCtx, stylesVar, dependencies, isShimmed, meta) {\n        this.outputCtx = outputCtx;\n        this.stylesVar = stylesVar;\n        this.dependencies = dependencies;\n        this.isShimmed = isShimmed;\n        this.meta = meta;\n    }\n    return CompiledStylesheet;\n}());\nvar StyleCompiler = /** @class */ (function () {\n    function StyleCompiler(_urlResolver) {\n        this._urlResolver = _urlResolver;\n        this._shadowCss = new ShadowCss();\n    }\n    /**\n     * @param {?} outputCtx\n     * @param {?} comp\n     * @return {?}\n     */\n    StyleCompiler.prototype.compileComponent = /**\n     * @param {?} outputCtx\n     * @param {?} comp\n     * @return {?}\n     */\n    function (outputCtx, comp) {\n        var /** @type {?} */ template = /** @type {?} */ ((comp.template));\n        return this._compileStyles(outputCtx, comp, new CompileStylesheetMetadata({\n            styles: template.styles,\n            styleUrls: template.styleUrls,\n            moduleUrl: identifierModuleUrl(comp.type)\n        }), this.needsStyleShim(comp), true);\n    };\n    /**\n     * @param {?} outputCtx\n     * @param {?} comp\n     * @param {?} stylesheet\n     * @param {?=} shim\n     * @return {?}\n     */\n    StyleCompiler.prototype.compileStyles = /**\n     * @param {?} outputCtx\n     * @param {?} comp\n     * @param {?} stylesheet\n     * @param {?=} shim\n     * @return {?}\n     */\n    function (outputCtx, comp, stylesheet, shim) {\n        if (shim === void 0) { shim = this.needsStyleShim(comp); }\n        return this._compileStyles(outputCtx, comp, stylesheet, shim, false);\n    };\n    /**\n     * @param {?} comp\n     * @return {?}\n     */\n    StyleCompiler.prototype.needsStyleShim = /**\n     * @param {?} comp\n     * @return {?}\n     */\n    function (comp) {\n        return /** @type {?} */ ((comp.template)).encapsulation === ViewEncapsulation.Emulated;\n    };\n    /**\n     * @param {?} outputCtx\n     * @param {?} comp\n     * @param {?} stylesheet\n     * @param {?} shim\n     * @param {?} isComponentStylesheet\n     * @return {?}\n     */\n    StyleCompiler.prototype._compileStyles = /**\n     * @param {?} outputCtx\n     * @param {?} comp\n     * @param {?} stylesheet\n     * @param {?} shim\n     * @param {?} isComponentStylesheet\n     * @return {?}\n     */\n    function (outputCtx, comp, stylesheet, shim, isComponentStylesheet) {\n        var _this = this;\n        var /** @type {?} */ styleExpressions = stylesheet.styles.map(function (plainStyle) { return literal(_this._shimIfNeeded(plainStyle, shim)); });\n        var /** @type {?} */ dependencies = [];\n        stylesheet.styleUrls.forEach(function (styleUrl) {\n            var /** @type {?} */ exprIndex = styleExpressions.length;\n            // Note: This placeholder will be filled later.\n            styleExpressions.push(/** @type {?} */ ((null)));\n            dependencies.push(new StylesCompileDependency(getStylesVarName(null), styleUrl, function (value) { return styleExpressions[exprIndex] = outputCtx.importExpr(value); }));\n        });\n        // styles variable contains plain strings and arrays of other styles arrays (recursive),\n        // so we set its type to dynamic.\n        var /** @type {?} */ stylesVar = getStylesVarName(isComponentStylesheet ? comp : null);\n        var /** @type {?} */ stmt = variable(stylesVar)\n            .set(literalArr(styleExpressions, new ArrayType(DYNAMIC_TYPE, [TypeModifier.Const])))\n            .toDeclStmt(null, isComponentStylesheet ? [StmtModifier.Final] : [\n            StmtModifier.Final, StmtModifier.Exported\n        ]);\n        outputCtx.statements.push(stmt);\n        return new CompiledStylesheet(outputCtx, stylesVar, dependencies, shim, stylesheet);\n    };\n    /**\n     * @param {?} style\n     * @param {?} shim\n     * @return {?}\n     */\n    StyleCompiler.prototype._shimIfNeeded = /**\n     * @param {?} style\n     * @param {?} shim\n     * @return {?}\n     */\n    function (style, shim) {\n        return shim ? this._shadowCss.shimCssText(style, CONTENT_ATTR, HOST_ATTR) : style;\n    };\n    return StyleCompiler;\n}());\n/**\n * @param {?} component\n * @return {?}\n */\nfunction getStylesVarName(component) {\n    var /** @type {?} */ result = \"styles\";\n    if (component) {\n        result += \"_\" + identifierName(component.type);\n    }\n    return result;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar PRESERVE_WS_ATTR_NAME = 'ngPreserveWhitespaces';\nvar SKIP_WS_TRIM_TAGS = new Set(['pre', 'template', 'textarea', 'script', 'style']);\n// Equivalent to \\s with \\u00a0 (non-breaking space) excluded.\n// Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp\nvar WS_CHARS = ' \\f\\n\\r\\t\\v\\u1680\\u180e\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff';\nvar NO_WS_REGEXP = new RegExp(\"[^\" + WS_CHARS + \"]\");\nvar WS_REPLACE_REGEXP = new RegExp(\"[\" + WS_CHARS + \"]{2,}\", 'g');\n/**\n * @param {?} attrs\n * @return {?}\n */\nfunction hasPreserveWhitespacesAttr(attrs) {\n    return attrs.some(function (attr) { return attr.name === PRESERVE_WS_ATTR_NAME; });\n}\n/**\n * Angular Dart introduced &ngsp; as a placeholder for non-removable space, see:\n * https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart#L25-L32\n * In Angular Dart &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character\n * and later on replaced by a space. We are re-implementing the same idea here.\n * @param {?} value\n * @return {?}\n */\nfunction replaceNgsp(value) {\n    // lexer is replacing the &ngsp; pseudo-entity with NGSP_UNICODE\n    return value.replace(new RegExp(NGSP_UNICODE, 'g'), ' ');\n}\n/**\n * This visitor can walk HTML parse tree and remove / trim text nodes using the following rules:\n * - consider spaces, tabs and new lines as whitespace characters;\n * - drop text nodes consisting of whitespace characters only;\n * - for all other text nodes replace consecutive whitespace characters with one space;\n * - convert &ngsp; pseudo-entity to a single space;\n *\n * Removal and trimming of whitespaces have positive performance impact (less code to generate\n * while compiling templates, faster view creation). At the same time it can be \"destructive\"\n * in some cases (whitespaces can influence layout). Because of the potential of breaking layout\n * this visitor is not activated by default in Angular 5 and people need to explicitly opt-in for\n * whitespace removal. The default option for whitespace removal will be revisited in Angular 6\n * and might be changed to \"on\" by default.\n */\nvar WhitespaceVisitor = /** @class */ (function () {\n    function WhitespaceVisitor() {\n    }\n    /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    WhitespaceVisitor.prototype.visitElement = /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    function (element, context) {\n        if (SKIP_WS_TRIM_TAGS.has(element.name) || hasPreserveWhitespacesAttr(element.attrs)) {\n            // don't descent into elements where we need to preserve whitespaces\n            // but still visit all attributes to eliminate one used as a market to preserve WS\n            return new Element(element.name, visitAll(this, element.attrs), element.children, element.sourceSpan, element.startSourceSpan, element.endSourceSpan);\n        }\n        return new Element(element.name, element.attrs, visitAll(this, element.children), element.sourceSpan, element.startSourceSpan, element.endSourceSpan);\n    };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    WhitespaceVisitor.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) {\n        return attribute.name !== PRESERVE_WS_ATTR_NAME ? attribute : null;\n    };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    WhitespaceVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) {\n        var /** @type {?} */ isNotBlank = text.value.match(NO_WS_REGEXP);\n        if (isNotBlank) {\n            return new Text(replaceNgsp(text.value).replace(WS_REPLACE_REGEXP, ' '), text.sourceSpan);\n        }\n        return null;\n    };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    WhitespaceVisitor.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { return comment; };\n    /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    WhitespaceVisitor.prototype.visitExpansion = /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansion, context) { return expansion; };\n    /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    WhitespaceVisitor.prototype.visitExpansionCase = /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansionCase, context) { return expansionCase; };\n    return WhitespaceVisitor;\n}());\n/**\n * @param {?} htmlAstWithErrors\n * @return {?}\n */\nfunction removeWhitespaces(htmlAstWithErrors) {\n    return new ParseTreeResult(visitAll(new WhitespaceVisitor(), htmlAstWithErrors.rootNodes), htmlAstWithErrors.errors);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// http://cldr.unicode.org/index/cldr-spec/plural-rules\nvar PLURAL_CASES = ['zero', 'one', 'two', 'few', 'many', 'other'];\n/**\n * Expands special forms into elements.\n *\n * For example,\n *\n * ```\n * { messages.length, plural,\n *   =0 {zero}\n *   =1 {one}\n *   other {more than one}\n * }\n * ```\n *\n * will be expanded into\n *\n * ```\n * <ng-container [ngPlural]=\"messages.length\">\n *   <ng-template ngPluralCase=\"=0\">zero</ng-template>\n *   <ng-template ngPluralCase=\"=1\">one</ng-template>\n *   <ng-template ngPluralCase=\"other\">more than one</ng-template>\n * </ng-container>\n * ```\n * @param {?} nodes\n * @return {?}\n */\nfunction expandNodes(nodes) {\n    var /** @type {?} */ expander = new _Expander();\n    return new ExpansionResult(visitAll(expander, nodes), expander.isExpanded, expander.errors);\n}\nvar ExpansionResult = /** @class */ (function () {\n    function ExpansionResult(nodes, expanded, errors) {\n        this.nodes = nodes;\n        this.expanded = expanded;\n        this.errors = errors;\n    }\n    return ExpansionResult;\n}());\nvar ExpansionError = /** @class */ (function (_super) {\n    __extends(ExpansionError, _super);\n    function ExpansionError(span, errorMsg) {\n        return _super.call(this, span, errorMsg) || this;\n    }\n    return ExpansionError;\n}(ParseError));\n/**\n * Expand expansion forms (plural, select) to directives\n *\n * \\@internal\n */\nvar _Expander = /** @class */ (function () {\n    function _Expander() {\n        this.isExpanded = false;\n        this.errors = [];\n    }\n    /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    _Expander.prototype.visitElement = /**\n     * @param {?} element\n     * @param {?} context\n     * @return {?}\n     */\n    function (element, context) {\n        return new Element(element.name, element.attrs, visitAll(this, element.children), element.sourceSpan, element.startSourceSpan, element.endSourceSpan);\n    };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    _Expander.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) { return attribute; };\n    /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    _Expander.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} context\n     * @return {?}\n     */\n    function (text, context) { return text; };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    _Expander.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { return comment; };\n    /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    _Expander.prototype.visitExpansion = /**\n     * @param {?} icu\n     * @param {?} context\n     * @return {?}\n     */\n    function (icu, context) {\n        this.isExpanded = true;\n        return icu.type == 'plural' ? _expandPluralForm(icu, this.errors) :\n            _expandDefaultForm(icu, this.errors);\n    };\n    /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    _Expander.prototype.visitExpansionCase = /**\n     * @param {?} icuCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (icuCase, context) {\n        throw new Error('Should not be reached');\n    };\n    return _Expander;\n}());\n/**\n * @param {?} ast\n * @param {?} errors\n * @return {?}\n */\nfunction _expandPluralForm(ast, errors) {\n    var /** @type {?} */ children = ast.cases.map(function (c) {\n        if (PLURAL_CASES.indexOf(c.value) == -1 && !c.value.match(/^=\\d+$/)) {\n            errors.push(new ExpansionError(c.valueSourceSpan, \"Plural cases should be \\\"=<number>\\\" or one of \" + PLURAL_CASES.join(\", \")));\n        }\n        var /** @type {?} */ expansionResult = expandNodes(c.expression);\n        errors.push.apply(errors, expansionResult.errors);\n        return new Element(\"ng-template\", [new Attribute$1('ngPluralCase', \"\" + c.value, c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n    });\n    var /** @type {?} */ switchAttr = new Attribute$1('[ngPlural]', ast.switchValue, ast.switchValueSourceSpan);\n    return new Element('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);\n}\n/**\n * @param {?} ast\n * @param {?} errors\n * @return {?}\n */\nfunction _expandDefaultForm(ast, errors) {\n    var /** @type {?} */ children = ast.cases.map(function (c) {\n        var /** @type {?} */ expansionResult = expandNodes(c.expression);\n        errors.push.apply(errors, expansionResult.errors);\n        if (c.value === 'other') {\n            // other is the default case when no values match\n            return new Element(\"ng-template\", [new Attribute$1('ngSwitchDefault', '', c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n        }\n        return new Element(\"ng-template\", [new Attribute$1('ngSwitchCase', \"\" + c.value, c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan);\n    });\n    var /** @type {?} */ switchAttr = new Attribute$1('[ngSwitch]', ast.switchValue, ast.switchValueSourceSpan);\n    return new Element('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar PROPERTY_PARTS_SEPARATOR = '.';\nvar ATTRIBUTE_PREFIX = 'attr';\nvar CLASS_PREFIX = 'class';\nvar STYLE_PREFIX = 'style';\nvar ANIMATE_PROP_PREFIX = 'animate-';\n/** @enum {number} */\nvar BoundPropertyType = {\n    DEFAULT: 0,\n    LITERAL_ATTR: 1,\n    ANIMATION: 2,\n};\nBoundPropertyType[BoundPropertyType.DEFAULT] = \"DEFAULT\";\nBoundPropertyType[BoundPropertyType.LITERAL_ATTR] = \"LITERAL_ATTR\";\nBoundPropertyType[BoundPropertyType.ANIMATION] = \"ANIMATION\";\n/**\n * Represents a parsed property.\n */\nvar BoundProperty = /** @class */ (function () {\n    function BoundProperty(name, expression, type, sourceSpan) {\n        this.name = name;\n        this.expression = expression;\n        this.type = type;\n        this.sourceSpan = sourceSpan;\n        this.isLiteral = this.type === BoundPropertyType.LITERAL_ATTR;\n        this.isAnimation = this.type === BoundPropertyType.ANIMATION;\n    }\n    return BoundProperty;\n}());\n/**\n * Parses bindings in templates and in the directive host area.\n */\nvar BindingParser = /** @class */ (function () {\n    function BindingParser(_exprParser, _interpolationConfig, _schemaRegistry, pipes, _targetErrors) {\n        var _this = this;\n        this._exprParser = _exprParser;\n        this._interpolationConfig = _interpolationConfig;\n        this._schemaRegistry = _schemaRegistry;\n        this._targetErrors = _targetErrors;\n        this.pipesByName = new Map();\n        this._usedPipes = new Map();\n        pipes.forEach(function (pipe) { return _this.pipesByName.set(pipe.name, pipe); });\n    }\n    /**\n     * @return {?}\n     */\n    BindingParser.prototype.getUsedPipes = /**\n     * @return {?}\n     */\n    function () { return Array.from(this._usedPipes.values()); };\n    /**\n     * @param {?} dirMeta\n     * @param {?} elementSelector\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    BindingParser.prototype.createDirectiveHostPropertyAsts = /**\n     * @param {?} dirMeta\n     * @param {?} elementSelector\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (dirMeta, elementSelector, sourceSpan) {\n        var _this = this;\n        if (dirMeta.hostProperties) {\n            var /** @type {?} */ boundProps_1 = [];\n            Object.keys(dirMeta.hostProperties).forEach(function (propName) {\n                var /** @type {?} */ expression = dirMeta.hostProperties[propName];\n                if (typeof expression === 'string') {\n                    _this.parsePropertyBinding(propName, expression, true, sourceSpan, [], boundProps_1);\n                }\n                else {\n                    _this._reportError(\"Value of the host property binding \\\"\" + propName + \"\\\" needs to be a string representing an expression but got \\\"\" + expression + \"\\\" (\" + typeof expression + \")\", sourceSpan);\n                }\n            });\n            return boundProps_1.map(function (prop) { return _this.createElementPropertyAst(elementSelector, prop); });\n        }\n        return null;\n    };\n    /**\n     * @param {?} dirMeta\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    BindingParser.prototype.createDirectiveHostEventAsts = /**\n     * @param {?} dirMeta\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (dirMeta, sourceSpan) {\n        var _this = this;\n        if (dirMeta.hostListeners) {\n            var /** @type {?} */ targetEventAsts_1 = [];\n            Object.keys(dirMeta.hostListeners).forEach(function (propName) {\n                var /** @type {?} */ expression = dirMeta.hostListeners[propName];\n                if (typeof expression === 'string') {\n                    _this.parseEvent(propName, expression, sourceSpan, [], targetEventAsts_1);\n                }\n                else {\n                    _this._reportError(\"Value of the host listener \\\"\" + propName + \"\\\" needs to be a string representing an expression but got \\\"\" + expression + \"\\\" (\" + typeof expression + \")\", sourceSpan);\n                }\n            });\n            return targetEventAsts_1;\n        }\n        return null;\n    };\n    /**\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    BindingParser.prototype.parseInterpolation = /**\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (value, sourceSpan) {\n        var /** @type {?} */ sourceInfo = sourceSpan.start.toString();\n        try {\n            var /** @type {?} */ ast = /** @type {?} */ ((this._exprParser.parseInterpolation(value, sourceInfo, this._interpolationConfig)));\n            if (ast)\n                this._reportExpressionParserErrors(ast.errors, sourceSpan);\n            this._checkPipes(ast, sourceSpan);\n            return ast;\n        }\n        catch (/** @type {?} */ e) {\n            this._reportError(\"\" + e, sourceSpan);\n            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);\n        }\n    };\n    /**\n     * @param {?} prefixToken\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @param {?} targetVars\n     * @return {?}\n     */\n    BindingParser.prototype.parseInlineTemplateBinding = /**\n     * @param {?} prefixToken\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @param {?} targetVars\n     * @return {?}\n     */\n    function (prefixToken, value, sourceSpan, targetMatchableAttrs, targetProps, targetVars) {\n        var /** @type {?} */ bindings = this._parseTemplateBindings(prefixToken, value, sourceSpan);\n        for (var /** @type {?} */ i = 0; i < bindings.length; i++) {\n            var /** @type {?} */ binding = bindings[i];\n            if (binding.keyIsVar) {\n                targetVars.push(new VariableAst(binding.key, binding.name, sourceSpan));\n            }\n            else if (binding.expression) {\n                this._parsePropertyAst(binding.key, binding.expression, sourceSpan, targetMatchableAttrs, targetProps);\n            }\n            else {\n                targetMatchableAttrs.push([binding.key, '']);\n                this.parseLiteralAttr(binding.key, null, sourceSpan, targetMatchableAttrs, targetProps);\n            }\n        }\n    };\n    /**\n     * @param {?} prefixToken\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    BindingParser.prototype._parseTemplateBindings = /**\n     * @param {?} prefixToken\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (prefixToken, value, sourceSpan) {\n        var _this = this;\n        var /** @type {?} */ sourceInfo = sourceSpan.start.toString();\n        try {\n            var /** @type {?} */ bindingsResult = this._exprParser.parseTemplateBindings(prefixToken, value, sourceInfo);\n            this._reportExpressionParserErrors(bindingsResult.errors, sourceSpan);\n            bindingsResult.templateBindings.forEach(function (binding) {\n                if (binding.expression) {\n                    _this._checkPipes(binding.expression, sourceSpan);\n                }\n            });\n            bindingsResult.warnings.forEach(function (warning) { _this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING); });\n            return bindingsResult.templateBindings;\n        }\n        catch (/** @type {?} */ e) {\n            this._reportError(\"\" + e, sourceSpan);\n            return [];\n        }\n    };\n    /**\n     * @param {?} name\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    BindingParser.prototype.parseLiteralAttr = /**\n     * @param {?} name\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    function (name, value, sourceSpan, targetMatchableAttrs, targetProps) {\n        if (_isAnimationLabel(name)) {\n            name = name.substring(1);\n            if (value) {\n                this._reportError(\"Assigning animation triggers via @prop=\\\"exp\\\" attributes with an expression is invalid.\" +\n                    \" Use property bindings (e.g. [@prop]=\\\"exp\\\") or use an attribute without a value (e.g. @prop) instead.\", sourceSpan, ParseErrorLevel.ERROR);\n            }\n            this._parseAnimation(name, value, sourceSpan, targetMatchableAttrs, targetProps);\n        }\n        else {\n            targetProps.push(new BoundProperty(name, this._exprParser.wrapLiteralPrimitive(value, ''), BoundPropertyType.LITERAL_ATTR, sourceSpan));\n        }\n    };\n    /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} isHost\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    BindingParser.prototype.parsePropertyBinding = /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} isHost\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    function (name, expression, isHost, sourceSpan, targetMatchableAttrs, targetProps) {\n        var /** @type {?} */ isAnimationProp = false;\n        if (name.startsWith(ANIMATE_PROP_PREFIX)) {\n            isAnimationProp = true;\n            name = name.substring(ANIMATE_PROP_PREFIX.length);\n        }\n        else if (_isAnimationLabel(name)) {\n            isAnimationProp = true;\n            name = name.substring(1);\n        }\n        if (isAnimationProp) {\n            this._parseAnimation(name, expression, sourceSpan, targetMatchableAttrs, targetProps);\n        }\n        else {\n            this._parsePropertyAst(name, this._parseBinding(expression, isHost, sourceSpan), sourceSpan, targetMatchableAttrs, targetProps);\n        }\n    };\n    /**\n     * @param {?} name\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    BindingParser.prototype.parsePropertyInterpolation = /**\n     * @param {?} name\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    function (name, value, sourceSpan, targetMatchableAttrs, targetProps) {\n        var /** @type {?} */ expr = this.parseInterpolation(value, sourceSpan);\n        if (expr) {\n            this._parsePropertyAst(name, expr, sourceSpan, targetMatchableAttrs, targetProps);\n            return true;\n        }\n        return false;\n    };\n    /**\n     * @param {?} name\n     * @param {?} ast\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    BindingParser.prototype._parsePropertyAst = /**\n     * @param {?} name\n     * @param {?} ast\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    function (name, ast, sourceSpan, targetMatchableAttrs, targetProps) {\n        targetMatchableAttrs.push([name, /** @type {?} */ ((ast.source))]);\n        targetProps.push(new BoundProperty(name, ast, BoundPropertyType.DEFAULT, sourceSpan));\n    };\n    /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    BindingParser.prototype._parseAnimation = /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @return {?}\n     */\n    function (name, expression, sourceSpan, targetMatchableAttrs, targetProps) {\n        // This will occur when a @trigger is not paired with an expression.\n        // For animations it is valid to not have an expression since */void\n        // states will be applied by angular when the element is attached/detached\n        var /** @type {?} */ ast = this._parseBinding(expression || 'undefined', false, sourceSpan);\n        targetMatchableAttrs.push([name, /** @type {?} */ ((ast.source))]);\n        targetProps.push(new BoundProperty(name, ast, BoundPropertyType.ANIMATION, sourceSpan));\n    };\n    /**\n     * @param {?} value\n     * @param {?} isHostBinding\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    BindingParser.prototype._parseBinding = /**\n     * @param {?} value\n     * @param {?} isHostBinding\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (value, isHostBinding, sourceSpan) {\n        var /** @type {?} */ sourceInfo = sourceSpan.start.toString();\n        try {\n            var /** @type {?} */ ast = isHostBinding ?\n                this._exprParser.parseSimpleBinding(value, sourceInfo, this._interpolationConfig) :\n                this._exprParser.parseBinding(value, sourceInfo, this._interpolationConfig);\n            if (ast)\n                this._reportExpressionParserErrors(ast.errors, sourceSpan);\n            this._checkPipes(ast, sourceSpan);\n            return ast;\n        }\n        catch (/** @type {?} */ e) {\n            this._reportError(\"\" + e, sourceSpan);\n            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);\n        }\n    };\n    /**\n     * @param {?} elementSelector\n     * @param {?} boundProp\n     * @return {?}\n     */\n    BindingParser.prototype.createElementPropertyAst = /**\n     * @param {?} elementSelector\n     * @param {?} boundProp\n     * @return {?}\n     */\n    function (elementSelector, boundProp) {\n        if (boundProp.isAnimation) {\n            return new BoundElementPropertyAst(boundProp.name, PropertyBindingType.Animation, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan);\n        }\n        var /** @type {?} */ unit = null;\n        var /** @type {?} */ bindingType = /** @type {?} */ ((undefined));\n        var /** @type {?} */ boundPropertyName = null;\n        var /** @type {?} */ parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);\n        var /** @type {?} */ securityContexts = /** @type {?} */ ((undefined));\n        // Check check for special cases (prefix style, attr, class)\n        if (parts.length > 1) {\n            if (parts[0] == ATTRIBUTE_PREFIX) {\n                boundPropertyName = parts[1];\n                this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);\n                securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, true);\n                var /** @type {?} */ nsSeparatorIdx = boundPropertyName.indexOf(':');\n                if (nsSeparatorIdx > -1) {\n                    var /** @type {?} */ ns = boundPropertyName.substring(0, nsSeparatorIdx);\n                    var /** @type {?} */ name_1 = boundPropertyName.substring(nsSeparatorIdx + 1);\n                    boundPropertyName = mergeNsAndName(ns, name_1);\n                }\n                bindingType = PropertyBindingType.Attribute;\n            }\n            else if (parts[0] == CLASS_PREFIX) {\n                boundPropertyName = parts[1];\n                bindingType = PropertyBindingType.Class;\n                securityContexts = [SecurityContext.NONE];\n            }\n            else if (parts[0] == STYLE_PREFIX) {\n                unit = parts.length > 2 ? parts[2] : null;\n                boundPropertyName = parts[1];\n                bindingType = PropertyBindingType.Style;\n                securityContexts = [SecurityContext.STYLE];\n            }\n        }\n        // If not a special case, use the full property name\n        if (boundPropertyName === null) {\n            boundPropertyName = this._schemaRegistry.getMappedPropName(boundProp.name);\n            securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, false);\n            bindingType = PropertyBindingType.Property;\n            this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, false);\n        }\n        return new BoundElementPropertyAst(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan);\n    };\n    /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetEvents\n     * @return {?}\n     */\n    BindingParser.prototype.parseEvent = /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetEvents\n     * @return {?}\n     */\n    function (name, expression, sourceSpan, targetMatchableAttrs, targetEvents) {\n        if (_isAnimationLabel(name)) {\n            name = name.substr(1);\n            this._parseAnimationEvent(name, expression, sourceSpan, targetEvents);\n        }\n        else {\n            this._parseEvent(name, expression, sourceSpan, targetMatchableAttrs, targetEvents);\n        }\n    };\n    /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetEvents\n     * @return {?}\n     */\n    BindingParser.prototype._parseAnimationEvent = /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetEvents\n     * @return {?}\n     */\n    function (name, expression, sourceSpan, targetEvents) {\n        var /** @type {?} */ matches = splitAtPeriod(name, [name, '']);\n        var /** @type {?} */ eventName = matches[0];\n        var /** @type {?} */ phase = matches[1].toLowerCase();\n        if (phase) {\n            switch (phase) {\n                case 'start':\n                case 'done':\n                    var /** @type {?} */ ast = this._parseAction(expression, sourceSpan);\n                    targetEvents.push(new BoundEventAst(eventName, null, phase, ast, sourceSpan));\n                    break;\n                default:\n                    this._reportError(\"The provided animation output phase value \\\"\" + phase + \"\\\" for \\\"@\" + eventName + \"\\\" is not supported (use start or done)\", sourceSpan);\n                    break;\n            }\n        }\n        else {\n            this._reportError(\"The animation trigger output event (@\" + eventName + \") is missing its phase value name (start or done are currently supported)\", sourceSpan);\n        }\n    };\n    /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetEvents\n     * @return {?}\n     */\n    BindingParser.prototype._parseEvent = /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetEvents\n     * @return {?}\n     */\n    function (name, expression, sourceSpan, targetMatchableAttrs, targetEvents) {\n        // long format: 'target: eventName'\n        var _a = splitAtColon(name, [/** @type {?} */ ((null)), name]), target = _a[0], eventName = _a[1];\n        var /** @type {?} */ ast = this._parseAction(expression, sourceSpan);\n        targetMatchableAttrs.push([/** @type {?} */ ((name)), /** @type {?} */ ((ast.source))]);\n        targetEvents.push(new BoundEventAst(eventName, target, null, ast, sourceSpan));\n        // Don't detect directives for event names for now,\n        // so don't add the event name to the matchableAttrs\n    };\n    /**\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    BindingParser.prototype._parseAction = /**\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (value, sourceSpan) {\n        var /** @type {?} */ sourceInfo = sourceSpan.start.toString();\n        try {\n            var /** @type {?} */ ast = this._exprParser.parseAction(value, sourceInfo, this._interpolationConfig);\n            if (ast) {\n                this._reportExpressionParserErrors(ast.errors, sourceSpan);\n            }\n            if (!ast || ast.ast instanceof EmptyExpr) {\n                this._reportError(\"Empty expressions are not allowed\", sourceSpan);\n                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);\n            }\n            this._checkPipes(ast, sourceSpan);\n            return ast;\n        }\n        catch (/** @type {?} */ e) {\n            this._reportError(\"\" + e, sourceSpan);\n            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);\n        }\n    };\n    /**\n     * @param {?} message\n     * @param {?} sourceSpan\n     * @param {?=} level\n     * @return {?}\n     */\n    BindingParser.prototype._reportError = /**\n     * @param {?} message\n     * @param {?} sourceSpan\n     * @param {?=} level\n     * @return {?}\n     */\n    function (message, sourceSpan, level) {\n        if (level === void 0) { level = ParseErrorLevel.ERROR; }\n        this._targetErrors.push(new ParseError(sourceSpan, message, level));\n    };\n    /**\n     * @param {?} errors\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    BindingParser.prototype._reportExpressionParserErrors = /**\n     * @param {?} errors\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (errors, sourceSpan) {\n        for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {\n            var error = errors_1[_i];\n            this._reportError(error.message, sourceSpan);\n        }\n    };\n    /**\n     * @param {?} ast\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    BindingParser.prototype._checkPipes = /**\n     * @param {?} ast\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (ast, sourceSpan) {\n        var _this = this;\n        if (ast) {\n            var /** @type {?} */ collector = new PipeCollector();\n            ast.visit(collector);\n            collector.pipes.forEach(function (ast, pipeName) {\n                var /** @type {?} */ pipeMeta = _this.pipesByName.get(pipeName);\n                if (!pipeMeta) {\n                    _this._reportError(\"The pipe '\" + pipeName + \"' could not be found\", new ParseSourceSpan(sourceSpan.start.moveBy(ast.span.start), sourceSpan.start.moveBy(ast.span.end)));\n                }\n                else {\n                    _this._usedPipes.set(pipeName, pipeMeta);\n                }\n            });\n        }\n    };\n    /**\n     * @param {?} propName the name of the property / attribute\n     * @param {?} sourceSpan\n     * @param {?} isAttr true when binding to an attribute\n     * @return {?}\n     */\n    BindingParser.prototype._validatePropertyOrAttributeName = /**\n     * @param {?} propName the name of the property / attribute\n     * @param {?} sourceSpan\n     * @param {?} isAttr true when binding to an attribute\n     * @return {?}\n     */\n    function (propName, sourceSpan, isAttr) {\n        var /** @type {?} */ report = isAttr ? this._schemaRegistry.validateAttribute(propName) :\n            this._schemaRegistry.validateProperty(propName);\n        if (report.error) {\n            this._reportError(/** @type {?} */ ((report.msg)), sourceSpan, ParseErrorLevel.ERROR);\n        }\n    };\n    return BindingParser;\n}());\nvar PipeCollector = /** @class */ (function (_super) {\n    __extends(PipeCollector, _super);\n    function PipeCollector() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.pipes = new Map();\n        return _this;\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    PipeCollector.prototype.visitPipe = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        this.pipes.set(ast.name, ast);\n        ast.exp.visit(this);\n        this.visitAll(ast.args, context);\n        return null;\n    };\n    return PipeCollector;\n}(RecursiveAstVisitor));\n/**\n * @param {?} name\n * @return {?}\n */\nfunction _isAnimationLabel(name) {\n    return name[0] == '@';\n}\n/**\n * @param {?} registry\n * @param {?} selector\n * @param {?} propName\n * @param {?} isAttribute\n * @return {?}\n */\nfunction calcPossibleSecurityContexts(registry, selector, propName, isAttribute) {\n    var /** @type {?} */ ctxs = [];\n    CssSelector.parse(selector).forEach(function (selector) {\n        var /** @type {?} */ elementNames = selector.element ? [selector.element] : registry.allKnownElementNames();\n        var /** @type {?} */ notElementNames = new Set(selector.notSelectors.filter(function (selector) { return selector.isElementSelector(); })\n            .map(function (selector) { return selector.element; }));\n        var /** @type {?} */ possibleElementNames = elementNames.filter(function (elementName) { return !notElementNames.has(elementName); });\n        ctxs.push.apply(ctxs, possibleElementNames.map(function (elementName) { return registry.securityContext(elementName, propName, isAttribute); }));\n    });\n    return ctxs.length === 0 ? [SecurityContext.NONE] : Array.from(new Set(ctxs)).sort();\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar BIND_NAME_REGEXP = /^(?:(?:(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.+))|\\[\\(([^\\)]+)\\)\\]|\\[([^\\]]+)\\]|\\(([^\\)]+)\\))$/;\n// Group 1 = \"bind-\"\nvar KW_BIND_IDX = 1;\n// Group 2 = \"let-\"\nvar KW_LET_IDX = 2;\n// Group 3 = \"ref-/#\"\nvar KW_REF_IDX = 3;\n// Group 4 = \"on-\"\nvar KW_ON_IDX = 4;\n// Group 5 = \"bindon-\"\nvar KW_BINDON_IDX = 5;\n// Group 6 = \"@\"\nvar KW_AT_IDX = 6;\n// Group 7 = the identifier after \"bind-\", \"let-\", \"ref-/#\", \"on-\", \"bindon-\" or \"@\"\nvar IDENT_KW_IDX = 7;\n// Group 8 = identifier inside [()]\nvar IDENT_BANANA_BOX_IDX = 8;\n// Group 9 = identifier inside []\nvar IDENT_PROPERTY_IDX = 9;\n// Group 10 = identifier inside ()\nvar IDENT_EVENT_IDX = 10;\n// deprecated in 4.x\nvar TEMPLATE_ELEMENT = 'template';\n// deprecated in 4.x\nvar TEMPLATE_ATTR = 'template';\nvar TEMPLATE_ATTR_PREFIX = '*';\nvar CLASS_ATTR = 'class';\nvar TEXT_CSS_SELECTOR = CssSelector.parse('*')[0];\nvar TEMPLATE_ELEMENT_DEPRECATION_WARNING = 'The <template> element is deprecated. Use <ng-template> instead';\nvar TEMPLATE_ATTR_DEPRECATION_WARNING = 'The template attribute is deprecated. Use an ng-template element instead.';\nvar warningCounts = {};\n/**\n * @param {?} warnings\n * @return {?}\n */\nfunction warnOnlyOnce(warnings) {\n    return function (error) {\n        if (warnings.indexOf(error.msg) !== -1) {\n            warningCounts[error.msg] = (warningCounts[error.msg] || 0) + 1;\n            return warningCounts[error.msg] <= 1;\n        }\n        return true;\n    };\n}\nvar TemplateParseError = /** @class */ (function (_super) {\n    __extends(TemplateParseError, _super);\n    function TemplateParseError(message, span, level) {\n        return _super.call(this, span, message, level) || this;\n    }\n    return TemplateParseError;\n}(ParseError));\nvar TemplateParseResult = /** @class */ (function () {\n    function TemplateParseResult(templateAst, usedPipes, errors) {\n        this.templateAst = templateAst;\n        this.usedPipes = usedPipes;\n        this.errors = errors;\n    }\n    return TemplateParseResult;\n}());\nvar TemplateParser = /** @class */ (function () {\n    function TemplateParser(_config, _reflector, _exprParser, _schemaRegistry, _htmlParser, _console, transforms) {\n        this._config = _config;\n        this._reflector = _reflector;\n        this._exprParser = _exprParser;\n        this._schemaRegistry = _schemaRegistry;\n        this._htmlParser = _htmlParser;\n        this._console = _console;\n        this.transforms = transforms;\n    }\n    /**\n     * @param {?} component\n     * @param {?} template\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} schemas\n     * @param {?} templateUrl\n     * @param {?} preserveWhitespaces\n     * @return {?}\n     */\n    TemplateParser.prototype.parse = /**\n     * @param {?} component\n     * @param {?} template\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} schemas\n     * @param {?} templateUrl\n     * @param {?} preserveWhitespaces\n     * @return {?}\n     */\n    function (component, template, directives, pipes, schemas, templateUrl, preserveWhitespaces) {\n        var /** @type {?} */ result = this.tryParse(component, template, directives, pipes, schemas, templateUrl, preserveWhitespaces);\n        var /** @type {?} */ warnings = /** @type {?} */ ((result.errors)).filter(function (error) { return error.level === ParseErrorLevel.WARNING; }).filter(warnOnlyOnce([TEMPLATE_ATTR_DEPRECATION_WARNING, TEMPLATE_ELEMENT_DEPRECATION_WARNING]));\n        var /** @type {?} */ errors = /** @type {?} */ ((result.errors)).filter(function (error) { return error.level === ParseErrorLevel.ERROR; });\n        if (warnings.length > 0) {\n            this._console.warn(\"Template parse warnings:\\n\" + warnings.join('\\n'));\n        }\n        if (errors.length > 0) {\n            var /** @type {?} */ errorString = errors.join('\\n');\n            throw syntaxError(\"Template parse errors:\\n\" + errorString, errors);\n        }\n        return { template: /** @type {?} */ ((result.templateAst)), pipes: /** @type {?} */ ((result.usedPipes)) };\n    };\n    /**\n     * @param {?} component\n     * @param {?} template\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} schemas\n     * @param {?} templateUrl\n     * @param {?} preserveWhitespaces\n     * @return {?}\n     */\n    TemplateParser.prototype.tryParse = /**\n     * @param {?} component\n     * @param {?} template\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} schemas\n     * @param {?} templateUrl\n     * @param {?} preserveWhitespaces\n     * @return {?}\n     */\n    function (component, template, directives, pipes, schemas, templateUrl, preserveWhitespaces) {\n        var /** @type {?} */ htmlParseResult = typeof template === 'string' ? /** @type {?} */ ((this._htmlParser)).parse(template, templateUrl, true, this.getInterpolationConfig(component)) :\n            template;\n        if (!preserveWhitespaces) {\n            htmlParseResult = removeWhitespaces(htmlParseResult);\n        }\n        return this.tryParseHtml(this.expandHtml(htmlParseResult), component, directives, pipes, schemas);\n    };\n    /**\n     * @param {?} htmlAstWithErrors\n     * @param {?} component\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} schemas\n     * @return {?}\n     */\n    TemplateParser.prototype.tryParseHtml = /**\n     * @param {?} htmlAstWithErrors\n     * @param {?} component\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} schemas\n     * @return {?}\n     */\n    function (htmlAstWithErrors, component, directives, pipes, schemas) {\n        var /** @type {?} */ result;\n        var /** @type {?} */ errors = htmlAstWithErrors.errors;\n        var /** @type {?} */ usedPipes = [];\n        if (htmlAstWithErrors.rootNodes.length > 0) {\n            var /** @type {?} */ uniqDirectives = removeSummaryDuplicates(directives);\n            var /** @type {?} */ uniqPipes = removeSummaryDuplicates(pipes);\n            var /** @type {?} */ providerViewContext = new ProviderViewContext(this._reflector, component);\n            var /** @type {?} */ interpolationConfig = /** @type {?} */ ((undefined));\n            if (component.template && component.template.interpolation) {\n                interpolationConfig = {\n                    start: component.template.interpolation[0],\n                    end: component.template.interpolation[1]\n                };\n            }\n            var /** @type {?} */ bindingParser = new BindingParser(this._exprParser, /** @type {?} */ ((interpolationConfig)), this._schemaRegistry, uniqPipes, errors);\n            var /** @type {?} */ parseVisitor = new TemplateParseVisitor(this._reflector, this._config, providerViewContext, uniqDirectives, bindingParser, this._schemaRegistry, schemas, errors);\n            result = visitAll(parseVisitor, htmlAstWithErrors.rootNodes, EMPTY_ELEMENT_CONTEXT);\n            errors.push.apply(errors, providerViewContext.errors);\n            usedPipes.push.apply(usedPipes, bindingParser.getUsedPipes());\n        }\n        else {\n            result = [];\n        }\n        this._assertNoReferenceDuplicationOnTemplate(result, errors);\n        if (errors.length > 0) {\n            return new TemplateParseResult(result, usedPipes, errors);\n        }\n        if (this.transforms) {\n            this.transforms.forEach(function (transform) { result = templateVisitAll(transform, result); });\n        }\n        return new TemplateParseResult(result, usedPipes, errors);\n    };\n    /**\n     * @param {?} htmlAstWithErrors\n     * @param {?=} forced\n     * @return {?}\n     */\n    TemplateParser.prototype.expandHtml = /**\n     * @param {?} htmlAstWithErrors\n     * @param {?=} forced\n     * @return {?}\n     */\n    function (htmlAstWithErrors, forced) {\n        if (forced === void 0) { forced = false; }\n        var /** @type {?} */ errors = htmlAstWithErrors.errors;\n        if (errors.length == 0 || forced) {\n            // Transform ICU messages to angular directives\n            var /** @type {?} */ expandedHtmlAst = expandNodes(htmlAstWithErrors.rootNodes);\n            errors.push.apply(errors, expandedHtmlAst.errors);\n            htmlAstWithErrors = new ParseTreeResult(expandedHtmlAst.nodes, errors);\n        }\n        return htmlAstWithErrors;\n    };\n    /**\n     * @param {?} component\n     * @return {?}\n     */\n    TemplateParser.prototype.getInterpolationConfig = /**\n     * @param {?} component\n     * @return {?}\n     */\n    function (component) {\n        if (component.template) {\n            return InterpolationConfig.fromArray(component.template.interpolation);\n        }\n        return undefined;\n    };\n    /** @internal */\n    /**\n     * \\@internal\n     * @param {?} result\n     * @param {?} errors\n     * @return {?}\n     */\n    TemplateParser.prototype._assertNoReferenceDuplicationOnTemplate = /**\n     * \\@internal\n     * @param {?} result\n     * @param {?} errors\n     * @return {?}\n     */\n    function (result, errors) {\n        var /** @type {?} */ existingReferences = [];\n        result.filter(function (element) { return !!(/** @type {?} */ (element)).references; })\n            .forEach(function (element) {\n            return (/** @type {?} */ (element)).references.forEach(function (reference) {\n                var /** @type {?} */ name = reference.name;\n                if (existingReferences.indexOf(name) < 0) {\n                    existingReferences.push(name);\n                }\n                else {\n                    var /** @type {?} */ error = new TemplateParseError(\"Reference \\\"#\" + name + \"\\\" is defined several times\", reference.sourceSpan, ParseErrorLevel.ERROR);\n                    errors.push(error);\n                }\n            });\n        });\n    };\n    return TemplateParser;\n}());\nvar TemplateParseVisitor = /** @class */ (function () {\n    function TemplateParseVisitor(reflector, config, providerViewContext, directives, _bindingParser, _schemaRegistry, _schemas, _targetErrors) {\n        var _this = this;\n        this.reflector = reflector;\n        this.config = config;\n        this.providerViewContext = providerViewContext;\n        this._bindingParser = _bindingParser;\n        this._schemaRegistry = _schemaRegistry;\n        this._schemas = _schemas;\n        this._targetErrors = _targetErrors;\n        this.selectorMatcher = new SelectorMatcher();\n        this.directivesIndex = new Map();\n        this.ngContentCount = 0;\n        // Note: queries start with id 1 so we can use the number in a Bloom filter!\n        this.contentQueryStartId = providerViewContext.component.viewQueries.length + 1;\n        directives.forEach(function (directive, index) {\n            var /** @type {?} */ selector = CssSelector.parse(/** @type {?} */ ((directive.selector)));\n            _this.selectorMatcher.addSelectables(selector, directive);\n            _this.directivesIndex.set(directive, index);\n        });\n    }\n    /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype.visitExpansion = /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansion, context) { return null; };\n    /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype.visitExpansionCase = /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansionCase, context) { return null; };\n    /**\n     * @param {?} text\n     * @param {?} parent\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} parent\n     * @return {?}\n     */\n    function (text, parent) {\n        var /** @type {?} */ ngContentIndex = /** @type {?} */ ((parent.findNgContentIndex(TEXT_CSS_SELECTOR)));\n        var /** @type {?} */ valueNoNgsp = replaceNgsp(text.value);\n        var /** @type {?} */ expr = this._bindingParser.parseInterpolation(valueNoNgsp, /** @type {?} */ ((text.sourceSpan)));\n        return expr ? new BoundTextAst(expr, ngContentIndex, /** @type {?} */ ((text.sourceSpan))) :\n            new TextAst(valueNoNgsp, ngContentIndex, /** @type {?} */ ((text.sourceSpan)));\n    };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) {\n        return new AttrAst(attribute.name, attribute.value, attribute.sourceSpan);\n    };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { return null; };\n    /**\n     * @param {?} element\n     * @param {?} parent\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype.visitElement = /**\n     * @param {?} element\n     * @param {?} parent\n     * @return {?}\n     */\n    function (element, parent) {\n        var _this = this;\n        var /** @type {?} */ queryStartIndex = this.contentQueryStartId;\n        var /** @type {?} */ nodeName = element.name;\n        var /** @type {?} */ preparsedElement = preparseElement(element);\n        if (preparsedElement.type === PreparsedElementType.SCRIPT ||\n            preparsedElement.type === PreparsedElementType.STYLE) {\n            // Skipping <script> for security reasons\n            // Skipping <style> as we already processed them\n            // in the StyleCompiler\n            return null;\n        }\n        if (preparsedElement.type === PreparsedElementType.STYLESHEET &&\n            isStyleUrlResolvable(preparsedElement.hrefAttr)) {\n            // Skipping stylesheets with either relative urls or package scheme as we already processed\n            // them in the StyleCompiler\n            return null;\n        }\n        var /** @type {?} */ matchableAttrs = [];\n        var /** @type {?} */ elementOrDirectiveProps = [];\n        var /** @type {?} */ elementOrDirectiveRefs = [];\n        var /** @type {?} */ elementVars = [];\n        var /** @type {?} */ events = [];\n        var /** @type {?} */ templateElementOrDirectiveProps = [];\n        var /** @type {?} */ templateMatchableAttrs = [];\n        var /** @type {?} */ templateElementVars = [];\n        var /** @type {?} */ hasInlineTemplates = false;\n        var /** @type {?} */ attrs = [];\n        var /** @type {?} */ isTemplateElement = isTemplate(element, this.config.enableLegacyTemplate, function (m, span) { return _this._reportError(m, span, ParseErrorLevel.WARNING); });\n        element.attrs.forEach(function (attr) {\n            var /** @type {?} */ hasBinding = _this._parseAttr(isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, events, elementOrDirectiveRefs, elementVars);\n            var /** @type {?} */ templateBindingsSource;\n            var /** @type {?} */ prefixToken;\n            var /** @type {?} */ normalizedName = _this._normalizeAttributeName(attr.name);\n            if (_this.config.enableLegacyTemplate && normalizedName == TEMPLATE_ATTR) {\n                _this._reportError(TEMPLATE_ATTR_DEPRECATION_WARNING, attr.sourceSpan, ParseErrorLevel.WARNING);\n                templateBindingsSource = attr.value;\n            }\n            else if (normalizedName.startsWith(TEMPLATE_ATTR_PREFIX)) {\n                templateBindingsSource = attr.value;\n                prefixToken = normalizedName.substring(TEMPLATE_ATTR_PREFIX.length) + ':';\n            }\n            var /** @type {?} */ hasTemplateBinding = templateBindingsSource != null;\n            if (hasTemplateBinding) {\n                if (hasInlineTemplates) {\n                    _this._reportError(\"Can't have multiple template bindings on one element. Use only one attribute named 'template' or prefixed with *\", attr.sourceSpan);\n                }\n                hasInlineTemplates = true;\n                _this._bindingParser.parseInlineTemplateBinding(/** @type {?} */ ((prefixToken)), /** @type {?} */ ((templateBindingsSource)), attr.sourceSpan, templateMatchableAttrs, templateElementOrDirectiveProps, templateElementVars);\n            }\n            if (!hasBinding && !hasTemplateBinding) {\n                // don't include the bindings as attributes as well in the AST\n                attrs.push(_this.visitAttribute(attr, null));\n                matchableAttrs.push([attr.name, attr.value]);\n            }\n        });\n        var /** @type {?} */ elementCssSelector = createElementCssSelector(nodeName, matchableAttrs);\n        var _a = this._parseDirectives(this.selectorMatcher, elementCssSelector), directiveMetas = _a.directives, matchElement = _a.matchElement;\n        var /** @type {?} */ references = [];\n        var /** @type {?} */ boundDirectivePropNames = new Set();\n        var /** @type {?} */ directiveAsts = this._createDirectiveAsts(isTemplateElement, element.name, directiveMetas, elementOrDirectiveProps, elementOrDirectiveRefs, /** @type {?} */ ((element.sourceSpan)), references, boundDirectivePropNames);\n        var /** @type {?} */ elementProps = this._createElementPropertyAsts(element.name, elementOrDirectiveProps, boundDirectivePropNames);\n        var /** @type {?} */ isViewRoot = parent.isTemplateElement || hasInlineTemplates;\n        var /** @type {?} */ providerContext = new ProviderElementContext(this.providerViewContext, /** @type {?} */ ((parent.providerContext)), isViewRoot, directiveAsts, attrs, references, isTemplateElement, queryStartIndex, /** @type {?} */ ((element.sourceSpan)));\n        var /** @type {?} */ children = visitAll(preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element.children, ElementContext.create(isTemplateElement, directiveAsts, isTemplateElement ? /** @type {?} */ ((parent.providerContext)) : providerContext));\n        providerContext.afterElement();\n        // Override the actual selector when the `ngProjectAs` attribute is provided\n        var /** @type {?} */ projectionSelector = preparsedElement.projectAs != null ?\n            CssSelector.parse(preparsedElement.projectAs)[0] :\n            elementCssSelector;\n        var /** @type {?} */ ngContentIndex = /** @type {?} */ ((parent.findNgContentIndex(projectionSelector)));\n        var /** @type {?} */ parsedElement;\n        if (preparsedElement.type === PreparsedElementType.NG_CONTENT) {\n            if (element.children && !element.children.every(_isEmptyTextNode)) {\n                this._reportError(\"<ng-content> element cannot have content.\", /** @type {?} */ ((element.sourceSpan)));\n            }\n            parsedElement = new NgContentAst(this.ngContentCount++, hasInlineTemplates ? /** @type {?} */ ((null)) : ngContentIndex, /** @type {?} */ ((element.sourceSpan)));\n        }\n        else if (isTemplateElement) {\n            this._assertAllEventsPublishedByDirectives(directiveAsts, events);\n            this._assertNoComponentsNorElementBindingsOnTemplate(directiveAsts, elementProps, /** @type {?} */ ((element.sourceSpan)));\n            parsedElement = new EmbeddedTemplateAst(attrs, events, references, elementVars, providerContext.transformedDirectiveAsts, providerContext.transformProviders, providerContext.transformedHasViewContainer, providerContext.queryMatches, children, hasInlineTemplates ? /** @type {?} */ ((null)) : ngContentIndex, /** @type {?} */ ((element.sourceSpan)));\n        }\n        else {\n            this._assertElementExists(matchElement, element);\n            this._assertOnlyOneComponent(directiveAsts, /** @type {?} */ ((element.sourceSpan)));\n            var /** @type {?} */ ngContentIndex_1 = hasInlineTemplates ? null : parent.findNgContentIndex(projectionSelector);\n            parsedElement = new ElementAst(nodeName, attrs, elementProps, events, references, providerContext.transformedDirectiveAsts, providerContext.transformProviders, providerContext.transformedHasViewContainer, providerContext.queryMatches, children, hasInlineTemplates ? null : ngContentIndex_1, element.sourceSpan, element.endSourceSpan || null);\n        }\n        if (hasInlineTemplates) {\n            var /** @type {?} */ templateQueryStartIndex = this.contentQueryStartId;\n            var /** @type {?} */ templateSelector = createElementCssSelector(TEMPLATE_ELEMENT, templateMatchableAttrs);\n            var templateDirectiveMetas = this._parseDirectives(this.selectorMatcher, templateSelector).directives;\n            var /** @type {?} */ templateBoundDirectivePropNames = new Set();\n            var /** @type {?} */ templateDirectiveAsts = this._createDirectiveAsts(true, element.name, templateDirectiveMetas, templateElementOrDirectiveProps, [], /** @type {?} */ ((element.sourceSpan)), [], templateBoundDirectivePropNames);\n            var /** @type {?} */ templateElementProps = this._createElementPropertyAsts(element.name, templateElementOrDirectiveProps, templateBoundDirectivePropNames);\n            this._assertNoComponentsNorElementBindingsOnTemplate(templateDirectiveAsts, templateElementProps, /** @type {?} */ ((element.sourceSpan)));\n            var /** @type {?} */ templateProviderContext = new ProviderElementContext(this.providerViewContext, /** @type {?} */ ((parent.providerContext)), parent.isTemplateElement, templateDirectiveAsts, [], [], true, templateQueryStartIndex, /** @type {?} */ ((element.sourceSpan)));\n            templateProviderContext.afterElement();\n            parsedElement = new EmbeddedTemplateAst([], [], [], templateElementVars, templateProviderContext.transformedDirectiveAsts, templateProviderContext.transformProviders, templateProviderContext.transformedHasViewContainer, templateProviderContext.queryMatches, [parsedElement], ngContentIndex, /** @type {?} */ ((element.sourceSpan)));\n        }\n        return parsedElement;\n    };\n    /**\n     * @param {?} isTemplateElement\n     * @param {?} attr\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @param {?} targetEvents\n     * @param {?} targetRefs\n     * @param {?} targetVars\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._parseAttr = /**\n     * @param {?} isTemplateElement\n     * @param {?} attr\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetProps\n     * @param {?} targetEvents\n     * @param {?} targetRefs\n     * @param {?} targetVars\n     * @return {?}\n     */\n    function (isTemplateElement, attr, targetMatchableAttrs, targetProps, targetEvents, targetRefs, targetVars) {\n        var /** @type {?} */ name = this._normalizeAttributeName(attr.name);\n        var /** @type {?} */ value = attr.value;\n        var /** @type {?} */ srcSpan = attr.sourceSpan;\n        var /** @type {?} */ bindParts = name.match(BIND_NAME_REGEXP);\n        var /** @type {?} */ hasBinding = false;\n        if (bindParts !== null) {\n            hasBinding = true;\n            if (bindParts[KW_BIND_IDX] != null) {\n                this._bindingParser.parsePropertyBinding(bindParts[IDENT_KW_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps);\n            }\n            else if (bindParts[KW_LET_IDX]) {\n                if (isTemplateElement) {\n                    var /** @type {?} */ identifier = bindParts[IDENT_KW_IDX];\n                    this._parseVariable(identifier, value, srcSpan, targetVars);\n                }\n                else {\n                    this._reportError(\"\\\"let-\\\" is only supported on ng-template elements.\", srcSpan);\n                }\n            }\n            else if (bindParts[KW_REF_IDX]) {\n                var /** @type {?} */ identifier = bindParts[IDENT_KW_IDX];\n                this._parseReference(identifier, value, srcSpan, targetRefs);\n            }\n            else if (bindParts[KW_ON_IDX]) {\n                this._bindingParser.parseEvent(bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);\n            }\n            else if (bindParts[KW_BINDON_IDX]) {\n                this._bindingParser.parsePropertyBinding(bindParts[IDENT_KW_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps);\n                this._parseAssignmentEvent(bindParts[IDENT_KW_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);\n            }\n            else if (bindParts[KW_AT_IDX]) {\n                this._bindingParser.parseLiteralAttr(name, value, srcSpan, targetMatchableAttrs, targetProps);\n            }\n            else if (bindParts[IDENT_BANANA_BOX_IDX]) {\n                this._bindingParser.parsePropertyBinding(bindParts[IDENT_BANANA_BOX_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps);\n                this._parseAssignmentEvent(bindParts[IDENT_BANANA_BOX_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);\n            }\n            else if (bindParts[IDENT_PROPERTY_IDX]) {\n                this._bindingParser.parsePropertyBinding(bindParts[IDENT_PROPERTY_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps);\n            }\n            else if (bindParts[IDENT_EVENT_IDX]) {\n                this._bindingParser.parseEvent(bindParts[IDENT_EVENT_IDX], value, srcSpan, targetMatchableAttrs, targetEvents);\n            }\n        }\n        else {\n            hasBinding = this._bindingParser.parsePropertyInterpolation(name, value, srcSpan, targetMatchableAttrs, targetProps);\n        }\n        if (!hasBinding) {\n            this._bindingParser.parseLiteralAttr(name, value, srcSpan, targetMatchableAttrs, targetProps);\n        }\n        return hasBinding;\n    };\n    /**\n     * @param {?} attrName\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._normalizeAttributeName = /**\n     * @param {?} attrName\n     * @return {?}\n     */\n    function (attrName) {\n        return /^data-/i.test(attrName) ? attrName.substring(5) : attrName;\n    };\n    /**\n     * @param {?} identifier\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetVars\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._parseVariable = /**\n     * @param {?} identifier\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetVars\n     * @return {?}\n     */\n    function (identifier, value, sourceSpan, targetVars) {\n        if (identifier.indexOf('-') > -1) {\n            this._reportError(\"\\\"-\\\" is not allowed in variable names\", sourceSpan);\n        }\n        targetVars.push(new VariableAst(identifier, value, sourceSpan));\n    };\n    /**\n     * @param {?} identifier\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetRefs\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._parseReference = /**\n     * @param {?} identifier\n     * @param {?} value\n     * @param {?} sourceSpan\n     * @param {?} targetRefs\n     * @return {?}\n     */\n    function (identifier, value, sourceSpan, targetRefs) {\n        if (identifier.indexOf('-') > -1) {\n            this._reportError(\"\\\"-\\\" is not allowed in reference names\", sourceSpan);\n        }\n        targetRefs.push(new ElementOrDirectiveRef(identifier, value, sourceSpan));\n    };\n    /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetEvents\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._parseAssignmentEvent = /**\n     * @param {?} name\n     * @param {?} expression\n     * @param {?} sourceSpan\n     * @param {?} targetMatchableAttrs\n     * @param {?} targetEvents\n     * @return {?}\n     */\n    function (name, expression, sourceSpan, targetMatchableAttrs, targetEvents) {\n        this._bindingParser.parseEvent(name + \"Change\", expression + \"=$event\", sourceSpan, targetMatchableAttrs, targetEvents);\n    };\n    /**\n     * @param {?} selectorMatcher\n     * @param {?} elementCssSelector\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._parseDirectives = /**\n     * @param {?} selectorMatcher\n     * @param {?} elementCssSelector\n     * @return {?}\n     */\n    function (selectorMatcher, elementCssSelector) {\n        var _this = this;\n        // Need to sort the directives so that we get consistent results throughout,\n        // as selectorMatcher uses Maps inside.\n        // Also deduplicate directives as they might match more than one time!\n        var /** @type {?} */ directives = new Array(this.directivesIndex.size);\n        // Whether any directive selector matches on the element name\n        var /** @type {?} */ matchElement = false;\n        selectorMatcher.match(elementCssSelector, function (selector, directive) {\n            directives[/** @type {?} */ ((_this.directivesIndex.get(directive)))] = directive;\n            matchElement = matchElement || selector.hasElementSelector();\n        });\n        return {\n            directives: directives.filter(function (dir) { return !!dir; }),\n            matchElement: matchElement,\n        };\n    };\n    /**\n     * @param {?} isTemplateElement\n     * @param {?} elementName\n     * @param {?} directives\n     * @param {?} props\n     * @param {?} elementOrDirectiveRefs\n     * @param {?} elementSourceSpan\n     * @param {?} targetReferences\n     * @param {?} targetBoundDirectivePropNames\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._createDirectiveAsts = /**\n     * @param {?} isTemplateElement\n     * @param {?} elementName\n     * @param {?} directives\n     * @param {?} props\n     * @param {?} elementOrDirectiveRefs\n     * @param {?} elementSourceSpan\n     * @param {?} targetReferences\n     * @param {?} targetBoundDirectivePropNames\n     * @return {?}\n     */\n    function (isTemplateElement, elementName, directives, props, elementOrDirectiveRefs, elementSourceSpan, targetReferences, targetBoundDirectivePropNames) {\n        var _this = this;\n        var /** @type {?} */ matchedReferences = new Set();\n        var /** @type {?} */ component = /** @type {?} */ ((null));\n        var /** @type {?} */ directiveAsts = directives.map(function (directive) {\n            var /** @type {?} */ sourceSpan = new ParseSourceSpan(elementSourceSpan.start, elementSourceSpan.end, \"Directive \" + identifierName(directive.type));\n            if (directive.isComponent) {\n                component = directive;\n            }\n            var /** @type {?} */ directiveProperties = [];\n            var /** @type {?} */ hostProperties = /** @type {?} */ ((_this._bindingParser.createDirectiveHostPropertyAsts(directive, elementName, sourceSpan)));\n            // Note: We need to check the host properties here as well,\n            // as we don't know the element name in the DirectiveWrapperCompiler yet.\n            hostProperties = _this._checkPropertiesInSchema(elementName, hostProperties);\n            var /** @type {?} */ hostEvents = /** @type {?} */ ((_this._bindingParser.createDirectiveHostEventAsts(directive, sourceSpan)));\n            _this._createDirectivePropertyAsts(directive.inputs, props, directiveProperties, targetBoundDirectivePropNames);\n            elementOrDirectiveRefs.forEach(function (elOrDirRef) {\n                if ((elOrDirRef.value.length === 0 && directive.isComponent) ||\n                    (elOrDirRef.isReferenceToDirective(directive))) {\n                    targetReferences.push(new ReferenceAst(elOrDirRef.name, createTokenForReference(directive.type.reference), elOrDirRef.sourceSpan));\n                    matchedReferences.add(elOrDirRef.name);\n                }\n            });\n            var /** @type {?} */ contentQueryStartId = _this.contentQueryStartId;\n            _this.contentQueryStartId += directive.queries.length;\n            return new DirectiveAst(directive, directiveProperties, hostProperties, hostEvents, contentQueryStartId, sourceSpan);\n        });\n        elementOrDirectiveRefs.forEach(function (elOrDirRef) {\n            if (elOrDirRef.value.length > 0) {\n                if (!matchedReferences.has(elOrDirRef.name)) {\n                    _this._reportError(\"There is no directive with \\\"exportAs\\\" set to \\\"\" + elOrDirRef.value + \"\\\"\", elOrDirRef.sourceSpan);\n                }\n            }\n            else if (!component) {\n                var /** @type {?} */ refToken = /** @type {?} */ ((null));\n                if (isTemplateElement) {\n                    refToken = createTokenForExternalReference(_this.reflector, Identifiers.TemplateRef);\n                }\n                targetReferences.push(new ReferenceAst(elOrDirRef.name, refToken, elOrDirRef.sourceSpan));\n            }\n        });\n        return directiveAsts;\n    };\n    /**\n     * @param {?} directiveProperties\n     * @param {?} boundProps\n     * @param {?} targetBoundDirectiveProps\n     * @param {?} targetBoundDirectivePropNames\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._createDirectivePropertyAsts = /**\n     * @param {?} directiveProperties\n     * @param {?} boundProps\n     * @param {?} targetBoundDirectiveProps\n     * @param {?} targetBoundDirectivePropNames\n     * @return {?}\n     */\n    function (directiveProperties, boundProps, targetBoundDirectiveProps, targetBoundDirectivePropNames) {\n        if (directiveProperties) {\n            var /** @type {?} */ boundPropsByName_1 = new Map();\n            boundProps.forEach(function (boundProp) {\n                var /** @type {?} */ prevValue = boundPropsByName_1.get(boundProp.name);\n                if (!prevValue || prevValue.isLiteral) {\n                    // give [a]=\"b\" a higher precedence than a=\"b\" on the same element\n                    // give [a]=\"b\" a higher precedence than a=\"b\" on the same element\n                    boundPropsByName_1.set(boundProp.name, boundProp);\n                }\n            });\n            Object.keys(directiveProperties).forEach(function (dirProp) {\n                var /** @type {?} */ elProp = directiveProperties[dirProp];\n                var /** @type {?} */ boundProp = boundPropsByName_1.get(elProp);\n                // Bindings are optional, so this binding only needs to be set up if an expression is given.\n                if (boundProp) {\n                    targetBoundDirectivePropNames.add(boundProp.name);\n                    if (!isEmptyExpression(boundProp.expression)) {\n                        targetBoundDirectiveProps.push(new BoundDirectivePropertyAst(dirProp, boundProp.name, boundProp.expression, boundProp.sourceSpan));\n                    }\n                }\n            });\n        }\n    };\n    /**\n     * @param {?} elementName\n     * @param {?} props\n     * @param {?} boundDirectivePropNames\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._createElementPropertyAsts = /**\n     * @param {?} elementName\n     * @param {?} props\n     * @param {?} boundDirectivePropNames\n     * @return {?}\n     */\n    function (elementName, props, boundDirectivePropNames) {\n        var _this = this;\n        var /** @type {?} */ boundElementProps = [];\n        props.forEach(function (prop) {\n            if (!prop.isLiteral && !boundDirectivePropNames.has(prop.name)) {\n                boundElementProps.push(_this._bindingParser.createElementPropertyAst(elementName, prop));\n            }\n        });\n        return this._checkPropertiesInSchema(elementName, boundElementProps);\n    };\n    /**\n     * @param {?} directives\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._findComponentDirectives = /**\n     * @param {?} directives\n     * @return {?}\n     */\n    function (directives) {\n        return directives.filter(function (directive) { return directive.directive.isComponent; });\n    };\n    /**\n     * @param {?} directives\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._findComponentDirectiveNames = /**\n     * @param {?} directives\n     * @return {?}\n     */\n    function (directives) {\n        return this._findComponentDirectives(directives)\n            .map(function (directive) { return ((identifierName(directive.directive.type))); });\n    };\n    /**\n     * @param {?} directives\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._assertOnlyOneComponent = /**\n     * @param {?} directives\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (directives, sourceSpan) {\n        var /** @type {?} */ componentTypeNames = this._findComponentDirectiveNames(directives);\n        if (componentTypeNames.length > 1) {\n            this._reportError(\"More than one component matched on this element.\\n\" +\n                \"Make sure that only one component's selector can match a given element.\\n\" +\n                (\"Conflicting components: \" + componentTypeNames.join(',')), sourceSpan);\n        }\n    };\n    /**\n     * Make sure that non-angular tags conform to the schemas.\n     *\n     * Note: An element is considered an angular tag when at least one directive selector matches the\n     * tag name.\n     *\n     * @param {?} matchElement Whether any directive has matched on the tag name\n     * @param {?} element the html element\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._assertElementExists = /**\n     * Make sure that non-angular tags conform to the schemas.\n     *\n     * Note: An element is considered an angular tag when at least one directive selector matches the\n     * tag name.\n     *\n     * @param {?} matchElement Whether any directive has matched on the tag name\n     * @param {?} element the html element\n     * @return {?}\n     */\n    function (matchElement, element) {\n        var /** @type {?} */ elName = element.name.replace(/^:xhtml:/, '');\n        if (!matchElement && !this._schemaRegistry.hasElement(elName, this._schemas)) {\n            var /** @type {?} */ errorMsg = \"'\" + elName + \"' is not a known element:\\n\";\n            errorMsg +=\n                \"1. If '\" + elName + \"' is an Angular component, then verify that it is part of this module.\\n\";\n            if (elName.indexOf('-') > -1) {\n                errorMsg +=\n                    \"2. If '\" + elName + \"' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the '@NgModule.schemas' of this component to suppress this message.\";\n            }\n            else {\n                errorMsg +=\n                    \"2. To allow any element add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component.\";\n            }\n            this._reportError(errorMsg, /** @type {?} */ ((element.sourceSpan)));\n        }\n    };\n    /**\n     * @param {?} directives\n     * @param {?} elementProps\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._assertNoComponentsNorElementBindingsOnTemplate = /**\n     * @param {?} directives\n     * @param {?} elementProps\n     * @param {?} sourceSpan\n     * @return {?}\n     */\n    function (directives, elementProps, sourceSpan) {\n        var _this = this;\n        var /** @type {?} */ componentTypeNames = this._findComponentDirectiveNames(directives);\n        if (componentTypeNames.length > 0) {\n            this._reportError(\"Components on an embedded template: \" + componentTypeNames.join(','), sourceSpan);\n        }\n        elementProps.forEach(function (prop) {\n            _this._reportError(\"Property binding \" + prop.name + \" not used by any directive on an embedded template. Make sure that the property name is spelled correctly and all directives are listed in the \\\"@NgModule.declarations\\\".\", sourceSpan);\n        });\n    };\n    /**\n     * @param {?} directives\n     * @param {?} events\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._assertAllEventsPublishedByDirectives = /**\n     * @param {?} directives\n     * @param {?} events\n     * @return {?}\n     */\n    function (directives, events) {\n        var _this = this;\n        var /** @type {?} */ allDirectiveEvents = new Set();\n        directives.forEach(function (directive) {\n            Object.keys(directive.directive.outputs).forEach(function (k) {\n                var /** @type {?} */ eventName = directive.directive.outputs[k];\n                allDirectiveEvents.add(eventName);\n            });\n        });\n        events.forEach(function (event) {\n            if (event.target != null || !allDirectiveEvents.has(event.name)) {\n                _this._reportError(\"Event binding \" + event.fullName + \" not emitted by any directive on an embedded template. Make sure that the event name is spelled correctly and all directives are listed in the \\\"@NgModule.declarations\\\".\", event.sourceSpan);\n            }\n        });\n    };\n    /**\n     * @param {?} elementName\n     * @param {?} boundProps\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._checkPropertiesInSchema = /**\n     * @param {?} elementName\n     * @param {?} boundProps\n     * @return {?}\n     */\n    function (elementName, boundProps) {\n        var _this = this;\n        // Note: We can't filter out empty expressions before this method,\n        // as we still want to validate them!\n        return boundProps.filter(function (boundProp) {\n            if (boundProp.type === PropertyBindingType.Property &&\n                !_this._schemaRegistry.hasProperty(elementName, boundProp.name, _this._schemas)) {\n                var /** @type {?} */ errorMsg = \"Can't bind to '\" + boundProp.name + \"' since it isn't a known property of '\" + elementName + \"'.\";\n                if (elementName.startsWith('ng-')) {\n                    errorMsg +=\n                        \"\\n1. If '\" + boundProp.name + \"' is an Angular directive, then add 'CommonModule' to the '@NgModule.imports' of this component.\" +\n                            \"\\n2. To allow any property add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component.\";\n                }\n                else if (elementName.indexOf('-') > -1) {\n                    errorMsg +=\n                        \"\\n1. If '\" + elementName + \"' is an Angular component and it has '\" + boundProp.name + \"' input, then verify that it is part of this module.\" +\n                            (\"\\n2. If '\" + elementName + \"' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the '@NgModule.schemas' of this component to suppress this message.\") +\n                            \"\\n3. To allow any property add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component.\";\n                }\n                _this._reportError(errorMsg, boundProp.sourceSpan);\n            }\n            return !isEmptyExpression(boundProp.value);\n        });\n    };\n    /**\n     * @param {?} message\n     * @param {?} sourceSpan\n     * @param {?=} level\n     * @return {?}\n     */\n    TemplateParseVisitor.prototype._reportError = /**\n     * @param {?} message\n     * @param {?} sourceSpan\n     * @param {?=} level\n     * @return {?}\n     */\n    function (message, sourceSpan, level) {\n        if (level === void 0) { level = ParseErrorLevel.ERROR; }\n        this._targetErrors.push(new ParseError(sourceSpan, message, level));\n    };\n    return TemplateParseVisitor;\n}());\nvar NonBindableVisitor = /** @class */ (function () {\n    function NonBindableVisitor() {\n    }\n    /**\n     * @param {?} ast\n     * @param {?} parent\n     * @return {?}\n     */\n    NonBindableVisitor.prototype.visitElement = /**\n     * @param {?} ast\n     * @param {?} parent\n     * @return {?}\n     */\n    function (ast, parent) {\n        var /** @type {?} */ preparsedElement = preparseElement(ast);\n        if (preparsedElement.type === PreparsedElementType.SCRIPT ||\n            preparsedElement.type === PreparsedElementType.STYLE ||\n            preparsedElement.type === PreparsedElementType.STYLESHEET) {\n            // Skipping <script> for security reasons\n            // Skipping <style> and stylesheets as we already processed them\n            // in the StyleCompiler\n            return null;\n        }\n        var /** @type {?} */ attrNameAndValues = ast.attrs.map(function (attr) { return [attr.name, attr.value]; });\n        var /** @type {?} */ selector = createElementCssSelector(ast.name, attrNameAndValues);\n        var /** @type {?} */ ngContentIndex = parent.findNgContentIndex(selector);\n        var /** @type {?} */ children = visitAll(this, ast.children, EMPTY_ELEMENT_CONTEXT);\n        return new ElementAst(ast.name, visitAll(this, ast.attrs), [], [], [], [], [], false, [], children, ngContentIndex, ast.sourceSpan, ast.endSourceSpan);\n    };\n    /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    NonBindableVisitor.prototype.visitComment = /**\n     * @param {?} comment\n     * @param {?} context\n     * @return {?}\n     */\n    function (comment, context) { return null; };\n    /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    NonBindableVisitor.prototype.visitAttribute = /**\n     * @param {?} attribute\n     * @param {?} context\n     * @return {?}\n     */\n    function (attribute, context) {\n        return new AttrAst(attribute.name, attribute.value, attribute.sourceSpan);\n    };\n    /**\n     * @param {?} text\n     * @param {?} parent\n     * @return {?}\n     */\n    NonBindableVisitor.prototype.visitText = /**\n     * @param {?} text\n     * @param {?} parent\n     * @return {?}\n     */\n    function (text, parent) {\n        var /** @type {?} */ ngContentIndex = /** @type {?} */ ((parent.findNgContentIndex(TEXT_CSS_SELECTOR)));\n        return new TextAst(text.value, ngContentIndex, /** @type {?} */ ((text.sourceSpan)));\n    };\n    /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    NonBindableVisitor.prototype.visitExpansion = /**\n     * @param {?} expansion\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansion, context) { return expansion; };\n    /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    NonBindableVisitor.prototype.visitExpansionCase = /**\n     * @param {?} expansionCase\n     * @param {?} context\n     * @return {?}\n     */\n    function (expansionCase, context) { return expansionCase; };\n    return NonBindableVisitor;\n}());\n/**\n * A reference to an element or directive in a template. E.g., the reference in this template:\n *\n * <div #myMenu=\"coolMenu\">\n *\n * would be {name: 'myMenu', value: 'coolMenu', sourceSpan: ...}\n */\nvar ElementOrDirectiveRef = /** @class */ (function () {\n    function ElementOrDirectiveRef(name, value, sourceSpan) {\n        this.name = name;\n        this.value = value;\n        this.sourceSpan = sourceSpan;\n    }\n    /** Gets whether this is a reference to the given directive. */\n    /**\n     * Gets whether this is a reference to the given directive.\n     * @param {?} directive\n     * @return {?}\n     */\n    ElementOrDirectiveRef.prototype.isReferenceToDirective = /**\n     * Gets whether this is a reference to the given directive.\n     * @param {?} directive\n     * @return {?}\n     */\n    function (directive) {\n        return splitExportAs(directive.exportAs).indexOf(this.value) !== -1;\n    };\n    return ElementOrDirectiveRef;\n}());\n/**\n * Splits a raw, potentially comma-delimted `exportAs` value into an array of names.\n * @param {?} exportAs\n * @return {?}\n */\nfunction splitExportAs(exportAs) {\n    return exportAs ? exportAs.split(',').map(function (e) { return e.trim(); }) : [];\n}\n/**\n * @param {?} classAttrValue\n * @return {?}\n */\nfunction splitClasses(classAttrValue) {\n    return classAttrValue.trim().split(/\\s+/g);\n}\nvar ElementContext = /** @class */ (function () {\n    function ElementContext(isTemplateElement, _ngContentIndexMatcher, _wildcardNgContentIndex, providerContext) {\n        this.isTemplateElement = isTemplateElement;\n        this._ngContentIndexMatcher = _ngContentIndexMatcher;\n        this._wildcardNgContentIndex = _wildcardNgContentIndex;\n        this.providerContext = providerContext;\n    }\n    /**\n     * @param {?} isTemplateElement\n     * @param {?} directives\n     * @param {?} providerContext\n     * @return {?}\n     */\n    ElementContext.create = /**\n     * @param {?} isTemplateElement\n     * @param {?} directives\n     * @param {?} providerContext\n     * @return {?}\n     */\n    function (isTemplateElement, directives, providerContext) {\n        var /** @type {?} */ matcher = new SelectorMatcher();\n        var /** @type {?} */ wildcardNgContentIndex = /** @type {?} */ ((null));\n        var /** @type {?} */ component = directives.find(function (directive) { return directive.directive.isComponent; });\n        if (component) {\n            var /** @type {?} */ ngContentSelectors = /** @type {?} */ ((component.directive.template)).ngContentSelectors;\n            for (var /** @type {?} */ i = 0; i < ngContentSelectors.length; i++) {\n                var /** @type {?} */ selector = ngContentSelectors[i];\n                if (selector === '*') {\n                    wildcardNgContentIndex = i;\n                }\n                else {\n                    matcher.addSelectables(CssSelector.parse(ngContentSelectors[i]), i);\n                }\n            }\n        }\n        return new ElementContext(isTemplateElement, matcher, wildcardNgContentIndex, providerContext);\n    };\n    /**\n     * @param {?} selector\n     * @return {?}\n     */\n    ElementContext.prototype.findNgContentIndex = /**\n     * @param {?} selector\n     * @return {?}\n     */\n    function (selector) {\n        var /** @type {?} */ ngContentIndices = [];\n        this._ngContentIndexMatcher.match(selector, function (selector, ngContentIndex) { ngContentIndices.push(ngContentIndex); });\n        ngContentIndices.sort();\n        if (this._wildcardNgContentIndex != null) {\n            ngContentIndices.push(this._wildcardNgContentIndex);\n        }\n        return ngContentIndices.length > 0 ? ngContentIndices[0] : null;\n    };\n    return ElementContext;\n}());\n/**\n * @param {?} elementName\n * @param {?} attributes\n * @return {?}\n */\nfunction createElementCssSelector(elementName, attributes) {\n    var /** @type {?} */ cssSelector = new CssSelector();\n    var /** @type {?} */ elNameNoNs = splitNsName(elementName)[1];\n    cssSelector.setElement(elNameNoNs);\n    for (var /** @type {?} */ i = 0; i < attributes.length; i++) {\n        var /** @type {?} */ attrName = attributes[i][0];\n        var /** @type {?} */ attrNameNoNs = splitNsName(attrName)[1];\n        var /** @type {?} */ attrValue = attributes[i][1];\n        cssSelector.addAttribute(attrNameNoNs, attrValue);\n        if (attrName.toLowerCase() == CLASS_ATTR) {\n            var /** @type {?} */ classes = splitClasses(attrValue);\n            classes.forEach(function (className) { return cssSelector.addClassName(className); });\n        }\n    }\n    return cssSelector;\n}\nvar EMPTY_ELEMENT_CONTEXT = new ElementContext(true, new SelectorMatcher(), null, null);\nvar NON_BINDABLE_VISITOR = new NonBindableVisitor();\n/**\n * @param {?} node\n * @return {?}\n */\nfunction _isEmptyTextNode(node) {\n    return node instanceof Text && node.value.trim().length == 0;\n}\n/**\n * @template T\n * @param {?} items\n * @return {?}\n */\nfunction removeSummaryDuplicates(items) {\n    var /** @type {?} */ map = new Map();\n    items.forEach(function (item) {\n        if (!map.get(item.type.reference)) {\n            map.set(item.type.reference, item);\n        }\n    });\n    return Array.from(map.values());\n}\n/**\n * @param {?} ast\n * @return {?}\n */\nfunction isEmptyExpression(ast) {\n    if (ast instanceof ASTWithSource) {\n        ast = ast.ast;\n    }\n    return ast instanceof EmptyExpr;\n}\n/**\n * @param {?} el\n * @param {?} enableLegacyTemplate\n * @param {?} reportDeprecation\n * @return {?}\n */\nfunction isTemplate(el, enableLegacyTemplate, reportDeprecation) {\n    if (isNgTemplate(el.name))\n        return true;\n    var /** @type {?} */ tagNoNs = splitNsName(el.name)[1];\n    // `<template>` is HTML and case insensitive\n    if (tagNoNs.toLowerCase() === TEMPLATE_ELEMENT) {\n        if (enableLegacyTemplate && tagNoNs.toLowerCase() === TEMPLATE_ELEMENT) {\n            reportDeprecation(TEMPLATE_ELEMENT_DEPRECATION_WARNING, /** @type {?} */ ((el.sourceSpan)));\n            return true;\n        }\n    }\n    return false;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar EventHandlerVars = /** @class */ (function () {\n    function EventHandlerVars() {\n    }\n    EventHandlerVars.event = variable('$event');\n    return EventHandlerVars;\n}());\n/**\n * @record\n */\n\nvar ConvertActionBindingResult = /** @class */ (function () {\n    function ConvertActionBindingResult(stmts, allowDefault) {\n        this.stmts = stmts;\n        this.allowDefault = allowDefault;\n    }\n    return ConvertActionBindingResult;\n}());\n/**\n * Converts the given expression AST into an executable output AST, assuming the expression is\n * used in an action binding (e.g. an event handler).\n * @param {?} localResolver\n * @param {?} implicitReceiver\n * @param {?} action\n * @param {?} bindingId\n * @return {?}\n */\nfunction convertActionBinding(localResolver, implicitReceiver, action, bindingId) {\n    if (!localResolver) {\n        localResolver = new DefaultLocalResolver();\n    }\n    var /** @type {?} */ actionWithoutBuiltins = convertPropertyBindingBuiltins({\n        createLiteralArrayConverter: function (argCount) {\n            // Note: no caching for literal arrays in actions.\n            return function (args) { return literalArr(args); };\n        },\n        createLiteralMapConverter: function (keys) {\n            // Note: no caching for literal maps in actions.\n            return function (values) {\n                var /** @type {?} */ entries = keys.map(function (k, i) {\n                    return ({\n                        key: k.key,\n                        value: values[i],\n                        quoted: k.quoted,\n                    });\n                });\n                return literalMap(entries);\n            };\n        },\n        createPipeConverter: function (name) {\n            throw new Error(\"Illegal State: Actions are not allowed to contain pipes. Pipe: \" + name);\n        }\n    }, action);\n    var /** @type {?} */ visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId);\n    var /** @type {?} */ actionStmts = [];\n    flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);\n    prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);\n    var /** @type {?} */ lastIndex = actionStmts.length - 1;\n    var /** @type {?} */ preventDefaultVar = /** @type {?} */ ((null));\n    if (lastIndex >= 0) {\n        var /** @type {?} */ lastStatement = actionStmts[lastIndex];\n        var /** @type {?} */ returnExpr = convertStmtIntoExpression(lastStatement);\n        if (returnExpr) {\n            // Note: We need to cast the result of the method call to dynamic,\n            // as it might be a void method!\n            preventDefaultVar = createPreventDefaultVar(bindingId);\n            actionStmts[lastIndex] =\n                preventDefaultVar.set(returnExpr.cast(DYNAMIC_TYPE).notIdentical(literal(false)))\n                    .toDeclStmt(null, [StmtModifier.Final]);\n        }\n    }\n    return new ConvertActionBindingResult(actionStmts, preventDefaultVar);\n}\n/**\n * @record\n */\n\n/**\n * @record\n */\n\n/**\n * @param {?} converterFactory\n * @param {?} ast\n * @return {?}\n */\nfunction convertPropertyBindingBuiltins(converterFactory, ast) {\n    return convertBuiltins(converterFactory, ast);\n}\nvar ConvertPropertyBindingResult = /** @class */ (function () {\n    function ConvertPropertyBindingResult(stmts, currValExpr) {\n        this.stmts = stmts;\n        this.currValExpr = currValExpr;\n    }\n    return ConvertPropertyBindingResult;\n}());\n/** @enum {number} */\nvar BindingForm = {\n    // The general form of binding expression, supports all expressions.\n    General: 0,\n    // Try to generate a simple binding (no temporaries or statements)\n    // otherise generate a general binding\n    TrySimple: 1,\n};\nBindingForm[BindingForm.General] = \"General\";\nBindingForm[BindingForm.TrySimple] = \"TrySimple\";\n/**\n * Converts the given expression AST into an executable output AST, assuming the expression\n * is used in property binding. The expression has to be preprocessed via\n * `convertPropertyBindingBuiltins`.\n * @param {?} localResolver\n * @param {?} implicitReceiver\n * @param {?} expressionWithoutBuiltins\n * @param {?} bindingId\n * @param {?} form\n * @return {?}\n */\nfunction convertPropertyBinding(localResolver, implicitReceiver, expressionWithoutBuiltins, bindingId, form) {\n    if (!localResolver) {\n        localResolver = new DefaultLocalResolver();\n    }\n    var /** @type {?} */ currValExpr = createCurrValueExpr(bindingId);\n    var /** @type {?} */ stmts = [];\n    var /** @type {?} */ visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId);\n    var /** @type {?} */ outputExpr = expressionWithoutBuiltins.visit(visitor, _Mode.Expression);\n    if (visitor.temporaryCount) {\n        for (var /** @type {?} */ i = 0; i < visitor.temporaryCount; i++) {\n            stmts.push(temporaryDeclaration(bindingId, i));\n        }\n    }\n    else if (form == BindingForm.TrySimple) {\n        return new ConvertPropertyBindingResult([], outputExpr);\n    }\n    stmts.push(currValExpr.set(outputExpr).toDeclStmt(DYNAMIC_TYPE, [StmtModifier.Final]));\n    return new ConvertPropertyBindingResult(stmts, currValExpr);\n}\n/**\n * @param {?} converterFactory\n * @param {?} ast\n * @return {?}\n */\nfunction convertBuiltins(converterFactory, ast) {\n    var /** @type {?} */ visitor = new _BuiltinAstConverter(converterFactory);\n    return ast.visit(visitor);\n}\n/**\n * @param {?} bindingId\n * @param {?} temporaryNumber\n * @return {?}\n */\nfunction temporaryName(bindingId, temporaryNumber) {\n    return \"tmp_\" + bindingId + \"_\" + temporaryNumber;\n}\n/**\n * @param {?} bindingId\n * @param {?} temporaryNumber\n * @return {?}\n */\nfunction temporaryDeclaration(bindingId, temporaryNumber) {\n    return new DeclareVarStmt(temporaryName(bindingId, temporaryNumber), NULL_EXPR);\n}\n/**\n * @param {?} temporaryCount\n * @param {?} bindingId\n * @param {?} statements\n * @return {?}\n */\nfunction prependTemporaryDecls(temporaryCount, bindingId, statements) {\n    for (var /** @type {?} */ i = temporaryCount - 1; i >= 0; i--) {\n        statements.unshift(temporaryDeclaration(bindingId, i));\n    }\n}\n/** @enum {number} */\nvar _Mode = {\n    Statement: 0,\n    Expression: 1,\n};\n_Mode[_Mode.Statement] = \"Statement\";\n_Mode[_Mode.Expression] = \"Expression\";\n/**\n * @param {?} mode\n * @param {?} ast\n * @return {?}\n */\nfunction ensureStatementMode(mode, ast) {\n    if (mode !== _Mode.Statement) {\n        throw new Error(\"Expected a statement, but saw \" + ast);\n    }\n}\n/**\n * @param {?} mode\n * @param {?} ast\n * @return {?}\n */\nfunction ensureExpressionMode(mode, ast) {\n    if (mode !== _Mode.Expression) {\n        throw new Error(\"Expected an expression, but saw \" + ast);\n    }\n}\n/**\n * @param {?} mode\n * @param {?} expr\n * @return {?}\n */\nfunction convertToStatementIfNeeded(mode, expr) {\n    if (mode === _Mode.Statement) {\n        return expr.toStmt();\n    }\n    else {\n        return expr;\n    }\n}\nvar _BuiltinAstConverter = /** @class */ (function (_super) {\n    __extends(_BuiltinAstConverter, _super);\n    function _BuiltinAstConverter(_converterFactory) {\n        var _this = _super.call(this) || this;\n        _this._converterFactory = _converterFactory;\n        return _this;\n    }\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    _BuiltinAstConverter.prototype.visitPipe = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        var /** @type {?} */ args = [ast.exp].concat(ast.args).map(function (ast) { return ast.visit(_this, context); });\n        return new BuiltinFunctionCall(ast.span, args, this._converterFactory.createPipeConverter(ast.name, args.length));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    _BuiltinAstConverter.prototype.visitLiteralArray = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        var /** @type {?} */ args = ast.expressions.map(function (ast) { return ast.visit(_this, context); });\n        return new BuiltinFunctionCall(ast.span, args, this._converterFactory.createLiteralArrayConverter(ast.expressions.length));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    _BuiltinAstConverter.prototype.visitLiteralMap = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        var /** @type {?} */ args = ast.values.map(function (ast) { return ast.visit(_this, context); });\n        return new BuiltinFunctionCall(ast.span, args, this._converterFactory.createLiteralMapConverter(ast.keys));\n    };\n    return _BuiltinAstConverter;\n}(AstTransformer));\nvar _AstToIrVisitor = /** @class */ (function () {\n    function _AstToIrVisitor(_localResolver, _implicitReceiver, bindingId) {\n        this._localResolver = _localResolver;\n        this._implicitReceiver = _implicitReceiver;\n        this.bindingId = bindingId;\n        this._nodeMap = new Map();\n        this._resultMap = new Map();\n        this._currentTemporary = 0;\n        this.temporaryCount = 0;\n    }\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitBinary = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        var /** @type {?} */ op;\n        switch (ast.operation) {\n            case '+':\n                op = BinaryOperator.Plus;\n                break;\n            case '-':\n                op = BinaryOperator.Minus;\n                break;\n            case '*':\n                op = BinaryOperator.Multiply;\n                break;\n            case '/':\n                op = BinaryOperator.Divide;\n                break;\n            case '%':\n                op = BinaryOperator.Modulo;\n                break;\n            case '&&':\n                op = BinaryOperator.And;\n                break;\n            case '||':\n                op = BinaryOperator.Or;\n                break;\n            case '==':\n                op = BinaryOperator.Equals;\n                break;\n            case '!=':\n                op = BinaryOperator.NotEquals;\n                break;\n            case '===':\n                op = BinaryOperator.Identical;\n                break;\n            case '!==':\n                op = BinaryOperator.NotIdentical;\n                break;\n            case '<':\n                op = BinaryOperator.Lower;\n                break;\n            case '>':\n                op = BinaryOperator.Bigger;\n                break;\n            case '<=':\n                op = BinaryOperator.LowerEquals;\n                break;\n            case '>=':\n                op = BinaryOperator.BiggerEquals;\n                break;\n            default:\n                throw new Error(\"Unsupported operation \" + ast.operation);\n        }\n        return convertToStatementIfNeeded(mode, new BinaryOperatorExpr(op, this._visit(ast.left, _Mode.Expression), this._visit(ast.right, _Mode.Expression)));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitChain = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        ensureStatementMode(mode, ast);\n        return this.visitAll(ast.expressions, mode);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitConditional = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        var /** @type {?} */ value = this._visit(ast.condition, _Mode.Expression);\n        return convertToStatementIfNeeded(mode, value.conditional(this._visit(ast.trueExp, _Mode.Expression), this._visit(ast.falseExp, _Mode.Expression)));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitPipe = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        throw new Error(\"Illegal state: Pipes should have been converted into functions. Pipe: \" + ast.name);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitFunctionCall = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        var /** @type {?} */ convertedArgs = this.visitAll(ast.args, _Mode.Expression);\n        var /** @type {?} */ fnResult;\n        if (ast instanceof BuiltinFunctionCall) {\n            fnResult = ast.converter(convertedArgs);\n        }\n        else {\n            fnResult = this._visit(/** @type {?} */ ((ast.target)), _Mode.Expression).callFn(convertedArgs);\n        }\n        return convertToStatementIfNeeded(mode, fnResult);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitImplicitReceiver = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        ensureExpressionMode(mode, ast);\n        return this._implicitReceiver;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitInterpolation = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        ensureExpressionMode(mode, ast);\n        var /** @type {?} */ args = [literal(ast.expressions.length)];\n        for (var /** @type {?} */ i = 0; i < ast.strings.length - 1; i++) {\n            args.push(literal(ast.strings[i]));\n            args.push(this._visit(ast.expressions[i], _Mode.Expression));\n        }\n        args.push(literal(ast.strings[ast.strings.length - 1]));\n        return ast.expressions.length <= 9 ?\n            importExpr(Identifiers.inlineInterpolate).callFn(args) :\n            importExpr(Identifiers.interpolate).callFn([args[0], literalArr(args.slice(1))]);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitKeyedRead = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        var /** @type {?} */ leftMostSafe = this.leftMostSafeNode(ast);\n        if (leftMostSafe) {\n            return this.convertSafeAccess(ast, leftMostSafe, mode);\n        }\n        else {\n            return convertToStatementIfNeeded(mode, this._visit(ast.obj, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));\n        }\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitKeyedWrite = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        var /** @type {?} */ obj = this._visit(ast.obj, _Mode.Expression);\n        var /** @type {?} */ key = this._visit(ast.key, _Mode.Expression);\n        var /** @type {?} */ value = this._visit(ast.value, _Mode.Expression);\n        return convertToStatementIfNeeded(mode, obj.key(key).set(value));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitLiteralArray = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        throw new Error(\"Illegal State: literal arrays should have been converted into functions\");\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitLiteralMap = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        throw new Error(\"Illegal State: literal maps should have been converted into functions\");\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitLiteralPrimitive = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        // For literal values of null, undefined, true, or false allow type inteference\n        // to infer the type.\n        var /** @type {?} */ type = ast.value === null || ast.value === undefined || ast.value === true || ast.value === true ?\n            INFERRED_TYPE :\n            undefined;\n        return convertToStatementIfNeeded(mode, literal(ast.value, type));\n    };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype._getLocal = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) { return this._localResolver.getLocal(name); };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitMethodCall = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        if (ast.receiver instanceof ImplicitReceiver && ast.name == '$any') {\n            var /** @type {?} */ args = /** @type {?} */ (this.visitAll(ast.args, _Mode.Expression));\n            if (args.length != 1) {\n                throw new Error(\"Invalid call to $any, expected 1 argument but received \" + (args.length || 'none'));\n            }\n            return (/** @type {?} */ (args[0])).cast(DYNAMIC_TYPE);\n        }\n        var /** @type {?} */ leftMostSafe = this.leftMostSafeNode(ast);\n        if (leftMostSafe) {\n            return this.convertSafeAccess(ast, leftMostSafe, mode);\n        }\n        else {\n            var /** @type {?} */ args = this.visitAll(ast.args, _Mode.Expression);\n            var /** @type {?} */ result = null;\n            var /** @type {?} */ receiver = this._visit(ast.receiver, _Mode.Expression);\n            if (receiver === this._implicitReceiver) {\n                var /** @type {?} */ varExpr = this._getLocal(ast.name);\n                if (varExpr) {\n                    result = varExpr.callFn(args);\n                }\n            }\n            if (result == null) {\n                result = receiver.callMethod(ast.name, args);\n            }\n            return convertToStatementIfNeeded(mode, result);\n        }\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitPrefixNot = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        return convertToStatementIfNeeded(mode, not(this._visit(ast.expression, _Mode.Expression)));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitNonNullAssert = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        return convertToStatementIfNeeded(mode, assertNotNull(this._visit(ast.expression, _Mode.Expression)));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitPropertyRead = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        var /** @type {?} */ leftMostSafe = this.leftMostSafeNode(ast);\n        if (leftMostSafe) {\n            return this.convertSafeAccess(ast, leftMostSafe, mode);\n        }\n        else {\n            var /** @type {?} */ result = null;\n            var /** @type {?} */ receiver = this._visit(ast.receiver, _Mode.Expression);\n            if (receiver === this._implicitReceiver) {\n                result = this._getLocal(ast.name);\n            }\n            if (result == null) {\n                result = receiver.prop(ast.name);\n            }\n            return convertToStatementIfNeeded(mode, result);\n        }\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitPropertyWrite = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        var /** @type {?} */ receiver = this._visit(ast.receiver, _Mode.Expression);\n        if (receiver === this._implicitReceiver) {\n            var /** @type {?} */ varExpr = this._getLocal(ast.name);\n            if (varExpr) {\n                throw new Error('Cannot assign to a reference or variable!');\n            }\n        }\n        return convertToStatementIfNeeded(mode, receiver.prop(ast.name).set(this._visit(ast.value, _Mode.Expression)));\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitSafePropertyRead = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitSafeMethodCall = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);\n    };\n    /**\n     * @param {?} asts\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitAll = /**\n     * @param {?} asts\n     * @param {?} mode\n     * @return {?}\n     */\n    function (asts, mode) {\n        var _this = this;\n        return asts.map(function (ast) { return _this._visit(ast, mode); });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.visitQuote = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        throw new Error(\"Quotes are not supported for evaluation!\\n        Statement: \" + ast.uninterpretedExpression + \" located at \" + ast.location);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype._visit = /**\n     * @param {?} ast\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, mode) {\n        var /** @type {?} */ result = this._resultMap.get(ast);\n        if (result)\n            return result;\n        return (this._nodeMap.get(ast) || ast).visit(this, mode);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} leftMostSafe\n     * @param {?} mode\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.convertSafeAccess = /**\n     * @param {?} ast\n     * @param {?} leftMostSafe\n     * @param {?} mode\n     * @return {?}\n     */\n    function (ast, leftMostSafe, mode) {\n        // If the expression contains a safe access node on the left it needs to be converted to\n        // an expression that guards the access to the member by checking the receiver for blank. As\n        // execution proceeds from left to right, the left most part of the expression must be guarded\n        // first but, because member access is left associative, the right side of the expression is at\n        // the top of the AST. The desired result requires lifting a copy of the the left part of the\n        // expression up to test it for blank before generating the unguarded version.\n        // Consider, for example the following expression: a?.b.c?.d.e\n        // This results in the ast:\n        //         .\n        //        / \\\n        //       ?.   e\n        //      /  \\\n        //     .    d\n        //    / \\\n        //   ?.  c\n        //  /  \\\n        // a    b\n        // The following tree should be generated:\n        //\n        //        /---- ? ----\\\n        //       /      |      \\\n        //     a   /--- ? ---\\  null\n        //        /     |     \\\n        //       .      .     null\n        //      / \\    / \\\n        //     .  c   .   e\n        //    / \\    / \\\n        //   a   b  ,   d\n        //         / \\\n        //        .   c\n        //       / \\\n        //      a   b\n        //\n        // Notice that the first guard condition is the left hand of the left most safe access node\n        // which comes in as leftMostSafe to this routine.\n        var /** @type {?} */ guardedExpression = this._visit(leftMostSafe.receiver, _Mode.Expression);\n        var /** @type {?} */ temporary = /** @type {?} */ ((undefined));\n        if (this.needsTemporary(leftMostSafe.receiver)) {\n            // If the expression has method calls or pipes then we need to save the result into a\n            // temporary variable to avoid calling stateful or impure code more than once.\n            temporary = this.allocateTemporary();\n            // Preserve the result in the temporary variable\n            guardedExpression = temporary.set(guardedExpression);\n            // Ensure all further references to the guarded expression refer to the temporary instead.\n            this._resultMap.set(leftMostSafe.receiver, temporary);\n        }\n        var /** @type {?} */ condition = guardedExpression.isBlank();\n        // Convert the ast to an unguarded access to the receiver's member. The map will substitute\n        // leftMostNode with its unguarded version in the call to `this.visit()`.\n        if (leftMostSafe instanceof SafeMethodCall) {\n            this._nodeMap.set(leftMostSafe, new MethodCall(leftMostSafe.span, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args));\n        }\n        else {\n            this._nodeMap.set(leftMostSafe, new PropertyRead(leftMostSafe.span, leftMostSafe.receiver, leftMostSafe.name));\n        }\n        // Recursively convert the node now without the guarded member access.\n        var /** @type {?} */ access = this._visit(ast, _Mode.Expression);\n        // Remove the mapping. This is not strictly required as the converter only traverses each node\n        // once but is safer if the conversion is changed to traverse the nodes more than once.\n        this._nodeMap.delete(leftMostSafe);\n        // If we allocated a temporary, release it.\n        if (temporary) {\n            this.releaseTemporary(temporary);\n        }\n        // Produce the conditional\n        return convertToStatementIfNeeded(mode, condition.conditional(literal(null), access));\n    };\n    /**\n     * @param {?} ast\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.leftMostSafeNode = /**\n     * @param {?} ast\n     * @return {?}\n     */\n    function (ast) {\n        var _this = this;\n        var /** @type {?} */ visit = function (visitor, ast) {\n            return (_this._nodeMap.get(ast) || ast).visit(visitor);\n        };\n        return ast.visit({\n            visitBinary: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitChain: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitConditional: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitFunctionCall: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitImplicitReceiver: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitInterpolation: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitKeyedRead: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return visit(this, ast.obj); },\n            visitKeyedWrite: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitLiteralArray: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitLiteralMap: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitLiteralPrimitive: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitMethodCall: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return visit(this, ast.receiver); },\n            visitPipe: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitPrefixNot: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitNonNullAssert: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitPropertyRead: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return visit(this, ast.receiver); },\n            visitPropertyWrite: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitQuote: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return null; },\n            visitSafeMethodCall: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return visit(this, ast.receiver) || ast; },\n            visitSafePropertyRead: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) {\n                return visit(this, ast.receiver) || ast;\n            }\n        });\n    };\n    /**\n     * @param {?} ast\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.needsTemporary = /**\n     * @param {?} ast\n     * @return {?}\n     */\n    function (ast) {\n        var _this = this;\n        var /** @type {?} */ visit = function (visitor, ast) {\n            return ast && (_this._nodeMap.get(ast) || ast).visit(visitor);\n        };\n        var /** @type {?} */ visitSome = function (visitor, ast) {\n            return ast.some(function (ast) { return visit(visitor, ast); });\n        };\n        return ast.visit({\n            visitBinary: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return visit(this, ast.left) || visit(this, ast.right); },\n            visitChain: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; },\n            visitConditional: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) {\n                return visit(this, ast.condition) || visit(this, ast.trueExp) ||\n                    visit(this, ast.falseExp);\n            },\n            visitFunctionCall: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return true; },\n            visitImplicitReceiver: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; },\n            visitInterpolation: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return visitSome(this, ast.expressions); },\n            visitKeyedRead: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; },\n            visitKeyedWrite: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; },\n            visitLiteralArray: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return true; },\n            visitLiteralMap: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return true; },\n            visitLiteralPrimitive: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; },\n            visitMethodCall: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return true; },\n            visitPipe: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return true; },\n            visitPrefixNot: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return visit(this, ast.expression); },\n            visitNonNullAssert: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return visit(this, ast.expression); },\n            visitPropertyRead: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; },\n            visitPropertyWrite: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; },\n            visitQuote: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; },\n            visitSafeMethodCall: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return true; },\n            visitSafePropertyRead: /**\n             * @param {?} ast\n             * @return {?}\n             */\n            function (ast) { return false; }\n        });\n    };\n    /**\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.allocateTemporary = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ tempNumber = this._currentTemporary++;\n        this.temporaryCount = Math.max(this._currentTemporary, this.temporaryCount);\n        return new ReadVarExpr(temporaryName(this.bindingId, tempNumber));\n    };\n    /**\n     * @param {?} temporary\n     * @return {?}\n     */\n    _AstToIrVisitor.prototype.releaseTemporary = /**\n     * @param {?} temporary\n     * @return {?}\n     */\n    function (temporary) {\n        this._currentTemporary--;\n        if (temporary.name != temporaryName(this.bindingId, this._currentTemporary)) {\n            throw new Error(\"Temporary \" + temporary.name + \" released out of order\");\n        }\n    };\n    return _AstToIrVisitor;\n}());\n/**\n * @param {?} arg\n * @param {?} output\n * @return {?}\n */\nfunction flattenStatements(arg, output) {\n    if (Array.isArray(arg)) {\n        (/** @type {?} */ (arg)).forEach(function (entry) { return flattenStatements(entry, output); });\n    }\n    else {\n        output.push(arg);\n    }\n}\nvar DefaultLocalResolver = /** @class */ (function () {\n    function DefaultLocalResolver() {\n    }\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    DefaultLocalResolver.prototype.getLocal = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        if (name === EventHandlerVars.event.name) {\n            return EventHandlerVars.event;\n        }\n        return null;\n    };\n    return DefaultLocalResolver;\n}());\n/**\n * @param {?} bindingId\n * @return {?}\n */\nfunction createCurrValueExpr(bindingId) {\n    return variable(\"currVal_\" + bindingId); // fix syntax highlighting: `\n}\n/**\n * @param {?} bindingId\n * @return {?}\n */\nfunction createPreventDefaultVar(bindingId) {\n    return variable(\"pd_\" + bindingId);\n}\n/**\n * @param {?} stmt\n * @return {?}\n */\nfunction convertStmtIntoExpression(stmt) {\n    if (stmt instanceof ExpressionStatement) {\n        return stmt.expr;\n    }\n    else if (stmt instanceof ReturnStatement) {\n        return stmt.value;\n    }\n    return null;\n}\nvar BuiltinFunctionCall = /** @class */ (function (_super) {\n    __extends(BuiltinFunctionCall, _super);\n    function BuiltinFunctionCall(span, args, converter) {\n        var _this = _super.call(this, span, null, args) || this;\n        _this.args = args;\n        _this.converter = converter;\n        return _this;\n    }\n    return BuiltinFunctionCall;\n}(FunctionCall));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Generates code that is used to type check templates.\n */\nvar TypeCheckCompiler = /** @class */ (function () {\n    function TypeCheckCompiler(options, reflector) {\n        this.options = options;\n        this.reflector = reflector;\n    }\n    /**\n     * Important notes:\n     * - This must not produce new `import` statements, but only refer to types outside\n     *   of the file via the variables provided via externalReferenceVars.\n     *   This allows Typescript to reuse the old program's structure as no imports have changed.\n     * - This must not produce any exports, as this would pollute the .d.ts file\n     *   and also violate the point above.\n     */\n    /**\n     * Important notes:\n     * - This must not produce new `import` statements, but only refer to types outside\n     *   of the file via the variables provided via externalReferenceVars.\n     *   This allows Typescript to reuse the old program's structure as no imports have changed.\n     * - This must not produce any exports, as this would pollute the .d.ts file\n     *   and also violate the point above.\n     * @param {?} componentId\n     * @param {?} component\n     * @param {?} template\n     * @param {?} usedPipes\n     * @param {?} externalReferenceVars\n     * @param {?} ctx\n     * @return {?}\n     */\n    TypeCheckCompiler.prototype.compileComponent = /**\n     * Important notes:\n     * - This must not produce new `import` statements, but only refer to types outside\n     *   of the file via the variables provided via externalReferenceVars.\n     *   This allows Typescript to reuse the old program's structure as no imports have changed.\n     * - This must not produce any exports, as this would pollute the .d.ts file\n     *   and also violate the point above.\n     * @param {?} componentId\n     * @param {?} component\n     * @param {?} template\n     * @param {?} usedPipes\n     * @param {?} externalReferenceVars\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (componentId, component, template, usedPipes, externalReferenceVars, ctx) {\n        var _this = this;\n        var /** @type {?} */ pipes = new Map();\n        usedPipes.forEach(function (p) { return pipes.set(p.name, p.type.reference); });\n        var /** @type {?} */ embeddedViewCount = 0;\n        var /** @type {?} */ viewBuilderFactory = function (parent, guards) {\n            var /** @type {?} */ embeddedViewIndex = embeddedViewCount++;\n            return new ViewBuilder(_this.options, _this.reflector, externalReferenceVars, parent, component.type.reference, component.isHost, embeddedViewIndex, pipes, guards, ctx, viewBuilderFactory);\n        };\n        var /** @type {?} */ visitor = viewBuilderFactory(null, []);\n        visitor.visitAll([], template);\n        return visitor.build(componentId);\n    };\n    return TypeCheckCompiler;\n}());\nvar DYNAMIC_VAR_NAME = '_any';\nvar TypeCheckLocalResolver = /** @class */ (function () {\n    function TypeCheckLocalResolver() {\n    }\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    TypeCheckLocalResolver.prototype.getLocal = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        if (name === EventHandlerVars.event.name) {\n            // References to the event should not be type-checked.\n            // TODO(chuckj): determine a better type for the event.\n            return variable(DYNAMIC_VAR_NAME);\n        }\n        return null;\n    };\n    return TypeCheckLocalResolver;\n}());\nvar defaultResolver = new TypeCheckLocalResolver();\nvar ViewBuilder = /** @class */ (function () {\n    function ViewBuilder(options, reflector, externalReferenceVars, parent, component, isHostComponent, embeddedViewIndex, pipes, guards, ctx, viewBuilderFactory) {\n        this.options = options;\n        this.reflector = reflector;\n        this.externalReferenceVars = externalReferenceVars;\n        this.parent = parent;\n        this.component = component;\n        this.isHostComponent = isHostComponent;\n        this.embeddedViewIndex = embeddedViewIndex;\n        this.pipes = pipes;\n        this.guards = guards;\n        this.ctx = ctx;\n        this.viewBuilderFactory = viewBuilderFactory;\n        this.refOutputVars = new Map();\n        this.variables = [];\n        this.children = [];\n        this.updates = [];\n        this.actions = [];\n    }\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    ViewBuilder.prototype.getOutputVar = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ varName;\n        if (type === this.component && this.isHostComponent) {\n            varName = DYNAMIC_VAR_NAME;\n        }\n        else if (type instanceof StaticSymbol) {\n            varName = this.externalReferenceVars.get(type);\n        }\n        else {\n            varName = DYNAMIC_VAR_NAME;\n        }\n        if (!varName) {\n            throw new Error(\"Illegal State: referring to a type without a variable \" + JSON.stringify(type));\n        }\n        return varName;\n    };\n    /**\n     * @param {?} ast\n     * @return {?}\n     */\n    ViewBuilder.prototype.getTypeGuardExpressions = /**\n     * @param {?} ast\n     * @return {?}\n     */\n    function (ast) {\n        var /** @type {?} */ result = this.guards.slice();\n        for (var _i = 0, _a = ast.directives; _i < _a.length; _i++) {\n            var directive = _a[_i];\n            for (var _b = 0, _c = directive.inputs; _b < _c.length; _b++) {\n                var input = _c[_b];\n                var /** @type {?} */ guard = directive.directive.guards[input.directiveName];\n                if (guard) {\n                    var /** @type {?} */ useIf = guard === 'UseIf';\n                    result.push({\n                        guard: guard,\n                        useIf: useIf,\n                        expression: /** @type {?} */ ({ context: this.component, value: input.value })\n                    });\n                }\n            }\n        }\n        return result;\n    };\n    /**\n     * @param {?} variables\n     * @param {?} astNodes\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitAll = /**\n     * @param {?} variables\n     * @param {?} astNodes\n     * @return {?}\n     */\n    function (variables, astNodes) {\n        this.variables = variables;\n        templateVisitAll(this, astNodes);\n    };\n    /**\n     * @param {?} componentId\n     * @param {?=} targetStatements\n     * @return {?}\n     */\n    ViewBuilder.prototype.build = /**\n     * @param {?} componentId\n     * @param {?=} targetStatements\n     * @return {?}\n     */\n    function (componentId, targetStatements) {\n        var _this = this;\n        if (targetStatements === void 0) { targetStatements = []; }\n        this.children.forEach(function (child) { return child.build(componentId, targetStatements); });\n        var /** @type {?} */ viewStmts = [variable(DYNAMIC_VAR_NAME).set(NULL_EXPR).toDeclStmt(DYNAMIC_TYPE)];\n        var /** @type {?} */ bindingCount = 0;\n        this.updates.forEach(function (expression) {\n            var _a = _this.preprocessUpdateExpression(expression), sourceSpan = _a.sourceSpan, context = _a.context, value = _a.value;\n            var /** @type {?} */ bindingId = \"\" + bindingCount++;\n            var /** @type {?} */ nameResolver = context === _this.component ? _this : defaultResolver;\n            var _b = convertPropertyBinding(nameResolver, variable(_this.getOutputVar(context)), value, bindingId, BindingForm.General), stmts = _b.stmts, currValExpr = _b.currValExpr;\n            stmts.push(new ExpressionStatement(currValExpr));\n            viewStmts.push.apply(viewStmts, stmts.map(function (stmt) { return applySourceSpanToStatementIfNeeded(stmt, sourceSpan); }));\n        });\n        this.actions.forEach(function (_a) {\n            var sourceSpan = _a.sourceSpan, context = _a.context, value = _a.value;\n            var /** @type {?} */ bindingId = \"\" + bindingCount++;\n            var /** @type {?} */ nameResolver = context === _this.component ? _this : defaultResolver;\n            var stmts = convertActionBinding(nameResolver, variable(_this.getOutputVar(context)), value, bindingId).stmts;\n            viewStmts.push.apply(viewStmts, stmts.map(function (stmt) { return applySourceSpanToStatementIfNeeded(stmt, sourceSpan); }));\n        });\n        if (this.guards.length) {\n            var /** @type {?} */ guardExpression = undefined;\n            for (var _i = 0, _a = this.guards; _i < _a.length; _i++) {\n                var guard = _a[_i];\n                var _b = this.preprocessUpdateExpression(guard.expression), context = _b.context, value = _b.value;\n                var /** @type {?} */ bindingId = \"\" + bindingCount++;\n                var /** @type {?} */ nameResolver = context === this.component ? this : defaultResolver;\n                // We only support support simple expressions and ignore others as they\n                // are unlikely to affect type narrowing.\n                var _c = convertPropertyBinding(nameResolver, variable(this.getOutputVar(context)), value, bindingId, BindingForm.TrySimple), stmts = _c.stmts, currValExpr = _c.currValExpr;\n                if (stmts.length == 0) {\n                    var /** @type {?} */ guardClause = guard.useIf ? currValExpr : this.ctx.importExpr(guard.guard).callFn([currValExpr]);\n                    guardExpression = guardExpression ? guardExpression.and(guardClause) : guardClause;\n                }\n            }\n            if (guardExpression) {\n                viewStmts = [new IfStmt(guardExpression, viewStmts)];\n            }\n        }\n        var /** @type {?} */ viewName = \"_View_\" + componentId + \"_\" + this.embeddedViewIndex;\n        var /** @type {?} */ viewFactory = new DeclareFunctionStmt(viewName, [], viewStmts);\n        targetStatements.push(viewFactory);\n        return targetStatements;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitBoundText = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        var /** @type {?} */ astWithSource = /** @type {?} */ (ast.value);\n        var /** @type {?} */ inter = /** @type {?} */ (astWithSource.ast);\n        inter.expressions.forEach(function (expr) {\n            return _this.updates.push({ context: _this.component, value: expr, sourceSpan: ast.sourceSpan });\n        });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitEmbeddedTemplate = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        this.visitElementOrTemplate(ast);\n        // Note: The old view compiler used to use an `any` type\n        // for the context in any embedded view.\n        // We keep this behaivor behind a flag for now.\n        if (this.options.fullTemplateTypeCheck) {\n            // Find any applicable type guards. For example, NgIf has a type guard on ngIf\n            // (see NgIf.ngIfTypeGuard) that can be used to indicate that a template is only\n            // stamped out if ngIf is truthy so any bindings in the template can assume that,\n            // if a nullable type is used for ngIf, that expression is not null or undefined.\n            var /** @type {?} */ guards = this.getTypeGuardExpressions(ast);\n            var /** @type {?} */ childVisitor = this.viewBuilderFactory(this, guards);\n            this.children.push(childVisitor);\n            childVisitor.visitAll(ast.variables, ast.children);\n        }\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitElement = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        this.visitElementOrTemplate(ast);\n        var /** @type {?} */ inputDefs = [];\n        var /** @type {?} */ updateRendererExpressions = [];\n        var /** @type {?} */ outputDefs = [];\n        ast.inputs.forEach(function (inputAst) {\n            _this.updates.push({ context: _this.component, value: inputAst.value, sourceSpan: inputAst.sourceSpan });\n        });\n        templateVisitAll(this, ast.children);\n    };\n    /**\n     * @param {?} ast\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitElementOrTemplate = /**\n     * @param {?} ast\n     * @return {?}\n     */\n    function (ast) {\n        var _this = this;\n        ast.directives.forEach(function (dirAst) { _this.visitDirective(dirAst); });\n        ast.references.forEach(function (ref) {\n            var /** @type {?} */ outputVarType = /** @type {?} */ ((null));\n            // Note: The old view compiler used to use an `any` type\n            // for directives exposed via `exportAs`.\n            // We keep this behaivor behind a flag for now.\n            if (ref.value && ref.value.identifier && _this.options.fullTemplateTypeCheck) {\n                outputVarType = ref.value.identifier.reference;\n            }\n            else {\n                outputVarType = BuiltinTypeName.Dynamic;\n            }\n            _this.refOutputVars.set(ref.name, outputVarType);\n        });\n        ast.outputs.forEach(function (outputAst) {\n            _this.actions.push({ context: _this.component, value: outputAst.handler, sourceSpan: outputAst.sourceSpan });\n        });\n    };\n    /**\n     * @param {?} dirAst\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitDirective = /**\n     * @param {?} dirAst\n     * @return {?}\n     */\n    function (dirAst) {\n        var _this = this;\n        var /** @type {?} */ dirType = dirAst.directive.type.reference;\n        dirAst.inputs.forEach(function (input) {\n            return _this.updates.push({ context: _this.component, value: input.value, sourceSpan: input.sourceSpan });\n        });\n        // Note: The old view compiler used to use an `any` type\n        // for expressions in host properties / events.\n        // We keep this behaivor behind a flag for now.\n        if (this.options.fullTemplateTypeCheck) {\n            dirAst.hostProperties.forEach(function (inputAst) {\n                return _this.updates.push({ context: dirType, value: inputAst.value, sourceSpan: inputAst.sourceSpan });\n            });\n            dirAst.hostEvents.forEach(function (hostEventAst) {\n                return _this.actions.push({\n                    context: dirType,\n                    value: hostEventAst.handler,\n                    sourceSpan: hostEventAst.sourceSpan\n                });\n            });\n        }\n    };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    ViewBuilder.prototype.getLocal = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        if (name == EventHandlerVars.event.name) {\n            return variable(this.getOutputVar(BuiltinTypeName.Dynamic));\n        }\n        for (var /** @type {?} */ currBuilder = this; currBuilder; currBuilder = currBuilder.parent) {\n            var /** @type {?} */ outputVarType = void 0;\n            // check references\n            outputVarType = currBuilder.refOutputVars.get(name);\n            if (outputVarType == null) {\n                // check variables\n                var /** @type {?} */ varAst = currBuilder.variables.find(function (varAst) { return varAst.name === name; });\n                if (varAst) {\n                    outputVarType = BuiltinTypeName.Dynamic;\n                }\n            }\n            if (outputVarType != null) {\n                return variable(this.getOutputVar(outputVarType));\n            }\n        }\n        return null;\n    };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    ViewBuilder.prototype.pipeOutputVar = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        var /** @type {?} */ pipe = this.pipes.get(name);\n        if (!pipe) {\n            throw new Error(\"Illegal State: Could not find pipe \" + name + \" in template of \" + this.component);\n        }\n        return this.getOutputVar(pipe);\n    };\n    /**\n     * @param {?} expression\n     * @return {?}\n     */\n    ViewBuilder.prototype.preprocessUpdateExpression = /**\n     * @param {?} expression\n     * @return {?}\n     */\n    function (expression) {\n        var _this = this;\n        return {\n            sourceSpan: expression.sourceSpan,\n            context: expression.context,\n            value: convertPropertyBindingBuiltins({\n                createLiteralArrayConverter: function (argCount) {\n                    return function (args) {\n                        var /** @type {?} */ arr = literalArr(args);\n                        // Note: The old view compiler used to use an `any` type\n                        // for arrays.\n                        return _this.options.fullTemplateTypeCheck ? arr : arr.cast(DYNAMIC_TYPE);\n                    };\n                },\n                createLiteralMapConverter: function (keys) {\n                    return function (values) {\n                        var /** @type {?} */ entries = keys.map(function (k, i) {\n                            return ({\n                                key: k.key,\n                                value: values[i],\n                                quoted: k.quoted,\n                            });\n                        });\n                        var /** @type {?} */ map = literalMap(entries);\n                        // Note: The old view compiler used to use an `any` type\n                        // for maps.\n                        return _this.options.fullTemplateTypeCheck ? map : map.cast(DYNAMIC_TYPE);\n                    };\n                },\n                createPipeConverter: function (name, argCount) {\n                    return function (args) {\n                        // Note: The old view compiler used to use an `any` type\n                        // for pipes.\n                        var /** @type {?} */ pipeExpr = _this.options.fullTemplateTypeCheck ?\n                            variable(_this.pipeOutputVar(name)) :\n                            variable(_this.getOutputVar(BuiltinTypeName.Dynamic));\n                        return pipeExpr.callMethod('transform', args);\n                    };\n                },\n            }, expression.value)\n        };\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitNgContent = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitText = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitDirectiveProperty = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitReference = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitVariable = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitEvent = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitElementProperty = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitAttr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    return ViewBuilder;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar CLASS_ATTR$1 = 'class';\nvar STYLE_ATTR = 'style';\nvar IMPLICIT_TEMPLATE_VAR = '\\$implicit';\nvar ViewCompileResult = /** @class */ (function () {\n    function ViewCompileResult(viewClassVar, rendererTypeVar) {\n        this.viewClassVar = viewClassVar;\n        this.rendererTypeVar = rendererTypeVar;\n    }\n    return ViewCompileResult;\n}());\nvar ViewCompiler = /** @class */ (function () {\n    function ViewCompiler(_reflector) {\n        this._reflector = _reflector;\n    }\n    /**\n     * @param {?} outputCtx\n     * @param {?} component\n     * @param {?} template\n     * @param {?} styles\n     * @param {?} usedPipes\n     * @return {?}\n     */\n    ViewCompiler.prototype.compileComponent = /**\n     * @param {?} outputCtx\n     * @param {?} component\n     * @param {?} template\n     * @param {?} styles\n     * @param {?} usedPipes\n     * @return {?}\n     */\n    function (outputCtx, component, template, styles, usedPipes) {\n        var _this = this;\n        var /** @type {?} */ embeddedViewCount = 0;\n        var /** @type {?} */ staticQueryIds = findStaticQueryIds(template);\n        var /** @type {?} */ renderComponentVarName = /** @type {?} */ ((undefined));\n        if (!component.isHost) {\n            var /** @type {?} */ template_1 = /** @type {?} */ ((component.template));\n            var /** @type {?} */ customRenderData = [];\n            if (template_1.animations && template_1.animations.length) {\n                customRenderData.push(new LiteralMapEntry('animation', convertValueToOutputAst(outputCtx, template_1.animations), true));\n            }\n            var /** @type {?} */ renderComponentVar = variable(rendererTypeName(component.type.reference));\n            renderComponentVarName = /** @type {?} */ ((renderComponentVar.name));\n            outputCtx.statements.push(renderComponentVar\n                .set(importExpr(Identifiers.createRendererType2).callFn([new LiteralMapExpr([\n                    new LiteralMapEntry('encapsulation', literal(template_1.encapsulation), false),\n                    new LiteralMapEntry('styles', styles, false),\n                    new LiteralMapEntry('data', new LiteralMapExpr(customRenderData), false)\n                ])]))\n                .toDeclStmt(importType(Identifiers.RendererType2), [StmtModifier.Final, StmtModifier.Exported]));\n        }\n        var /** @type {?} */ viewBuilderFactory = function (parent) {\n            var /** @type {?} */ embeddedViewIndex = embeddedViewCount++;\n            return new ViewBuilder$1(_this._reflector, outputCtx, parent, component, embeddedViewIndex, usedPipes, staticQueryIds, viewBuilderFactory);\n        };\n        var /** @type {?} */ visitor = viewBuilderFactory(null);\n        visitor.visitAll([], template);\n        (_a = outputCtx.statements).push.apply(_a, visitor.build());\n        return new ViewCompileResult(visitor.viewName, renderComponentVarName);\n        var _a;\n    };\n    return ViewCompiler;\n}());\nvar LOG_VAR$1 = variable('_l');\nvar VIEW_VAR = variable('_v');\nvar CHECK_VAR = variable('_ck');\nvar COMP_VAR = variable('_co');\nvar EVENT_NAME_VAR = variable('en');\nvar ALLOW_DEFAULT_VAR = variable(\"ad\");\nvar ViewBuilder$1 = /** @class */ (function () {\n    function ViewBuilder(reflector, outputCtx, parent, component, embeddedViewIndex, usedPipes, staticQueryIds, viewBuilderFactory) {\n        this.reflector = reflector;\n        this.outputCtx = outputCtx;\n        this.parent = parent;\n        this.component = component;\n        this.embeddedViewIndex = embeddedViewIndex;\n        this.usedPipes = usedPipes;\n        this.staticQueryIds = staticQueryIds;\n        this.viewBuilderFactory = viewBuilderFactory;\n        this.nodes = [];\n        this.purePipeNodeIndices = Object.create(null);\n        this.refNodeIndices = Object.create(null);\n        this.variables = [];\n        this.children = [];\n        // TODO(tbosch): The old view compiler used to use an `any` type\n        // for the context in any embedded view. We keep this behaivor for now\n        // to be able to introduce the new view compiler without too many errors.\n        this.compType = this.embeddedViewIndex > 0 ?\n            DYNAMIC_TYPE : /** @type {?} */\n            ((expressionType(outputCtx.importExpr(this.component.type.reference))));\n        this.viewName = viewClassName(this.component.type.reference, this.embeddedViewIndex);\n    }\n    /**\n     * @param {?} variables\n     * @param {?} astNodes\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitAll = /**\n     * @param {?} variables\n     * @param {?} astNodes\n     * @return {?}\n     */\n    function (variables, astNodes) {\n        var _this = this;\n        this.variables = variables;\n        // create the pipes for the pure pipes immediately, so that we know their indices.\n        if (!this.parent) {\n            this.usedPipes.forEach(function (pipe) {\n                if (pipe.pure) {\n                    _this.purePipeNodeIndices[pipe.name] = _this._createPipe(null, pipe);\n                }\n            });\n        }\n        if (!this.parent) {\n            var /** @type {?} */ queryIds_1 = staticViewQueryIds(this.staticQueryIds);\n            this.component.viewQueries.forEach(function (query, queryIndex) {\n                // Note: queries start with id 1 so we can use the number in a Bloom filter!\n                var /** @type {?} */ queryId = queryIndex + 1;\n                var /** @type {?} */ bindingType = query.first ? 0 /* First */ : 1;\n                var /** @type {?} */ flags = 134217728 /* TypeViewQuery */ | calcStaticDynamicQueryFlags(queryIds_1, queryId, query.first);\n                _this.nodes.push(function () {\n                    return ({\n                        sourceSpan: null,\n                        nodeFlags: flags,\n                        nodeDef: importExpr(Identifiers.queryDef).callFn([\n                            literal(flags), literal(queryId),\n                            new LiteralMapExpr([new LiteralMapEntry(query.propertyName, literal(bindingType), false)])\n                        ])\n                    });\n                });\n            });\n        }\n        templateVisitAll(this, astNodes);\n        if (this.parent && (astNodes.length === 0 || needsAdditionalRootNode(astNodes))) {\n            // if the view is an embedded view, then we need to add an additional root node in some cases\n            this.nodes.push(function () {\n                return ({\n                    sourceSpan: null,\n                    nodeFlags: 1 /* TypeElement */,\n                    nodeDef: importExpr(Identifiers.anchorDef).callFn([\n                        literal(0 /* None */), NULL_EXPR, NULL_EXPR, literal(0)\n                    ])\n                });\n            });\n        }\n    };\n    /**\n     * @param {?=} targetStatements\n     * @return {?}\n     */\n    ViewBuilder.prototype.build = /**\n     * @param {?=} targetStatements\n     * @return {?}\n     */\n    function (targetStatements) {\n        if (targetStatements === void 0) { targetStatements = []; }\n        this.children.forEach(function (child) { return child.build(targetStatements); });\n        var _a = this._createNodeExpressions(), updateRendererStmts = _a.updateRendererStmts, updateDirectivesStmts = _a.updateDirectivesStmts, nodeDefExprs = _a.nodeDefExprs;\n        var /** @type {?} */ updateRendererFn = this._createUpdateFn(updateRendererStmts);\n        var /** @type {?} */ updateDirectivesFn = this._createUpdateFn(updateDirectivesStmts);\n        var /** @type {?} */ viewFlags = 0;\n        if (!this.parent && this.component.changeDetection === ChangeDetectionStrategy.OnPush) {\n            viewFlags |= 2 /* OnPush */;\n        }\n        var /** @type {?} */ viewFactory = new DeclareFunctionStmt(this.viewName, [new FnParam(/** @type {?} */ ((LOG_VAR$1.name)))], [new ReturnStatement(importExpr(Identifiers.viewDef).callFn([\n                literal(viewFlags),\n                literalArr(nodeDefExprs),\n                updateDirectivesFn,\n                updateRendererFn,\n            ]))], importType(Identifiers.ViewDefinition), this.embeddedViewIndex === 0 ? [StmtModifier.Exported] : []);\n        targetStatements.push(viewFactory);\n        return targetStatements;\n    };\n    /**\n     * @param {?} updateStmts\n     * @return {?}\n     */\n    ViewBuilder.prototype._createUpdateFn = /**\n     * @param {?} updateStmts\n     * @return {?}\n     */\n    function (updateStmts) {\n        var /** @type {?} */ updateFn;\n        if (updateStmts.length > 0) {\n            var /** @type {?} */ preStmts = [];\n            if (!this.component.isHost && findReadVarNames(updateStmts).has(/** @type {?} */ ((COMP_VAR.name)))) {\n                preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType));\n            }\n            updateFn = fn([\n                new FnParam(/** @type {?} */ ((CHECK_VAR.name)), INFERRED_TYPE),\n                new FnParam(/** @type {?} */ ((VIEW_VAR.name)), INFERRED_TYPE)\n            ], preStmts.concat(updateStmts), INFERRED_TYPE);\n        }\n        else {\n            updateFn = NULL_EXPR;\n        }\n        return updateFn;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitNgContent = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        // ngContentDef(ngContentIndex: number, index: number): NodeDef;\n        this.nodes.push(function () {\n            return ({\n                sourceSpan: ast.sourceSpan,\n                nodeFlags: 8 /* TypeNgContent */,\n                nodeDef: importExpr(Identifiers.ngContentDef).callFn([\n                    literal(ast.ngContentIndex), literal(ast.index)\n                ])\n            });\n        });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitText = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        // Static text nodes have no check function\n        var /** @type {?} */ checkIndex = -1;\n        this.nodes.push(function () {\n            return ({\n                sourceSpan: ast.sourceSpan,\n                nodeFlags: 2 /* TypeText */,\n                nodeDef: importExpr(Identifiers.textDef).callFn([\n                    literal(checkIndex),\n                    literal(ast.ngContentIndex),\n                    literalArr([literal(ast.value)]),\n                ])\n            });\n        });\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitBoundText = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        var /** @type {?} */ nodeIndex = this.nodes.length;\n        // reserve the space in the nodeDefs array\n        this.nodes.push(/** @type {?} */ ((null)));\n        var /** @type {?} */ astWithSource = /** @type {?} */ (ast.value);\n        var /** @type {?} */ inter = /** @type {?} */ (astWithSource.ast);\n        var /** @type {?} */ updateRendererExpressions = inter.expressions.map(function (expr, bindingIndex) {\n            return _this._preprocessUpdateExpression({ nodeIndex: nodeIndex, bindingIndex: bindingIndex, sourceSpan: ast.sourceSpan, context: COMP_VAR, value: expr });\n        });\n        // Check index is the same as the node index during compilation\n        // They might only differ at runtime\n        var /** @type {?} */ checkIndex = nodeIndex;\n        this.nodes[nodeIndex] = function () {\n            return ({\n                sourceSpan: ast.sourceSpan,\n                nodeFlags: 2 /* TypeText */,\n                nodeDef: importExpr(Identifiers.textDef).callFn([\n                    literal(checkIndex),\n                    literal(ast.ngContentIndex),\n                    literalArr(inter.strings.map(function (s) { return literal(s); })),\n                ]),\n                updateRenderer: updateRendererExpressions\n            });\n        };\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitEmbeddedTemplate = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        var /** @type {?} */ nodeIndex = this.nodes.length;\n        // reserve the space in the nodeDefs array\n        this.nodes.push(/** @type {?} */ ((null)));\n        var _a = this._visitElementOrTemplate(nodeIndex, ast), flags = _a.flags, queryMatchesExpr = _a.queryMatchesExpr, hostEvents = _a.hostEvents;\n        var /** @type {?} */ childVisitor = this.viewBuilderFactory(this);\n        this.children.push(childVisitor);\n        childVisitor.visitAll(ast.variables, ast.children);\n        var /** @type {?} */ childCount = this.nodes.length - nodeIndex - 1;\n        // anchorDef(\n        //   flags: NodeFlags, matchedQueries: [string, QueryValueType][], ngContentIndex: number,\n        //   childCount: number, handleEventFn?: ElementHandleEventFn, templateFactory?:\n        //   ViewDefinitionFactory): NodeDef;\n        this.nodes[nodeIndex] = function () {\n            return ({\n                sourceSpan: ast.sourceSpan,\n                nodeFlags: 1 /* TypeElement */ | flags,\n                nodeDef: importExpr(Identifiers.anchorDef).callFn([\n                    literal(flags),\n                    queryMatchesExpr,\n                    literal(ast.ngContentIndex),\n                    literal(childCount),\n                    _this._createElementHandleEventFn(nodeIndex, hostEvents),\n                    variable(childVisitor.viewName),\n                ])\n            });\n        };\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitElement = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var _this = this;\n        var /** @type {?} */ nodeIndex = this.nodes.length;\n        // reserve the space in the nodeDefs array so we can add children\n        this.nodes.push(/** @type {?} */ ((null)));\n        // Using a null element name creates an anchor.\n        var /** @type {?} */ elName = isNgContainer(ast.name) ? null : ast.name;\n        var _a = this._visitElementOrTemplate(nodeIndex, ast), flags = _a.flags, usedEvents = _a.usedEvents, queryMatchesExpr = _a.queryMatchesExpr, dirHostBindings = _a.hostBindings, hostEvents = _a.hostEvents;\n        var /** @type {?} */ inputDefs = [];\n        var /** @type {?} */ updateRendererExpressions = [];\n        var /** @type {?} */ outputDefs = [];\n        if (elName) {\n            var /** @type {?} */ hostBindings = ast.inputs\n                .map(function (inputAst) {\n                return ({\n                    context: /** @type {?} */ (COMP_VAR),\n                    inputAst: inputAst,\n                    dirAst: /** @type {?} */ (null),\n                });\n            })\n                .concat(dirHostBindings);\n            if (hostBindings.length) {\n                updateRendererExpressions =\n                    hostBindings.map(function (hostBinding, bindingIndex) {\n                        return _this._preprocessUpdateExpression({\n                            context: hostBinding.context,\n                            nodeIndex: nodeIndex,\n                            bindingIndex: bindingIndex,\n                            sourceSpan: hostBinding.inputAst.sourceSpan,\n                            value: hostBinding.inputAst.value\n                        });\n                    });\n                inputDefs = hostBindings.map(function (hostBinding) { return elementBindingDef(hostBinding.inputAst, hostBinding.dirAst); });\n            }\n            outputDefs = usedEvents.map(function (_a) {\n                var target = _a[0], eventName = _a[1];\n                return literalArr([literal(target), literal(eventName)]);\n            });\n        }\n        templateVisitAll(this, ast.children);\n        var /** @type {?} */ childCount = this.nodes.length - nodeIndex - 1;\n        var /** @type {?} */ compAst = ast.directives.find(function (dirAst) { return dirAst.directive.isComponent; });\n        var /** @type {?} */ compRendererType = /** @type {?} */ (NULL_EXPR);\n        var /** @type {?} */ compView = /** @type {?} */ (NULL_EXPR);\n        if (compAst) {\n            compView = this.outputCtx.importExpr(compAst.directive.componentViewType);\n            compRendererType = this.outputCtx.importExpr(compAst.directive.rendererType);\n        }\n        // Check index is the same as the node index during compilation\n        // They might only differ at runtime\n        var /** @type {?} */ checkIndex = nodeIndex;\n        this.nodes[nodeIndex] = function () {\n            return ({\n                sourceSpan: ast.sourceSpan,\n                nodeFlags: 1 /* TypeElement */ | flags,\n                nodeDef: importExpr(Identifiers.elementDef).callFn([\n                    literal(checkIndex),\n                    literal(flags),\n                    queryMatchesExpr,\n                    literal(ast.ngContentIndex),\n                    literal(childCount),\n                    literal(elName),\n                    elName ? fixedAttrsDef(ast) : NULL_EXPR,\n                    inputDefs.length ? literalArr(inputDefs) : NULL_EXPR,\n                    outputDefs.length ? literalArr(outputDefs) : NULL_EXPR,\n                    _this._createElementHandleEventFn(nodeIndex, hostEvents),\n                    compView,\n                    compRendererType,\n                ]),\n                updateRenderer: updateRendererExpressions\n            });\n        };\n    };\n    /**\n     * @param {?} nodeIndex\n     * @param {?} ast\n     * @return {?}\n     */\n    ViewBuilder.prototype._visitElementOrTemplate = /**\n     * @param {?} nodeIndex\n     * @param {?} ast\n     * @return {?}\n     */\n    function (nodeIndex, ast) {\n        var _this = this;\n        var /** @type {?} */ flags = 0;\n        if (ast.hasViewContainer) {\n            flags |= 16777216 /* EmbeddedViews */;\n        }\n        var /** @type {?} */ usedEvents = new Map();\n        ast.outputs.forEach(function (event) {\n            var _a = elementEventNameAndTarget(event, null), name = _a.name, target = _a.target;\n            usedEvents.set(elementEventFullName(target, name), [target, name]);\n        });\n        ast.directives.forEach(function (dirAst) {\n            dirAst.hostEvents.forEach(function (event) {\n                var _a = elementEventNameAndTarget(event, dirAst), name = _a.name, target = _a.target;\n                usedEvents.set(elementEventFullName(target, name), [target, name]);\n            });\n        });\n        var /** @type {?} */ hostBindings = [];\n        var /** @type {?} */ hostEvents = [];\n        this._visitComponentFactoryResolverProvider(ast.directives);\n        ast.providers.forEach(function (providerAst, providerIndex) {\n            var /** @type {?} */ dirAst = /** @type {?} */ ((undefined));\n            var /** @type {?} */ dirIndex = /** @type {?} */ ((undefined));\n            ast.directives.forEach(function (localDirAst, i) {\n                if (localDirAst.directive.type.reference === tokenReference(providerAst.token)) {\n                    dirAst = localDirAst;\n                    dirIndex = i;\n                }\n            });\n            if (dirAst) {\n                var _a = _this._visitDirective(providerAst, dirAst, dirIndex, nodeIndex, ast.references, ast.queryMatches, usedEvents, /** @type {?} */ ((_this.staticQueryIds.get(/** @type {?} */ (ast))))), dirHostBindings = _a.hostBindings, dirHostEvents = _a.hostEvents;\n                hostBindings.push.apply(hostBindings, dirHostBindings);\n                hostEvents.push.apply(hostEvents, dirHostEvents);\n            }\n            else {\n                _this._visitProvider(providerAst, ast.queryMatches);\n            }\n        });\n        var /** @type {?} */ queryMatchExprs = [];\n        ast.queryMatches.forEach(function (match) {\n            var /** @type {?} */ valueType = /** @type {?} */ ((undefined));\n            if (tokenReference(match.value) ===\n                _this.reflector.resolveExternalReference(Identifiers.ElementRef)) {\n                valueType = 0 /* ElementRef */;\n            }\n            else if (tokenReference(match.value) ===\n                _this.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) {\n                valueType = 3 /* ViewContainerRef */;\n            }\n            else if (tokenReference(match.value) ===\n                _this.reflector.resolveExternalReference(Identifiers.TemplateRef)) {\n                valueType = 2 /* TemplateRef */;\n            }\n            if (valueType != null) {\n                queryMatchExprs.push(literalArr([literal(match.queryId), literal(valueType)]));\n            }\n        });\n        ast.references.forEach(function (ref) {\n            var /** @type {?} */ valueType = /** @type {?} */ ((undefined));\n            if (!ref.value) {\n                valueType = 1 /* RenderElement */;\n            }\n            else if (tokenReference(ref.value) ===\n                _this.reflector.resolveExternalReference(Identifiers.TemplateRef)) {\n                valueType = 2 /* TemplateRef */;\n            }\n            if (valueType != null) {\n                _this.refNodeIndices[ref.name] = nodeIndex;\n                queryMatchExprs.push(literalArr([literal(ref.name), literal(valueType)]));\n            }\n        });\n        ast.outputs.forEach(function (outputAst) {\n            hostEvents.push({ context: COMP_VAR, eventAst: outputAst, dirAst: /** @type {?} */ ((null)) });\n        });\n        return {\n            flags: flags,\n            usedEvents: Array.from(usedEvents.values()),\n            queryMatchesExpr: queryMatchExprs.length ? literalArr(queryMatchExprs) : NULL_EXPR,\n            hostBindings: hostBindings,\n            hostEvents: hostEvents\n        };\n    };\n    /**\n     * @param {?} providerAst\n     * @param {?} dirAst\n     * @param {?} directiveIndex\n     * @param {?} elementNodeIndex\n     * @param {?} refs\n     * @param {?} queryMatches\n     * @param {?} usedEvents\n     * @param {?} queryIds\n     * @return {?}\n     */\n    ViewBuilder.prototype._visitDirective = /**\n     * @param {?} providerAst\n     * @param {?} dirAst\n     * @param {?} directiveIndex\n     * @param {?} elementNodeIndex\n     * @param {?} refs\n     * @param {?} queryMatches\n     * @param {?} usedEvents\n     * @param {?} queryIds\n     * @return {?}\n     */\n    function (providerAst, dirAst, directiveIndex, elementNodeIndex, refs, queryMatches, usedEvents, queryIds) {\n        var _this = this;\n        var /** @type {?} */ nodeIndex = this.nodes.length;\n        // reserve the space in the nodeDefs array so we can add children\n        this.nodes.push(/** @type {?} */ ((null)));\n        dirAst.directive.queries.forEach(function (query, queryIndex) {\n            var /** @type {?} */ queryId = dirAst.contentQueryStartId + queryIndex;\n            var /** @type {?} */ flags = 67108864 /* TypeContentQuery */ | calcStaticDynamicQueryFlags(queryIds, queryId, query.first);\n            var /** @type {?} */ bindingType = query.first ? 0 /* First */ : 1;\n            _this.nodes.push(function () {\n                return ({\n                    sourceSpan: dirAst.sourceSpan,\n                    nodeFlags: flags,\n                    nodeDef: importExpr(Identifiers.queryDef).callFn([\n                        literal(flags), literal(queryId),\n                        new LiteralMapExpr([new LiteralMapEntry(query.propertyName, literal(bindingType), false)])\n                    ]),\n                });\n            });\n        });\n        // Note: the operation below might also create new nodeDefs,\n        // but we don't want them to be a child of a directive,\n        // as they might be a provider/pipe on their own.\n        // I.e. we only allow queries as children of directives nodes.\n        var /** @type {?} */ childCount = this.nodes.length - nodeIndex - 1;\n        var _a = this._visitProviderOrDirective(providerAst, queryMatches), flags = _a.flags, queryMatchExprs = _a.queryMatchExprs, providerExpr = _a.providerExpr, depsExpr = _a.depsExpr;\n        refs.forEach(function (ref) {\n            if (ref.value && tokenReference(ref.value) === tokenReference(providerAst.token)) {\n                _this.refNodeIndices[ref.name] = nodeIndex;\n                queryMatchExprs.push(literalArr([literal(ref.name), literal(4 /* Provider */)]));\n            }\n        });\n        if (dirAst.directive.isComponent) {\n            flags |= 32768 /* Component */;\n        }\n        var /** @type {?} */ inputDefs = dirAst.inputs.map(function (inputAst, inputIndex) {\n            var /** @type {?} */ mapValue = literalArr([literal(inputIndex), literal(inputAst.directiveName)]);\n            // Note: it's important to not quote the key so that we can capture renames by minifiers!\n            return new LiteralMapEntry(inputAst.directiveName, mapValue, false);\n        });\n        var /** @type {?} */ outputDefs = [];\n        var /** @type {?} */ dirMeta = dirAst.directive;\n        Object.keys(dirMeta.outputs).forEach(function (propName) {\n            var /** @type {?} */ eventName = dirMeta.outputs[propName];\n            if (usedEvents.has(eventName)) {\n                // Note: it's important to not quote the key so that we can capture renames by minifiers!\n                outputDefs.push(new LiteralMapEntry(propName, literal(eventName), false));\n            }\n        });\n        var /** @type {?} */ updateDirectiveExpressions = [];\n        if (dirAst.inputs.length || (flags & (262144 /* DoCheck */ | 65536 /* OnInit */)) > 0) {\n            updateDirectiveExpressions =\n                dirAst.inputs.map(function (input, bindingIndex) {\n                    return _this._preprocessUpdateExpression({\n                        nodeIndex: nodeIndex,\n                        bindingIndex: bindingIndex,\n                        sourceSpan: input.sourceSpan,\n                        context: COMP_VAR,\n                        value: input.value\n                    });\n                });\n        }\n        var /** @type {?} */ dirContextExpr = importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, literal(nodeIndex)]);\n        var /** @type {?} */ hostBindings = dirAst.hostProperties.map(function (inputAst) {\n            return ({\n                context: dirContextExpr,\n                dirAst: dirAst,\n                inputAst: inputAst,\n            });\n        });\n        var /** @type {?} */ hostEvents = dirAst.hostEvents.map(function (hostEventAst) {\n            return ({\n                context: dirContextExpr,\n                eventAst: hostEventAst, dirAst: dirAst,\n            });\n        });\n        // Check index is the same as the node index during compilation\n        // They might only differ at runtime\n        var /** @type {?} */ checkIndex = nodeIndex;\n        this.nodes[nodeIndex] = function () {\n            return ({\n                sourceSpan: dirAst.sourceSpan,\n                nodeFlags: 16384 /* TypeDirective */ | flags,\n                nodeDef: importExpr(Identifiers.directiveDef).callFn([\n                    literal(checkIndex),\n                    literal(flags),\n                    queryMatchExprs.length ? literalArr(queryMatchExprs) : NULL_EXPR,\n                    literal(childCount),\n                    providerExpr,\n                    depsExpr,\n                    inputDefs.length ? new LiteralMapExpr(inputDefs) : NULL_EXPR,\n                    outputDefs.length ? new LiteralMapExpr(outputDefs) : NULL_EXPR,\n                ]),\n                updateDirectives: updateDirectiveExpressions,\n                directive: dirAst.directive.type,\n            });\n        };\n        return { hostBindings: hostBindings, hostEvents: hostEvents };\n    };\n    /**\n     * @param {?} providerAst\n     * @param {?} queryMatches\n     * @return {?}\n     */\n    ViewBuilder.prototype._visitProvider = /**\n     * @param {?} providerAst\n     * @param {?} queryMatches\n     * @return {?}\n     */\n    function (providerAst, queryMatches) {\n        this._addProviderNode(this._visitProviderOrDirective(providerAst, queryMatches));\n    };\n    /**\n     * @param {?} directives\n     * @return {?}\n     */\n    ViewBuilder.prototype._visitComponentFactoryResolverProvider = /**\n     * @param {?} directives\n     * @return {?}\n     */\n    function (directives) {\n        var /** @type {?} */ componentDirMeta = directives.find(function (dirAst) { return dirAst.directive.isComponent; });\n        if (componentDirMeta && componentDirMeta.directive.entryComponents.length) {\n            var _a = componentFactoryResolverProviderDef(this.reflector, this.outputCtx, 8192 /* PrivateProvider */, componentDirMeta.directive.entryComponents), providerExpr = _a.providerExpr, depsExpr = _a.depsExpr, flags = _a.flags, tokenExpr = _a.tokenExpr;\n            this._addProviderNode({\n                providerExpr: providerExpr,\n                depsExpr: depsExpr,\n                flags: flags,\n                tokenExpr: tokenExpr,\n                queryMatchExprs: [],\n                sourceSpan: componentDirMeta.sourceSpan\n            });\n        }\n    };\n    /**\n     * @param {?} data\n     * @return {?}\n     */\n    ViewBuilder.prototype._addProviderNode = /**\n     * @param {?} data\n     * @return {?}\n     */\n    function (data) {\n        var /** @type {?} */ nodeIndex = this.nodes.length;\n        // providerDef(\n        //   flags: NodeFlags, matchedQueries: [string, QueryValueType][], token:any,\n        //   value: any, deps: ([DepFlags, any] | any)[]): NodeDef;\n        this.nodes.push(function () {\n            return ({\n                sourceSpan: data.sourceSpan,\n                nodeFlags: data.flags,\n                nodeDef: importExpr(Identifiers.providerDef).callFn([\n                    literal(data.flags),\n                    data.queryMatchExprs.length ? literalArr(data.queryMatchExprs) : NULL_EXPR,\n                    data.tokenExpr, data.providerExpr, data.depsExpr\n                ])\n            });\n        });\n    };\n    /**\n     * @param {?} providerAst\n     * @param {?} queryMatches\n     * @return {?}\n     */\n    ViewBuilder.prototype._visitProviderOrDirective = /**\n     * @param {?} providerAst\n     * @param {?} queryMatches\n     * @return {?}\n     */\n    function (providerAst, queryMatches) {\n        var /** @type {?} */ flags = 0;\n        var /** @type {?} */ queryMatchExprs = [];\n        queryMatches.forEach(function (match) {\n            if (tokenReference(match.value) === tokenReference(providerAst.token)) {\n                queryMatchExprs.push(literalArr([literal(match.queryId), literal(4 /* Provider */)]));\n            }\n        });\n        var _a = providerDef(this.outputCtx, providerAst), providerExpr = _a.providerExpr, depsExpr = _a.depsExpr, providerFlags = _a.flags, tokenExpr = _a.tokenExpr;\n        return {\n            flags: flags | providerFlags,\n            queryMatchExprs: queryMatchExprs,\n            providerExpr: providerExpr,\n            depsExpr: depsExpr,\n            tokenExpr: tokenExpr,\n            sourceSpan: providerAst.sourceSpan\n        };\n    };\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    ViewBuilder.prototype.getLocal = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        if (name == EventHandlerVars.event.name) {\n            return EventHandlerVars.event;\n        }\n        var /** @type {?} */ currViewExpr = VIEW_VAR;\n        for (var /** @type {?} */ currBuilder = this; currBuilder; currBuilder = currBuilder.parent,\n            currViewExpr = currViewExpr.prop('parent').cast(DYNAMIC_TYPE)) {\n            // check references\n            var /** @type {?} */ refNodeIndex = currBuilder.refNodeIndices[name];\n            if (refNodeIndex != null) {\n                return importExpr(Identifiers.nodeValue).callFn([currViewExpr, literal(refNodeIndex)]);\n            }\n            // check variables\n            var /** @type {?} */ varAst = currBuilder.variables.find(function (varAst) { return varAst.name === name; });\n            if (varAst) {\n                var /** @type {?} */ varValue = varAst.value || IMPLICIT_TEMPLATE_VAR;\n                return currViewExpr.prop('context').prop(varValue);\n            }\n        }\n        return null;\n    };\n    /**\n     * @param {?} sourceSpan\n     * @param {?} argCount\n     * @return {?}\n     */\n    ViewBuilder.prototype._createLiteralArrayConverter = /**\n     * @param {?} sourceSpan\n     * @param {?} argCount\n     * @return {?}\n     */\n    function (sourceSpan, argCount) {\n        if (argCount === 0) {\n            var /** @type {?} */ valueExpr_1 = importExpr(Identifiers.EMPTY_ARRAY);\n            return function () { return valueExpr_1; };\n        }\n        var /** @type {?} */ checkIndex = this.nodes.length;\n        this.nodes.push(function () {\n            return ({\n                sourceSpan: sourceSpan,\n                nodeFlags: 32 /* TypePureArray */,\n                nodeDef: importExpr(Identifiers.pureArrayDef).callFn([\n                    literal(checkIndex),\n                    literal(argCount),\n                ])\n            });\n        });\n        return function (args) { return callCheckStmt(checkIndex, args); };\n    };\n    /**\n     * @param {?} sourceSpan\n     * @param {?} keys\n     * @return {?}\n     */\n    ViewBuilder.prototype._createLiteralMapConverter = /**\n     * @param {?} sourceSpan\n     * @param {?} keys\n     * @return {?}\n     */\n    function (sourceSpan, keys) {\n        if (keys.length === 0) {\n            var /** @type {?} */ valueExpr_2 = importExpr(Identifiers.EMPTY_MAP);\n            return function () { return valueExpr_2; };\n        }\n        var /** @type {?} */ map = literalMap(keys.map(function (e, i) { return (__assign({}, e, { value: literal(i) })); }));\n        var /** @type {?} */ checkIndex = this.nodes.length;\n        this.nodes.push(function () {\n            return ({\n                sourceSpan: sourceSpan,\n                nodeFlags: 64 /* TypePureObject */,\n                nodeDef: importExpr(Identifiers.pureObjectDef).callFn([\n                    literal(checkIndex),\n                    map,\n                ])\n            });\n        });\n        return function (args) { return callCheckStmt(checkIndex, args); };\n    };\n    /**\n     * @param {?} expression\n     * @param {?} name\n     * @param {?} argCount\n     * @return {?}\n     */\n    ViewBuilder.prototype._createPipeConverter = /**\n     * @param {?} expression\n     * @param {?} name\n     * @param {?} argCount\n     * @return {?}\n     */\n    function (expression, name, argCount) {\n        var /** @type {?} */ pipe = /** @type {?} */ ((this.usedPipes.find(function (pipeSummary) { return pipeSummary.name === name; })));\n        if (pipe.pure) {\n            var /** @type {?} */ checkIndex_1 = this.nodes.length;\n            this.nodes.push(function () {\n                return ({\n                    sourceSpan: expression.sourceSpan,\n                    nodeFlags: 128 /* TypePurePipe */,\n                    nodeDef: importExpr(Identifiers.purePipeDef).callFn([\n                        literal(checkIndex_1),\n                        literal(argCount),\n                    ])\n                });\n            });\n            // find underlying pipe in the component view\n            var /** @type {?} */ compViewExpr = VIEW_VAR;\n            var /** @type {?} */ compBuilder = this;\n            while (compBuilder.parent) {\n                compBuilder = compBuilder.parent;\n                compViewExpr = compViewExpr.prop('parent').cast(DYNAMIC_TYPE);\n            }\n            var /** @type {?} */ pipeNodeIndex = compBuilder.purePipeNodeIndices[name];\n            var /** @type {?} */ pipeValueExpr_1 = importExpr(Identifiers.nodeValue).callFn([compViewExpr, literal(pipeNodeIndex)]);\n            return function (args) {\n                return callUnwrapValue(expression.nodeIndex, expression.bindingIndex, callCheckStmt(checkIndex_1, [pipeValueExpr_1].concat(args)));\n            };\n        }\n        else {\n            var /** @type {?} */ nodeIndex = this._createPipe(expression.sourceSpan, pipe);\n            var /** @type {?} */ nodeValueExpr_1 = importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, literal(nodeIndex)]);\n            return function (args) {\n                return callUnwrapValue(expression.nodeIndex, expression.bindingIndex, nodeValueExpr_1.callMethod('transform', args));\n            };\n        }\n    };\n    /**\n     * @param {?} sourceSpan\n     * @param {?} pipe\n     * @return {?}\n     */\n    ViewBuilder.prototype._createPipe = /**\n     * @param {?} sourceSpan\n     * @param {?} pipe\n     * @return {?}\n     */\n    function (sourceSpan, pipe) {\n        var _this = this;\n        var /** @type {?} */ nodeIndex = this.nodes.length;\n        var /** @type {?} */ flags = 0;\n        pipe.type.lifecycleHooks.forEach(function (lifecycleHook) {\n            // for pipes, we only support ngOnDestroy\n            if (lifecycleHook === LifecycleHooks.OnDestroy) {\n                flags |= lifecycleHookToNodeFlag(lifecycleHook);\n            }\n        });\n        var /** @type {?} */ depExprs = pipe.type.diDeps.map(function (diDep) { return depDef(_this.outputCtx, diDep); });\n        // function pipeDef(\n        //   flags: NodeFlags, ctor: any, deps: ([DepFlags, any] | any)[]): NodeDef\n        this.nodes.push(function () {\n            return ({\n                sourceSpan: sourceSpan,\n                nodeFlags: 16 /* TypePipe */,\n                nodeDef: importExpr(Identifiers.pipeDef).callFn([\n                    literal(flags), _this.outputCtx.importExpr(pipe.type.reference), literalArr(depExprs)\n                ])\n            });\n        });\n        return nodeIndex;\n    };\n    /**\n     * For the AST in `UpdateExpression.value`:\n     * - create nodes for pipes, literal arrays and, literal maps,\n     * - update the AST to replace pipes, literal arrays and, literal maps with calls to check fn.\n     *\n     * WARNING: This might create new nodeDefs (for pipes and literal arrays and literal maps)!\n     * @param {?} expression\n     * @return {?}\n     */\n    ViewBuilder.prototype._preprocessUpdateExpression = /**\n     * For the AST in `UpdateExpression.value`:\n     * - create nodes for pipes, literal arrays and, literal maps,\n     * - update the AST to replace pipes, literal arrays and, literal maps with calls to check fn.\n     *\n     * WARNING: This might create new nodeDefs (for pipes and literal arrays and literal maps)!\n     * @param {?} expression\n     * @return {?}\n     */\n    function (expression) {\n        var _this = this;\n        return {\n            nodeIndex: expression.nodeIndex,\n            bindingIndex: expression.bindingIndex,\n            sourceSpan: expression.sourceSpan,\n            context: expression.context,\n            value: convertPropertyBindingBuiltins({\n                createLiteralArrayConverter: function (argCount) {\n                    return _this._createLiteralArrayConverter(expression.sourceSpan, argCount);\n                },\n                createLiteralMapConverter: function (keys) {\n                    return _this._createLiteralMapConverter(expression.sourceSpan, keys);\n                },\n                createPipeConverter: function (name, argCount) {\n                    return _this._createPipeConverter(expression, name, argCount);\n                }\n            }, expression.value)\n        };\n    };\n    /**\n     * @return {?}\n     */\n    ViewBuilder.prototype._createNodeExpressions = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ self = this;\n        var /** @type {?} */ updateBindingCount = 0;\n        var /** @type {?} */ updateRendererStmts = [];\n        var /** @type {?} */ updateDirectivesStmts = [];\n        var /** @type {?} */ nodeDefExprs = this.nodes.map(function (factory, nodeIndex) {\n            var _a = factory(), nodeDef = _a.nodeDef, nodeFlags = _a.nodeFlags, updateDirectives = _a.updateDirectives, updateRenderer = _a.updateRenderer, sourceSpan = _a.sourceSpan;\n            if (updateRenderer) {\n                updateRendererStmts.push.apply(updateRendererStmts, createUpdateStatements(nodeIndex, sourceSpan, updateRenderer, false));\n            }\n            if (updateDirectives) {\n                updateDirectivesStmts.push.apply(updateDirectivesStmts, createUpdateStatements(nodeIndex, sourceSpan, updateDirectives, (nodeFlags & (262144 /* DoCheck */ | 65536 /* OnInit */)) > 0));\n            }\n            // We use a comma expression to call the log function before\n            // the nodeDef function, but still use the result of the nodeDef function\n            // as the value.\n            // Note: We only add the logger to elements / text nodes,\n            // so we don't generate too much code.\n            var /** @type {?} */ logWithNodeDef = nodeFlags & 3 /* CatRenderNode */ ?\n                new CommaExpr([LOG_VAR$1.callFn([]).callFn([]), nodeDef]) :\n                nodeDef;\n            return applySourceSpanToExpressionIfNeeded(logWithNodeDef, sourceSpan);\n        });\n        return { updateRendererStmts: updateRendererStmts, updateDirectivesStmts: updateDirectivesStmts, nodeDefExprs: nodeDefExprs };\n        /**\n         * @param {?} nodeIndex\n         * @param {?} sourceSpan\n         * @param {?} expressions\n         * @param {?} allowEmptyExprs\n         * @return {?}\n         */\n        function createUpdateStatements(nodeIndex, sourceSpan, expressions, allowEmptyExprs) {\n            var /** @type {?} */ updateStmts = [];\n            var /** @type {?} */ exprs = expressions.map(function (_a) {\n                var sourceSpan = _a.sourceSpan, context = _a.context, value = _a.value;\n                var /** @type {?} */ bindingId = \"\" + updateBindingCount++;\n                var /** @type {?} */ nameResolver = context === COMP_VAR ? self : null;\n                var _b = convertPropertyBinding(nameResolver, context, value, bindingId, BindingForm.General), stmts = _b.stmts, currValExpr = _b.currValExpr;\n                updateStmts.push.apply(updateStmts, stmts.map(function (stmt) { return applySourceSpanToStatementIfNeeded(stmt, sourceSpan); }));\n                return applySourceSpanToExpressionIfNeeded(currValExpr, sourceSpan);\n            });\n            if (expressions.length || allowEmptyExprs) {\n                updateStmts.push(applySourceSpanToStatementIfNeeded(callCheckStmt(nodeIndex, exprs).toStmt(), sourceSpan));\n            }\n            return updateStmts;\n        }\n    };\n    /**\n     * @param {?} nodeIndex\n     * @param {?} handlers\n     * @return {?}\n     */\n    ViewBuilder.prototype._createElementHandleEventFn = /**\n     * @param {?} nodeIndex\n     * @param {?} handlers\n     * @return {?}\n     */\n    function (nodeIndex, handlers) {\n        var _this = this;\n        var /** @type {?} */ handleEventStmts = [];\n        var /** @type {?} */ handleEventBindingCount = 0;\n        handlers.forEach(function (_a) {\n            var context = _a.context, eventAst = _a.eventAst, dirAst = _a.dirAst;\n            var /** @type {?} */ bindingId = \"\" + handleEventBindingCount++;\n            var /** @type {?} */ nameResolver = context === COMP_VAR ? _this : null;\n            var _b = convertActionBinding(nameResolver, context, eventAst.handler, bindingId), stmts = _b.stmts, allowDefault = _b.allowDefault;\n            var /** @type {?} */ trueStmts = stmts;\n            if (allowDefault) {\n                trueStmts.push(ALLOW_DEFAULT_VAR.set(allowDefault.and(ALLOW_DEFAULT_VAR)).toStmt());\n            }\n            var _c = elementEventNameAndTarget(eventAst, dirAst), eventTarget = _c.target, eventName = _c.name;\n            var /** @type {?} */ fullEventName = elementEventFullName(eventTarget, eventName);\n            handleEventStmts.push(applySourceSpanToStatementIfNeeded(new IfStmt(literal(fullEventName).identical(EVENT_NAME_VAR), trueStmts), eventAst.sourceSpan));\n        });\n        var /** @type {?} */ handleEventFn;\n        if (handleEventStmts.length > 0) {\n            var /** @type {?} */ preStmts = [ALLOW_DEFAULT_VAR.set(literal(true)).toDeclStmt(BOOL_TYPE)];\n            if (!this.component.isHost && findReadVarNames(handleEventStmts).has(/** @type {?} */ ((COMP_VAR.name)))) {\n                preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType));\n            }\n            handleEventFn = fn([\n                new FnParam(/** @type {?} */ ((VIEW_VAR.name)), INFERRED_TYPE),\n                new FnParam(/** @type {?} */ ((EVENT_NAME_VAR.name)), INFERRED_TYPE),\n                new FnParam(/** @type {?} */ ((EventHandlerVars.event.name)), INFERRED_TYPE)\n            ], preStmts.concat(handleEventStmts, [new ReturnStatement(ALLOW_DEFAULT_VAR)]), INFERRED_TYPE);\n        }\n        else {\n            handleEventFn = NULL_EXPR;\n        }\n        return handleEventFn;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitDirective = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitDirectiveProperty = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitReference = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitVariable = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitEvent = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitElementProperty = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    ViewBuilder.prototype.visitAttr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) { };\n    return ViewBuilder;\n}());\n/**\n * @param {?} astNodes\n * @return {?}\n */\nfunction needsAdditionalRootNode(astNodes) {\n    var /** @type {?} */ lastAstNode = astNodes[astNodes.length - 1];\n    if (lastAstNode instanceof EmbeddedTemplateAst) {\n        return lastAstNode.hasViewContainer;\n    }\n    if (lastAstNode instanceof ElementAst) {\n        if (isNgContainer(lastAstNode.name) && lastAstNode.children.length) {\n            return needsAdditionalRootNode(lastAstNode.children);\n        }\n        return lastAstNode.hasViewContainer;\n    }\n    return lastAstNode instanceof NgContentAst;\n}\n/**\n * @param {?} inputAst\n * @param {?} dirAst\n * @return {?}\n */\nfunction elementBindingDef(inputAst, dirAst) {\n    switch (inputAst.type) {\n        case PropertyBindingType.Attribute:\n            return literalArr([\n                literal(1 /* TypeElementAttribute */), literal(inputAst.name),\n                literal(inputAst.securityContext)\n            ]);\n        case PropertyBindingType.Property:\n            return literalArr([\n                literal(8 /* TypeProperty */), literal(inputAst.name),\n                literal(inputAst.securityContext)\n            ]);\n        case PropertyBindingType.Animation:\n            var /** @type {?} */ bindingType = 8 /* TypeProperty */ |\n                (dirAst && dirAst.directive.isComponent ? 32 /* SyntheticHostProperty */ :\n                    16 /* SyntheticProperty */);\n            return literalArr([\n                literal(bindingType), literal('@' + inputAst.name), literal(inputAst.securityContext)\n            ]);\n        case PropertyBindingType.Class:\n            return literalArr([literal(2 /* TypeElementClass */), literal(inputAst.name), NULL_EXPR]);\n        case PropertyBindingType.Style:\n            return literalArr([\n                literal(4 /* TypeElementStyle */), literal(inputAst.name), literal(inputAst.unit)\n            ]);\n    }\n}\n/**\n * @param {?} elementAst\n * @return {?}\n */\nfunction fixedAttrsDef(elementAst) {\n    var /** @type {?} */ mapResult = Object.create(null);\n    elementAst.attrs.forEach(function (attrAst) { mapResult[attrAst.name] = attrAst.value; });\n    elementAst.directives.forEach(function (dirAst) {\n        Object.keys(dirAst.directive.hostAttributes).forEach(function (name) {\n            var /** @type {?} */ value = dirAst.directive.hostAttributes[name];\n            var /** @type {?} */ prevValue = mapResult[name];\n            mapResult[name] = prevValue != null ? mergeAttributeValue(name, prevValue, value) : value;\n        });\n    });\n    // Note: We need to sort to get a defined output order\n    // for tests and for caching generated artifacts...\n    return literalArr(Object.keys(mapResult).sort().map(function (attrName) { return literalArr([literal(attrName), literal(mapResult[attrName])]); }));\n}\n/**\n * @param {?} attrName\n * @param {?} attrValue1\n * @param {?} attrValue2\n * @return {?}\n */\nfunction mergeAttributeValue(attrName, attrValue1, attrValue2) {\n    if (attrName == CLASS_ATTR$1 || attrName == STYLE_ATTR) {\n        return attrValue1 + \" \" + attrValue2;\n    }\n    else {\n        return attrValue2;\n    }\n}\n/**\n * @param {?} nodeIndex\n * @param {?} exprs\n * @return {?}\n */\nfunction callCheckStmt(nodeIndex, exprs) {\n    if (exprs.length > 10) {\n        return CHECK_VAR.callFn([VIEW_VAR, literal(nodeIndex), literal(1 /* Dynamic */), literalArr(exprs)]);\n    }\n    else {\n        return CHECK_VAR.callFn([VIEW_VAR, literal(nodeIndex), literal(0 /* Inline */)].concat(exprs));\n    }\n}\n/**\n * @param {?} nodeIndex\n * @param {?} bindingIdx\n * @param {?} expr\n * @return {?}\n */\nfunction callUnwrapValue(nodeIndex, bindingIdx, expr) {\n    return importExpr(Identifiers.unwrapValue).callFn([\n        VIEW_VAR, literal(nodeIndex), literal(bindingIdx), expr\n    ]);\n}\n/**\n * @param {?} nodes\n * @param {?=} result\n * @return {?}\n */\nfunction findStaticQueryIds(nodes, result) {\n    if (result === void 0) { result = new Map(); }\n    nodes.forEach(function (node) {\n        var /** @type {?} */ staticQueryIds = new Set();\n        var /** @type {?} */ dynamicQueryIds = new Set();\n        var /** @type {?} */ queryMatches = /** @type {?} */ ((undefined));\n        if (node instanceof ElementAst) {\n            findStaticQueryIds(node.children, result);\n            node.children.forEach(function (child) {\n                var /** @type {?} */ childData = /** @type {?} */ ((result.get(child)));\n                childData.staticQueryIds.forEach(function (queryId) { return staticQueryIds.add(queryId); });\n                childData.dynamicQueryIds.forEach(function (queryId) { return dynamicQueryIds.add(queryId); });\n            });\n            queryMatches = node.queryMatches;\n        }\n        else if (node instanceof EmbeddedTemplateAst) {\n            findStaticQueryIds(node.children, result);\n            node.children.forEach(function (child) {\n                var /** @type {?} */ childData = /** @type {?} */ ((result.get(child)));\n                childData.staticQueryIds.forEach(function (queryId) { return dynamicQueryIds.add(queryId); });\n                childData.dynamicQueryIds.forEach(function (queryId) { return dynamicQueryIds.add(queryId); });\n            });\n            queryMatches = node.queryMatches;\n        }\n        if (queryMatches) {\n            queryMatches.forEach(function (match) { return staticQueryIds.add(match.queryId); });\n        }\n        dynamicQueryIds.forEach(function (queryId) { return staticQueryIds.delete(queryId); });\n        result.set(node, { staticQueryIds: staticQueryIds, dynamicQueryIds: dynamicQueryIds });\n    });\n    return result;\n}\n/**\n * @param {?} nodeStaticQueryIds\n * @return {?}\n */\nfunction staticViewQueryIds(nodeStaticQueryIds) {\n    var /** @type {?} */ staticQueryIds = new Set();\n    var /** @type {?} */ dynamicQueryIds = new Set();\n    Array.from(nodeStaticQueryIds.values()).forEach(function (entry) {\n        entry.staticQueryIds.forEach(function (queryId) { return staticQueryIds.add(queryId); });\n        entry.dynamicQueryIds.forEach(function (queryId) { return dynamicQueryIds.add(queryId); });\n    });\n    dynamicQueryIds.forEach(function (queryId) { return staticQueryIds.delete(queryId); });\n    return { staticQueryIds: staticQueryIds, dynamicQueryIds: dynamicQueryIds };\n}\n/**\n * @param {?} eventAst\n * @param {?} dirAst\n * @return {?}\n */\nfunction elementEventNameAndTarget(eventAst, dirAst) {\n    if (eventAst.isAnimation) {\n        return {\n            name: \"@\" + eventAst.name + \".\" + eventAst.phase,\n            target: dirAst && dirAst.directive.isComponent ? 'component' : null\n        };\n    }\n    else {\n        return eventAst;\n    }\n}\n/**\n * @param {?} queryIds\n * @param {?} queryId\n * @param {?} isFirst\n * @return {?}\n */\nfunction calcStaticDynamicQueryFlags(queryIds, queryId, isFirst) {\n    var /** @type {?} */ flags = 0;\n    // Note: We only make queries static that query for a single item.\n    // This is because of backwards compatibility with the old view compiler...\n    if (isFirst && (queryIds.staticQueryIds.has(queryId) || !queryIds.dynamicQueryIds.has(queryId))) {\n        flags |= 268435456 /* StaticQuery */;\n    }\n    else {\n        flags |= 536870912 /* DynamicQuery */;\n    }\n    return flags;\n}\n/**\n * @param {?} target\n * @param {?} name\n * @return {?}\n */\nfunction elementEventFullName(target, name) {\n    return target ? target + \":\" + name : name;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * A container for message extracted from the templates.\n */\nvar MessageBundle = /** @class */ (function () {\n    function MessageBundle(_htmlParser, _implicitTags, _implicitAttrs, _locale) {\n        if (_locale === void 0) { _locale = null; }\n        this._htmlParser = _htmlParser;\n        this._implicitTags = _implicitTags;\n        this._implicitAttrs = _implicitAttrs;\n        this._locale = _locale;\n        this._messages = [];\n    }\n    /**\n     * @param {?} html\n     * @param {?} url\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    MessageBundle.prototype.updateFromTemplate = /**\n     * @param {?} html\n     * @param {?} url\n     * @param {?} interpolationConfig\n     * @return {?}\n     */\n    function (html, url, interpolationConfig) {\n        var /** @type {?} */ htmlParserResult = this._htmlParser.parse(html, url, true, interpolationConfig);\n        if (htmlParserResult.errors.length) {\n            return htmlParserResult.errors;\n        }\n        var /** @type {?} */ i18nParserResult = extractMessages(htmlParserResult.rootNodes, interpolationConfig, this._implicitTags, this._implicitAttrs);\n        if (i18nParserResult.errors.length) {\n            return i18nParserResult.errors;\n        }\n        (_a = this._messages).push.apply(_a, i18nParserResult.messages);\n        return [];\n        var _a;\n    };\n    // Return the message in the internal format\n    // The public (serialized) format might be different, see the `write` method.\n    /**\n     * @return {?}\n     */\n    MessageBundle.prototype.getMessages = /**\n     * @return {?}\n     */\n    function () { return this._messages; };\n    /**\n     * @param {?} serializer\n     * @param {?=} filterSources\n     * @return {?}\n     */\n    MessageBundle.prototype.write = /**\n     * @param {?} serializer\n     * @param {?=} filterSources\n     * @return {?}\n     */\n    function (serializer, filterSources) {\n        var /** @type {?} */ messages = {};\n        var /** @type {?} */ mapperVisitor = new MapPlaceholderNames();\n        // Deduplicate messages based on their ID\n        this._messages.forEach(function (message) {\n            var /** @type {?} */ id = serializer.digest(message);\n            if (!messages.hasOwnProperty(id)) {\n                messages[id] = message;\n            }\n            else {\n                (_a = messages[id].sources).push.apply(_a, message.sources);\n            }\n            var _a;\n        });\n        // Transform placeholder names using the serializer mapping\n        var /** @type {?} */ msgList = Object.keys(messages).map(function (id) {\n            var /** @type {?} */ mapper = serializer.createNameMapper(messages[id]);\n            var /** @type {?} */ src = messages[id];\n            var /** @type {?} */ nodes = mapper ? mapperVisitor.convert(src.nodes, mapper) : src.nodes;\n            var /** @type {?} */ transformedMessage = new Message(nodes, {}, {}, src.meaning, src.description, id);\n            transformedMessage.sources = src.sources;\n            if (filterSources) {\n                transformedMessage.sources.forEach(function (source) { return source.filePath = filterSources(source.filePath); });\n            }\n            return transformedMessage;\n        });\n        return serializer.write(msgList, this._locale);\n    };\n    return MessageBundle;\n}());\nvar MapPlaceholderNames = /** @class */ (function (_super) {\n    __extends(MapPlaceholderNames, _super);\n    function MapPlaceholderNames() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param {?} nodes\n     * @param {?} mapper\n     * @return {?}\n     */\n    MapPlaceholderNames.prototype.convert = /**\n     * @param {?} nodes\n     * @param {?} mapper\n     * @return {?}\n     */\n    function (nodes, mapper) {\n        var _this = this;\n        return mapper ? nodes.map(function (n) { return n.visit(_this, mapper); }) : nodes;\n    };\n    /**\n     * @param {?} ph\n     * @param {?} mapper\n     * @return {?}\n     */\n    MapPlaceholderNames.prototype.visitTagPlaceholder = /**\n     * @param {?} ph\n     * @param {?} mapper\n     * @return {?}\n     */\n    function (ph, mapper) {\n        var _this = this;\n        var /** @type {?} */ startName = /** @type {?} */ ((mapper.toPublicName(ph.startName)));\n        var /** @type {?} */ closeName = ph.closeName ? /** @type {?} */ ((mapper.toPublicName(ph.closeName))) : ph.closeName;\n        var /** @type {?} */ children = ph.children.map(function (n) { return n.visit(_this, mapper); });\n        return new TagPlaceholder(ph.tag, ph.attrs, startName, closeName, children, ph.isVoid, ph.sourceSpan);\n    };\n    /**\n     * @param {?} ph\n     * @param {?} mapper\n     * @return {?}\n     */\n    MapPlaceholderNames.prototype.visitPlaceholder = /**\n     * @param {?} ph\n     * @param {?} mapper\n     * @return {?}\n     */\n    function (ph, mapper) {\n        return new Placeholder(ph.value, /** @type {?} */ ((mapper.toPublicName(ph.name))), ph.sourceSpan);\n    };\n    /**\n     * @param {?} ph\n     * @param {?} mapper\n     * @return {?}\n     */\n    MapPlaceholderNames.prototype.visitIcuPlaceholder = /**\n     * @param {?} ph\n     * @param {?} mapper\n     * @return {?}\n     */\n    function (ph, mapper) {\n        return new IcuPlaceholder(ph.value, /** @type {?} */ ((mapper.toPublicName(ph.name))), ph.sourceSpan);\n    };\n    return MapPlaceholderNames;\n}(CloneVisitor));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar GeneratedFile = /** @class */ (function () {\n    function GeneratedFile(srcFileUrl, genFileUrl, sourceOrStmts) {\n        this.srcFileUrl = srcFileUrl;\n        this.genFileUrl = genFileUrl;\n        if (typeof sourceOrStmts === 'string') {\n            this.source = sourceOrStmts;\n            this.stmts = null;\n        }\n        else {\n            this.source = null;\n            this.stmts = sourceOrStmts;\n        }\n    }\n    /**\n     * @param {?} other\n     * @return {?}\n     */\n    GeneratedFile.prototype.isEquivalent = /**\n     * @param {?} other\n     * @return {?}\n     */\n    function (other) {\n        if (this.genFileUrl !== other.genFileUrl) {\n            return false;\n        }\n        if (this.source) {\n            return this.source === other.source;\n        }\n        if (other.stmts == null) {\n            return false;\n        }\n        // Note: the constructor guarantees that if this.source is not filled,\n        // then this.stmts is.\n        return areAllEquivalent(/** @type {?} */ ((this.stmts)), /** @type {?} */ ((other.stmts)));\n    };\n    return GeneratedFile;\n}());\n/**\n * @param {?} file\n * @param {?=} preamble\n * @return {?}\n */\nfunction toTypeScript(file, preamble) {\n    if (preamble === void 0) { preamble = ''; }\n    if (!file.stmts) {\n        throw new Error(\"Illegal state: No stmts present on GeneratedFile \" + file.genFileUrl);\n    }\n    return new TypeScriptEmitter().emitStatements(file.genFileUrl, file.stmts, preamble);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @record\n */\n\n/**\n * @param {?} moduleMeta\n * @param {?} reflector\n * @return {?}\n */\nfunction listLazyRoutes(moduleMeta, reflector) {\n    var /** @type {?} */ allLazyRoutes = [];\n    for (var _i = 0, _a = moduleMeta.transitiveModule.providers; _i < _a.length; _i++) {\n        var _b = _a[_i], provider = _b.provider, module = _b.module;\n        if (tokenReference(provider.token) === reflector.ROUTES) {\n            var /** @type {?} */ loadChildren = _collectLoadChildren(provider.useValue);\n            for (var _c = 0, loadChildren_1 = loadChildren; _c < loadChildren_1.length; _c++) {\n                var route = loadChildren_1[_c];\n                allLazyRoutes.push(parseLazyRoute(route, reflector, module.reference));\n            }\n        }\n    }\n    return allLazyRoutes;\n}\n/**\n * @param {?} routes\n * @param {?=} target\n * @return {?}\n */\nfunction _collectLoadChildren(routes, target) {\n    if (target === void 0) { target = []; }\n    if (typeof routes === 'string') {\n        target.push(routes);\n    }\n    else if (Array.isArray(routes)) {\n        for (var _i = 0, routes_1 = routes; _i < routes_1.length; _i++) {\n            var route = routes_1[_i];\n            _collectLoadChildren(route, target);\n        }\n    }\n    else if (routes.loadChildren) {\n        _collectLoadChildren(routes.loadChildren, target);\n    }\n    else if (routes.children) {\n        _collectLoadChildren(routes.children, target);\n    }\n    return target;\n}\n/**\n * @param {?} route\n * @param {?} reflector\n * @param {?=} module\n * @return {?}\n */\nfunction parseLazyRoute(route, reflector, module) {\n    var _a = route.split('#'), routePath = _a[0], routeName = _a[1];\n    var /** @type {?} */ referencedModule = reflector.resolveExternalReference({\n        moduleName: routePath,\n        name: routeName,\n    }, module ? module.filePath : undefined);\n    return { route: route, module: module || referencedModule, referencedModule: referencedModule };\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ResolvedStaticSymbol = /** @class */ (function () {\n    function ResolvedStaticSymbol(symbol, metadata) {\n        this.symbol = symbol;\n        this.metadata = metadata;\n    }\n    return ResolvedStaticSymbol;\n}());\n/**\n * The host of the SymbolResolverHost disconnects the implementation from TypeScript / other\n * language\n * services and from underlying file systems.\n * @record\n */\n\nvar SUPPORTED_SCHEMA_VERSION = 4;\n/**\n * This class is responsible for loading metadata per symbol,\n * and normalizing references between symbols.\n *\n * Internally, it only uses symbols without members,\n * and deduces the values for symbols with members based\n * on these symbols.\n */\nvar StaticSymbolResolver = /** @class */ (function () {\n    function StaticSymbolResolver(host, staticSymbolCache, summaryResolver, errorRecorder) {\n        this.host = host;\n        this.staticSymbolCache = staticSymbolCache;\n        this.summaryResolver = summaryResolver;\n        this.errorRecorder = errorRecorder;\n        this.metadataCache = new Map();\n        this.resolvedSymbols = new Map();\n        this.resolvedFilePaths = new Set();\n        this.importAs = new Map();\n        this.symbolResourcePaths = new Map();\n        this.symbolFromFile = new Map();\n        this.knownFileNameToModuleNames = new Map();\n    }\n    /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.resolveSymbol = /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    function (staticSymbol) {\n        if (staticSymbol.members.length > 0) {\n            return /** @type {?} */ ((this._resolveSymbolMembers(staticSymbol)));\n        }\n        // Note: always ask for a summary first,\n        // as we might have read shallow metadata via a .d.ts file\n        // for the symbol.\n        var /** @type {?} */ resultFromSummary = /** @type {?} */ ((this._resolveSymbolFromSummary(staticSymbol)));\n        if (resultFromSummary) {\n            return resultFromSummary;\n        }\n        var /** @type {?} */ resultFromCache = this.resolvedSymbols.get(staticSymbol);\n        if (resultFromCache) {\n            return resultFromCache;\n        }\n        // Note: Some users use libraries that were not compiled with ngc, i.e. they don't\n        // have summaries, only .d.ts files. So we always need to check both, the summary\n        // and metadata.\n        this._createSymbolsOf(staticSymbol.filePath);\n        return /** @type {?} */ ((this.resolvedSymbols.get(staticSymbol)));\n    };\n    /**\n     * getImportAs produces a symbol that can be used to import the given symbol.\n     * The import might be different than the symbol if the symbol is exported from\n     * a library with a summary; in which case we want to import the symbol from the\n     * ngfactory re-export instead of directly to avoid introducing a direct dependency\n     * on an otherwise indirect dependency.\n     *\n     * @param staticSymbol the symbol for which to generate a import symbol\n     */\n    /**\n     * getImportAs produces a symbol that can be used to import the given symbol.\n     * The import might be different than the symbol if the symbol is exported from\n     * a library with a summary; in which case we want to import the symbol from the\n     * ngfactory re-export instead of directly to avoid introducing a direct dependency\n     * on an otherwise indirect dependency.\n     *\n     * @param {?} staticSymbol the symbol for which to generate a import symbol\n     * @param {?=} useSummaries\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.getImportAs = /**\n     * getImportAs produces a symbol that can be used to import the given symbol.\n     * The import might be different than the symbol if the symbol is exported from\n     * a library with a summary; in which case we want to import the symbol from the\n     * ngfactory re-export instead of directly to avoid introducing a direct dependency\n     * on an otherwise indirect dependency.\n     *\n     * @param {?} staticSymbol the symbol for which to generate a import symbol\n     * @param {?=} useSummaries\n     * @return {?}\n     */\n    function (staticSymbol, useSummaries) {\n        if (useSummaries === void 0) { useSummaries = true; }\n        if (staticSymbol.members.length) {\n            var /** @type {?} */ baseSymbol = this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name);\n            var /** @type {?} */ baseImportAs = this.getImportAs(baseSymbol, useSummaries);\n            return baseImportAs ?\n                this.getStaticSymbol(baseImportAs.filePath, baseImportAs.name, staticSymbol.members) :\n                null;\n        }\n        var /** @type {?} */ summarizedFileName = stripSummaryForJitFileSuffix(staticSymbol.filePath);\n        if (summarizedFileName !== staticSymbol.filePath) {\n            var /** @type {?} */ summarizedName = stripSummaryForJitNameSuffix(staticSymbol.name);\n            var /** @type {?} */ baseSymbol = this.getStaticSymbol(summarizedFileName, summarizedName, staticSymbol.members);\n            var /** @type {?} */ baseImportAs = this.getImportAs(baseSymbol, useSummaries);\n            return baseImportAs ?\n                this.getStaticSymbol(summaryForJitFileName(baseImportAs.filePath), summaryForJitName(baseImportAs.name), baseSymbol.members) :\n                null;\n        }\n        var /** @type {?} */ result = (useSummaries && this.summaryResolver.getImportAs(staticSymbol)) || null;\n        if (!result) {\n            result = /** @type {?} */ ((this.importAs.get(staticSymbol)));\n        }\n        return result;\n    };\n    /**\n     * getResourcePath produces the path to the original location of the symbol and should\n     * be used to determine the relative location of resource references recorded in\n     * symbol metadata.\n     */\n    /**\n     * getResourcePath produces the path to the original location of the symbol and should\n     * be used to determine the relative location of resource references recorded in\n     * symbol metadata.\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.getResourcePath = /**\n     * getResourcePath produces the path to the original location of the symbol and should\n     * be used to determine the relative location of resource references recorded in\n     * symbol metadata.\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    function (staticSymbol) {\n        return this.symbolResourcePaths.get(staticSymbol) || staticSymbol.filePath;\n    };\n    /**\n     * getTypeArity returns the number of generic type parameters the given symbol\n     * has. If the symbol is not a type the result is null.\n     */\n    /**\n     * getTypeArity returns the number of generic type parameters the given symbol\n     * has. If the symbol is not a type the result is null.\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.getTypeArity = /**\n     * getTypeArity returns the number of generic type parameters the given symbol\n     * has. If the symbol is not a type the result is null.\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    function (staticSymbol) {\n        // If the file is a factory/ngsummary file, don't resolve the symbol as doing so would\n        // cause the metadata for an factory/ngsummary file to be loaded which doesn't exist.\n        // All references to generated classes must include the correct arity whenever\n        // generating code.\n        if (isGeneratedFile(staticSymbol.filePath)) {\n            return null;\n        }\n        var /** @type {?} */ resolvedSymbol = unwrapResolvedMetadata(this.resolveSymbol(staticSymbol));\n        while (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) {\n            resolvedSymbol = unwrapResolvedMetadata(this.resolveSymbol(resolvedSymbol.metadata));\n        }\n        return (resolvedSymbol && resolvedSymbol.metadata && resolvedSymbol.metadata.arity) || null;\n    };\n    /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.getKnownModuleName = /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    function (filePath) {\n        return this.knownFileNameToModuleNames.get(filePath) || null;\n    };\n    /**\n     * @param {?} sourceSymbol\n     * @param {?} targetSymbol\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.recordImportAs = /**\n     * @param {?} sourceSymbol\n     * @param {?} targetSymbol\n     * @return {?}\n     */\n    function (sourceSymbol, targetSymbol) {\n        sourceSymbol.assertNoMembers();\n        targetSymbol.assertNoMembers();\n        this.importAs.set(sourceSymbol, targetSymbol);\n    };\n    /**\n     * @param {?} fileName\n     * @param {?} moduleName\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.recordModuleNameForFileName = /**\n     * @param {?} fileName\n     * @param {?} moduleName\n     * @return {?}\n     */\n    function (fileName, moduleName) {\n        this.knownFileNameToModuleNames.set(fileName, moduleName);\n    };\n    /**\n     * Invalidate all information derived from the given file.\n     *\n     * @param fileName the file to invalidate\n     */\n    /**\n     * Invalidate all information derived from the given file.\n     *\n     * @param {?} fileName the file to invalidate\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.invalidateFile = /**\n     * Invalidate all information derived from the given file.\n     *\n     * @param {?} fileName the file to invalidate\n     * @return {?}\n     */\n    function (fileName) {\n        this.metadataCache.delete(fileName);\n        this.resolvedFilePaths.delete(fileName);\n        var /** @type {?} */ symbols = this.symbolFromFile.get(fileName);\n        if (symbols) {\n            this.symbolFromFile.delete(fileName);\n            for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {\n                var symbol = symbols_1[_i];\n                this.resolvedSymbols.delete(symbol);\n                this.importAs.delete(symbol);\n                this.symbolResourcePaths.delete(symbol);\n            }\n        }\n    };\n    /* @internal */\n    /**\n     * @template T\n     * @param {?} cb\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.ignoreErrorsFor = /**\n     * @template T\n     * @param {?} cb\n     * @return {?}\n     */\n    function (cb) {\n        var /** @type {?} */ recorder = this.errorRecorder;\n        this.errorRecorder = function () { };\n        try {\n            return cb();\n        }\n        finally {\n            this.errorRecorder = recorder;\n        }\n    };\n    /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype._resolveSymbolMembers = /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    function (staticSymbol) {\n        var /** @type {?} */ members = staticSymbol.members;\n        var /** @type {?} */ baseResolvedSymbol = this.resolveSymbol(this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name));\n        if (!baseResolvedSymbol) {\n            return null;\n        }\n        var /** @type {?} */ baseMetadata = unwrapResolvedMetadata(baseResolvedSymbol.metadata);\n        if (baseMetadata instanceof StaticSymbol) {\n            return new ResolvedStaticSymbol(staticSymbol, this.getStaticSymbol(baseMetadata.filePath, baseMetadata.name, members));\n        }\n        else if (baseMetadata && baseMetadata.__symbolic === 'class') {\n            if (baseMetadata.statics && members.length === 1) {\n                return new ResolvedStaticSymbol(staticSymbol, baseMetadata.statics[members[0]]);\n            }\n        }\n        else {\n            var /** @type {?} */ value = baseMetadata;\n            for (var /** @type {?} */ i = 0; i < members.length && value; i++) {\n                value = value[members[i]];\n            }\n            return new ResolvedStaticSymbol(staticSymbol, value);\n        }\n        return null;\n    };\n    /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype._resolveSymbolFromSummary = /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    function (staticSymbol) {\n        var /** @type {?} */ summary = this.summaryResolver.resolveSummary(staticSymbol);\n        return summary ? new ResolvedStaticSymbol(staticSymbol, summary.metadata) : null;\n    };\n    /**\n     * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.\n     * All types passed to the StaticResolver should be pseudo-types returned by this method.\n     *\n     * @param declarationFile the absolute path of the file where the symbol is declared\n     * @param name the name of the type.\n     * @param members a symbol for a static member of the named type\n     */\n    /**\n     * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.\n     * All types passed to the StaticResolver should be pseudo-types returned by this method.\n     *\n     * @param {?} declarationFile the absolute path of the file where the symbol is declared\n     * @param {?} name the name of the type.\n     * @param {?=} members a symbol for a static member of the named type\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.getStaticSymbol = /**\n     * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.\n     * All types passed to the StaticResolver should be pseudo-types returned by this method.\n     *\n     * @param {?} declarationFile the absolute path of the file where the symbol is declared\n     * @param {?} name the name of the type.\n     * @param {?=} members a symbol for a static member of the named type\n     * @return {?}\n     */\n    function (declarationFile, name, members) {\n        return this.staticSymbolCache.get(declarationFile, name, members);\n    };\n    /**\n     * hasDecorators checks a file's metadata for the presense of decorators without evalutating the\n     * metadata.\n     *\n     * @param filePath the absolute path to examine for decorators.\n     * @returns true if any class in the file has a decorator.\n     */\n    /**\n     * hasDecorators checks a file's metadata for the presense of decorators without evalutating the\n     * metadata.\n     *\n     * @param {?} filePath the absolute path to examine for decorators.\n     * @return {?} true if any class in the file has a decorator.\n     */\n    StaticSymbolResolver.prototype.hasDecorators = /**\n     * hasDecorators checks a file's metadata for the presense of decorators without evalutating the\n     * metadata.\n     *\n     * @param {?} filePath the absolute path to examine for decorators.\n     * @return {?} true if any class in the file has a decorator.\n     */\n    function (filePath) {\n        var /** @type {?} */ metadata = this.getModuleMetadata(filePath);\n        if (metadata['metadata']) {\n            return Object.keys(metadata['metadata']).some(function (metadataKey) {\n                var /** @type {?} */ entry = metadata['metadata'][metadataKey];\n                return entry && entry.__symbolic === 'class' && entry.decorators;\n            });\n        }\n        return false;\n    };\n    /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.getSymbolsOf = /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    function (filePath) {\n        var /** @type {?} */ summarySymbols = this.summaryResolver.getSymbolsOf(filePath);\n        if (summarySymbols) {\n            return summarySymbols;\n        }\n        // Note: Some users use libraries that were not compiled with ngc, i.e. they don't\n        // have summaries, only .d.ts files, but `summaryResolver.isLibraryFile` returns true.\n        this._createSymbolsOf(filePath);\n        var /** @type {?} */ metadataSymbols = [];\n        this.resolvedSymbols.forEach(function (resolvedSymbol) {\n            if (resolvedSymbol.symbol.filePath === filePath) {\n                metadataSymbols.push(resolvedSymbol.symbol);\n            }\n        });\n        return metadataSymbols;\n    };\n    /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype._createSymbolsOf = /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    function (filePath) {\n        var _this = this;\n        if (this.resolvedFilePaths.has(filePath)) {\n            return;\n        }\n        this.resolvedFilePaths.add(filePath);\n        var /** @type {?} */ resolvedSymbols = [];\n        var /** @type {?} */ metadata = this.getModuleMetadata(filePath);\n        if (metadata['importAs']) {\n            // Index bundle indices should use the importAs module name defined\n            // in the bundle.\n            this.knownFileNameToModuleNames.set(filePath, metadata['importAs']);\n        }\n        // handle the symbols in one of the re-export location\n        if (metadata['exports']) {\n            var _loop_1 = function (moduleExport) {\n                // handle the symbols in the list of explicitly re-exported symbols.\n                if (moduleExport.export) {\n                    moduleExport.export.forEach(function (exportSymbol) {\n                        var /** @type {?} */ symbolName;\n                        if (typeof exportSymbol === 'string') {\n                            symbolName = exportSymbol;\n                        }\n                        else {\n                            symbolName = exportSymbol.as;\n                        }\n                        symbolName = unescapeIdentifier(symbolName);\n                        var /** @type {?} */ symName = symbolName;\n                        if (typeof exportSymbol !== 'string') {\n                            symName = unescapeIdentifier(exportSymbol.name);\n                        }\n                        var /** @type {?} */ resolvedModule = _this.resolveModule(moduleExport.from, filePath);\n                        if (resolvedModule) {\n                            var /** @type {?} */ targetSymbol = _this.getStaticSymbol(resolvedModule, symName);\n                            var /** @type {?} */ sourceSymbol = _this.getStaticSymbol(filePath, symbolName);\n                            resolvedSymbols.push(_this.createExport(sourceSymbol, targetSymbol));\n                        }\n                    });\n                }\n                else {\n                    // handle the symbols via export * directives.\n                    var /** @type {?} */ resolvedModule = this_1.resolveModule(moduleExport.from, filePath);\n                    if (resolvedModule) {\n                        var /** @type {?} */ nestedExports = this_1.getSymbolsOf(resolvedModule);\n                        nestedExports.forEach(function (targetSymbol) {\n                            var /** @type {?} */ sourceSymbol = _this.getStaticSymbol(filePath, targetSymbol.name);\n                            resolvedSymbols.push(_this.createExport(sourceSymbol, targetSymbol));\n                        });\n                    }\n                }\n            };\n            var this_1 = this;\n            for (var _i = 0, _a = metadata['exports']; _i < _a.length; _i++) {\n                var moduleExport = _a[_i];\n                _loop_1(moduleExport);\n            }\n        }\n        // handle the actual metadata. Has to be after the exports\n        // as there migth be collisions in the names, and we want the symbols\n        // of the current module to win ofter reexports.\n        if (metadata['metadata']) {\n            // handle direct declarations of the symbol\n            var /** @type {?} */ topLevelSymbolNames_1 = new Set(Object.keys(metadata['metadata']).map(unescapeIdentifier));\n            var /** @type {?} */ origins_1 = metadata['origins'] || {};\n            Object.keys(metadata['metadata']).forEach(function (metadataKey) {\n                var /** @type {?} */ symbolMeta = metadata['metadata'][metadataKey];\n                var /** @type {?} */ name = unescapeIdentifier(metadataKey);\n                var /** @type {?} */ symbol = _this.getStaticSymbol(filePath, name);\n                var /** @type {?} */ origin = origins_1.hasOwnProperty(metadataKey) && origins_1[metadataKey];\n                if (origin) {\n                    // If the symbol is from a bundled index, use the declaration location of the\n                    // symbol so relative references (such as './my.html') will be calculated\n                    // correctly.\n                    var /** @type {?} */ originFilePath = _this.resolveModule(origin, filePath);\n                    if (!originFilePath) {\n                        _this.reportError(new Error(\"Couldn't resolve original symbol for \" + origin + \" from \" + filePath));\n                    }\n                    else {\n                        _this.symbolResourcePaths.set(symbol, originFilePath);\n                    }\n                }\n                resolvedSymbols.push(_this.createResolvedSymbol(symbol, filePath, topLevelSymbolNames_1, symbolMeta));\n            });\n        }\n        resolvedSymbols.forEach(function (resolvedSymbol) { return _this.resolvedSymbols.set(resolvedSymbol.symbol, resolvedSymbol); });\n        this.symbolFromFile.set(filePath, resolvedSymbols.map(function (resolvedSymbol) { return resolvedSymbol.symbol; }));\n    };\n    /**\n     * @param {?} sourceSymbol\n     * @param {?} topLevelPath\n     * @param {?} topLevelSymbolNames\n     * @param {?} metadata\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.createResolvedSymbol = /**\n     * @param {?} sourceSymbol\n     * @param {?} topLevelPath\n     * @param {?} topLevelSymbolNames\n     * @param {?} metadata\n     * @return {?}\n     */\n    function (sourceSymbol, topLevelPath, topLevelSymbolNames, metadata) {\n        var _this = this;\n        // For classes that don't have Angular summaries / metadata,\n        // we only keep their arity, but nothing else\n        // (e.g. their constructor parameters).\n        // We do this to prevent introducing deep imports\n        // as we didn't generate .ngfactory.ts files with proper reexports.\n        if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) && metadata &&\n            metadata['__symbolic'] === 'class') {\n            var /** @type {?} */ transformedMeta_1 = { __symbolic: 'class', arity: metadata.arity };\n            return new ResolvedStaticSymbol(sourceSymbol, transformedMeta_1);\n        }\n        var /** @type {?} */ _originalFileMemo;\n        var /** @type {?} */ getOriginalName = function () {\n            if (!_originalFileMemo) {\n                // Guess what hte original file name is from the reference. If it has a `.d.ts` extension\n                // replace it with `.ts`. If it already has `.ts` just leave it in place. If it doesn't have\n                // .ts or .d.ts, append `.ts'. Also, if it is in `node_modules`, trim the `node_module`\n                // location as it is not important to finding the file.\n                _originalFileMemo =\n                    _this.host.getOutputName(topLevelPath.replace(/((\\.ts)|(\\.d\\.ts)|)$/, '.ts')\n                        .replace(/^.*node_modules[/\\\\]/, ''));\n            }\n            return _originalFileMemo;\n        };\n        var /** @type {?} */ self = this;\n        var ReferenceTransformer = /** @class */ (function (_super) {\n            __extends(ReferenceTransformer, _super);\n            function ReferenceTransformer() {\n                return _super !== null && _super.apply(this, arguments) || this;\n            }\n            /**\n             * @param {?} map\n             * @param {?} functionParams\n             * @return {?}\n             */\n            ReferenceTransformer.prototype.visitStringMap = /**\n             * @param {?} map\n             * @param {?} functionParams\n             * @return {?}\n             */\n            function (map, functionParams) {\n                var /** @type {?} */ symbolic = map['__symbolic'];\n                if (symbolic === 'function') {\n                    var /** @type {?} */ oldLen = functionParams.length;\n                    functionParams.push.apply(functionParams, (map['parameters'] || []));\n                    var /** @type {?} */ result = _super.prototype.visitStringMap.call(this, map, functionParams);\n                    functionParams.length = oldLen;\n                    return result;\n                }\n                else if (symbolic === 'reference') {\n                    var /** @type {?} */ module = map['module'];\n                    var /** @type {?} */ name_1 = map['name'] ? unescapeIdentifier(map['name']) : map['name'];\n                    if (!name_1) {\n                        return null;\n                    }\n                    var /** @type {?} */ filePath = void 0;\n                    if (module) {\n                        filePath = /** @type {?} */ ((self.resolveModule(module, sourceSymbol.filePath)));\n                        if (!filePath) {\n                            return {\n                                __symbolic: 'error',\n                                message: \"Could not resolve \" + module + \" relative to \" + sourceSymbol.filePath + \".\",\n                                line: map[\"line\"],\n                                character: map[\"character\"],\n                                fileName: getOriginalName()\n                            };\n                        }\n                        return {\n                            __symbolic: 'resolved',\n                            symbol: self.getStaticSymbol(filePath, name_1),\n                            line: map[\"line\"],\n                            character: map[\"character\"],\n                            fileName: getOriginalName()\n                        };\n                    }\n                    else if (functionParams.indexOf(name_1) >= 0) {\n                        // reference to a function parameter\n                        return { __symbolic: 'reference', name: name_1 };\n                    }\n                    else {\n                        if (topLevelSymbolNames.has(name_1)) {\n                            return self.getStaticSymbol(topLevelPath, name_1);\n                        }\n                        // ambient value\n                        null;\n                    }\n                }\n                else if (symbolic === 'error') {\n                    return __assign({}, map, { fileName: getOriginalName() });\n                }\n                else {\n                    return _super.prototype.visitStringMap.call(this, map, functionParams);\n                }\n            };\n            return ReferenceTransformer;\n        }(ValueTransformer));\n        var /** @type {?} */ transformedMeta = visitValue(metadata, new ReferenceTransformer(), []);\n        var /** @type {?} */ unwrappedTransformedMeta = unwrapResolvedMetadata(transformedMeta);\n        if (unwrappedTransformedMeta instanceof StaticSymbol) {\n            return this.createExport(sourceSymbol, unwrappedTransformedMeta);\n        }\n        return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);\n    };\n    /**\n     * @param {?} sourceSymbol\n     * @param {?} targetSymbol\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.createExport = /**\n     * @param {?} sourceSymbol\n     * @param {?} targetSymbol\n     * @return {?}\n     */\n    function (sourceSymbol, targetSymbol) {\n        sourceSymbol.assertNoMembers();\n        targetSymbol.assertNoMembers();\n        if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) &&\n            this.summaryResolver.isLibraryFile(targetSymbol.filePath)) {\n            // This case is for an ng library importing symbols from a plain ts library\n            // transitively.\n            // Note: We rely on the fact that we discover symbols in the direction\n            // from source files to library files\n            this.importAs.set(targetSymbol, this.getImportAs(sourceSymbol) || sourceSymbol);\n        }\n        return new ResolvedStaticSymbol(sourceSymbol, targetSymbol);\n    };\n    /**\n     * @param {?} error\n     * @param {?=} context\n     * @param {?=} path\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.reportError = /**\n     * @param {?} error\n     * @param {?=} context\n     * @param {?=} path\n     * @return {?}\n     */\n    function (error, context, path) {\n        if (this.errorRecorder) {\n            this.errorRecorder(error, (context && context.filePath) || path);\n        }\n        else {\n            throw error;\n        }\n    };\n    /**\n     * @param {?} module an absolute path to a module file.\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.getModuleMetadata = /**\n     * @param {?} module an absolute path to a module file.\n     * @return {?}\n     */\n    function (module) {\n        var /** @type {?} */ moduleMetadata = this.metadataCache.get(module);\n        if (!moduleMetadata) {\n            var /** @type {?} */ moduleMetadatas = this.host.getMetadataFor(module);\n            if (moduleMetadatas) {\n                var /** @type {?} */ maxVersion_1 = -1;\n                moduleMetadatas.forEach(function (md) {\n                    if (md && md['version'] > maxVersion_1) {\n                        maxVersion_1 = md['version'];\n                        moduleMetadata = md;\n                    }\n                });\n            }\n            if (!moduleMetadata) {\n                moduleMetadata =\n                    { __symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {} };\n            }\n            if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {\n                var /** @type {?} */ errorMessage = moduleMetadata['version'] == 2 ?\n                    \"Unsupported metadata version \" + moduleMetadata['version'] + \" for module \" + module + \". This module should be compiled with a newer version of ngc\" :\n                    \"Metadata version mismatch for module \" + module + \", found version \" + moduleMetadata['version'] + \", expected \" + SUPPORTED_SCHEMA_VERSION;\n                this.reportError(new Error(errorMessage));\n            }\n            this.metadataCache.set(module, moduleMetadata);\n        }\n        return moduleMetadata;\n    };\n    /**\n     * @param {?} module\n     * @param {?} symbolName\n     * @param {?=} containingFile\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.getSymbolByModule = /**\n     * @param {?} module\n     * @param {?} symbolName\n     * @param {?=} containingFile\n     * @return {?}\n     */\n    function (module, symbolName, containingFile) {\n        var /** @type {?} */ filePath = this.resolveModule(module, containingFile);\n        if (!filePath) {\n            this.reportError(new Error(\"Could not resolve module \" + module + (containingFile ? ' relative to ' +\n                containingFile : '')));\n            return this.getStaticSymbol(\"ERROR:\" + module, symbolName);\n        }\n        return this.getStaticSymbol(filePath, symbolName);\n    };\n    /**\n     * @param {?} module\n     * @param {?=} containingFile\n     * @return {?}\n     */\n    StaticSymbolResolver.prototype.resolveModule = /**\n     * @param {?} module\n     * @param {?=} containingFile\n     * @return {?}\n     */\n    function (module, containingFile) {\n        try {\n            return this.host.moduleNameToFileName(module, containingFile);\n        }\n        catch (/** @type {?} */ e) {\n            console.error(\"Could not resolve module '\" + module + \"' relative to file \" + containingFile);\n            this.reportError(e, undefined, containingFile);\n        }\n        return null;\n    };\n    return StaticSymbolResolver;\n}());\n/**\n * @param {?} identifier\n * @return {?}\n */\nfunction unescapeIdentifier(identifier) {\n    return identifier.startsWith('___') ? identifier.substr(1) : identifier;\n}\n/**\n * @param {?} metadata\n * @return {?}\n */\nfunction unwrapResolvedMetadata(metadata) {\n    if (metadata && metadata.__symbolic === 'resolved') {\n        return metadata.symbol;\n    }\n    return metadata;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @param {?} srcFileName\n * @param {?} forJitCtx\n * @param {?} summaryResolver\n * @param {?} symbolResolver\n * @param {?} symbols\n * @param {?} types\n * @return {?}\n */\nfunction serializeSummaries(srcFileName, forJitCtx, summaryResolver, symbolResolver, symbols, types) {\n    var /** @type {?} */ toJsonSerializer = new ToJsonSerializer(symbolResolver, summaryResolver, srcFileName);\n    // for symbols, we use everything except for the class metadata itself\n    // (we keep the statics though), as the class metadata is contained in the\n    // CompileTypeSummary.\n    symbols.forEach(function (resolvedSymbol) {\n        return toJsonSerializer.addSummary({ symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata });\n    });\n    // Add type summaries.\n    types.forEach(function (_a) {\n        var summary = _a.summary, metadata = _a.metadata;\n        toJsonSerializer.addSummary({ symbol: summary.type.reference, metadata: undefined, type: summary });\n    });\n    var _a = toJsonSerializer.serialize(), json = _a.json, exportAs = _a.exportAs;\n    if (forJitCtx) {\n        var /** @type {?} */ forJitSerializer_1 = new ForJitSerializer(forJitCtx, symbolResolver, summaryResolver);\n        types.forEach(function (_a) {\n            var summary = _a.summary, metadata = _a.metadata;\n            forJitSerializer_1.addSourceType(summary, metadata);\n        });\n        toJsonSerializer.unprocessedSymbolSummariesBySymbol.forEach(function (summary) {\n            if (summaryResolver.isLibraryFile(summary.symbol.filePath) && summary.type) {\n                forJitSerializer_1.addLibType(summary.type);\n            }\n        });\n        forJitSerializer_1.serialize(exportAs);\n    }\n    return { json: json, exportAs: exportAs };\n}\n/**\n * @param {?} symbolCache\n * @param {?} summaryResolver\n * @param {?} libraryFileName\n * @param {?} json\n * @return {?}\n */\nfunction deserializeSummaries(symbolCache, summaryResolver, libraryFileName, json) {\n    var /** @type {?} */ deserializer = new FromJsonDeserializer(symbolCache, summaryResolver);\n    return deserializer.deserialize(libraryFileName, json);\n}\n/**\n * @param {?} outputCtx\n * @param {?} reference\n * @return {?}\n */\nfunction createForJitStub(outputCtx, reference) {\n    return createSummaryForJitFunction(outputCtx, reference, NULL_EXPR);\n}\n/**\n * @param {?} outputCtx\n * @param {?} reference\n * @param {?} value\n * @return {?}\n */\nfunction createSummaryForJitFunction(outputCtx, reference, value) {\n    var /** @type {?} */ fnName = summaryForJitName(reference.name);\n    outputCtx.statements.push(fn([], [new ReturnStatement(value)], new ArrayType(DYNAMIC_TYPE)).toDeclStmt(fnName, [\n        StmtModifier.Final, StmtModifier.Exported\n    ]));\n}\nvar ToJsonSerializer = /** @class */ (function (_super) {\n    __extends(ToJsonSerializer, _super);\n    function ToJsonSerializer(symbolResolver, summaryResolver, srcFileName) {\n        var _this = _super.call(this) || this;\n        _this.symbolResolver = symbolResolver;\n        _this.summaryResolver = summaryResolver;\n        _this.srcFileName = srcFileName;\n        _this.symbols = [];\n        _this.indexBySymbol = new Map();\n        _this.reexportedBy = new Map();\n        _this.processedSummaryBySymbol = new Map();\n        _this.processedSummaries = [];\n        _this.unprocessedSymbolSummariesBySymbol = new Map();\n        _this.moduleName = symbolResolver.getKnownModuleName(srcFileName);\n        return _this;\n    }\n    /**\n     * @param {?} summary\n     * @return {?}\n     */\n    ToJsonSerializer.prototype.addSummary = /**\n     * @param {?} summary\n     * @return {?}\n     */\n    function (summary) {\n        var _this = this;\n        var /** @type {?} */ unprocessedSummary = this.unprocessedSymbolSummariesBySymbol.get(summary.symbol);\n        var /** @type {?} */ processedSummary = this.processedSummaryBySymbol.get(summary.symbol);\n        if (!unprocessedSummary) {\n            unprocessedSummary = { symbol: summary.symbol, metadata: undefined };\n            this.unprocessedSymbolSummariesBySymbol.set(summary.symbol, unprocessedSummary);\n            processedSummary = { symbol: this.processValue(summary.symbol, 0 /* None */) };\n            this.processedSummaries.push(processedSummary);\n            this.processedSummaryBySymbol.set(summary.symbol, processedSummary);\n        }\n        if (!unprocessedSummary.metadata && summary.metadata) {\n            var /** @type {?} */ metadata_1 = summary.metadata || {};\n            if (metadata_1.__symbolic === 'class') {\n                // For classes, we keep everything except their class decorators.\n                // We need to keep e.g. the ctor args, method names, method decorators\n                // so that the class can be extended in another compilation unit.\n                // We don't keep the class decorators as\n                // 1) they refer to data\n                //   that should not cause a rebuild of downstream compilation units\n                //   (e.g. inline templates of @Component, or @NgModule.declarations)\n                // 2) their data is already captured in TypeSummaries, e.g. DirectiveSummary.\n                var /** @type {?} */ clone_1 = {};\n                Object.keys(metadata_1).forEach(function (propName) {\n                    if (propName !== 'decorators') {\n                        clone_1[propName] = metadata_1[propName];\n                    }\n                });\n                metadata_1 = clone_1;\n            }\n            else if (isCall(metadata_1)) {\n                if (!isFunctionCall(metadata_1) && !isMethodCallOnVariable(metadata_1)) {\n                    // Don't store complex calls as we won't be able to simplify them anyways later on.\n                    // Don't store complex calls as we won't be able to simplify them anyways later on.\n                    metadata_1 = {\n                        __symbolic: 'error',\n                        message: 'Complex function calls are not supported.',\n                    };\n                }\n            }\n            // Note: We need to keep storing ctor calls for e.g.\n            // `export const x = new InjectionToken(...)`\n            unprocessedSummary.metadata = metadata_1;\n            processedSummary.metadata = this.processValue(metadata_1, 1 /* ResolveValue */);\n            if (metadata_1 instanceof StaticSymbol &&\n                this.summaryResolver.isLibraryFile(metadata_1.filePath)) {\n                var /** @type {?} */ declarationSymbol = this.symbols[/** @type {?} */ ((this.indexBySymbol.get(metadata_1)))];\n                if (!isLoweredSymbol(declarationSymbol.name)) {\n                    // Note: symbols that were introduced during codegen in the user file can have a reexport\n                    // if a user used `export *`. However, we can't rely on this as tsickle will change\n                    // `export *` into named exports, using only the information from the typechecker.\n                    // As we introduce the new symbols after typecheck, Tsickle does not know about them,\n                    // and omits them when expanding `export *`.\n                    // So we have to keep reexporting these symbols manually via .ngfactory files.\n                    this.reexportedBy.set(declarationSymbol, summary.symbol);\n                }\n            }\n        }\n        if (!unprocessedSummary.type && summary.type) {\n            unprocessedSummary.type = summary.type;\n            // Note: We don't add the summaries of all referenced symbols as for the ResolvedSymbols,\n            // as the type summaries already contain the transitive data that they require\n            // (in a minimal way).\n            processedSummary.type = this.processValue(summary.type, 0 /* None */);\n            // except for reexported directives / pipes, so we need to store\n            // their summaries explicitly.\n            if (summary.type.summaryKind === CompileSummaryKind.NgModule) {\n                var /** @type {?} */ ngModuleSummary = /** @type {?} */ (summary.type);\n                ngModuleSummary.exportedDirectives.concat(ngModuleSummary.exportedPipes).forEach(function (id) {\n                    var /** @type {?} */ symbol = id.reference;\n                    if (_this.summaryResolver.isLibraryFile(symbol.filePath) &&\n                        !_this.unprocessedSymbolSummariesBySymbol.has(symbol)) {\n                        var /** @type {?} */ summary_1 = _this.summaryResolver.resolveSummary(symbol);\n                        if (summary_1) {\n                            _this.addSummary(summary_1);\n                        }\n                    }\n                });\n            }\n        }\n    };\n    /**\n     * @return {?}\n     */\n    ToJsonSerializer.prototype.serialize = /**\n     * @return {?}\n     */\n    function () {\n        var _this = this;\n        var /** @type {?} */ exportAs = [];\n        var /** @type {?} */ json = JSON.stringify({\n            moduleName: this.moduleName,\n            summaries: this.processedSummaries,\n            symbols: this.symbols.map(function (symbol, index) {\n                symbol.assertNoMembers();\n                var /** @type {?} */ importAs = /** @type {?} */ ((undefined));\n                if (_this.summaryResolver.isLibraryFile(symbol.filePath)) {\n                    var /** @type {?} */ reexportSymbol = _this.reexportedBy.get(symbol);\n                    if (reexportSymbol) {\n                        importAs = /** @type {?} */ ((_this.indexBySymbol.get(reexportSymbol)));\n                    }\n                    else {\n                        var /** @type {?} */ summary = _this.unprocessedSymbolSummariesBySymbol.get(symbol);\n                        if (!summary || !summary.metadata || summary.metadata.__symbolic !== 'interface') {\n                            importAs = symbol.name + \"_\" + index;\n                            exportAs.push({ symbol: symbol, exportAs: importAs });\n                        }\n                    }\n                }\n                return {\n                    __symbol: index,\n                    name: symbol.name,\n                    filePath: _this.summaryResolver.toSummaryFileName(symbol.filePath, _this.srcFileName),\n                    importAs: importAs\n                };\n            })\n        });\n        return { json: json, exportAs: exportAs };\n    };\n    /**\n     * @param {?} value\n     * @param {?} flags\n     * @return {?}\n     */\n    ToJsonSerializer.prototype.processValue = /**\n     * @param {?} value\n     * @param {?} flags\n     * @return {?}\n     */\n    function (value, flags) {\n        return visitValue(value, this, flags);\n    };\n    /**\n     * @param {?} value\n     * @param {?} context\n     * @return {?}\n     */\n    ToJsonSerializer.prototype.visitOther = /**\n     * @param {?} value\n     * @param {?} context\n     * @return {?}\n     */\n    function (value, context) {\n        if (value instanceof StaticSymbol) {\n            var /** @type {?} */ baseSymbol = this.symbolResolver.getStaticSymbol(value.filePath, value.name);\n            var /** @type {?} */ index = this.visitStaticSymbol(baseSymbol, context);\n            return { __symbol: index, members: value.members };\n        }\n    };\n    /**\n     * Returns null if the options.resolveValue is true, and the summary for the symbol\n     * resolved to a type or could not be resolved.\n     * @param {?} baseSymbol\n     * @param {?} flags\n     * @return {?}\n     */\n    ToJsonSerializer.prototype.visitStaticSymbol = /**\n     * Returns null if the options.resolveValue is true, and the summary for the symbol\n     * resolved to a type or could not be resolved.\n     * @param {?} baseSymbol\n     * @param {?} flags\n     * @return {?}\n     */\n    function (baseSymbol, flags) {\n        var /** @type {?} */ index = this.indexBySymbol.get(baseSymbol);\n        var /** @type {?} */ summary = null;\n        if (flags & 1 /* ResolveValue */ &&\n            this.summaryResolver.isLibraryFile(baseSymbol.filePath)) {\n            if (this.unprocessedSymbolSummariesBySymbol.has(baseSymbol)) {\n                // the summary for this symbol was already added\n                // -> nothing to do.\n                return /** @type {?} */ ((index));\n            }\n            summary = this.loadSummary(baseSymbol);\n            if (summary && summary.metadata instanceof StaticSymbol) {\n                // The summary is a reexport\n                index = this.visitStaticSymbol(summary.metadata, flags);\n                // reset the summary as it is just a reexport, so we don't want to store it.\n                summary = null;\n            }\n        }\n        else if (index != null) {\n            // Note: == on purpose to compare with undefined!\n            // No summary and the symbol is already added -> nothing to do.\n            return index;\n        }\n        // Note: == on purpose to compare with undefined!\n        if (index == null) {\n            index = this.symbols.length;\n            this.symbols.push(baseSymbol);\n        }\n        this.indexBySymbol.set(baseSymbol, index);\n        if (summary) {\n            this.addSummary(summary);\n        }\n        return index;\n    };\n    /**\n     * @param {?} symbol\n     * @return {?}\n     */\n    ToJsonSerializer.prototype.loadSummary = /**\n     * @param {?} symbol\n     * @return {?}\n     */\n    function (symbol) {\n        var /** @type {?} */ summary = this.summaryResolver.resolveSummary(symbol);\n        if (!summary) {\n            // some symbols might originate from a plain typescript library\n            // that just exported .d.ts and .metadata.json files, i.e. where no summary\n            // files were created.\n            var /** @type {?} */ resolvedSymbol = this.symbolResolver.resolveSymbol(symbol);\n            if (resolvedSymbol) {\n                summary = { symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata };\n            }\n        }\n        return summary;\n    };\n    return ToJsonSerializer;\n}(ValueTransformer));\nvar ForJitSerializer = /** @class */ (function () {\n    function ForJitSerializer(outputCtx, symbolResolver, summaryResolver) {\n        this.outputCtx = outputCtx;\n        this.symbolResolver = symbolResolver;\n        this.summaryResolver = summaryResolver;\n        this.data = [];\n    }\n    /**\n     * @param {?} summary\n     * @param {?} metadata\n     * @return {?}\n     */\n    ForJitSerializer.prototype.addSourceType = /**\n     * @param {?} summary\n     * @param {?} metadata\n     * @return {?}\n     */\n    function (summary, metadata) {\n        this.data.push({ summary: summary, metadata: metadata, isLibrary: false });\n    };\n    /**\n     * @param {?} summary\n     * @return {?}\n     */\n    ForJitSerializer.prototype.addLibType = /**\n     * @param {?} summary\n     * @return {?}\n     */\n    function (summary) {\n        this.data.push({ summary: summary, metadata: null, isLibrary: true });\n    };\n    /**\n     * @param {?} exportAsArr\n     * @return {?}\n     */\n    ForJitSerializer.prototype.serialize = /**\n     * @param {?} exportAsArr\n     * @return {?}\n     */\n    function (exportAsArr) {\n        var _this = this;\n        var /** @type {?} */ exportAsBySymbol = new Map();\n        for (var _i = 0, exportAsArr_1 = exportAsArr; _i < exportAsArr_1.length; _i++) {\n            var _a = exportAsArr_1[_i], symbol = _a.symbol, exportAs = _a.exportAs;\n            exportAsBySymbol.set(symbol, exportAs);\n        }\n        var /** @type {?} */ ngModuleSymbols = new Set();\n        for (var _b = 0, _c = this.data; _b < _c.length; _b++) {\n            var _d = _c[_b], summary = _d.summary, metadata = _d.metadata, isLibrary = _d.isLibrary;\n            if (summary.summaryKind === CompileSummaryKind.NgModule) {\n                // collect the symbols that refer to NgModule classes.\n                // Note: we can't just rely on `summary.type.summaryKind` to determine this as\n                // we don't add the summaries of all referenced symbols when we serialize type summaries.\n                // See serializeSummaries for details.\n                ngModuleSymbols.add(summary.type.reference);\n                var /** @type {?} */ modSummary = /** @type {?} */ (summary);\n                for (var _e = 0, _f = modSummary.modules; _e < _f.length; _e++) {\n                    var mod = _f[_e];\n                    ngModuleSymbols.add(mod.reference);\n                }\n            }\n            if (!isLibrary) {\n                var /** @type {?} */ fnName = summaryForJitName(summary.type.reference.name);\n                createSummaryForJitFunction(this.outputCtx, summary.type.reference, this.serializeSummaryWithDeps(summary, /** @type {?} */ ((metadata))));\n            }\n        }\n        ngModuleSymbols.forEach(function (ngModuleSymbol) {\n            if (_this.summaryResolver.isLibraryFile(ngModuleSymbol.filePath)) {\n                var /** @type {?} */ exportAs = exportAsBySymbol.get(ngModuleSymbol) || ngModuleSymbol.name;\n                var /** @type {?} */ jitExportAsName = summaryForJitName(exportAs);\n                _this.outputCtx.statements.push(variable(jitExportAsName)\n                    .set(_this.serializeSummaryRef(ngModuleSymbol))\n                    .toDeclStmt(null, [StmtModifier.Exported]));\n            }\n        });\n    };\n    /**\n     * @param {?} summary\n     * @param {?} metadata\n     * @return {?}\n     */\n    ForJitSerializer.prototype.serializeSummaryWithDeps = /**\n     * @param {?} summary\n     * @param {?} metadata\n     * @return {?}\n     */\n    function (summary, metadata) {\n        var _this = this;\n        var /** @type {?} */ expressions = [this.serializeSummary(summary)];\n        var /** @type {?} */ providers = [];\n        if (metadata instanceof CompileNgModuleMetadata) {\n            expressions.push.apply(expressions, \n            // For directives / pipes, we only add the declared ones,\n            // and rely on transitively importing NgModules to get the transitive\n            // summaries.\n            metadata.declaredDirectives.concat(metadata.declaredPipes)\n                .map(function (type) { return type.reference; })\n                .concat(metadata.transitiveModule.modules.map(function (type) { return type.reference; })\n                .filter(function (ref) { return ref !== metadata.type.reference; }))\n                .map(function (ref) { return _this.serializeSummaryRef(ref); }));\n            // Note: We don't use `NgModuleSummary.providers`, as that one is transitive,\n            // and we already have transitive modules.\n            providers = metadata.providers;\n        }\n        else if (summary.summaryKind === CompileSummaryKind.Directive) {\n            var /** @type {?} */ dirSummary = /** @type {?} */ (summary);\n            providers = dirSummary.providers.concat(dirSummary.viewProviders);\n        }\n        // Note: We can't just refer to the `ngsummary.ts` files for `useClass` providers (as we do for\n        // declaredDirectives / declaredPipes), as we allow\n        // providers without ctor arguments to skip the `@Injectable` decorator,\n        // i.e. we didn't generate .ngsummary.ts files for these.\n        expressions.push.apply(expressions, providers.filter(function (provider) { return !!provider.useClass; }).map(function (provider) {\n            return _this.serializeSummary(/** @type {?} */ ({\n                summaryKind: CompileSummaryKind.Injectable, type: provider.useClass\n            }));\n        }));\n        return literalArr(expressions);\n    };\n    /**\n     * @param {?} typeSymbol\n     * @return {?}\n     */\n    ForJitSerializer.prototype.serializeSummaryRef = /**\n     * @param {?} typeSymbol\n     * @return {?}\n     */\n    function (typeSymbol) {\n        var /** @type {?} */ jitImportedSymbol = this.symbolResolver.getStaticSymbol(summaryForJitFileName(typeSymbol.filePath), summaryForJitName(typeSymbol.name));\n        return this.outputCtx.importExpr(jitImportedSymbol);\n    };\n    /**\n     * @param {?} data\n     * @return {?}\n     */\n    ForJitSerializer.prototype.serializeSummary = /**\n     * @param {?} data\n     * @return {?}\n     */\n    function (data) {\n        var /** @type {?} */ outputCtx = this.outputCtx;\n        var Transformer = /** @class */ (function () {\n            function Transformer() {\n            }\n            /**\n             * @param {?} arr\n             * @param {?} context\n             * @return {?}\n             */\n            Transformer.prototype.visitArray = /**\n             * @param {?} arr\n             * @param {?} context\n             * @return {?}\n             */\n            function (arr, context) {\n                var _this = this;\n                return literalArr(arr.map(function (entry) { return visitValue(entry, _this, context); }));\n            };\n            /**\n             * @param {?} map\n             * @param {?} context\n             * @return {?}\n             */\n            Transformer.prototype.visitStringMap = /**\n             * @param {?} map\n             * @param {?} context\n             * @return {?}\n             */\n            function (map, context) {\n                var _this = this;\n                return new LiteralMapExpr(Object.keys(map).map(function (key) { return new LiteralMapEntry(key, visitValue(map[key], _this, context), false); }));\n            };\n            /**\n             * @param {?} value\n             * @param {?} context\n             * @return {?}\n             */\n            Transformer.prototype.visitPrimitive = /**\n             * @param {?} value\n             * @param {?} context\n             * @return {?}\n             */\n            function (value, context) { return literal(value); };\n            /**\n             * @param {?} value\n             * @param {?} context\n             * @return {?}\n             */\n            Transformer.prototype.visitOther = /**\n             * @param {?} value\n             * @param {?} context\n             * @return {?}\n             */\n            function (value, context) {\n                if (value instanceof StaticSymbol) {\n                    return outputCtx.importExpr(value);\n                }\n                else {\n                    throw new Error(\"Illegal State: Encountered value \" + value);\n                }\n            };\n            return Transformer;\n        }());\n        return visitValue(data, new Transformer(), null);\n    };\n    return ForJitSerializer;\n}());\nvar FromJsonDeserializer = /** @class */ (function (_super) {\n    __extends(FromJsonDeserializer, _super);\n    function FromJsonDeserializer(symbolCache, summaryResolver) {\n        var _this = _super.call(this) || this;\n        _this.symbolCache = symbolCache;\n        _this.summaryResolver = summaryResolver;\n        return _this;\n    }\n    /**\n     * @param {?} libraryFileName\n     * @param {?} json\n     * @return {?}\n     */\n    FromJsonDeserializer.prototype.deserialize = /**\n     * @param {?} libraryFileName\n     * @param {?} json\n     * @return {?}\n     */\n    function (libraryFileName, json) {\n        var _this = this;\n        var /** @type {?} */ data = JSON.parse(json);\n        var /** @type {?} */ allImportAs = [];\n        this.symbols = data.symbols.map(function (serializedSymbol) {\n            return _this.symbolCache.get(_this.summaryResolver.fromSummaryFileName(serializedSymbol.filePath, libraryFileName), serializedSymbol.name);\n        });\n        data.symbols.forEach(function (serializedSymbol, index) {\n            var /** @type {?} */ symbol = _this.symbols[index];\n            var /** @type {?} */ importAs = serializedSymbol.importAs;\n            if (typeof importAs === 'number') {\n                allImportAs.push({ symbol: symbol, importAs: _this.symbols[importAs] });\n            }\n            else if (typeof importAs === 'string') {\n                allImportAs.push({ symbol: symbol, importAs: _this.symbolCache.get(ngfactoryFilePath(libraryFileName), importAs) });\n            }\n        });\n        var /** @type {?} */ summaries = /** @type {?} */ (visitValue(data.summaries, this, null));\n        return { moduleName: data.moduleName, summaries: summaries, importAs: allImportAs };\n    };\n    /**\n     * @param {?} map\n     * @param {?} context\n     * @return {?}\n     */\n    FromJsonDeserializer.prototype.visitStringMap = /**\n     * @param {?} map\n     * @param {?} context\n     * @return {?}\n     */\n    function (map, context) {\n        if ('__symbol' in map) {\n            var /** @type {?} */ baseSymbol = this.symbols[map['__symbol']];\n            var /** @type {?} */ members = map['members'];\n            return members.length ? this.symbolCache.get(baseSymbol.filePath, baseSymbol.name, members) :\n                baseSymbol;\n        }\n        else {\n            return _super.prototype.visitStringMap.call(this, map, context);\n        }\n    };\n    return FromJsonDeserializer;\n}(ValueTransformer));\n/**\n * @param {?} metadata\n * @return {?}\n */\nfunction isCall(metadata) {\n    return metadata && metadata.__symbolic === 'call';\n}\n/**\n * @param {?} metadata\n * @return {?}\n */\nfunction isFunctionCall(metadata) {\n    return isCall(metadata) && unwrapResolvedMetadata(metadata.expression) instanceof StaticSymbol;\n}\n/**\n * @param {?} metadata\n * @return {?}\n */\nfunction isMethodCallOnVariable(metadata) {\n    return isCall(metadata) && metadata.expression && metadata.expression.__symbolic === 'select' &&\n        unwrapResolvedMetadata(metadata.expression.expression) instanceof StaticSymbol;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/** @enum {number} */\nvar StubEmitFlags = {\n    Basic: 1,\n    TypeCheck: 2,\n    All: 3,\n};\nStubEmitFlags[StubEmitFlags.Basic] = \"Basic\";\nStubEmitFlags[StubEmitFlags.TypeCheck] = \"TypeCheck\";\nStubEmitFlags[StubEmitFlags.All] = \"All\";\nvar AotCompiler = /** @class */ (function () {\n    function AotCompiler(_config, _options, _host, _reflector, _metadataResolver, _templateParser, _styleCompiler, _viewCompiler, _typeCheckCompiler, _ngModuleCompiler, _outputEmitter, _summaryResolver, _symbolResolver) {\n        this._config = _config;\n        this._options = _options;\n        this._host = _host;\n        this._reflector = _reflector;\n        this._metadataResolver = _metadataResolver;\n        this._templateParser = _templateParser;\n        this._styleCompiler = _styleCompiler;\n        this._viewCompiler = _viewCompiler;\n        this._typeCheckCompiler = _typeCheckCompiler;\n        this._ngModuleCompiler = _ngModuleCompiler;\n        this._outputEmitter = _outputEmitter;\n        this._summaryResolver = _summaryResolver;\n        this._symbolResolver = _symbolResolver;\n        this._templateAstCache = new Map();\n        this._analyzedFiles = new Map();\n    }\n    /**\n     * @return {?}\n     */\n    AotCompiler.prototype.clearCache = /**\n     * @return {?}\n     */\n    function () { this._metadataResolver.clearCache(); };\n    /**\n     * @param {?} rootFiles\n     * @return {?}\n     */\n    AotCompiler.prototype.analyzeModulesSync = /**\n     * @param {?} rootFiles\n     * @return {?}\n     */\n    function (rootFiles) {\n        var _this = this;\n        var /** @type {?} */ analyzeResult = analyzeAndValidateNgModules(rootFiles, this._host, this._symbolResolver, this._metadataResolver);\n        analyzeResult.ngModules.forEach(function (ngModule) {\n            return _this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, true);\n        });\n        return analyzeResult;\n    };\n    /**\n     * @param {?} rootFiles\n     * @return {?}\n     */\n    AotCompiler.prototype.analyzeModulesAsync = /**\n     * @param {?} rootFiles\n     * @return {?}\n     */\n    function (rootFiles) {\n        var _this = this;\n        var /** @type {?} */ analyzeResult = analyzeAndValidateNgModules(rootFiles, this._host, this._symbolResolver, this._metadataResolver);\n        return Promise\n            .all(analyzeResult.ngModules.map(function (ngModule) {\n            return _this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, false);\n        }))\n            .then(function () { return analyzeResult; });\n    };\n    /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    AotCompiler.prototype._analyzeFile = /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    function (fileName) {\n        var /** @type {?} */ analyzedFile = this._analyzedFiles.get(fileName);\n        if (!analyzedFile) {\n            analyzedFile =\n                analyzeFile(this._host, this._symbolResolver, this._metadataResolver, fileName);\n            this._analyzedFiles.set(fileName, analyzedFile);\n        }\n        return analyzedFile;\n    };\n    /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    AotCompiler.prototype.findGeneratedFileNames = /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    function (fileName) {\n        var _this = this;\n        var /** @type {?} */ genFileNames = [];\n        var /** @type {?} */ file = this._analyzeFile(fileName);\n        // Make sure we create a .ngfactory if we have a injectable/directive/pipe/NgModule\n        // or a reference to a non source file.\n        // Note: This is overestimating the required .ngfactory files as the real calculation is harder.\n        // Only do this for StubEmitFlags.Basic, as adding a type check block\n        // does not change this file (as we generate type check blocks based on NgModules).\n        if (this._options.allowEmptyCodegenFiles || file.directives.length || file.pipes.length ||\n            file.injectables.length || file.ngModules.length || file.exportsNonSourceFiles) {\n            genFileNames.push(ngfactoryFilePath(file.fileName, true));\n            if (this._options.enableSummariesForJit) {\n                genFileNames.push(summaryForJitFileName(file.fileName, true));\n            }\n        }\n        var /** @type {?} */ fileSuffix = normalizeGenFileSuffix(splitTypescriptSuffix(file.fileName, true)[1]);\n        file.directives.forEach(function (dirSymbol) {\n            var /** @type {?} */ compMeta = /** @type {?} */ ((_this._metadataResolver.getNonNormalizedDirectiveMetadata(dirSymbol))).metadata;\n            if (!compMeta.isComponent) {\n                return;\n            } /** @type {?} */\n            ((\n            // Note: compMeta is a component and therefore template is non null.\n            compMeta.template)).styleUrls.forEach(function (styleUrl) {\n                var /** @type {?} */ normalizedUrl = _this._host.resourceNameToFileName(styleUrl, file.fileName);\n                if (!normalizedUrl) {\n                    throw syntaxError(\"Couldn't resolve resource \" + styleUrl + \" relative to \" + file.fileName);\n                }\n                var /** @type {?} */ needsShim = (/** @type {?} */ ((compMeta.template)).encapsulation || _this._config.defaultEncapsulation) === ViewEncapsulation.Emulated;\n                genFileNames.push(_stylesModuleUrl(normalizedUrl, needsShim, fileSuffix));\n                if (_this._options.allowEmptyCodegenFiles) {\n                    genFileNames.push(_stylesModuleUrl(normalizedUrl, !needsShim, fileSuffix));\n                }\n            });\n        });\n        return genFileNames;\n    };\n    /**\n     * @param {?} genFileName\n     * @param {?=} originalFileName\n     * @return {?}\n     */\n    AotCompiler.prototype.emitBasicStub = /**\n     * @param {?} genFileName\n     * @param {?=} originalFileName\n     * @return {?}\n     */\n    function (genFileName, originalFileName) {\n        var /** @type {?} */ outputCtx = this._createOutputContext(genFileName);\n        if (genFileName.endsWith('.ngfactory.ts')) {\n            if (!originalFileName) {\n                throw new Error(\"Assertion error: require the original file for .ngfactory.ts stubs. File: \" + genFileName);\n            }\n            var /** @type {?} */ originalFile = this._analyzeFile(originalFileName);\n            this._createNgFactoryStub(outputCtx, originalFile, StubEmitFlags.Basic);\n        }\n        else if (genFileName.endsWith('.ngsummary.ts')) {\n            if (this._options.enableSummariesForJit) {\n                if (!originalFileName) {\n                    throw new Error(\"Assertion error: require the original file for .ngsummary.ts stubs. File: \" + genFileName);\n                }\n                var /** @type {?} */ originalFile = this._analyzeFile(originalFileName);\n                _createEmptyStub(outputCtx);\n                originalFile.ngModules.forEach(function (ngModule) {\n                    // create exports that user code can reference\n                    createForJitStub(outputCtx, ngModule.type.reference);\n                });\n            }\n        }\n        else if (genFileName.endsWith('.ngstyle.ts')) {\n            _createEmptyStub(outputCtx);\n        }\n        // Note: for the stubs, we don't need a property srcFileUrl,\n        // as lateron in emitAllImpls we will create the proper GeneratedFiles with the\n        // correct srcFileUrl.\n        // This is good as e.g. for .ngstyle.ts files we can't derive\n        // the url of components based on the genFileUrl.\n        return this._codegenSourceModule('unknown', outputCtx);\n    };\n    /**\n     * @param {?} genFileName\n     * @param {?} originalFileName\n     * @return {?}\n     */\n    AotCompiler.prototype.emitTypeCheckStub = /**\n     * @param {?} genFileName\n     * @param {?} originalFileName\n     * @return {?}\n     */\n    function (genFileName, originalFileName) {\n        var /** @type {?} */ originalFile = this._analyzeFile(originalFileName);\n        var /** @type {?} */ outputCtx = this._createOutputContext(genFileName);\n        if (genFileName.endsWith('.ngfactory.ts')) {\n            this._createNgFactoryStub(outputCtx, originalFile, StubEmitFlags.TypeCheck);\n        }\n        return outputCtx.statements.length > 0 ?\n            this._codegenSourceModule(originalFile.fileName, outputCtx) :\n            null;\n    };\n    /**\n     * @param {?} fileNames\n     * @return {?}\n     */\n    AotCompiler.prototype.loadFilesAsync = /**\n     * @param {?} fileNames\n     * @return {?}\n     */\n    function (fileNames) {\n        var _this = this;\n        var /** @type {?} */ files = fileNames.map(function (fileName) { return _this._analyzeFile(fileName); });\n        var /** @type {?} */ loadingPromises = [];\n        files.forEach(function (file) {\n            return file.ngModules.forEach(function (ngModule) {\n                return loadingPromises.push(_this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, false));\n            });\n        });\n        return Promise.all(loadingPromises).then(function (_) { return mergeAndValidateNgFiles(files); });\n    };\n    /**\n     * @param {?} fileNames\n     * @return {?}\n     */\n    AotCompiler.prototype.loadFilesSync = /**\n     * @param {?} fileNames\n     * @return {?}\n     */\n    function (fileNames) {\n        var _this = this;\n        var /** @type {?} */ files = fileNames.map(function (fileName) { return _this._analyzeFile(fileName); });\n        files.forEach(function (file) {\n            return file.ngModules.forEach(function (ngModule) {\n                return _this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, true);\n            });\n        });\n        return mergeAndValidateNgFiles(files);\n    };\n    /**\n     * @param {?} outputCtx\n     * @param {?} file\n     * @param {?} emitFlags\n     * @return {?}\n     */\n    AotCompiler.prototype._createNgFactoryStub = /**\n     * @param {?} outputCtx\n     * @param {?} file\n     * @param {?} emitFlags\n     * @return {?}\n     */\n    function (outputCtx, file, emitFlags) {\n        var _this = this;\n        var /** @type {?} */ componentId = 0;\n        file.ngModules.forEach(function (ngModuleMeta, ngModuleIndex) {\n            // Note: the code below needs to executed for StubEmitFlags.Basic and StubEmitFlags.TypeCheck,\n            // so we don't change the .ngfactory file too much when adding the typecheck block.\n            // create exports that user code can reference\n            // Note: the code below needs to executed for StubEmitFlags.Basic and StubEmitFlags.TypeCheck,\n            // so we don't change the .ngfactory file too much when adding the typecheck block.\n            // create exports that user code can reference\n            _this._ngModuleCompiler.createStub(outputCtx, ngModuleMeta.type.reference);\n            // add references to the symbols from the metadata.\n            // These can be used by the type check block for components,\n            // and they also cause TypeScript to include these files into the program too,\n            // which will make them part of the analyzedFiles.\n            var /** @type {?} */ externalReferences = ngModuleMeta.transitiveModule.directives.map(function (d) { return d.reference; }).concat(ngModuleMeta.transitiveModule.pipes.map(function (d) { return d.reference; }), ngModuleMeta.importedModules.map(function (m) { return m.type.reference; }), ngModuleMeta.exportedModules.map(function (m) { return m.type.reference; }), _this._externalIdentifierReferences([Identifiers.TemplateRef, Identifiers.ElementRef]));\n            var /** @type {?} */ externalReferenceVars = new Map();\n            externalReferences.forEach(function (ref, typeIndex) {\n                externalReferenceVars.set(ref, \"_decl\" + ngModuleIndex + \"_\" + typeIndex);\n            });\n            externalReferenceVars.forEach(function (varName, reference) {\n                outputCtx.statements.push(variable(varName)\n                    .set(NULL_EXPR.cast(DYNAMIC_TYPE))\n                    .toDeclStmt(expressionType(outputCtx.importExpr(reference, /* typeParams */ null, /* useSummaries */ /* useSummaries */ false))));\n            });\n            if (emitFlags & StubEmitFlags.TypeCheck) {\n                // add the typecheck block for all components of the NgModule\n                ngModuleMeta.declaredDirectives.forEach(function (dirId) {\n                    var /** @type {?} */ compMeta = _this._metadataResolver.getDirectiveMetadata(dirId.reference);\n                    if (!compMeta.isComponent) {\n                        return;\n                    }\n                    componentId++;\n                    _this._createTypeCheckBlock(outputCtx, compMeta.type.reference.name + \"_Host_\" + componentId, ngModuleMeta, _this._metadataResolver.getHostComponentMetadata(compMeta), [compMeta.type], externalReferenceVars);\n                    _this._createTypeCheckBlock(outputCtx, compMeta.type.reference.name + \"_\" + componentId, ngModuleMeta, compMeta, ngModuleMeta.transitiveModule.directives, externalReferenceVars);\n                });\n            }\n        });\n        if (outputCtx.statements.length === 0) {\n            _createEmptyStub(outputCtx);\n        }\n    };\n    /**\n     * @param {?} references\n     * @return {?}\n     */\n    AotCompiler.prototype._externalIdentifierReferences = /**\n     * @param {?} references\n     * @return {?}\n     */\n    function (references) {\n        var /** @type {?} */ result = [];\n        for (var _i = 0, references_1 = references; _i < references_1.length; _i++) {\n            var reference = references_1[_i];\n            var /** @type {?} */ token = createTokenForExternalReference(this._reflector, reference);\n            if (token.identifier) {\n                result.push(token.identifier.reference);\n            }\n        }\n        return result;\n    };\n    /**\n     * @param {?} ctx\n     * @param {?} componentId\n     * @param {?} moduleMeta\n     * @param {?} compMeta\n     * @param {?} directives\n     * @param {?} externalReferenceVars\n     * @return {?}\n     */\n    AotCompiler.prototype._createTypeCheckBlock = /**\n     * @param {?} ctx\n     * @param {?} componentId\n     * @param {?} moduleMeta\n     * @param {?} compMeta\n     * @param {?} directives\n     * @param {?} externalReferenceVars\n     * @return {?}\n     */\n    function (ctx, componentId, moduleMeta, compMeta, directives, externalReferenceVars) {\n        var _a = this._parseTemplate(compMeta, moduleMeta, directives), parsedTemplate = _a.template, usedPipes = _a.pipes;\n        (_b = ctx.statements).push.apply(_b, this._typeCheckCompiler.compileComponent(componentId, compMeta, parsedTemplate, usedPipes, externalReferenceVars, ctx));\n        var _b;\n    };\n    /**\n     * @param {?} analyzeResult\n     * @param {?} locale\n     * @return {?}\n     */\n    AotCompiler.prototype.emitMessageBundle = /**\n     * @param {?} analyzeResult\n     * @param {?} locale\n     * @return {?}\n     */\n    function (analyzeResult, locale) {\n        var _this = this;\n        var /** @type {?} */ errors = [];\n        var /** @type {?} */ htmlParser = new HtmlParser();\n        // TODO(vicb): implicit tags & attributes\n        var /** @type {?} */ messageBundle = new MessageBundle(htmlParser, [], {}, locale);\n        analyzeResult.files.forEach(function (file) {\n            var /** @type {?} */ compMetas = [];\n            file.directives.forEach(function (directiveType) {\n                var /** @type {?} */ dirMeta = _this._metadataResolver.getDirectiveMetadata(directiveType);\n                if (dirMeta && dirMeta.isComponent) {\n                    compMetas.push(dirMeta);\n                }\n            });\n            compMetas.forEach(function (compMeta) {\n                var /** @type {?} */ html = /** @type {?} */ ((/** @type {?} */ ((compMeta.template)).template));\n                var /** @type {?} */ interpolationConfig = InterpolationConfig.fromArray(/** @type {?} */ ((compMeta.template)).interpolation);\n                errors.push.apply(errors, /** @type {?} */ ((messageBundle.updateFromTemplate(html, file.fileName, interpolationConfig))));\n            });\n        });\n        if (errors.length) {\n            throw new Error(errors.map(function (e) { return e.toString(); }).join('\\n'));\n        }\n        return messageBundle;\n    };\n    /**\n     * @param {?} analyzeResult\n     * @return {?}\n     */\n    AotCompiler.prototype.emitAllImpls = /**\n     * @param {?} analyzeResult\n     * @return {?}\n     */\n    function (analyzeResult) {\n        var _this = this;\n        var ngModuleByPipeOrDirective = analyzeResult.ngModuleByPipeOrDirective, files = analyzeResult.files;\n        var /** @type {?} */ sourceModules = files.map(function (file) {\n            return _this._compileImplFile(file.fileName, ngModuleByPipeOrDirective, file.directives, file.pipes, file.ngModules, file.injectables);\n        });\n        return flatten(sourceModules);\n    };\n    /**\n     * @param {?} srcFileUrl\n     * @param {?} ngModuleByPipeOrDirective\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} ngModules\n     * @param {?} injectables\n     * @return {?}\n     */\n    AotCompiler.prototype._compileImplFile = /**\n     * @param {?} srcFileUrl\n     * @param {?} ngModuleByPipeOrDirective\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} ngModules\n     * @param {?} injectables\n     * @return {?}\n     */\n    function (srcFileUrl, ngModuleByPipeOrDirective, directives, pipes, ngModules, injectables) {\n        var _this = this;\n        var /** @type {?} */ fileSuffix = normalizeGenFileSuffix(splitTypescriptSuffix(srcFileUrl, true)[1]);\n        var /** @type {?} */ generatedFiles = [];\n        var /** @type {?} */ outputCtx = this._createOutputContext(ngfactoryFilePath(srcFileUrl, true));\n        generatedFiles.push.apply(generatedFiles, this._createSummary(srcFileUrl, directives, pipes, ngModules, injectables, outputCtx));\n        // compile all ng modules\n        ngModules.forEach(function (ngModuleMeta) { return _this._compileModule(outputCtx, ngModuleMeta); });\n        // compile components\n        directives.forEach(function (dirType) {\n            var /** @type {?} */ compMeta = _this._metadataResolver.getDirectiveMetadata(/** @type {?} */ (dirType));\n            if (!compMeta.isComponent) {\n                return;\n            }\n            var /** @type {?} */ ngModule = ngModuleByPipeOrDirective.get(dirType);\n            if (!ngModule) {\n                throw new Error(\"Internal Error: cannot determine the module for component \" + identifierName(compMeta.type) + \"!\");\n            }\n            // compile styles\n            var /** @type {?} */ componentStylesheet = _this._styleCompiler.compileComponent(outputCtx, compMeta); /** @type {?} */\n            ((\n            // Note: compMeta is a component and therefore template is non null.\n            compMeta.template)).externalStylesheets.forEach(function (stylesheetMeta) {\n                // Note: fill non shim and shim style files as they might\n                // be shared by component with and without ViewEncapsulation.\n                var /** @type {?} */ shim = _this._styleCompiler.needsStyleShim(compMeta);\n                generatedFiles.push(_this._codegenStyles(srcFileUrl, compMeta, stylesheetMeta, shim, fileSuffix));\n                if (_this._options.allowEmptyCodegenFiles) {\n                    generatedFiles.push(_this._codegenStyles(srcFileUrl, compMeta, stylesheetMeta, !shim, fileSuffix));\n                }\n            });\n            // compile components\n            var /** @type {?} */ compViewVars = _this._compileComponent(outputCtx, compMeta, ngModule, ngModule.transitiveModule.directives, componentStylesheet, fileSuffix);\n            _this._compileComponentFactory(outputCtx, compMeta, ngModule, fileSuffix);\n        });\n        if (outputCtx.statements.length > 0 || this._options.allowEmptyCodegenFiles) {\n            var /** @type {?} */ srcModule = this._codegenSourceModule(srcFileUrl, outputCtx);\n            generatedFiles.unshift(srcModule);\n        }\n        return generatedFiles;\n    };\n    /**\n     * @param {?} srcFileName\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} ngModules\n     * @param {?} injectables\n     * @param {?} ngFactoryCtx\n     * @return {?}\n     */\n    AotCompiler.prototype._createSummary = /**\n     * @param {?} srcFileName\n     * @param {?} directives\n     * @param {?} pipes\n     * @param {?} ngModules\n     * @param {?} injectables\n     * @param {?} ngFactoryCtx\n     * @return {?}\n     */\n    function (srcFileName, directives, pipes, ngModules, injectables, ngFactoryCtx) {\n        var _this = this;\n        var /** @type {?} */ symbolSummaries = this._symbolResolver.getSymbolsOf(srcFileName)\n            .map(function (symbol) { return _this._symbolResolver.resolveSymbol(symbol); });\n        var /** @type {?} */ typeData = ngModules.map(function (meta) {\n            return ({\n                summary: /** @type {?} */ ((_this._metadataResolver.getNgModuleSummary(meta.type.reference))),\n                metadata: /** @type {?} */ ((_this._metadataResolver.getNgModuleMetadata(meta.type.reference)))\n            });\n        }).concat(directives.map(function (ref) {\n            return ({\n                summary: /** @type {?} */ ((_this._metadataResolver.getDirectiveSummary(ref))),\n                metadata: /** @type {?} */ ((_this._metadataResolver.getDirectiveMetadata(ref)))\n            });\n        }), pipes.map(function (ref) {\n            return ({\n                summary: /** @type {?} */ ((_this._metadataResolver.getPipeSummary(ref))),\n                metadata: /** @type {?} */ ((_this._metadataResolver.getPipeMetadata(ref)))\n            });\n        }), injectables.map(function (ref) {\n            return ({\n                summary: /** @type {?} */ ((_this._metadataResolver.getInjectableSummary(ref))),\n                metadata: /** @type {?} */ ((_this._metadataResolver.getInjectableSummary(ref))).type\n            });\n        }));\n        var /** @type {?} */ forJitOutputCtx = this._options.enableSummariesForJit ?\n            this._createOutputContext(summaryForJitFileName(srcFileName, true)) :\n            null;\n        var _a = serializeSummaries(srcFileName, forJitOutputCtx, this._summaryResolver, this._symbolResolver, symbolSummaries, typeData), json = _a.json, exportAs = _a.exportAs;\n        exportAs.forEach(function (entry) {\n            ngFactoryCtx.statements.push(variable(entry.exportAs).set(ngFactoryCtx.importExpr(entry.symbol)).toDeclStmt(null, [\n                StmtModifier.Exported\n            ]));\n        });\n        var /** @type {?} */ summaryJson = new GeneratedFile(srcFileName, summaryFileName(srcFileName), json);\n        var /** @type {?} */ result = [summaryJson];\n        if (forJitOutputCtx) {\n            result.push(this._codegenSourceModule(srcFileName, forJitOutputCtx));\n        }\n        return result;\n    };\n    /**\n     * @param {?} outputCtx\n     * @param {?} ngModule\n     * @return {?}\n     */\n    AotCompiler.prototype._compileModule = /**\n     * @param {?} outputCtx\n     * @param {?} ngModule\n     * @return {?}\n     */\n    function (outputCtx, ngModule) {\n        var /** @type {?} */ providers = [];\n        if (this._options.locale) {\n            var /** @type {?} */ normalizedLocale = this._options.locale.replace(/_/g, '-');\n            providers.push({\n                token: createTokenForExternalReference(this._reflector, Identifiers.LOCALE_ID),\n                useValue: normalizedLocale,\n            });\n        }\n        if (this._options.i18nFormat) {\n            providers.push({\n                token: createTokenForExternalReference(this._reflector, Identifiers.TRANSLATIONS_FORMAT),\n                useValue: this._options.i18nFormat\n            });\n        }\n        this._ngModuleCompiler.compile(outputCtx, ngModule, providers);\n    };\n    /**\n     * @param {?} outputCtx\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @param {?} fileSuffix\n     * @return {?}\n     */\n    AotCompiler.prototype._compileComponentFactory = /**\n     * @param {?} outputCtx\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @param {?} fileSuffix\n     * @return {?}\n     */\n    function (outputCtx, compMeta, ngModule, fileSuffix) {\n        var /** @type {?} */ hostMeta = this._metadataResolver.getHostComponentMetadata(compMeta);\n        var /** @type {?} */ hostViewFactoryVar = this._compileComponent(outputCtx, hostMeta, ngModule, [compMeta.type], null, fileSuffix)\n            .viewClassVar;\n        var /** @type {?} */ compFactoryVar = componentFactoryName(compMeta.type.reference);\n        var /** @type {?} */ inputsExprs = [];\n        for (var /** @type {?} */ propName in compMeta.inputs) {\n            var /** @type {?} */ templateName = compMeta.inputs[propName];\n            // Don't quote so that the key gets minified...\n            inputsExprs.push(new LiteralMapEntry(propName, literal(templateName), false));\n        }\n        var /** @type {?} */ outputsExprs = [];\n        for (var /** @type {?} */ propName in compMeta.outputs) {\n            var /** @type {?} */ templateName = compMeta.outputs[propName];\n            // Don't quote so that the key gets minified...\n            outputsExprs.push(new LiteralMapEntry(propName, literal(templateName), false));\n        }\n        outputCtx.statements.push(variable(compFactoryVar)\n            .set(importExpr(Identifiers.createComponentFactory).callFn([\n            literal(compMeta.selector), outputCtx.importExpr(compMeta.type.reference),\n            variable(hostViewFactoryVar), new LiteralMapExpr(inputsExprs),\n            new LiteralMapExpr(outputsExprs),\n            literalArr(/** @type {?} */ ((compMeta.template)).ngContentSelectors.map(function (selector) { return literal(selector); }))\n        ]))\n            .toDeclStmt(importType(Identifiers.ComponentFactory, [/** @type {?} */ ((expressionType(outputCtx.importExpr(compMeta.type.reference))))], [TypeModifier.Const]), [StmtModifier.Final, StmtModifier.Exported]));\n    };\n    /**\n     * @param {?} outputCtx\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @param {?} directiveIdentifiers\n     * @param {?} componentStyles\n     * @param {?} fileSuffix\n     * @return {?}\n     */\n    AotCompiler.prototype._compileComponent = /**\n     * @param {?} outputCtx\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @param {?} directiveIdentifiers\n     * @param {?} componentStyles\n     * @param {?} fileSuffix\n     * @return {?}\n     */\n    function (outputCtx, compMeta, ngModule, directiveIdentifiers, componentStyles, fileSuffix) {\n        var _a = this._parseTemplate(compMeta, ngModule, directiveIdentifiers), parsedTemplate = _a.template, usedPipes = _a.pipes;\n        var /** @type {?} */ stylesExpr = componentStyles ? variable(componentStyles.stylesVar) : literalArr([]);\n        var /** @type {?} */ viewResult = this._viewCompiler.compileComponent(outputCtx, compMeta, parsedTemplate, stylesExpr, usedPipes);\n        if (componentStyles) {\n            _resolveStyleStatements(this._symbolResolver, componentStyles, this._styleCompiler.needsStyleShim(compMeta), fileSuffix);\n        }\n        return viewResult;\n    };\n    /**\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @param {?} directiveIdentifiers\n     * @return {?}\n     */\n    AotCompiler.prototype._parseTemplate = /**\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @param {?} directiveIdentifiers\n     * @return {?}\n     */\n    function (compMeta, ngModule, directiveIdentifiers) {\n        var _this = this;\n        if (this._templateAstCache.has(compMeta.type.reference)) {\n            return /** @type {?} */ ((this._templateAstCache.get(compMeta.type.reference)));\n        }\n        var /** @type {?} */ preserveWhitespaces = /** @type {?} */ ((/** @type {?} */ ((compMeta)).template)).preserveWhitespaces;\n        var /** @type {?} */ directives = directiveIdentifiers.map(function (dir) { return _this._metadataResolver.getDirectiveSummary(dir.reference); });\n        var /** @type {?} */ pipes = ngModule.transitiveModule.pipes.map(function (pipe) { return _this._metadataResolver.getPipeSummary(pipe.reference); });\n        var /** @type {?} */ result = this._templateParser.parse(compMeta, /** @type {?} */ ((/** @type {?} */ ((compMeta.template)).htmlAst)), directives, pipes, ngModule.schemas, templateSourceUrl(ngModule.type, compMeta, /** @type {?} */ ((compMeta.template))), preserveWhitespaces);\n        this._templateAstCache.set(compMeta.type.reference, result);\n        return result;\n    };\n    /**\n     * @param {?} genFilePath\n     * @return {?}\n     */\n    AotCompiler.prototype._createOutputContext = /**\n     * @param {?} genFilePath\n     * @return {?}\n     */\n    function (genFilePath) {\n        var _this = this;\n        var /** @type {?} */ importExpr$$1 = function (symbol, typeParams, useSummaries) {\n            if (typeParams === void 0) { typeParams = null; }\n            if (useSummaries === void 0) { useSummaries = true; }\n            if (!(symbol instanceof StaticSymbol)) {\n                throw new Error(\"Internal error: unknown identifier \" + JSON.stringify(symbol));\n            }\n            var /** @type {?} */ arity = _this._symbolResolver.getTypeArity(symbol) || 0;\n            var _a = _this._symbolResolver.getImportAs(symbol, useSummaries) || symbol, filePath = _a.filePath, name = _a.name, members = _a.members;\n            var /** @type {?} */ importModule = _this._fileNameToModuleName(filePath, genFilePath);\n            // It should be good enough to compare filePath to genFilePath and if they are equal\n            // there is a self reference. However, ngfactory files generate to .ts but their\n            // symbols have .d.ts so a simple compare is insufficient. They should be canonical\n            // and is tracked by #17705.\n            var /** @type {?} */ selfReference = _this._fileNameToModuleName(genFilePath, genFilePath);\n            var /** @type {?} */ moduleName = importModule === selfReference ? null : importModule;\n            // If we are in a type expression that refers to a generic type then supply\n            // the required type parameters. If there were not enough type parameters\n            // supplied, supply any as the type. Outside a type expression the reference\n            // should not supply type parameters and be treated as a simple value reference\n            // to the constructor function itself.\n            var /** @type {?} */ suppliedTypeParams = typeParams || [];\n            var /** @type {?} */ missingTypeParamsCount = arity - suppliedTypeParams.length;\n            var /** @type {?} */ allTypeParams = suppliedTypeParams.concat(new Array(missingTypeParamsCount).fill(DYNAMIC_TYPE));\n            return members.reduce(function (expr, memberName) { return expr.prop(memberName); }, /** @type {?} */ (importExpr(new ExternalReference(moduleName, name, null), allTypeParams)));\n        };\n        return { statements: [], genFilePath: genFilePath, importExpr: importExpr$$1 };\n    };\n    /**\n     * @param {?} importedFilePath\n     * @param {?} containingFilePath\n     * @return {?}\n     */\n    AotCompiler.prototype._fileNameToModuleName = /**\n     * @param {?} importedFilePath\n     * @param {?} containingFilePath\n     * @return {?}\n     */\n    function (importedFilePath, containingFilePath) {\n        return this._summaryResolver.getKnownModuleName(importedFilePath) ||\n            this._symbolResolver.getKnownModuleName(importedFilePath) ||\n            this._host.fileNameToModuleName(importedFilePath, containingFilePath);\n    };\n    /**\n     * @param {?} srcFileUrl\n     * @param {?} compMeta\n     * @param {?} stylesheetMetadata\n     * @param {?} isShimmed\n     * @param {?} fileSuffix\n     * @return {?}\n     */\n    AotCompiler.prototype._codegenStyles = /**\n     * @param {?} srcFileUrl\n     * @param {?} compMeta\n     * @param {?} stylesheetMetadata\n     * @param {?} isShimmed\n     * @param {?} fileSuffix\n     * @return {?}\n     */\n    function (srcFileUrl, compMeta, stylesheetMetadata, isShimmed, fileSuffix) {\n        var /** @type {?} */ outputCtx = this._createOutputContext(_stylesModuleUrl(/** @type {?} */ ((stylesheetMetadata.moduleUrl)), isShimmed, fileSuffix));\n        var /** @type {?} */ compiledStylesheet = this._styleCompiler.compileStyles(outputCtx, compMeta, stylesheetMetadata, isShimmed);\n        _resolveStyleStatements(this._symbolResolver, compiledStylesheet, isShimmed, fileSuffix);\n        return this._codegenSourceModule(srcFileUrl, outputCtx);\n    };\n    /**\n     * @param {?} srcFileUrl\n     * @param {?} ctx\n     * @return {?}\n     */\n    AotCompiler.prototype._codegenSourceModule = /**\n     * @param {?} srcFileUrl\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (srcFileUrl, ctx) {\n        return new GeneratedFile(srcFileUrl, ctx.genFilePath, ctx.statements);\n    };\n    /**\n     * @param {?=} entryRoute\n     * @param {?=} analyzedModules\n     * @return {?}\n     */\n    AotCompiler.prototype.listLazyRoutes = /**\n     * @param {?=} entryRoute\n     * @param {?=} analyzedModules\n     * @return {?}\n     */\n    function (entryRoute, analyzedModules) {\n        var /** @type {?} */ self = this;\n        if (entryRoute) {\n            var /** @type {?} */ symbol = parseLazyRoute(entryRoute, this._reflector).referencedModule;\n            return visitLazyRoute(symbol);\n        }\n        else if (analyzedModules) {\n            var /** @type {?} */ allLazyRoutes = [];\n            for (var _i = 0, _a = analyzedModules.ngModules; _i < _a.length; _i++) {\n                var ngModule = _a[_i];\n                var /** @type {?} */ lazyRoutes = listLazyRoutes(ngModule, this._reflector);\n                for (var _b = 0, lazyRoutes_1 = lazyRoutes; _b < lazyRoutes_1.length; _b++) {\n                    var lazyRoute = lazyRoutes_1[_b];\n                    allLazyRoutes.push(lazyRoute);\n                }\n            }\n            return allLazyRoutes;\n        }\n        else {\n            throw new Error(\"Either route or analyzedModules has to be specified!\");\n        }\n        /**\n         * @param {?} symbol\n         * @param {?=} seenRoutes\n         * @param {?=} allLazyRoutes\n         * @return {?}\n         */\n        function visitLazyRoute(symbol, seenRoutes, allLazyRoutes) {\n            if (seenRoutes === void 0) { seenRoutes = new Set(); }\n            if (allLazyRoutes === void 0) { allLazyRoutes = []; }\n            // Support pointing to default exports, but stop recursing there,\n            // as the StaticReflector does not yet support default exports.\n            if (seenRoutes.has(symbol) || !symbol.name) {\n                return allLazyRoutes;\n            }\n            seenRoutes.add(symbol);\n            var /** @type {?} */ lazyRoutes = listLazyRoutes(/** @type {?} */ ((self._metadataResolver.getNgModuleMetadata(symbol, true))), self._reflector);\n            for (var _i = 0, lazyRoutes_2 = lazyRoutes; _i < lazyRoutes_2.length; _i++) {\n                var lazyRoute = lazyRoutes_2[_i];\n                allLazyRoutes.push(lazyRoute);\n                visitLazyRoute(lazyRoute.referencedModule, seenRoutes, allLazyRoutes);\n            }\n            return allLazyRoutes;\n        }\n    };\n    return AotCompiler;\n}());\n/**\n * @param {?} outputCtx\n * @return {?}\n */\nfunction _createEmptyStub(outputCtx) {\n    // Note: We need to produce at least one import statement so that\n    // TypeScript knows that the file is an es6 module. Otherwise our generated\n    // exports / imports won't be emitted properly by TypeScript.\n    outputCtx.statements.push(importExpr(Identifiers.ComponentFactory).toStmt());\n}\n/**\n * @param {?} symbolResolver\n * @param {?} compileResult\n * @param {?} needsShim\n * @param {?} fileSuffix\n * @return {?}\n */\nfunction _resolveStyleStatements(symbolResolver, compileResult, needsShim, fileSuffix) {\n    compileResult.dependencies.forEach(function (dep) {\n        dep.setValue(symbolResolver.getStaticSymbol(_stylesModuleUrl(dep.moduleUrl, needsShim, fileSuffix), dep.name));\n    });\n}\n/**\n * @param {?} stylesheetUrl\n * @param {?} shim\n * @param {?} suffix\n * @return {?}\n */\nfunction _stylesModuleUrl(stylesheetUrl, shim, suffix) {\n    return \"\" + stylesheetUrl + (shim ? '.shim' : '') + \".ngstyle\" + suffix;\n}\n/**\n * @record\n */\n\n/**\n * @record\n */\n\n/**\n * @record\n */\n\n/**\n * @param {?} fileNames\n * @param {?} host\n * @param {?} staticSymbolResolver\n * @param {?} metadataResolver\n * @return {?}\n */\nfunction analyzeNgModules(fileNames, host, staticSymbolResolver, metadataResolver) {\n    var /** @type {?} */ files = _analyzeFilesIncludingNonProgramFiles(fileNames, host, staticSymbolResolver, metadataResolver);\n    return mergeAnalyzedFiles(files);\n}\n/**\n * @param {?} fileNames\n * @param {?} host\n * @param {?} staticSymbolResolver\n * @param {?} metadataResolver\n * @return {?}\n */\nfunction analyzeAndValidateNgModules(fileNames, host, staticSymbolResolver, metadataResolver) {\n    return validateAnalyzedModules(analyzeNgModules(fileNames, host, staticSymbolResolver, metadataResolver));\n}\n/**\n * @param {?} analyzedModules\n * @return {?}\n */\nfunction validateAnalyzedModules(analyzedModules) {\n    if (analyzedModules.symbolsMissingModule && analyzedModules.symbolsMissingModule.length) {\n        var /** @type {?} */ messages = analyzedModules.symbolsMissingModule.map(function (s) {\n            return \"Cannot determine the module for class \" + s.name + \" in \" + s.filePath + \"! Add \" + s.name + \" to the NgModule to fix it.\";\n        });\n        throw syntaxError(messages.join('\\n'));\n    }\n    return analyzedModules;\n}\n/**\n * @param {?} fileNames\n * @param {?} host\n * @param {?} staticSymbolResolver\n * @param {?} metadataResolver\n * @return {?}\n */\nfunction _analyzeFilesIncludingNonProgramFiles(fileNames, host, staticSymbolResolver, metadataResolver) {\n    var /** @type {?} */ seenFiles = new Set();\n    var /** @type {?} */ files = [];\n    var /** @type {?} */ visitFile = function (fileName) {\n        if (seenFiles.has(fileName) || !host.isSourceFile(fileName)) {\n            return false;\n        }\n        seenFiles.add(fileName);\n        var /** @type {?} */ analyzedFile = analyzeFile(host, staticSymbolResolver, metadataResolver, fileName);\n        files.push(analyzedFile);\n        analyzedFile.ngModules.forEach(function (ngModule) {\n            ngModule.transitiveModule.modules.forEach(function (modMeta) { return visitFile(modMeta.reference.filePath); });\n        });\n    };\n    fileNames.forEach(function (fileName) { return visitFile(fileName); });\n    return files;\n}\n/**\n * @param {?} host\n * @param {?} staticSymbolResolver\n * @param {?} metadataResolver\n * @param {?} fileName\n * @return {?}\n */\nfunction analyzeFile(host, staticSymbolResolver, metadataResolver, fileName) {\n    var /** @type {?} */ directives = [];\n    var /** @type {?} */ pipes = [];\n    var /** @type {?} */ injectables = [];\n    var /** @type {?} */ ngModules = [];\n    var /** @type {?} */ hasDecorators = staticSymbolResolver.hasDecorators(fileName);\n    var /** @type {?} */ exportsNonSourceFiles = false;\n    // Don't analyze .d.ts files that have no decorators as a shortcut\n    // to speed up the analysis. This prevents us from\n    // resolving the references in these files.\n    // Note: exportsNonSourceFiles is only needed when compiling with summaries,\n    // which is not the case when .d.ts files are treated as input files.\n    if (!fileName.endsWith('.d.ts') || hasDecorators) {\n        staticSymbolResolver.getSymbolsOf(fileName).forEach(function (symbol) {\n            var /** @type {?} */ resolvedSymbol = staticSymbolResolver.resolveSymbol(symbol);\n            var /** @type {?} */ symbolMeta = resolvedSymbol.metadata;\n            if (!symbolMeta || symbolMeta.__symbolic === 'error') {\n                return;\n            }\n            var /** @type {?} */ isNgSymbol = false;\n            if (symbolMeta.__symbolic === 'class') {\n                if (metadataResolver.isDirective(symbol)) {\n                    isNgSymbol = true;\n                    directives.push(symbol);\n                }\n                else if (metadataResolver.isPipe(symbol)) {\n                    isNgSymbol = true;\n                    pipes.push(symbol);\n                }\n                else if (metadataResolver.isNgModule(symbol)) {\n                    var /** @type {?} */ ngModule = metadataResolver.getNgModuleMetadata(symbol, false);\n                    if (ngModule) {\n                        isNgSymbol = true;\n                        ngModules.push(ngModule);\n                    }\n                }\n                else if (metadataResolver.isInjectable(symbol)) {\n                    isNgSymbol = true;\n                    injectables.push(symbol);\n                }\n            }\n            if (!isNgSymbol) {\n                exportsNonSourceFiles =\n                    exportsNonSourceFiles || isValueExportingNonSourceFile(host, symbolMeta);\n            }\n        });\n    }\n    return {\n        fileName: fileName, directives: directives, pipes: pipes, ngModules: ngModules, injectables: injectables, exportsNonSourceFiles: exportsNonSourceFiles,\n    };\n}\n/**\n * @param {?} host\n * @param {?} metadata\n * @return {?}\n */\nfunction isValueExportingNonSourceFile(host, metadata) {\n    var /** @type {?} */ exportsNonSourceFiles = false;\n    var Visitor = /** @class */ (function () {\n        function Visitor() {\n        }\n        /**\n         * @param {?} arr\n         * @param {?} context\n         * @return {?}\n         */\n        Visitor.prototype.visitArray = /**\n         * @param {?} arr\n         * @param {?} context\n         * @return {?}\n         */\n        function (arr, context) {\n            var _this = this;\n            arr.forEach(function (v) { return visitValue(v, _this, context); });\n        };\n        /**\n         * @param {?} map\n         * @param {?} context\n         * @return {?}\n         */\n        Visitor.prototype.visitStringMap = /**\n         * @param {?} map\n         * @param {?} context\n         * @return {?}\n         */\n        function (map, context) {\n            var _this = this;\n            Object.keys(map).forEach(function (key) { return visitValue(map[key], _this, context); });\n        };\n        /**\n         * @param {?} value\n         * @param {?} context\n         * @return {?}\n         */\n        Visitor.prototype.visitPrimitive = /**\n         * @param {?} value\n         * @param {?} context\n         * @return {?}\n         */\n        function (value, context) { };\n        /**\n         * @param {?} value\n         * @param {?} context\n         * @return {?}\n         */\n        Visitor.prototype.visitOther = /**\n         * @param {?} value\n         * @param {?} context\n         * @return {?}\n         */\n        function (value, context) {\n            if (value instanceof StaticSymbol && !host.isSourceFile(value.filePath)) {\n                exportsNonSourceFiles = true;\n            }\n        };\n        return Visitor;\n    }());\n    visitValue(metadata, new Visitor(), null);\n    return exportsNonSourceFiles;\n}\n/**\n * @param {?} analyzedFiles\n * @return {?}\n */\nfunction mergeAnalyzedFiles(analyzedFiles) {\n    var /** @type {?} */ allNgModules = [];\n    var /** @type {?} */ ngModuleByPipeOrDirective = new Map();\n    var /** @type {?} */ allPipesAndDirectives = new Set();\n    analyzedFiles.forEach(function (af) {\n        af.ngModules.forEach(function (ngModule) {\n            allNgModules.push(ngModule);\n            ngModule.declaredDirectives.forEach(function (d) { return ngModuleByPipeOrDirective.set(d.reference, ngModule); });\n            ngModule.declaredPipes.forEach(function (p) { return ngModuleByPipeOrDirective.set(p.reference, ngModule); });\n        });\n        af.directives.forEach(function (d) { return allPipesAndDirectives.add(d); });\n        af.pipes.forEach(function (p) { return allPipesAndDirectives.add(p); });\n    });\n    var /** @type {?} */ symbolsMissingModule = [];\n    allPipesAndDirectives.forEach(function (ref) {\n        if (!ngModuleByPipeOrDirective.has(ref)) {\n            symbolsMissingModule.push(ref);\n        }\n    });\n    return {\n        ngModules: allNgModules,\n        ngModuleByPipeOrDirective: ngModuleByPipeOrDirective,\n        symbolsMissingModule: symbolsMissingModule,\n        files: analyzedFiles\n    };\n}\n/**\n * @param {?} files\n * @return {?}\n */\nfunction mergeAndValidateNgFiles(files) {\n    return validateAnalyzedModules(mergeAnalyzedFiles(files));\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @record\n */\n\n/**\n * @record\n */\n\nvar FORMATTED_MESSAGE = 'ngFormattedMessage';\n/**\n * @param {?} level\n * @return {?}\n */\nfunction indentStr(level) {\n    if (level <= 0)\n        return '';\n    if (level < 6)\n        return ['', ' ', '  ', '   ', '    ', '     '][level];\n    var /** @type {?} */ half = indentStr(Math.floor(level / 2));\n    return half + half + (level % 2 === 1 ? ' ' : '');\n}\n/**\n * @param {?} chain\n * @param {?=} indent\n * @return {?}\n */\nfunction formatChain(chain, indent) {\n    if (indent === void 0) { indent = 0; }\n    if (!chain)\n        return '';\n    var /** @type {?} */ position = chain.position ?\n        chain.position.fileName + \"(\" + (chain.position.line + 1) + \",\" + (chain.position.column + 1) + \")\" :\n        '';\n    var /** @type {?} */ prefix = position && indent === 0 ? position + \": \" : '';\n    var /** @type {?} */ postfix = position && indent !== 0 ? \" at \" + position : '';\n    var /** @type {?} */ message = \"\" + prefix + chain.message + postfix;\n    return \"\" + indentStr(indent) + message + ((chain.next && ('\\n' + formatChain(chain.next, indent + 2))) || '');\n}\n/**\n * @param {?} chain\n * @return {?}\n */\nfunction formattedError(chain) {\n    var /** @type {?} */ message = formatChain(chain) + '.';\n    var /** @type {?} */ error = /** @type {?} */ (syntaxError(message));\n    (/** @type {?} */ (error))[FORMATTED_MESSAGE] = true;\n    error.chain = chain;\n    error.position = chain.position;\n    return error;\n}\n/**\n * @param {?} error\n * @return {?}\n */\nfunction isFormattedError(error) {\n    return !!(/** @type {?} */ (error))[FORMATTED_MESSAGE];\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar ANGULAR_CORE = '@angular/core';\nvar ANGULAR_ROUTER = '@angular/router';\nvar HIDDEN_KEY = /^\\$.*\\$$/;\nvar IGNORE = {\n    __symbolic: 'ignore'\n};\nvar USE_VALUE = 'useValue';\nvar PROVIDE = 'provide';\nvar REFERENCE_SET = new Set([USE_VALUE, 'useFactory', 'data']);\nvar TYPEGUARD_POSTFIX = 'TypeGuard';\nvar USE_IF = 'UseIf';\n/**\n * @param {?} value\n * @return {?}\n */\nfunction shouldIgnore(value) {\n    return value && value.__symbolic == 'ignore';\n}\n/**\n * A static reflector implements enough of the Reflector API that is necessary to compile\n * templates statically.\n */\nvar StaticReflector = /** @class */ (function () {\n    function StaticReflector(summaryResolver, symbolResolver, knownMetadataClasses, knownMetadataFunctions, errorRecorder) {\n        if (knownMetadataClasses === void 0) { knownMetadataClasses = []; }\n        if (knownMetadataFunctions === void 0) { knownMetadataFunctions = []; }\n        var _this = this;\n        this.summaryResolver = summaryResolver;\n        this.symbolResolver = symbolResolver;\n        this.errorRecorder = errorRecorder;\n        this.annotationCache = new Map();\n        this.propertyCache = new Map();\n        this.parameterCache = new Map();\n        this.methodCache = new Map();\n        this.staticCache = new Map();\n        this.conversionMap = new Map();\n        this.resolvedExternalReferences = new Map();\n        this.annotationForParentClassWithSummaryKind = new Map();\n        this.initializeConversionMap();\n        knownMetadataClasses.forEach(function (kc) {\n            return _this._registerDecoratorOrConstructor(_this.getStaticSymbol(kc.filePath, kc.name), kc.ctor);\n        });\n        knownMetadataFunctions.forEach(function (kf) { return _this._registerFunction(_this.getStaticSymbol(kf.filePath, kf.name), kf.fn); });\n        this.annotationForParentClassWithSummaryKind.set(CompileSummaryKind.Directive, [createDirective, createComponent]);\n        this.annotationForParentClassWithSummaryKind.set(CompileSummaryKind.Pipe, [createPipe]);\n        this.annotationForParentClassWithSummaryKind.set(CompileSummaryKind.NgModule, [createNgModule]);\n        this.annotationForParentClassWithSummaryKind.set(CompileSummaryKind.Injectable, [createInjectable, createPipe, createDirective, createComponent, createNgModule]);\n    }\n    /**\n     * @param {?} typeOrFunc\n     * @return {?}\n     */\n    StaticReflector.prototype.componentModuleUrl = /**\n     * @param {?} typeOrFunc\n     * @return {?}\n     */\n    function (typeOrFunc) {\n        var /** @type {?} */ staticSymbol = this.findSymbolDeclaration(typeOrFunc);\n        return this.symbolResolver.getResourcePath(staticSymbol);\n    };\n    /**\n     * @param {?} ref\n     * @param {?=} containingFile\n     * @return {?}\n     */\n    StaticReflector.prototype.resolveExternalReference = /**\n     * @param {?} ref\n     * @param {?=} containingFile\n     * @return {?}\n     */\n    function (ref, containingFile) {\n        var /** @type {?} */ key = undefined;\n        if (!containingFile) {\n            key = ref.moduleName + \":\" + ref.name;\n            var /** @type {?} */ declarationSymbol_1 = this.resolvedExternalReferences.get(key);\n            if (declarationSymbol_1)\n                return declarationSymbol_1;\n        }\n        var /** @type {?} */ refSymbol = this.symbolResolver.getSymbolByModule(/** @type {?} */ ((ref.moduleName)), /** @type {?} */ ((ref.name)), containingFile);\n        var /** @type {?} */ declarationSymbol = this.findSymbolDeclaration(refSymbol);\n        if (!containingFile) {\n            this.symbolResolver.recordModuleNameForFileName(refSymbol.filePath, /** @type {?} */ ((ref.moduleName)));\n            this.symbolResolver.recordImportAs(declarationSymbol, refSymbol);\n        }\n        if (key) {\n            this.resolvedExternalReferences.set(key, declarationSymbol);\n        }\n        return declarationSymbol;\n    };\n    /**\n     * @param {?} moduleUrl\n     * @param {?} name\n     * @param {?=} containingFile\n     * @return {?}\n     */\n    StaticReflector.prototype.findDeclaration = /**\n     * @param {?} moduleUrl\n     * @param {?} name\n     * @param {?=} containingFile\n     * @return {?}\n     */\n    function (moduleUrl, name, containingFile) {\n        return this.findSymbolDeclaration(this.symbolResolver.getSymbolByModule(moduleUrl, name, containingFile));\n    };\n    /**\n     * @param {?} moduleUrl\n     * @param {?} name\n     * @return {?}\n     */\n    StaticReflector.prototype.tryFindDeclaration = /**\n     * @param {?} moduleUrl\n     * @param {?} name\n     * @return {?}\n     */\n    function (moduleUrl, name) {\n        var _this = this;\n        return this.symbolResolver.ignoreErrorsFor(function () { return _this.findDeclaration(moduleUrl, name); });\n    };\n    /**\n     * @param {?} symbol\n     * @return {?}\n     */\n    StaticReflector.prototype.findSymbolDeclaration = /**\n     * @param {?} symbol\n     * @return {?}\n     */\n    function (symbol) {\n        var /** @type {?} */ resolvedSymbol = this.symbolResolver.resolveSymbol(symbol);\n        if (resolvedSymbol) {\n            var /** @type {?} */ resolvedMetadata = resolvedSymbol.metadata;\n            if (resolvedMetadata && resolvedMetadata.__symbolic === 'resolved') {\n                resolvedMetadata = resolvedMetadata.symbol;\n            }\n            if (resolvedMetadata instanceof StaticSymbol) {\n                return this.findSymbolDeclaration(resolvedSymbol.metadata);\n            }\n        }\n        return symbol;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    StaticReflector.prototype.annotations = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ annotations = this.annotationCache.get(type);\n        if (!annotations) {\n            annotations = [];\n            var /** @type {?} */ classMetadata = this.getTypeMetadata(type);\n            var /** @type {?} */ parentType = this.findParentType(type, classMetadata);\n            if (parentType) {\n                var /** @type {?} */ parentAnnotations = this.annotations(parentType);\n                annotations.push.apply(annotations, parentAnnotations);\n            }\n            var /** @type {?} */ ownAnnotations_1 = [];\n            if (classMetadata['decorators']) {\n                ownAnnotations_1 = this.simplify(type, classMetadata['decorators']);\n                annotations.push.apply(annotations, ownAnnotations_1);\n            }\n            if (parentType && !this.summaryResolver.isLibraryFile(type.filePath) &&\n                this.summaryResolver.isLibraryFile(parentType.filePath)) {\n                var /** @type {?} */ summary = this.summaryResolver.resolveSummary(parentType);\n                if (summary && summary.type) {\n                    var /** @type {?} */ requiredAnnotationTypes = /** @type {?} */ ((this.annotationForParentClassWithSummaryKind.get(/** @type {?} */ ((summary.type.summaryKind)))));\n                    var /** @type {?} */ typeHasRequiredAnnotation = requiredAnnotationTypes.some(function (requiredType) { return ownAnnotations_1.some(function (ann) { return requiredType.isTypeOf(ann); }); });\n                    if (!typeHasRequiredAnnotation) {\n                        this.reportError(formatMetadataError(metadataError(\"Class \" + type.name + \" in \" + type.filePath + \" extends from a \" + CompileSummaryKind[(/** @type {?} */ ((summary.type.summaryKind)))] + \" in another compilation unit without duplicating the decorator\", undefined, \"Please add a \" + requiredAnnotationTypes.map(function (type) { return type.ngMetadataName; }).join(' or ') + \" decorator to the class\"), type), type);\n                    }\n                }\n            }\n            this.annotationCache.set(type, annotations.filter(function (ann) { return !!ann; }));\n        }\n        return annotations;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    StaticReflector.prototype.propMetadata = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var _this = this;\n        var /** @type {?} */ propMetadata = this.propertyCache.get(type);\n        if (!propMetadata) {\n            var /** @type {?} */ classMetadata = this.getTypeMetadata(type);\n            propMetadata = {};\n            var /** @type {?} */ parentType = this.findParentType(type, classMetadata);\n            if (parentType) {\n                var /** @type {?} */ parentPropMetadata_1 = this.propMetadata(parentType);\n                Object.keys(parentPropMetadata_1).forEach(function (parentProp) {\n                    /** @type {?} */ ((propMetadata))[parentProp] = parentPropMetadata_1[parentProp];\n                });\n            }\n            var /** @type {?} */ members_1 = classMetadata['members'] || {};\n            Object.keys(members_1).forEach(function (propName) {\n                var /** @type {?} */ propData = members_1[propName];\n                var /** @type {?} */ prop = (/** @type {?} */ (propData))\n                    .find(function (a) { return a['__symbolic'] == 'property' || a['__symbolic'] == 'method'; });\n                var /** @type {?} */ decorators = [];\n                if (/** @type {?} */ ((propMetadata))[propName]) {\n                    decorators.push.apply(decorators, /** @type {?} */ ((propMetadata))[propName]);\n                } /** @type {?} */\n                ((propMetadata))[propName] = decorators;\n                if (prop && prop['decorators']) {\n                    decorators.push.apply(decorators, _this.simplify(type, prop['decorators']));\n                }\n            });\n            this.propertyCache.set(type, propMetadata);\n        }\n        return propMetadata;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    StaticReflector.prototype.parameters = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var _this = this;\n        if (!(type instanceof StaticSymbol)) {\n            this.reportError(new Error(\"parameters received \" + JSON.stringify(type) + \" which is not a StaticSymbol\"), type);\n            return [];\n        }\n        try {\n            var /** @type {?} */ parameters_1 = this.parameterCache.get(type);\n            if (!parameters_1) {\n                var /** @type {?} */ classMetadata = this.getTypeMetadata(type);\n                var /** @type {?} */ parentType = this.findParentType(type, classMetadata);\n                var /** @type {?} */ members = classMetadata ? classMetadata['members'] : null;\n                var /** @type {?} */ ctorData = members ? members['__ctor__'] : null;\n                if (ctorData) {\n                    var /** @type {?} */ ctor = (/** @type {?} */ (ctorData)).find(function (a) { return a['__symbolic'] == 'constructor'; });\n                    var /** @type {?} */ rawParameterTypes = /** @type {?} */ (ctor['parameters']) || [];\n                    var /** @type {?} */ parameterDecorators_1 = /** @type {?} */ (this.simplify(type, ctor['parameterDecorators'] || []));\n                    parameters_1 = [];\n                    rawParameterTypes.forEach(function (rawParamType, index) {\n                        var /** @type {?} */ nestedResult = [];\n                        var /** @type {?} */ paramType = _this.trySimplify(type, rawParamType);\n                        if (paramType)\n                            nestedResult.push(paramType);\n                        var /** @type {?} */ decorators = parameterDecorators_1 ? parameterDecorators_1[index] : null;\n                        if (decorators) {\n                            nestedResult.push.apply(nestedResult, decorators);\n                        } /** @type {?} */\n                        ((parameters_1)).push(nestedResult);\n                    });\n                }\n                else if (parentType) {\n                    parameters_1 = this.parameters(parentType);\n                }\n                if (!parameters_1) {\n                    parameters_1 = [];\n                }\n                this.parameterCache.set(type, parameters_1);\n            }\n            return parameters_1;\n        }\n        catch (/** @type {?} */ e) {\n            console.error(\"Failed on type \" + JSON.stringify(type) + \" with error \" + e);\n            throw e;\n        }\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    StaticReflector.prototype._methodNames = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ methodNames = this.methodCache.get(type);\n        if (!methodNames) {\n            var /** @type {?} */ classMetadata = this.getTypeMetadata(type);\n            methodNames = {};\n            var /** @type {?} */ parentType = this.findParentType(type, classMetadata);\n            if (parentType) {\n                var /** @type {?} */ parentMethodNames_1 = this._methodNames(parentType);\n                Object.keys(parentMethodNames_1).forEach(function (parentProp) {\n                    /** @type {?} */ ((methodNames))[parentProp] = parentMethodNames_1[parentProp];\n                });\n            }\n            var /** @type {?} */ members_2 = classMetadata['members'] || {};\n            Object.keys(members_2).forEach(function (propName) {\n                var /** @type {?} */ propData = members_2[propName];\n                var /** @type {?} */ isMethod = (/** @type {?} */ (propData)).some(function (a) { return a['__symbolic'] == 'method'; }); /** @type {?} */\n                ((methodNames))[propName] = /** @type {?} */ ((methodNames))[propName] || isMethod;\n            });\n            this.methodCache.set(type, methodNames);\n        }\n        return methodNames;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    StaticReflector.prototype._staticMembers = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ staticMembers = this.staticCache.get(type);\n        if (!staticMembers) {\n            var /** @type {?} */ classMetadata = this.getTypeMetadata(type);\n            var /** @type {?} */ staticMemberData = classMetadata['statics'] || {};\n            staticMembers = Object.keys(staticMemberData);\n            this.staticCache.set(type, staticMembers);\n        }\n        return staticMembers;\n    };\n    /**\n     * @param {?} type\n     * @param {?} classMetadata\n     * @return {?}\n     */\n    StaticReflector.prototype.findParentType = /**\n     * @param {?} type\n     * @param {?} classMetadata\n     * @return {?}\n     */\n    function (type, classMetadata) {\n        var /** @type {?} */ parentType = this.trySimplify(type, classMetadata['extends']);\n        if (parentType instanceof StaticSymbol) {\n            return parentType;\n        }\n    };\n    /**\n     * @param {?} type\n     * @param {?} lcProperty\n     * @return {?}\n     */\n    StaticReflector.prototype.hasLifecycleHook = /**\n     * @param {?} type\n     * @param {?} lcProperty\n     * @return {?}\n     */\n    function (type, lcProperty) {\n        if (!(type instanceof StaticSymbol)) {\n            this.reportError(new Error(\"hasLifecycleHook received \" + JSON.stringify(type) + \" which is not a StaticSymbol\"), type);\n        }\n        try {\n            return !!this._methodNames(type)[lcProperty];\n        }\n        catch (/** @type {?} */ e) {\n            console.error(\"Failed on type \" + JSON.stringify(type) + \" with error \" + e);\n            throw e;\n        }\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    StaticReflector.prototype.guards = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        if (!(type instanceof StaticSymbol)) {\n            this.reportError(new Error(\"guards received \" + JSON.stringify(type) + \" which is not a StaticSymbol\"), type);\n            return {};\n        }\n        var /** @type {?} */ staticMembers = this._staticMembers(type);\n        var /** @type {?} */ result = {};\n        for (var _i = 0, staticMembers_1 = staticMembers; _i < staticMembers_1.length; _i++) {\n            var name_1 = staticMembers_1[_i];\n            if (name_1.endsWith(TYPEGUARD_POSTFIX)) {\n                var /** @type {?} */ property = name_1.substr(0, name_1.length - TYPEGUARD_POSTFIX.length);\n                var /** @type {?} */ value = void 0;\n                if (property.endsWith(USE_IF)) {\n                    property = name_1.substr(0, property.length - USE_IF.length);\n                    value = USE_IF;\n                }\n                else {\n                    value = this.getStaticSymbol(type.filePath, type.name, [name_1]);\n                }\n                result[property] = value;\n            }\n        }\n        return result;\n    };\n    /**\n     * @param {?} type\n     * @param {?} ctor\n     * @return {?}\n     */\n    StaticReflector.prototype._registerDecoratorOrConstructor = /**\n     * @param {?} type\n     * @param {?} ctor\n     * @return {?}\n     */\n    function (type, ctor) {\n        this.conversionMap.set(type, function (context, args) { return new (ctor.bind.apply(ctor, [void 0].concat(args)))(); });\n    };\n    /**\n     * @param {?} type\n     * @param {?} fn\n     * @return {?}\n     */\n    StaticReflector.prototype._registerFunction = /**\n     * @param {?} type\n     * @param {?} fn\n     * @return {?}\n     */\n    function (type, fn) {\n        this.conversionMap.set(type, function (context, args) { return fn.apply(undefined, args); });\n    };\n    /**\n     * @return {?}\n     */\n    StaticReflector.prototype.initializeConversionMap = /**\n     * @return {?}\n     */\n    function () {\n        this.injectionToken = this.findDeclaration(ANGULAR_CORE, 'InjectionToken');\n        this.opaqueToken = this.findDeclaration(ANGULAR_CORE, 'OpaqueToken');\n        this.ROUTES = this.tryFindDeclaration(ANGULAR_ROUTER, 'ROUTES');\n        this.ANALYZE_FOR_ENTRY_COMPONENTS =\n            this.findDeclaration(ANGULAR_CORE, 'ANALYZE_FOR_ENTRY_COMPONENTS');\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Host'), createHost);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Injectable'), createInjectable);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Self'), createSelf);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'SkipSelf'), createSkipSelf);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Inject'), createInject);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Optional'), createOptional);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Attribute'), createAttribute);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'ContentChild'), createContentChild);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'ContentChildren'), createContentChildren);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'ViewChild'), createViewChild);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'ViewChildren'), createViewChildren);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Input'), createInput);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Output'), createOutput);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Pipe'), createPipe);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'HostBinding'), createHostBinding);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'HostListener'), createHostListener);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Directive'), createDirective);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Component'), createComponent);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'NgModule'), createNgModule);\n        // Note: Some metadata classes can be used directly with Provider.deps.\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Host'), createHost);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Self'), createSelf);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'SkipSelf'), createSkipSelf);\n        this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Optional'), createOptional);\n    };\n    /**\n     * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.\n     * All types passed to the StaticResolver should be pseudo-types returned by this method.\n     *\n     * @param declarationFile the absolute path of the file where the symbol is declared\n     * @param name the name of the type.\n     */\n    /**\n     * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.\n     * All types passed to the StaticResolver should be pseudo-types returned by this method.\n     *\n     * @param {?} declarationFile the absolute path of the file where the symbol is declared\n     * @param {?} name the name of the type.\n     * @param {?=} members\n     * @return {?}\n     */\n    StaticReflector.prototype.getStaticSymbol = /**\n     * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.\n     * All types passed to the StaticResolver should be pseudo-types returned by this method.\n     *\n     * @param {?} declarationFile the absolute path of the file where the symbol is declared\n     * @param {?} name the name of the type.\n     * @param {?=} members\n     * @return {?}\n     */\n    function (declarationFile, name, members) {\n        return this.symbolResolver.getStaticSymbol(declarationFile, name, members);\n    };\n    /**\n     * Simplify but discard any errors\n     * @param {?} context\n     * @param {?} value\n     * @return {?}\n     */\n    StaticReflector.prototype.trySimplify = /**\n     * Simplify but discard any errors\n     * @param {?} context\n     * @param {?} value\n     * @return {?}\n     */\n    function (context, value) {\n        var /** @type {?} */ originalRecorder = this.errorRecorder;\n        this.errorRecorder = function (error, fileName) { };\n        var /** @type {?} */ result = this.simplify(context, value);\n        this.errorRecorder = originalRecorder;\n        return result;\n    };\n    /**\n     * \\@internal\n     * @param {?} context\n     * @param {?} value\n     * @return {?}\n     */\n    StaticReflector.prototype.simplify = /**\n     * \\@internal\n     * @param {?} context\n     * @param {?} value\n     * @return {?}\n     */\n    function (context, value) {\n        var /** @type {?} */ self = this;\n        var /** @type {?} */ scope = BindingScope.empty;\n        var /** @type {?} */ calling = new Map();\n        var /** @type {?} */ rootContext = context;\n        /**\n         * @param {?} context\n         * @param {?} value\n         * @param {?} depth\n         * @param {?} references\n         * @return {?}\n         */\n        function simplifyInContext(context, value, depth, references) {\n            /**\n             * @param {?} staticSymbol\n             * @return {?}\n             */\n            function resolveReferenceValue(staticSymbol) {\n                var /** @type {?} */ resolvedSymbol = self.symbolResolver.resolveSymbol(staticSymbol);\n                return resolvedSymbol ? resolvedSymbol.metadata : null;\n            }\n            /**\n             * @param {?} value\n             * @return {?}\n             */\n            function simplifyEagerly(value) {\n                return simplifyInContext(context, value, depth, 0);\n            }\n            /**\n             * @param {?} value\n             * @return {?}\n             */\n            function simplifyLazily(value) {\n                return simplifyInContext(context, value, depth, references + 1);\n            }\n            /**\n             * @param {?} nestedContext\n             * @param {?} value\n             * @return {?}\n             */\n            function simplifyNested(nestedContext, value) {\n                if (nestedContext === context) {\n                    // If the context hasn't changed let the exception propagate unmodified.\n                    return simplifyInContext(nestedContext, value, depth + 1, references);\n                }\n                try {\n                    return simplifyInContext(nestedContext, value, depth + 1, references);\n                }\n                catch (/** @type {?} */ e) {\n                    if (isMetadataError(e)) {\n                        // Propagate the message text up but add a message to the chain that explains how we got\n                        // here.\n                        // e.chain implies e.symbol\n                        var /** @type {?} */ summaryMsg = e.chain ? 'references \\'' + /** @type {?} */ ((e.symbol)).name + '\\'' : errorSummary(e);\n                        var /** @type {?} */ summary = \"'\" + nestedContext.name + \"' \" + summaryMsg;\n                        var /** @type {?} */ chain = { message: summary, position: e.position, next: e.chain };\n                        // TODO(chuckj): retrieve the position information indirectly from the collectors node\n                        // map if the metadata is from a .ts file.\n                        self.error({\n                            message: e.message,\n                            advise: e.advise,\n                            context: e.context, chain: chain,\n                            symbol: nestedContext\n                        }, context);\n                    }\n                    else {\n                        // It is probably an internal error.\n                        throw e;\n                    }\n                }\n            }\n            /**\n             * @param {?} functionSymbol\n             * @param {?} targetFunction\n             * @param {?} args\n             * @param {?} targetExpression\n             * @return {?}\n             */\n            function simplifyCall(functionSymbol, targetFunction, args, targetExpression) {\n                if (targetFunction && targetFunction['__symbolic'] == 'function') {\n                    if (calling.get(functionSymbol)) {\n                        self.error({\n                            message: 'Recursion is not supported',\n                            summary: \"called '\" + functionSymbol.name + \"' recursively\",\n                            value: targetFunction\n                        }, functionSymbol);\n                    }\n                    try {\n                        var /** @type {?} */ value_1 = targetFunction['value'];\n                        if (value_1 && (depth != 0 || value_1.__symbolic != 'error')) {\n                            var /** @type {?} */ parameters = targetFunction['parameters'];\n                            var /** @type {?} */ defaults = targetFunction.defaults;\n                            args = args.map(function (arg) { return simplifyNested(context, arg); })\n                                .map(function (arg) { return shouldIgnore(arg) ? undefined : arg; });\n                            if (defaults && defaults.length > args.length) {\n                                args.push.apply(args, defaults.slice(args.length).map(function (value) { return simplify(value); }));\n                            }\n                            calling.set(functionSymbol, true);\n                            var /** @type {?} */ functionScope = BindingScope.build();\n                            for (var /** @type {?} */ i = 0; i < parameters.length; i++) {\n                                functionScope.define(parameters[i], args[i]);\n                            }\n                            var /** @type {?} */ oldScope = scope;\n                            var /** @type {?} */ result_1;\n                            try {\n                                scope = functionScope.done();\n                                result_1 = simplifyNested(functionSymbol, value_1);\n                            }\n                            finally {\n                                scope = oldScope;\n                            }\n                            return result_1;\n                        }\n                    }\n                    finally {\n                        calling.delete(functionSymbol);\n                    }\n                }\n                if (depth === 0) {\n                    // If depth is 0 we are evaluating the top level expression that is describing element\n                    // decorator. In this case, it is a decorator we don't understand, such as a custom\n                    // non-angular decorator, and we should just ignore it.\n                    return IGNORE;\n                }\n                var /** @type {?} */ position = undefined;\n                if (targetExpression && targetExpression.__symbolic == 'resolved') {\n                    var /** @type {?} */ line = targetExpression.line;\n                    var /** @type {?} */ character = targetExpression.character;\n                    var /** @type {?} */ fileName = targetExpression.fileName;\n                    if (fileName != null && line != null && character != null) {\n                        position = { fileName: fileName, line: line, column: character };\n                    }\n                }\n                self.error({\n                    message: FUNCTION_CALL_NOT_SUPPORTED,\n                    context: functionSymbol,\n                    value: targetFunction, position: position\n                }, context);\n            }\n            /**\n             * @param {?} expression\n             * @return {?}\n             */\n            function simplify(expression) {\n                if (isPrimitive(expression)) {\n                    return expression;\n                }\n                if (expression instanceof Array) {\n                    var /** @type {?} */ result_2 = [];\n                    for (var _i = 0, _a = (/** @type {?} */ (expression)); _i < _a.length; _i++) {\n                        var item = _a[_i];\n                        // Check for a spread expression\n                        if (item && item.__symbolic === 'spread') {\n                            // We call with references as 0 because we require the actual value and cannot\n                            // tolerate a reference here.\n                            var /** @type {?} */ spreadArray = simplifyEagerly(item.expression);\n                            if (Array.isArray(spreadArray)) {\n                                for (var _b = 0, spreadArray_1 = spreadArray; _b < spreadArray_1.length; _b++) {\n                                    var spreadItem = spreadArray_1[_b];\n                                    result_2.push(spreadItem);\n                                }\n                                continue;\n                            }\n                        }\n                        var /** @type {?} */ value_2 = simplify(item);\n                        if (shouldIgnore(value_2)) {\n                            continue;\n                        }\n                        result_2.push(value_2);\n                    }\n                    return result_2;\n                }\n                if (expression instanceof StaticSymbol) {\n                    // Stop simplification at builtin symbols or if we are in a reference context and\n                    // the symbol doesn't have members.\n                    if (expression === self.injectionToken || self.conversionMap.has(expression) ||\n                        (references > 0 && !expression.members.length)) {\n                        return expression;\n                    }\n                    else {\n                        var /** @type {?} */ staticSymbol = expression;\n                        var /** @type {?} */ declarationValue = resolveReferenceValue(staticSymbol);\n                        if (declarationValue != null) {\n                            return simplifyNested(staticSymbol, declarationValue);\n                        }\n                        else {\n                            return staticSymbol;\n                        }\n                    }\n                }\n                if (expression) {\n                    if (expression['__symbolic']) {\n                        var /** @type {?} */ staticSymbol = void 0;\n                        switch (expression['__symbolic']) {\n                            case 'binop':\n                                var /** @type {?} */ left = simplify(expression['left']);\n                                if (shouldIgnore(left))\n                                    return left;\n                                var /** @type {?} */ right = simplify(expression['right']);\n                                if (shouldIgnore(right))\n                                    return right;\n                                switch (expression['operator']) {\n                                    case '&&':\n                                        return left && right;\n                                    case '||':\n                                        return left || right;\n                                    case '|':\n                                        return left | right;\n                                    case '^':\n                                        return left ^ right;\n                                    case '&':\n                                        return left & right;\n                                    case '==':\n                                        return left == right;\n                                    case '!=':\n                                        return left != right;\n                                    case '===':\n                                        return left === right;\n                                    case '!==':\n                                        return left !== right;\n                                    case '<':\n                                        return left < right;\n                                    case '>':\n                                        return left > right;\n                                    case '<=':\n                                        return left <= right;\n                                    case '>=':\n                                        return left >= right;\n                                    case '<<':\n                                        return left << right;\n                                    case '>>':\n                                        return left >> right;\n                                    case '+':\n                                        return left + right;\n                                    case '-':\n                                        return left - right;\n                                    case '*':\n                                        return left * right;\n                                    case '/':\n                                        return left / right;\n                                    case '%':\n                                        return left % right;\n                                }\n                                return null;\n                            case 'if':\n                                var /** @type {?} */ condition = simplify(expression['condition']);\n                                return condition ? simplify(expression['thenExpression']) :\n                                    simplify(expression['elseExpression']);\n                            case 'pre':\n                                var /** @type {?} */ operand = simplify(expression['operand']);\n                                if (shouldIgnore(operand))\n                                    return operand;\n                                switch (expression['operator']) {\n                                    case '+':\n                                        return operand;\n                                    case '-':\n                                        return -operand;\n                                    case '!':\n                                        return !operand;\n                                    case '~':\n                                        return ~operand;\n                                }\n                                return null;\n                            case 'index':\n                                var /** @type {?} */ indexTarget = simplifyEagerly(expression['expression']);\n                                var /** @type {?} */ index = simplifyEagerly(expression['index']);\n                                if (indexTarget && isPrimitive(index))\n                                    return indexTarget[index];\n                                return null;\n                            case 'select':\n                                var /** @type {?} */ member = expression['member'];\n                                var /** @type {?} */ selectContext = context;\n                                var /** @type {?} */ selectTarget = simplify(expression['expression']);\n                                if (selectTarget instanceof StaticSymbol) {\n                                    var /** @type {?} */ members = selectTarget.members.concat(member);\n                                    selectContext =\n                                        self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);\n                                    var /** @type {?} */ declarationValue = resolveReferenceValue(selectContext);\n                                    if (declarationValue != null) {\n                                        return simplifyNested(selectContext, declarationValue);\n                                    }\n                                    else {\n                                        return selectContext;\n                                    }\n                                }\n                                if (selectTarget && isPrimitive(member))\n                                    return simplifyNested(selectContext, selectTarget[member]);\n                                return null;\n                            case 'reference':\n                                // Note: This only has to deal with variable references, as symbol references have\n                                // been converted into 'resolved'\n                                // in the StaticSymbolResolver.\n                                var /** @type {?} */ name_2 = expression['name'];\n                                var /** @type {?} */ localValue = scope.resolve(name_2);\n                                if (localValue != BindingScope.missing) {\n                                    return localValue;\n                                }\n                                break;\n                            case 'resolved':\n                                try {\n                                    return simplify(expression.symbol);\n                                }\n                                catch (/** @type {?} */ e) {\n                                    // If an error is reported evaluating the symbol record the position of the\n                                    // reference in the error so it can\n                                    // be reported in the error message generated from the exception.\n                                    if (isMetadataError(e) && expression.fileName != null &&\n                                        expression.line != null && expression.character != null) {\n                                        e.position = {\n                                            fileName: expression.fileName,\n                                            line: expression.line,\n                                            column: expression.character\n                                        };\n                                    }\n                                    throw e;\n                                }\n                            case 'class':\n                                return context;\n                            case 'function':\n                                return context;\n                            case 'new':\n                            case 'call':\n                                // Determine if the function is a built-in conversion\n                                staticSymbol = simplifyInContext(context, expression['expression'], depth + 1, /* references */ 0);\n                                if (staticSymbol instanceof StaticSymbol) {\n                                    if (staticSymbol === self.injectionToken || staticSymbol === self.opaqueToken) {\n                                        // if somebody calls new InjectionToken, don't create an InjectionToken,\n                                        // but rather return the symbol to which the InjectionToken is assigned to.\n                                        // OpaqueToken is supported too as it is required by the language service to\n                                        // support v4 and prior versions of Angular.\n                                        return context;\n                                    }\n                                    var /** @type {?} */ argExpressions = expression['arguments'] || [];\n                                    var /** @type {?} */ converter = self.conversionMap.get(staticSymbol);\n                                    if (converter) {\n                                        var /** @type {?} */ args = argExpressions.map(function (arg) { return simplifyNested(context, arg); })\n                                            .map(function (arg) { return shouldIgnore(arg) ? undefined : arg; });\n                                        return converter(context, args);\n                                    }\n                                    else {\n                                        // Determine if the function is one we can simplify.\n                                        var /** @type {?} */ targetFunction = resolveReferenceValue(staticSymbol);\n                                        return simplifyCall(staticSymbol, targetFunction, argExpressions, expression['expression']);\n                                    }\n                                }\n                                return IGNORE;\n                            case 'error':\n                                var /** @type {?} */ message = expression.message;\n                                if (expression['line'] != null) {\n                                    self.error({\n                                        message: message,\n                                        context: expression.context,\n                                        value: expression,\n                                        position: {\n                                            fileName: expression['fileName'],\n                                            line: expression['line'],\n                                            column: expression['character']\n                                        }\n                                    }, context);\n                                }\n                                else {\n                                    self.error({ message: message, context: expression.context }, context);\n                                }\n                                return IGNORE;\n                            case 'ignore':\n                                return expression;\n                        }\n                        return null;\n                    }\n                    return mapStringMap(expression, function (value, name) {\n                        if (REFERENCE_SET.has(name)) {\n                            if (name === USE_VALUE && PROVIDE in expression) {\n                                // If this is a provider expression, check for special tokens that need the value\n                                // during analysis.\n                                var /** @type {?} */ provide = simplify(expression.provide);\n                                if (provide === self.ROUTES || provide == self.ANALYZE_FOR_ENTRY_COMPONENTS) {\n                                    return simplify(value);\n                                }\n                            }\n                            return simplifyLazily(value);\n                        }\n                        return simplify(value);\n                    });\n                }\n                return IGNORE;\n            }\n            return simplify(value);\n        }\n        var /** @type {?} */ result;\n        try {\n            result = simplifyInContext(context, value, 0, 0);\n        }\n        catch (/** @type {?} */ e) {\n            if (this.errorRecorder) {\n                this.reportError(e, context);\n            }\n            else {\n                throw formatMetadataError(e, context);\n            }\n        }\n        if (shouldIgnore(result)) {\n            return undefined;\n        }\n        return result;\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    StaticReflector.prototype.getTypeMetadata = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        var /** @type {?} */ resolvedSymbol = this.symbolResolver.resolveSymbol(type);\n        return resolvedSymbol && resolvedSymbol.metadata ? resolvedSymbol.metadata :\n            { __symbolic: 'class' };\n    };\n    /**\n     * @param {?} error\n     * @param {?} context\n     * @param {?=} path\n     * @return {?}\n     */\n    StaticReflector.prototype.reportError = /**\n     * @param {?} error\n     * @param {?} context\n     * @param {?=} path\n     * @return {?}\n     */\n    function (error, context, path) {\n        if (this.errorRecorder) {\n            this.errorRecorder(formatMetadataError(error, context), (context && context.filePath) || path);\n        }\n        else {\n            throw error;\n        }\n    };\n    /**\n     * @param {?} __0\n     * @param {?} reportingContext\n     * @return {?}\n     */\n    StaticReflector.prototype.error = /**\n     * @param {?} __0\n     * @param {?} reportingContext\n     * @return {?}\n     */\n    function (_a, reportingContext) {\n        var message = _a.message, summary = _a.summary, advise = _a.advise, position = _a.position, context = _a.context, value = _a.value, symbol = _a.symbol, chain = _a.chain;\n        this.reportError(metadataError(message, summary, advise, position, symbol, context, chain), reportingContext);\n    };\n    return StaticReflector;\n}());\nvar METADATA_ERROR = 'ngMetadataError';\n/**\n * @param {?} message\n * @param {?=} summary\n * @param {?=} advise\n * @param {?=} position\n * @param {?=} symbol\n * @param {?=} context\n * @param {?=} chain\n * @return {?}\n */\nfunction metadataError(message, summary, advise, position, symbol, context, chain) {\n    var /** @type {?} */ error = /** @type {?} */ (syntaxError(message));\n    (/** @type {?} */ (error))[METADATA_ERROR] = true;\n    if (advise)\n        error.advise = advise;\n    if (position)\n        error.position = position;\n    if (summary)\n        error.summary = summary;\n    if (context)\n        error.context = context;\n    if (chain)\n        error.chain = chain;\n    if (symbol)\n        error.symbol = symbol;\n    return error;\n}\n/**\n * @param {?} error\n * @return {?}\n */\nfunction isMetadataError(error) {\n    return !!(/** @type {?} */ (error))[METADATA_ERROR];\n}\nvar REFERENCE_TO_NONEXPORTED_CLASS = 'Reference to non-exported class';\nvar VARIABLE_NOT_INITIALIZED = 'Variable not initialized';\nvar DESTRUCTURE_NOT_SUPPORTED = 'Destructuring not supported';\nvar COULD_NOT_RESOLVE_TYPE = 'Could not resolve type';\nvar FUNCTION_CALL_NOT_SUPPORTED = 'Function call not supported';\nvar REFERENCE_TO_LOCAL_SYMBOL = 'Reference to a local symbol';\nvar LAMBDA_NOT_SUPPORTED = 'Lambda not supported';\n/**\n * @param {?} message\n * @param {?} context\n * @return {?}\n */\nfunction expandedMessage(message, context) {\n    switch (message) {\n        case REFERENCE_TO_NONEXPORTED_CLASS:\n            if (context && context.className) {\n                return \"References to a non-exported class are not supported in decorators but \" + context.className + \" was referenced.\";\n            }\n            break;\n        case VARIABLE_NOT_INITIALIZED:\n            return 'Only initialized variables and constants can be referenced in decorators because the value of this variable is needed by the template compiler';\n        case DESTRUCTURE_NOT_SUPPORTED:\n            return 'Referencing an exported destructured variable or constant is not supported in decorators and this value is needed by the template compiler';\n        case COULD_NOT_RESOLVE_TYPE:\n            if (context && context.typeName) {\n                return \"Could not resolve type \" + context.typeName;\n            }\n            break;\n        case FUNCTION_CALL_NOT_SUPPORTED:\n            if (context && context.name) {\n                return \"Function calls are not supported in decorators but '\" + context.name + \"' was called\";\n            }\n            return 'Function calls are not supported in decorators';\n        case REFERENCE_TO_LOCAL_SYMBOL:\n            if (context && context.name) {\n                return \"Reference to a local (non-exported) symbols are not supported in decorators but '\" + context.name + \"' was referenced\";\n            }\n            break;\n        case LAMBDA_NOT_SUPPORTED:\n            return \"Function expressions are not supported in decorators\";\n    }\n    return message;\n}\n/**\n * @param {?} message\n * @param {?} context\n * @return {?}\n */\nfunction messageAdvise(message, context) {\n    switch (message) {\n        case REFERENCE_TO_NONEXPORTED_CLASS:\n            if (context && context.className) {\n                return \"Consider exporting '\" + context.className + \"'\";\n            }\n            break;\n        case DESTRUCTURE_NOT_SUPPORTED:\n            return 'Consider simplifying to avoid destructuring';\n        case REFERENCE_TO_LOCAL_SYMBOL:\n            if (context && context.name) {\n                return \"Consider exporting '\" + context.name + \"'\";\n            }\n            break;\n        case LAMBDA_NOT_SUPPORTED:\n            return \"Consider changing the function expression into an exported function\";\n    }\n    return undefined;\n}\n/**\n * @param {?} error\n * @return {?}\n */\nfunction errorSummary(error) {\n    if (error.summary) {\n        return error.summary;\n    }\n    switch (error.message) {\n        case REFERENCE_TO_NONEXPORTED_CLASS:\n            if (error.context && error.context.className) {\n                return \"references non-exported class \" + error.context.className;\n            }\n            break;\n        case VARIABLE_NOT_INITIALIZED:\n            return 'is not initialized';\n        case DESTRUCTURE_NOT_SUPPORTED:\n            return 'is a destructured variable';\n        case COULD_NOT_RESOLVE_TYPE:\n            return 'could not be resolved';\n        case FUNCTION_CALL_NOT_SUPPORTED:\n            if (error.context && error.context.name) {\n                return \"calls '\" + error.context.name + \"'\";\n            }\n            return \"calls a function\";\n        case REFERENCE_TO_LOCAL_SYMBOL:\n            if (error.context && error.context.name) {\n                return \"references local variable \" + error.context.name;\n            }\n            return \"references a local variable\";\n    }\n    return 'contains the error';\n}\n/**\n * @param {?} input\n * @param {?} transform\n * @return {?}\n */\nfunction mapStringMap(input, transform) {\n    if (!input)\n        return {};\n    var /** @type {?} */ result = {};\n    Object.keys(input).forEach(function (key) {\n        var /** @type {?} */ value = transform(input[key], key);\n        if (!shouldIgnore(value)) {\n            if (HIDDEN_KEY.test(key)) {\n                Object.defineProperty(result, key, { enumerable: false, configurable: true, value: value });\n            }\n            else {\n                result[key] = value;\n            }\n        }\n    });\n    return result;\n}\n/**\n * @param {?} o\n * @return {?}\n */\nfunction isPrimitive(o) {\n    return o === null || (typeof o !== 'function' && typeof o !== 'object');\n}\n/**\n * @abstract\n */\nvar BindingScope = /** @class */ (function () {\n    function BindingScope() {\n    }\n    /**\n     * @return {?}\n     */\n    BindingScope.build = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ current = new Map();\n        return {\n            define: function (name, value) {\n                current.set(name, value);\n                return this;\n            },\n            done: function () {\n                return current.size > 0 ? new PopulatedScope(current) : BindingScope.empty;\n            }\n        };\n    };\n    BindingScope.missing = {};\n    BindingScope.empty = { resolve: function (name) { return BindingScope.missing; } };\n    return BindingScope;\n}());\nvar PopulatedScope = /** @class */ (function (_super) {\n    __extends(PopulatedScope, _super);\n    function PopulatedScope(bindings) {\n        var _this = _super.call(this) || this;\n        _this.bindings = bindings;\n        return _this;\n    }\n    /**\n     * @param {?} name\n     * @return {?}\n     */\n    PopulatedScope.prototype.resolve = /**\n     * @param {?} name\n     * @return {?}\n     */\n    function (name) {\n        return this.bindings.has(name) ? this.bindings.get(name) : BindingScope.missing;\n    };\n    return PopulatedScope;\n}(BindingScope));\n/**\n * @param {?} chain\n * @param {?} advise\n * @return {?}\n */\nfunction formatMetadataMessageChain(chain, advise) {\n    var /** @type {?} */ expanded = expandedMessage(chain.message, chain.context);\n    var /** @type {?} */ nesting = chain.symbol ? \" in '\" + chain.symbol.name + \"'\" : '';\n    var /** @type {?} */ message = \"\" + expanded + nesting;\n    var /** @type {?} */ position = chain.position;\n    var /** @type {?} */ next = chain.next ?\n        formatMetadataMessageChain(chain.next, advise) :\n        advise ? { message: advise } : undefined;\n    return { message: message, position: position, next: next };\n}\n/**\n * @param {?} e\n * @param {?} context\n * @return {?}\n */\nfunction formatMetadataError(e, context) {\n    if (isMetadataError(e)) {\n        // Produce a formatted version of the and leaving enough information in the original error\n        // to recover the formatting information to eventually produce a diagnostic error message.\n        var /** @type {?} */ position = e.position;\n        var /** @type {?} */ chain = {\n            message: \"Error during template compile of '\" + context.name + \"'\",\n            position: position,\n            next: { message: e.message, next: e.chain, context: e.context, symbol: e.symbol }\n        };\n        var /** @type {?} */ advise = e.advise || messageAdvise(e.message, e.context);\n        return formattedError(formatMetadataMessageChain(chain, advise));\n    }\n    return e;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @record\n */\n\nvar AotSummaryResolver = /** @class */ (function () {\n    function AotSummaryResolver(host, staticSymbolCache) {\n        this.host = host;\n        this.staticSymbolCache = staticSymbolCache;\n        this.summaryCache = new Map();\n        this.loadedFilePaths = new Map();\n        this.importAs = new Map();\n        this.knownFileNameToModuleNames = new Map();\n    }\n    /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    AotSummaryResolver.prototype.isLibraryFile = /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    function (filePath) {\n        // Note: We need to strip the .ngfactory. file path,\n        // so this method also works for generated files\n        // (for which host.isSourceFile will always return false).\n        return !this.host.isSourceFile(stripGeneratedFileSuffix(filePath));\n    };\n    /**\n     * @param {?} filePath\n     * @param {?} referringSrcFileName\n     * @return {?}\n     */\n    AotSummaryResolver.prototype.toSummaryFileName = /**\n     * @param {?} filePath\n     * @param {?} referringSrcFileName\n     * @return {?}\n     */\n    function (filePath, referringSrcFileName) {\n        return this.host.toSummaryFileName(filePath, referringSrcFileName);\n    };\n    /**\n     * @param {?} fileName\n     * @param {?} referringLibFileName\n     * @return {?}\n     */\n    AotSummaryResolver.prototype.fromSummaryFileName = /**\n     * @param {?} fileName\n     * @param {?} referringLibFileName\n     * @return {?}\n     */\n    function (fileName, referringLibFileName) {\n        return this.host.fromSummaryFileName(fileName, referringLibFileName);\n    };\n    /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    AotSummaryResolver.prototype.resolveSummary = /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    function (staticSymbol) {\n        var /** @type {?} */ rootSymbol = staticSymbol.members.length ?\n            this.staticSymbolCache.get(staticSymbol.filePath, staticSymbol.name) :\n            staticSymbol;\n        var /** @type {?} */ summary = this.summaryCache.get(rootSymbol);\n        if (!summary) {\n            this._loadSummaryFile(staticSymbol.filePath);\n            summary = /** @type {?} */ ((this.summaryCache.get(staticSymbol)));\n        }\n        return (rootSymbol === staticSymbol && summary) || null;\n    };\n    /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    AotSummaryResolver.prototype.getSymbolsOf = /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    function (filePath) {\n        if (this._loadSummaryFile(filePath)) {\n            return Array.from(this.summaryCache.keys()).filter(function (symbol) { return symbol.filePath === filePath; });\n        }\n        return null;\n    };\n    /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    AotSummaryResolver.prototype.getImportAs = /**\n     * @param {?} staticSymbol\n     * @return {?}\n     */\n    function (staticSymbol) {\n        staticSymbol.assertNoMembers();\n        return /** @type {?} */ ((this.importAs.get(staticSymbol)));\n    };\n    /**\n     * Converts a file path to a module name that can be used as an `import`.\n     */\n    /**\n     * Converts a file path to a module name that can be used as an `import`.\n     * @param {?} importedFilePath\n     * @return {?}\n     */\n    AotSummaryResolver.prototype.getKnownModuleName = /**\n     * Converts a file path to a module name that can be used as an `import`.\n     * @param {?} importedFilePath\n     * @return {?}\n     */\n    function (importedFilePath) {\n        return this.knownFileNameToModuleNames.get(importedFilePath) || null;\n    };\n    /**\n     * @param {?} summary\n     * @return {?}\n     */\n    AotSummaryResolver.prototype.addSummary = /**\n     * @param {?} summary\n     * @return {?}\n     */\n    function (summary) { this.summaryCache.set(summary.symbol, summary); };\n    /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    AotSummaryResolver.prototype._loadSummaryFile = /**\n     * @param {?} filePath\n     * @return {?}\n     */\n    function (filePath) {\n        var _this = this;\n        var /** @type {?} */ hasSummary = this.loadedFilePaths.get(filePath);\n        if (hasSummary != null) {\n            return hasSummary;\n        }\n        var /** @type {?} */ json = null;\n        if (this.isLibraryFile(filePath)) {\n            var /** @type {?} */ summaryFilePath = summaryFileName(filePath);\n            try {\n                json = this.host.loadSummary(summaryFilePath);\n            }\n            catch (/** @type {?} */ e) {\n                console.error(\"Error loading summary file \" + summaryFilePath);\n                throw e;\n            }\n        }\n        hasSummary = json != null;\n        this.loadedFilePaths.set(filePath, hasSummary);\n        if (json) {\n            var _a = deserializeSummaries(this.staticSymbolCache, this, filePath, json), moduleName = _a.moduleName, summaries = _a.summaries, importAs = _a.importAs;\n            summaries.forEach(function (summary) { return _this.summaryCache.set(summary.symbol, summary); });\n            if (moduleName) {\n                this.knownFileNameToModuleNames.set(filePath, moduleName);\n            }\n            importAs.forEach(function (importAs) { _this.importAs.set(importAs.symbol, importAs.importAs); });\n        }\n        return hasSummary;\n    };\n    return AotSummaryResolver;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @param {?} host\n * @return {?}\n */\nfunction createAotUrlResolver(host) {\n    return {\n        resolve: function (basePath, url) {\n            var /** @type {?} */ filePath = host.resourceNameToFileName(url, basePath);\n            if (!filePath) {\n                throw syntaxError(\"Couldn't resolve resource \" + url + \" from \" + basePath);\n            }\n            return filePath;\n        }\n    };\n}\n/**\n * Creates a new AotCompiler based on options and a host.\n * @param {?} compilerHost\n * @param {?} options\n * @param {?=} errorCollector\n * @return {?}\n */\nfunction createAotCompiler(compilerHost, options, errorCollector) {\n    var /** @type {?} */ translations = options.translations || '';\n    var /** @type {?} */ urlResolver = createAotUrlResolver(compilerHost);\n    var /** @type {?} */ symbolCache = new StaticSymbolCache();\n    var /** @type {?} */ summaryResolver = new AotSummaryResolver(compilerHost, symbolCache);\n    var /** @type {?} */ symbolResolver = new StaticSymbolResolver(compilerHost, symbolCache, summaryResolver);\n    var /** @type {?} */ staticReflector = new StaticReflector(summaryResolver, symbolResolver, [], [], errorCollector);\n    var /** @type {?} */ htmlParser = new I18NHtmlParser(new HtmlParser(), translations, options.i18nFormat, options.missingTranslation, console);\n    var /** @type {?} */ config = new CompilerConfig({\n        defaultEncapsulation: ViewEncapsulation.Emulated,\n        useJit: false,\n        enableLegacyTemplate: options.enableLegacyTemplate === true,\n        missingTranslation: options.missingTranslation,\n        preserveWhitespaces: options.preserveWhitespaces,\n        strictInjectionParameters: options.strictInjectionParameters,\n    });\n    var /** @type {?} */ normalizer = new DirectiveNormalizer({ get: function (url) { return compilerHost.loadResource(url); } }, urlResolver, htmlParser, config);\n    var /** @type {?} */ expressionParser = new Parser(new Lexer());\n    var /** @type {?} */ elementSchemaRegistry = new DomElementSchemaRegistry();\n    var /** @type {?} */ tmplParser = new TemplateParser(config, staticReflector, expressionParser, elementSchemaRegistry, htmlParser, console, []);\n    var /** @type {?} */ resolver = new CompileMetadataResolver(config, htmlParser, new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector), new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer, console, symbolCache, staticReflector, errorCollector);\n    // TODO(vicb): do not pass options.i18nFormat here\n    var /** @type {?} */ viewCompiler = new ViewCompiler(staticReflector);\n    var /** @type {?} */ typeCheckCompiler = new TypeCheckCompiler(options, staticReflector);\n    var /** @type {?} */ compiler = new AotCompiler(config, options, compilerHost, staticReflector, resolver, tmplParser, new StyleCompiler(urlResolver), viewCompiler, typeCheckCompiler, new NgModuleCompiler(staticReflector), new TypeScriptEmitter(), summaryResolver, symbolResolver);\n    return { compiler: compiler, reflector: staticReflector };\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @record\n * @template T\n */\n\n/**\n * @abstract\n * @template T\n */\nvar SummaryResolver = /** @class */ (function () {\n    function SummaryResolver() {\n    }\n    return SummaryResolver;\n}());\nvar JitSummaryResolver = /** @class */ (function () {\n    function JitSummaryResolver() {\n        this._summaries = new Map();\n    }\n    /**\n     * @return {?}\n     */\n    JitSummaryResolver.prototype.isLibraryFile = /**\n     * @return {?}\n     */\n    function () { return false; };\n    /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    JitSummaryResolver.prototype.toSummaryFileName = /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    function (fileName) { return fileName; };\n    /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    JitSummaryResolver.prototype.fromSummaryFileName = /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    function (fileName) { return fileName; };\n    /**\n     * @param {?} reference\n     * @return {?}\n     */\n    JitSummaryResolver.prototype.resolveSummary = /**\n     * @param {?} reference\n     * @return {?}\n     */\n    function (reference) {\n        return this._summaries.get(reference) || null;\n    };\n    /**\n     * @return {?}\n     */\n    JitSummaryResolver.prototype.getSymbolsOf = /**\n     * @return {?}\n     */\n    function () { return []; };\n    /**\n     * @param {?} reference\n     * @return {?}\n     */\n    JitSummaryResolver.prototype.getImportAs = /**\n     * @param {?} reference\n     * @return {?}\n     */\n    function (reference) { return reference; };\n    /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    JitSummaryResolver.prototype.getKnownModuleName = /**\n     * @param {?} fileName\n     * @return {?}\n     */\n    function (fileName) { return null; };\n    /**\n     * @param {?} summary\n     * @return {?}\n     */\n    JitSummaryResolver.prototype.addSummary = /**\n     * @param {?} summary\n     * @return {?}\n     */\n    function (summary) { this._summaries.set(summary.symbol, summary); };\n    return JitSummaryResolver;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @param {?} statements\n * @param {?} reflector\n * @return {?}\n */\nfunction interpretStatements(statements, reflector) {\n    var /** @type {?} */ ctx = new _ExecutionContext(null, null, null, new Map());\n    var /** @type {?} */ visitor = new StatementInterpreter(reflector);\n    visitor.visitAllStatements(statements, ctx);\n    var /** @type {?} */ result = {};\n    ctx.exports.forEach(function (exportName) { result[exportName] = ctx.vars.get(exportName); });\n    return result;\n}\n/**\n * @param {?} varNames\n * @param {?} varValues\n * @param {?} statements\n * @param {?} ctx\n * @param {?} visitor\n * @return {?}\n */\nfunction _executeFunctionStatements(varNames, varValues, statements, ctx, visitor) {\n    var /** @type {?} */ childCtx = ctx.createChildWihtLocalVars();\n    for (var /** @type {?} */ i = 0; i < varNames.length; i++) {\n        childCtx.vars.set(varNames[i], varValues[i]);\n    }\n    var /** @type {?} */ result = visitor.visitAllStatements(statements, childCtx);\n    return result ? result.value : null;\n}\nvar _ExecutionContext = /** @class */ (function () {\n    function _ExecutionContext(parent, instance, className, vars) {\n        this.parent = parent;\n        this.instance = instance;\n        this.className = className;\n        this.vars = vars;\n        this.exports = [];\n    }\n    /**\n     * @return {?}\n     */\n    _ExecutionContext.prototype.createChildWihtLocalVars = /**\n     * @return {?}\n     */\n    function () {\n        return new _ExecutionContext(this, this.instance, this.className, new Map());\n    };\n    return _ExecutionContext;\n}());\nvar ReturnValue = /** @class */ (function () {\n    function ReturnValue(value) {\n        this.value = value;\n    }\n    return ReturnValue;\n}());\n/**\n * @param {?} _classStmt\n * @param {?} _ctx\n * @param {?} _visitor\n * @return {?}\n */\nfunction createDynamicClass(_classStmt, _ctx, _visitor) {\n    var /** @type {?} */ propertyDescriptors = {};\n    _classStmt.getters.forEach(function (getter) {\n        // Note: use `function` instead of arrow function to capture `this`\n        propertyDescriptors[getter.name] = {\n            configurable: false,\n            get: function () {\n                var /** @type {?} */ instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);\n                return _executeFunctionStatements([], [], getter.body, instanceCtx, _visitor);\n            }\n        };\n    });\n    _classStmt.methods.forEach(function (method) {\n        var /** @type {?} */ paramNames = method.params.map(function (param) { return param.name; });\n        // Note: use `function` instead of arrow function to capture `this`\n        propertyDescriptors[/** @type {?} */ ((method.name))] = {\n            writable: false,\n            configurable: false,\n            value: function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                var /** @type {?} */ instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);\n                return _executeFunctionStatements(paramNames, args, method.body, instanceCtx, _visitor);\n            }\n        };\n    });\n    var /** @type {?} */ ctorParamNames = _classStmt.constructorMethod.params.map(function (param) { return param.name; });\n    // Note: use `function` instead of arrow function to capture `this`\n    var /** @type {?} */ ctor = function () {\n        var _this = this;\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var /** @type {?} */ instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars);\n        _classStmt.fields.forEach(function (field) { _this[field.name] = undefined; });\n        _executeFunctionStatements(ctorParamNames, args, _classStmt.constructorMethod.body, instanceCtx, _visitor);\n    };\n    var /** @type {?} */ superClass = _classStmt.parent ? _classStmt.parent.visitExpression(_visitor, _ctx) : Object;\n    ctor.prototype = Object.create(superClass.prototype, propertyDescriptors);\n    return ctor;\n}\nvar StatementInterpreter = /** @class */ (function () {\n    function StatementInterpreter(reflector) {\n        this.reflector = reflector;\n    }\n    /**\n     * @param {?} ast\n     * @return {?}\n     */\n    StatementInterpreter.prototype.debugAst = /**\n     * @param {?} ast\n     * @return {?}\n     */\n    function (ast) { return debugOutputAstAsTypeScript(ast); };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitDeclareVarStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.vars.set(stmt.name, stmt.value.visitExpression(this, ctx));\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            ctx.exports.push(stmt.name);\n        }\n        return null;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitWriteVarExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        var /** @type {?} */ value = expr.value.visitExpression(this, ctx);\n        var /** @type {?} */ currCtx = ctx;\n        while (currCtx != null) {\n            if (currCtx.vars.has(expr.name)) {\n                currCtx.vars.set(expr.name, value);\n                return value;\n            }\n            currCtx = /** @type {?} */ ((currCtx.parent));\n        }\n        throw new Error(\"Not declared variable \" + expr.name);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitReadVarExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ varName = /** @type {?} */ ((ast.name));\n        if (ast.builtin != null) {\n            switch (ast.builtin) {\n                case BuiltinVar.Super:\n                    return ctx.instance.__proto__;\n                case BuiltinVar.This:\n                    return ctx.instance;\n                case BuiltinVar.CatchError:\n                    varName = CATCH_ERROR_VAR$2;\n                    break;\n                case BuiltinVar.CatchStack:\n                    varName = CATCH_STACK_VAR$2;\n                    break;\n                default:\n                    throw new Error(\"Unknown builtin variable \" + ast.builtin);\n            }\n        }\n        var /** @type {?} */ currCtx = ctx;\n        while (currCtx != null) {\n            if (currCtx.vars.has(varName)) {\n                return currCtx.vars.get(varName);\n            }\n            currCtx = /** @type {?} */ ((currCtx.parent));\n        }\n        throw new Error(\"Not declared variable \" + varName);\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitWriteKeyExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        var /** @type {?} */ receiver = expr.receiver.visitExpression(this, ctx);\n        var /** @type {?} */ index = expr.index.visitExpression(this, ctx);\n        var /** @type {?} */ value = expr.value.visitExpression(this, ctx);\n        receiver[index] = value;\n        return value;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitWritePropExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        var /** @type {?} */ receiver = expr.receiver.visitExpression(this, ctx);\n        var /** @type {?} */ value = expr.value.visitExpression(this, ctx);\n        receiver[expr.name] = value;\n        return value;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitInvokeMethodExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        var /** @type {?} */ receiver = expr.receiver.visitExpression(this, ctx);\n        var /** @type {?} */ args = this.visitAllExpressions(expr.args, ctx);\n        var /** @type {?} */ result;\n        if (expr.builtin != null) {\n            switch (expr.builtin) {\n                case BuiltinMethod.ConcatArray:\n                    result = receiver.concat.apply(receiver, args);\n                    break;\n                case BuiltinMethod.SubscribeObservable:\n                    result = receiver.subscribe({ next: args[0] });\n                    break;\n                case BuiltinMethod.Bind:\n                    result = receiver.bind.apply(receiver, args);\n                    break;\n                default:\n                    throw new Error(\"Unknown builtin method \" + expr.builtin);\n            }\n        }\n        else {\n            result = receiver[/** @type {?} */ ((expr.name))].apply(receiver, args);\n        }\n        return result;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitInvokeFunctionExpr = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        var /** @type {?} */ args = this.visitAllExpressions(stmt.args, ctx);\n        var /** @type {?} */ fnExpr = stmt.fn;\n        if (fnExpr instanceof ReadVarExpr && fnExpr.builtin === BuiltinVar.Super) {\n            ctx.instance.constructor.prototype.constructor.apply(ctx.instance, args);\n            return null;\n        }\n        else {\n            var /** @type {?} */ fn$$1 = stmt.fn.visitExpression(this, ctx);\n            return fn$$1.apply(null, args);\n        }\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitReturnStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        return new ReturnValue(stmt.value.visitExpression(this, ctx));\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitDeclareClassStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        var /** @type {?} */ clazz = createDynamicClass(stmt, ctx, this);\n        ctx.vars.set(stmt.name, clazz);\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            ctx.exports.push(stmt.name);\n        }\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitExpressionStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        return stmt.expr.visitExpression(this, ctx);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitIfStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        var /** @type {?} */ condition = stmt.condition.visitExpression(this, ctx);\n        if (condition) {\n            return this.visitAllStatements(stmt.trueCase, ctx);\n        }\n        else if (stmt.falseCase != null) {\n            return this.visitAllStatements(stmt.falseCase, ctx);\n        }\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitTryCatchStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        try {\n            return this.visitAllStatements(stmt.bodyStmts, ctx);\n        }\n        catch (/** @type {?} */ e) {\n            var /** @type {?} */ childCtx = ctx.createChildWihtLocalVars();\n            childCtx.vars.set(CATCH_ERROR_VAR$2, e);\n            childCtx.vars.set(CATCH_STACK_VAR$2, e.stack);\n            return this.visitAllStatements(stmt.catchStmts, childCtx);\n        }\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitThrowStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        throw stmt.error.visitExpression(this, ctx);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?=} context\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitCommentStmt = /**\n     * @param {?} stmt\n     * @param {?=} context\n     * @return {?}\n     */\n    function (stmt, context) { return null; };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitInstantiateExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ args = this.visitAllExpressions(ast.args, ctx);\n        var /** @type {?} */ clazz = ast.classExpr.visitExpression(this, ctx);\n        return new (clazz.bind.apply(clazz, [void 0].concat(args)))();\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitLiteralExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) { return ast.value; };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitExternalExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        return this.reflector.resolveExternalReference(ast.value);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitConditionalExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        if (ast.condition.visitExpression(this, ctx)) {\n            return ast.trueCase.visitExpression(this, ctx);\n        }\n        else if (ast.falseCase != null) {\n            return ast.falseCase.visitExpression(this, ctx);\n        }\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitNotExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        return !ast.condition.visitExpression(this, ctx);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitAssertNotNullExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        return ast.condition.visitExpression(this, ctx);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitCastExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        return ast.value.visitExpression(this, ctx);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitFunctionExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ paramNames = ast.params.map(function (param) { return param.name; });\n        return _declareFn(paramNames, ast.statements, ctx, this);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitDeclareFunctionStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        var /** @type {?} */ paramNames = stmt.params.map(function (param) { return param.name; });\n        ctx.vars.set(stmt.name, _declareFn(paramNames, stmt.statements, ctx, this));\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            ctx.exports.push(stmt.name);\n        }\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitBinaryOperatorExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var _this = this;\n        var /** @type {?} */ lhs = function () { return ast.lhs.visitExpression(_this, ctx); };\n        var /** @type {?} */ rhs = function () { return ast.rhs.visitExpression(_this, ctx); };\n        switch (ast.operator) {\n            case BinaryOperator.Equals:\n                return lhs() == rhs();\n            case BinaryOperator.Identical:\n                return lhs() === rhs();\n            case BinaryOperator.NotEquals:\n                return lhs() != rhs();\n            case BinaryOperator.NotIdentical:\n                return lhs() !== rhs();\n            case BinaryOperator.And:\n                return lhs() && rhs();\n            case BinaryOperator.Or:\n                return lhs() || rhs();\n            case BinaryOperator.Plus:\n                return lhs() + rhs();\n            case BinaryOperator.Minus:\n                return lhs() - rhs();\n            case BinaryOperator.Divide:\n                return lhs() / rhs();\n            case BinaryOperator.Multiply:\n                return lhs() * rhs();\n            case BinaryOperator.Modulo:\n                return lhs() % rhs();\n            case BinaryOperator.Lower:\n                return lhs() < rhs();\n            case BinaryOperator.LowerEquals:\n                return lhs() <= rhs();\n            case BinaryOperator.Bigger:\n                return lhs() > rhs();\n            case BinaryOperator.BiggerEquals:\n                return lhs() >= rhs();\n            default:\n                throw new Error(\"Unknown operator \" + ast.operator);\n        }\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitReadPropExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ result;\n        var /** @type {?} */ receiver = ast.receiver.visitExpression(this, ctx);\n        result = receiver[ast.name];\n        return result;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitReadKeyExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ receiver = ast.receiver.visitExpression(this, ctx);\n        var /** @type {?} */ prop = ast.index.visitExpression(this, ctx);\n        return receiver[prop];\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitLiteralArrayExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        return this.visitAllExpressions(ast.entries, ctx);\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitLiteralMapExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var _this = this;\n        var /** @type {?} */ result = {};\n        ast.entries.forEach(function (entry) { return result[entry.key] = entry.value.visitExpression(_this, ctx); });\n        return result;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitCommaExpr = /**\n     * @param {?} ast\n     * @param {?} context\n     * @return {?}\n     */\n    function (ast, context) {\n        var /** @type {?} */ values = this.visitAllExpressions(ast.parts, context);\n        return values[values.length - 1];\n    };\n    /**\n     * @param {?} expressions\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitAllExpressions = /**\n     * @param {?} expressions\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expressions, ctx) {\n        var _this = this;\n        return expressions.map(function (expr) { return expr.visitExpression(_this, ctx); });\n    };\n    /**\n     * @param {?} statements\n     * @param {?} ctx\n     * @return {?}\n     */\n    StatementInterpreter.prototype.visitAllStatements = /**\n     * @param {?} statements\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (statements, ctx) {\n        for (var /** @type {?} */ i = 0; i < statements.length; i++) {\n            var /** @type {?} */ stmt = statements[i];\n            var /** @type {?} */ val = stmt.visitStatement(this, ctx);\n            if (val instanceof ReturnValue) {\n                return val;\n            }\n        }\n        return null;\n    };\n    return StatementInterpreter;\n}());\n/**\n * @param {?} varNames\n * @param {?} statements\n * @param {?} ctx\n * @param {?} visitor\n * @return {?}\n */\nfunction _declareFn(varNames, statements, ctx, visitor) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return _executeFunctionStatements(varNames, args, statements, ctx, visitor);\n    };\n}\nvar CATCH_ERROR_VAR$2 = 'error';\nvar CATCH_STACK_VAR$2 = 'stack';\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @abstract\n */\nvar AbstractJsEmitterVisitor = /** @class */ (function (_super) {\n    __extends(AbstractJsEmitterVisitor, _super);\n    function AbstractJsEmitterVisitor() {\n        return _super.call(this, false) || this;\n    }\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.visitDeclareClassStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        var _this = this;\n        ctx.pushClass(stmt);\n        this._visitClassConstructor(stmt, ctx);\n        if (stmt.parent != null) {\n            ctx.print(stmt, stmt.name + \".prototype = Object.create(\");\n            stmt.parent.visitExpression(this, ctx);\n            ctx.println(stmt, \".prototype);\");\n        }\n        stmt.getters.forEach(function (getter) { return _this._visitClassGetter(stmt, getter, ctx); });\n        stmt.methods.forEach(function (method) { return _this._visitClassMethod(stmt, method, ctx); });\n        ctx.popClass();\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype._visitClassConstructor = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.print(stmt, \"function \" + stmt.name + \"(\");\n        if (stmt.constructorMethod != null) {\n            this._visitParams(stmt.constructorMethod.params, ctx);\n        }\n        ctx.println(stmt, \") {\");\n        ctx.incIndent();\n        if (stmt.constructorMethod != null) {\n            if (stmt.constructorMethod.body.length > 0) {\n                ctx.println(stmt, \"var self = this;\");\n                this.visitAllStatements(stmt.constructorMethod.body, ctx);\n            }\n        }\n        ctx.decIndent();\n        ctx.println(stmt, \"}\");\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} getter\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype._visitClassGetter = /**\n     * @param {?} stmt\n     * @param {?} getter\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, getter, ctx) {\n        ctx.println(stmt, \"Object.defineProperty(\" + stmt.name + \".prototype, '\" + getter.name + \"', { get: function() {\");\n        ctx.incIndent();\n        if (getter.body.length > 0) {\n            ctx.println(stmt, \"var self = this;\");\n            this.visitAllStatements(getter.body, ctx);\n        }\n        ctx.decIndent();\n        ctx.println(stmt, \"}});\");\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} method\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype._visitClassMethod = /**\n     * @param {?} stmt\n     * @param {?} method\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, method, ctx) {\n        ctx.print(stmt, stmt.name + \".prototype.\" + method.name + \" = function(\");\n        this._visitParams(method.params, ctx);\n        ctx.println(stmt, \") {\");\n        ctx.incIndent();\n        if (method.body.length > 0) {\n            ctx.println(stmt, \"var self = this;\");\n            this.visitAllStatements(method.body, ctx);\n        }\n        ctx.decIndent();\n        ctx.println(stmt, \"};\");\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.visitReadVarExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        if (ast.builtin === BuiltinVar.This) {\n            ctx.print(ast, 'self');\n        }\n        else if (ast.builtin === BuiltinVar.Super) {\n            throw new Error(\"'super' needs to be handled at a parent ast node, not at the variable level!\");\n        }\n        else {\n            _super.prototype.visitReadVarExpr.call(this, ast, ctx);\n        }\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.visitDeclareVarStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.print(stmt, \"var \" + stmt.name + \" = \");\n        stmt.value.visitExpression(this, ctx);\n        ctx.println(stmt, \";\");\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.visitCastExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ast.value.visitExpression(this, ctx);\n        return null;\n    };\n    /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.visitInvokeFunctionExpr = /**\n     * @param {?} expr\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (expr, ctx) {\n        var /** @type {?} */ fnExpr = expr.fn;\n        if (fnExpr instanceof ReadVarExpr && fnExpr.builtin === BuiltinVar.Super) {\n            /** @type {?} */ ((/** @type {?} */ ((ctx.currentClass)).parent)).visitExpression(this, ctx);\n            ctx.print(expr, \".call(this\");\n            if (expr.args.length > 0) {\n                ctx.print(expr, \", \");\n                this.visitAllExpressions(expr.args, ctx, ',');\n            }\n            ctx.print(expr, \")\");\n        }\n        else {\n            _super.prototype.visitInvokeFunctionExpr.call(this, expr, ctx);\n        }\n        return null;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.visitFunctionExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        ctx.print(ast, \"function(\");\n        this._visitParams(ast.params, ctx);\n        ctx.println(ast, \") {\");\n        ctx.incIndent();\n        this.visitAllStatements(ast.statements, ctx);\n        ctx.decIndent();\n        ctx.print(ast, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.visitDeclareFunctionStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.print(stmt, \"function \" + stmt.name + \"(\");\n        this._visitParams(stmt.params, ctx);\n        ctx.println(stmt, \") {\");\n        ctx.incIndent();\n        this.visitAllStatements(stmt.statements, ctx);\n        ctx.decIndent();\n        ctx.println(stmt, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.visitTryCatchStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        ctx.println(stmt, \"try {\");\n        ctx.incIndent();\n        this.visitAllStatements(stmt.bodyStmts, ctx);\n        ctx.decIndent();\n        ctx.println(stmt, \"} catch (\" + CATCH_ERROR_VAR$1.name + \") {\");\n        ctx.incIndent();\n        var /** @type {?} */ catchStmts = [/** @type {?} */ (CATCH_STACK_VAR$1.set(CATCH_ERROR_VAR$1.prop('stack')).toDeclStmt(null, [\n                StmtModifier.Final\n            ]))].concat(stmt.catchStmts);\n        this.visitAllStatements(catchStmts, ctx);\n        ctx.decIndent();\n        ctx.println(stmt, \"}\");\n        return null;\n    };\n    /**\n     * @param {?} params\n     * @param {?} ctx\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype._visitParams = /**\n     * @param {?} params\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (params, ctx) {\n        this.visitAllObjects(function (param) { return ctx.print(null, param.name); }, params, ctx, ',');\n    };\n    /**\n     * @param {?} method\n     * @return {?}\n     */\n    AbstractJsEmitterVisitor.prototype.getBuiltinMethodName = /**\n     * @param {?} method\n     * @return {?}\n     */\n    function (method) {\n        var /** @type {?} */ name;\n        switch (method) {\n            case BuiltinMethod.ConcatArray:\n                name = 'concat';\n                break;\n            case BuiltinMethod.SubscribeObservable:\n                name = 'subscribe';\n                break;\n            case BuiltinMethod.Bind:\n                name = 'bind';\n                break;\n            default:\n                throw new Error(\"Unknown builtin method: \" + method);\n        }\n        return name;\n    };\n    return AbstractJsEmitterVisitor;\n}(AbstractEmitterVisitor));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @param {?} sourceUrl\n * @param {?} ctx\n * @param {?} vars\n * @param {?} createSourceMap\n * @return {?}\n */\nfunction evalExpression(sourceUrl, ctx, vars, createSourceMap) {\n    var /** @type {?} */ fnBody = ctx.toSource() + \"\\n//# sourceURL=\" + sourceUrl;\n    var /** @type {?} */ fnArgNames = [];\n    var /** @type {?} */ fnArgValues = [];\n    for (var /** @type {?} */ argName in vars) {\n        fnArgNames.push(argName);\n        fnArgValues.push(vars[argName]);\n    }\n    if (createSourceMap) {\n        // using `new Function(...)` generates a header, 1 line of no arguments, 2 lines otherwise\n        // E.g. ```\n        // function anonymous(a,b,c\n        // /**/) { ... }```\n        // We don't want to hard code this fact, so we auto detect it via an empty function first.\n        var /** @type {?} */ emptyFn = new (Function.bind.apply(Function, [void 0].concat(fnArgNames.concat('return null;'))))().toString();\n        var /** @type {?} */ headerLines = emptyFn.slice(0, emptyFn.indexOf('return null;')).split('\\n').length - 1;\n        fnBody += \"\\n\" + ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment();\n    }\n    return new (Function.bind.apply(Function, [void 0].concat(fnArgNames.concat(fnBody))))().apply(void 0, fnArgValues);\n}\n/**\n * @param {?} sourceUrl\n * @param {?} statements\n * @param {?} reflector\n * @param {?} createSourceMaps\n * @return {?}\n */\nfunction jitStatements(sourceUrl, statements, reflector, createSourceMaps) {\n    var /** @type {?} */ converter = new JitEmitterVisitor(reflector);\n    var /** @type {?} */ ctx = EmitterVisitorContext.createRoot();\n    converter.visitAllStatements(statements, ctx);\n    converter.createReturnStmt(ctx);\n    return evalExpression(sourceUrl, ctx, converter.getArgs(), createSourceMaps);\n}\nvar JitEmitterVisitor = /** @class */ (function (_super) {\n    __extends(JitEmitterVisitor, _super);\n    function JitEmitterVisitor(reflector) {\n        var _this = _super.call(this) || this;\n        _this.reflector = reflector;\n        _this._evalArgNames = [];\n        _this._evalArgValues = [];\n        _this._evalExportedVars = [];\n        return _this;\n    }\n    /**\n     * @param {?} ctx\n     * @return {?}\n     */\n    JitEmitterVisitor.prototype.createReturnStmt = /**\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ctx) {\n        var /** @type {?} */ stmt = new ReturnStatement(new LiteralMapExpr(this._evalExportedVars.map(function (resultVar) { return new LiteralMapEntry(resultVar, variable(resultVar), false); })));\n        stmt.visitStatement(this, ctx);\n    };\n    /**\n     * @return {?}\n     */\n    JitEmitterVisitor.prototype.getArgs = /**\n     * @return {?}\n     */\n    function () {\n        var /** @type {?} */ result = {};\n        for (var /** @type {?} */ i = 0; i < this._evalArgNames.length; i++) {\n            result[this._evalArgNames[i]] = this._evalArgValues[i];\n        }\n        return result;\n    };\n    /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    JitEmitterVisitor.prototype.visitExternalExpr = /**\n     * @param {?} ast\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (ast, ctx) {\n        var /** @type {?} */ value = this.reflector.resolveExternalReference(ast.value);\n        var /** @type {?} */ id = this._evalArgValues.indexOf(value);\n        if (id === -1) {\n            id = this._evalArgValues.length;\n            this._evalArgValues.push(value);\n            var /** @type {?} */ name_1 = identifierName({ reference: value }) || 'val';\n            this._evalArgNames.push(\"jit_\" + name_1 + \"_\" + id);\n        }\n        ctx.print(ast, this._evalArgNames[id]);\n        return null;\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    JitEmitterVisitor.prototype.visitDeclareVarStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            this._evalExportedVars.push(stmt.name);\n        }\n        return _super.prototype.visitDeclareVarStmt.call(this, stmt, ctx);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    JitEmitterVisitor.prototype.visitDeclareFunctionStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            this._evalExportedVars.push(stmt.name);\n        }\n        return _super.prototype.visitDeclareFunctionStmt.call(this, stmt, ctx);\n    };\n    /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    JitEmitterVisitor.prototype.visitDeclareClassStmt = /**\n     * @param {?} stmt\n     * @param {?} ctx\n     * @return {?}\n     */\n    function (stmt, ctx) {\n        if (stmt.hasModifier(StmtModifier.Exported)) {\n            this._evalExportedVars.push(stmt.name);\n        }\n        return _super.prototype.visitDeclareClassStmt.call(this, stmt, ctx);\n    };\n    return JitEmitterVisitor;\n}(AbstractJsEmitterVisitor));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @record\n */\n\n/**\n * An internal module of the Angular compiler that begins with component types,\n * extracts templates, and eventually produces a compiled version of the component\n * ready for linking into an application.\n *\n * \\@security When compiling templates at runtime, you must ensure that the entire template comes\n * from a trusted source. Attacker-controlled data introduced by a template could expose your\n * application to XSS risks.  For more detail, see the [Security Guide](http://g.co/ng/security).\n */\nvar JitCompiler = /** @class */ (function () {\n    function JitCompiler(_metadataResolver, _templateParser, _styleCompiler, _viewCompiler, _ngModuleCompiler, _summaryResolver, _reflector, _compilerConfig, _console, getExtraNgModuleProviders) {\n        this._metadataResolver = _metadataResolver;\n        this._templateParser = _templateParser;\n        this._styleCompiler = _styleCompiler;\n        this._viewCompiler = _viewCompiler;\n        this._ngModuleCompiler = _ngModuleCompiler;\n        this._summaryResolver = _summaryResolver;\n        this._reflector = _reflector;\n        this._compilerConfig = _compilerConfig;\n        this._console = _console;\n        this.getExtraNgModuleProviders = getExtraNgModuleProviders;\n        this._compiledTemplateCache = new Map();\n        this._compiledHostTemplateCache = new Map();\n        this._compiledDirectiveWrapperCache = new Map();\n        this._compiledNgModuleCache = new Map();\n        this._sharedStylesheetCount = 0;\n        this._addedAotSummaries = new Set();\n    }\n    /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    JitCompiler.prototype.compileModuleSync = /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    function (moduleType) {\n        return SyncAsync.assertSync(this._compileModuleAndComponents(moduleType, true));\n    };\n    /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    JitCompiler.prototype.compileModuleAsync = /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    function (moduleType) {\n        return Promise.resolve(this._compileModuleAndComponents(moduleType, false));\n    };\n    /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    JitCompiler.prototype.compileModuleAndAllComponentsSync = /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    function (moduleType) {\n        return SyncAsync.assertSync(this._compileModuleAndAllComponents(moduleType, true));\n    };\n    /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    JitCompiler.prototype.compileModuleAndAllComponentsAsync = /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    function (moduleType) {\n        return Promise.resolve(this._compileModuleAndAllComponents(moduleType, false));\n    };\n    /**\n     * @param {?} component\n     * @return {?}\n     */\n    JitCompiler.prototype.getComponentFactory = /**\n     * @param {?} component\n     * @return {?}\n     */\n    function (component) {\n        var /** @type {?} */ summary = this._metadataResolver.getDirectiveSummary(component);\n        return /** @type {?} */ (summary.componentFactory);\n    };\n    /**\n     * @param {?} summaries\n     * @return {?}\n     */\n    JitCompiler.prototype.loadAotSummaries = /**\n     * @param {?} summaries\n     * @return {?}\n     */\n    function (summaries) {\n        this.clearCache();\n        this._addAotSummaries(summaries);\n    };\n    /**\n     * @param {?} fn\n     * @return {?}\n     */\n    JitCompiler.prototype._addAotSummaries = /**\n     * @param {?} fn\n     * @return {?}\n     */\n    function (fn$$1) {\n        if (this._addedAotSummaries.has(fn$$1)) {\n            return;\n        }\n        this._addedAotSummaries.add(fn$$1);\n        var /** @type {?} */ summaries = fn$$1();\n        for (var /** @type {?} */ i = 0; i < summaries.length; i++) {\n            var /** @type {?} */ entry = summaries[i];\n            if (typeof entry === 'function') {\n                this._addAotSummaries(entry);\n            }\n            else {\n                var /** @type {?} */ summary = /** @type {?} */ (entry);\n                this._summaryResolver.addSummary({ symbol: summary.type.reference, metadata: null, type: summary });\n            }\n        }\n    };\n    /**\n     * @param {?} ref\n     * @return {?}\n     */\n    JitCompiler.prototype.hasAotSummary = /**\n     * @param {?} ref\n     * @return {?}\n     */\n    function (ref) { return !!this._summaryResolver.resolveSummary(ref); };\n    /**\n     * @param {?} ids\n     * @return {?}\n     */\n    JitCompiler.prototype._filterJitIdentifiers = /**\n     * @param {?} ids\n     * @return {?}\n     */\n    function (ids) {\n        var _this = this;\n        return ids.map(function (mod) { return mod.reference; }).filter(function (ref) { return !_this.hasAotSummary(ref); });\n    };\n    /**\n     * @param {?} moduleType\n     * @param {?} isSync\n     * @return {?}\n     */\n    JitCompiler.prototype._compileModuleAndComponents = /**\n     * @param {?} moduleType\n     * @param {?} isSync\n     * @return {?}\n     */\n    function (moduleType, isSync) {\n        var _this = this;\n        return SyncAsync.then(this._loadModules(moduleType, isSync), function () {\n            _this._compileComponents(moduleType, null);\n            return _this._compileModule(moduleType);\n        });\n    };\n    /**\n     * @param {?} moduleType\n     * @param {?} isSync\n     * @return {?}\n     */\n    JitCompiler.prototype._compileModuleAndAllComponents = /**\n     * @param {?} moduleType\n     * @param {?} isSync\n     * @return {?}\n     */\n    function (moduleType, isSync) {\n        var _this = this;\n        return SyncAsync.then(this._loadModules(moduleType, isSync), function () {\n            var /** @type {?} */ componentFactories = [];\n            _this._compileComponents(moduleType, componentFactories);\n            return {\n                ngModuleFactory: _this._compileModule(moduleType),\n                componentFactories: componentFactories\n            };\n        });\n    };\n    /**\n     * @param {?} mainModule\n     * @param {?} isSync\n     * @return {?}\n     */\n    JitCompiler.prototype._loadModules = /**\n     * @param {?} mainModule\n     * @param {?} isSync\n     * @return {?}\n     */\n    function (mainModule, isSync) {\n        var _this = this;\n        var /** @type {?} */ loading = [];\n        var /** @type {?} */ mainNgModule = /** @type {?} */ ((this._metadataResolver.getNgModuleMetadata(mainModule)));\n        // Note: for runtime compilation, we want to transitively compile all modules,\n        // so we also need to load the declared directives / pipes for all nested modules.\n        this._filterJitIdentifiers(mainNgModule.transitiveModule.modules).forEach(function (nestedNgModule) {\n            // getNgModuleMetadata only returns null if the value passed in is not an NgModule\n            var /** @type {?} */ moduleMeta = /** @type {?} */ ((_this._metadataResolver.getNgModuleMetadata(nestedNgModule)));\n            _this._filterJitIdentifiers(moduleMeta.declaredDirectives).forEach(function (ref) {\n                var /** @type {?} */ promise = _this._metadataResolver.loadDirectiveMetadata(moduleMeta.type.reference, ref, isSync);\n                if (promise) {\n                    loading.push(promise);\n                }\n            });\n            _this._filterJitIdentifiers(moduleMeta.declaredPipes)\n                .forEach(function (ref) { return _this._metadataResolver.getOrLoadPipeMetadata(ref); });\n        });\n        return SyncAsync.all(loading);\n    };\n    /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    JitCompiler.prototype._compileModule = /**\n     * @param {?} moduleType\n     * @return {?}\n     */\n    function (moduleType) {\n        var /** @type {?} */ ngModuleFactory = /** @type {?} */ ((this._compiledNgModuleCache.get(moduleType)));\n        if (!ngModuleFactory) {\n            var /** @type {?} */ moduleMeta = /** @type {?} */ ((this._metadataResolver.getNgModuleMetadata(moduleType)));\n            // Always provide a bound Compiler\n            var /** @type {?} */ extraProviders = this.getExtraNgModuleProviders(moduleMeta.type.reference);\n            var /** @type {?} */ outputCtx = createOutputContext();\n            var /** @type {?} */ compileResult = this._ngModuleCompiler.compile(outputCtx, moduleMeta, extraProviders);\n            ngModuleFactory = this._interpretOrJit(ngModuleJitUrl(moduleMeta), outputCtx.statements)[compileResult.ngModuleFactoryVar];\n            this._compiledNgModuleCache.set(moduleMeta.type.reference, ngModuleFactory);\n        }\n        return ngModuleFactory;\n    };\n    /**\n     * @internal\n     */\n    /**\n     * \\@internal\n     * @param {?} mainModule\n     * @param {?} allComponentFactories\n     * @return {?}\n     */\n    JitCompiler.prototype._compileComponents = /**\n     * \\@internal\n     * @param {?} mainModule\n     * @param {?} allComponentFactories\n     * @return {?}\n     */\n    function (mainModule, allComponentFactories) {\n        var _this = this;\n        var /** @type {?} */ ngModule = /** @type {?} */ ((this._metadataResolver.getNgModuleMetadata(mainModule)));\n        var /** @type {?} */ moduleByJitDirective = new Map();\n        var /** @type {?} */ templates = new Set();\n        var /** @type {?} */ transJitModules = this._filterJitIdentifiers(ngModule.transitiveModule.modules);\n        transJitModules.forEach(function (localMod) {\n            var /** @type {?} */ localModuleMeta = /** @type {?} */ ((_this._metadataResolver.getNgModuleMetadata(localMod)));\n            _this._filterJitIdentifiers(localModuleMeta.declaredDirectives).forEach(function (dirRef) {\n                moduleByJitDirective.set(dirRef, localModuleMeta);\n                var /** @type {?} */ dirMeta = _this._metadataResolver.getDirectiveMetadata(dirRef);\n                if (dirMeta.isComponent) {\n                    templates.add(_this._createCompiledTemplate(dirMeta, localModuleMeta));\n                    if (allComponentFactories) {\n                        var /** @type {?} */ template = _this._createCompiledHostTemplate(dirMeta.type.reference, localModuleMeta);\n                        templates.add(template);\n                        allComponentFactories.push(/** @type {?} */ (dirMeta.componentFactory));\n                    }\n                }\n            });\n        });\n        transJitModules.forEach(function (localMod) {\n            var /** @type {?} */ localModuleMeta = /** @type {?} */ ((_this._metadataResolver.getNgModuleMetadata(localMod)));\n            _this._filterJitIdentifiers(localModuleMeta.declaredDirectives).forEach(function (dirRef) {\n                var /** @type {?} */ dirMeta = _this._metadataResolver.getDirectiveMetadata(dirRef);\n                if (dirMeta.isComponent) {\n                    dirMeta.entryComponents.forEach(function (entryComponentType) {\n                        var /** @type {?} */ moduleMeta = /** @type {?} */ ((moduleByJitDirective.get(entryComponentType.componentType)));\n                        templates.add(_this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta));\n                    });\n                }\n            });\n            localModuleMeta.entryComponents.forEach(function (entryComponentType) {\n                if (!_this.hasAotSummary(entryComponentType.componentType.reference)) {\n                    var /** @type {?} */ moduleMeta = /** @type {?} */ ((moduleByJitDirective.get(entryComponentType.componentType)));\n                    templates.add(_this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta));\n                }\n            });\n        });\n        templates.forEach(function (template) { return _this._compileTemplate(template); });\n    };\n    /**\n     * @param {?} type\n     * @return {?}\n     */\n    JitCompiler.prototype.clearCacheFor = /**\n     * @param {?} type\n     * @return {?}\n     */\n    function (type) {\n        this._compiledNgModuleCache.delete(type);\n        this._metadataResolver.clearCacheFor(type);\n        this._compiledHostTemplateCache.delete(type);\n        var /** @type {?} */ compiledTemplate = this._compiledTemplateCache.get(type);\n        if (compiledTemplate) {\n            this._compiledTemplateCache.delete(type);\n        }\n    };\n    /**\n     * @return {?}\n     */\n    JitCompiler.prototype.clearCache = /**\n     * @return {?}\n     */\n    function () {\n        // Note: don't clear the _addedAotSummaries, as they don't change!\n        this._metadataResolver.clearCache();\n        this._compiledTemplateCache.clear();\n        this._compiledHostTemplateCache.clear();\n        this._compiledNgModuleCache.clear();\n    };\n    /**\n     * @param {?} compType\n     * @param {?} ngModule\n     * @return {?}\n     */\n    JitCompiler.prototype._createCompiledHostTemplate = /**\n     * @param {?} compType\n     * @param {?} ngModule\n     * @return {?}\n     */\n    function (compType, ngModule) {\n        if (!ngModule) {\n            throw new Error(\"Component \" + stringify(compType) + \" is not part of any NgModule or the module has not been imported into your module.\");\n        }\n        var /** @type {?} */ compiledTemplate = this._compiledHostTemplateCache.get(compType);\n        if (!compiledTemplate) {\n            var /** @type {?} */ compMeta = this._metadataResolver.getDirectiveMetadata(compType);\n            assertComponent(compMeta);\n            var /** @type {?} */ hostMeta = this._metadataResolver.getHostComponentMetadata(compMeta, (/** @type {?} */ (compMeta.componentFactory)).viewDefFactory);\n            compiledTemplate =\n                new CompiledTemplate(true, compMeta.type, hostMeta, ngModule, [compMeta.type]);\n            this._compiledHostTemplateCache.set(compType, compiledTemplate);\n        }\n        return compiledTemplate;\n    };\n    /**\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @return {?}\n     */\n    JitCompiler.prototype._createCompiledTemplate = /**\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @return {?}\n     */\n    function (compMeta, ngModule) {\n        var /** @type {?} */ compiledTemplate = this._compiledTemplateCache.get(compMeta.type.reference);\n        if (!compiledTemplate) {\n            assertComponent(compMeta);\n            compiledTemplate = new CompiledTemplate(false, compMeta.type, compMeta, ngModule, ngModule.transitiveModule.directives);\n            this._compiledTemplateCache.set(compMeta.type.reference, compiledTemplate);\n        }\n        return compiledTemplate;\n    };\n    /**\n     * @param {?} template\n     * @return {?}\n     */\n    JitCompiler.prototype._compileTemplate = /**\n     * @param {?} template\n     * @return {?}\n     */\n    function (template) {\n        var _this = this;\n        if (template.isCompiled) {\n            return;\n        }\n        var /** @type {?} */ compMeta = template.compMeta;\n        var /** @type {?} */ externalStylesheetsByModuleUrl = new Map();\n        var /** @type {?} */ outputContext = createOutputContext();\n        var /** @type {?} */ componentStylesheet = this._styleCompiler.compileComponent(outputContext, compMeta); /** @type {?} */\n        ((compMeta.template)).externalStylesheets.forEach(function (stylesheetMeta) {\n            var /** @type {?} */ compiledStylesheet = _this._styleCompiler.compileStyles(createOutputContext(), compMeta, stylesheetMeta);\n            externalStylesheetsByModuleUrl.set(/** @type {?} */ ((stylesheetMeta.moduleUrl)), compiledStylesheet);\n        });\n        this._resolveStylesCompileResult(componentStylesheet, externalStylesheetsByModuleUrl);\n        var /** @type {?} */ pipes = template.ngModule.transitiveModule.pipes.map(function (pipe) { return _this._metadataResolver.getPipeSummary(pipe.reference); });\n        var _a = this._parseTemplate(compMeta, template.ngModule, template.directives), parsedTemplate = _a.template, usedPipes = _a.pipes;\n        var /** @type {?} */ compileResult = this._viewCompiler.compileComponent(outputContext, compMeta, parsedTemplate, variable(componentStylesheet.stylesVar), usedPipes);\n        var /** @type {?} */ evalResult = this._interpretOrJit(templateJitUrl(template.ngModule.type, template.compMeta), outputContext.statements);\n        var /** @type {?} */ viewClass = evalResult[compileResult.viewClassVar];\n        var /** @type {?} */ rendererType = evalResult[compileResult.rendererTypeVar];\n        template.compiled(viewClass, rendererType);\n    };\n    /**\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @param {?} directiveIdentifiers\n     * @return {?}\n     */\n    JitCompiler.prototype._parseTemplate = /**\n     * @param {?} compMeta\n     * @param {?} ngModule\n     * @param {?} directiveIdentifiers\n     * @return {?}\n     */\n    function (compMeta, ngModule, directiveIdentifiers) {\n        var _this = this;\n        // Note: ! is ok here as components always have a template.\n        var /** @type {?} */ preserveWhitespaces = /** @type {?} */ ((compMeta.template)).preserveWhitespaces;\n        var /** @type {?} */ directives = directiveIdentifiers.map(function (dir) { return _this._metadataResolver.getDirectiveSummary(dir.reference); });\n        var /** @type {?} */ pipes = ngModule.transitiveModule.pipes.map(function (pipe) { return _this._metadataResolver.getPipeSummary(pipe.reference); });\n        return this._templateParser.parse(compMeta, /** @type {?} */ ((/** @type {?} */ ((compMeta.template)).htmlAst)), directives, pipes, ngModule.schemas, templateSourceUrl(ngModule.type, compMeta, /** @type {?} */ ((compMeta.template))), preserveWhitespaces);\n    };\n    /**\n     * @param {?} result\n     * @param {?} externalStylesheetsByModuleUrl\n     * @return {?}\n     */\n    JitCompiler.prototype._resolveStylesCompileResult = /**\n     * @param {?} result\n     * @param {?} externalStylesheetsByModuleUrl\n     * @return {?}\n     */\n    function (result, externalStylesheetsByModuleUrl) {\n        var _this = this;\n        result.dependencies.forEach(function (dep, i) {\n            var /** @type {?} */ nestedCompileResult = /** @type {?} */ ((externalStylesheetsByModuleUrl.get(dep.moduleUrl)));\n            var /** @type {?} */ nestedStylesArr = _this._resolveAndEvalStylesCompileResult(nestedCompileResult, externalStylesheetsByModuleUrl);\n            dep.setValue(nestedStylesArr);\n        });\n    };\n    /**\n     * @param {?} result\n     * @param {?} externalStylesheetsByModuleUrl\n     * @return {?}\n     */\n    JitCompiler.prototype._resolveAndEvalStylesCompileResult = /**\n     * @param {?} result\n     * @param {?} externalStylesheetsByModuleUrl\n     * @return {?}\n     */\n    function (result, externalStylesheetsByModuleUrl) {\n        this._resolveStylesCompileResult(result, externalStylesheetsByModuleUrl);\n        return this._interpretOrJit(sharedStylesheetJitUrl(result.meta, this._sharedStylesheetCount++), result.outputCtx.statements)[result.stylesVar];\n    };\n    /**\n     * @param {?} sourceUrl\n     * @param {?} statements\n     * @return {?}\n     */\n    JitCompiler.prototype._interpretOrJit = /**\n     * @param {?} sourceUrl\n     * @param {?} statements\n     * @return {?}\n     */\n    function (sourceUrl, statements) {\n        if (!this._compilerConfig.useJit) {\n            return interpretStatements(statements, this._reflector);\n        }\n        else {\n            return jitStatements(sourceUrl, statements, this._reflector, this._compilerConfig.jitDevMode);\n        }\n    };\n    return JitCompiler;\n}());\nvar CompiledTemplate = /** @class */ (function () {\n    function CompiledTemplate(isHost, compType, compMeta, ngModule, directives) {\n        this.isHost = isHost;\n        this.compType = compType;\n        this.compMeta = compMeta;\n        this.ngModule = ngModule;\n        this.directives = directives;\n        this._viewClass = /** @type {?} */ ((null));\n        this.isCompiled = false;\n    }\n    /**\n     * @param {?} viewClass\n     * @param {?} rendererType\n     * @return {?}\n     */\n    CompiledTemplate.prototype.compiled = /**\n     * @param {?} viewClass\n     * @param {?} rendererType\n     * @return {?}\n     */\n    function (viewClass, rendererType) {\n        this._viewClass = viewClass;\n        (/** @type {?} */ (this.compMeta.componentViewType)).setDelegate(viewClass);\n        for (var /** @type {?} */ prop in rendererType) {\n            (/** @type {?} */ (this.compMeta.rendererType))[prop] = rendererType[prop];\n        }\n        this.isCompiled = true;\n    };\n    return CompiledTemplate;\n}());\n/**\n * @param {?} meta\n * @return {?}\n */\nfunction assertComponent(meta) {\n    if (!meta.isComponent) {\n        throw new Error(\"Could not compile '\" + identifierName(meta.type) + \"' because it is not a component.\");\n    }\n}\n/**\n * @return {?}\n */\nfunction createOutputContext() {\n    var /** @type {?} */ importExpr$$1 = function (symbol) {\n        return importExpr({ name: identifierName(symbol), moduleName: null, runtime: symbol });\n    };\n    return { statements: [], genFilePath: '', importExpr: importExpr$$1 };\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Provides access to reflection data about symbols that the compiler needs.\n * @abstract\n */\nvar CompileReflector = /** @class */ (function () {\n    function CompileReflector() {\n    }\n    return CompileReflector;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Create a {\\@link UrlResolver} with no package prefix.\n * @return {?}\n */\nfunction createUrlResolverWithoutPackagePrefix() {\n    return new UrlResolver();\n}\n/**\n * @return {?}\n */\nfunction createOfflineCompileUrlResolver() {\n    return new UrlResolver('.');\n}\n/**\n * @record\n */\n\nvar UrlResolver = /** @class */ (function () {\n    function UrlResolverImpl(_packagePrefix) {\n        if (_packagePrefix === void 0) { _packagePrefix = null; }\n        this._packagePrefix = _packagePrefix;\n    }\n    /**\n     * Resolves the `url` given the `baseUrl`:\n     * - when the `url` is null, the `baseUrl` is returned,\n     * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of\n     * `baseUrl` and `url`,\n     * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is\n     * returned as is (ignoring the `baseUrl`)\n     */\n    /**\n     * Resolves the `url` given the `baseUrl`:\n     * - when the `url` is null, the `baseUrl` is returned,\n     * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of\n     * `baseUrl` and `url`,\n     * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is\n     * returned as is (ignoring the `baseUrl`)\n     * @param {?} baseUrl\n     * @param {?} url\n     * @return {?}\n     */\n    UrlResolverImpl.prototype.resolve = /**\n     * Resolves the `url` given the `baseUrl`:\n     * - when the `url` is null, the `baseUrl` is returned,\n     * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of\n     * `baseUrl` and `url`,\n     * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is\n     * returned as is (ignoring the `baseUrl`)\n     * @param {?} baseUrl\n     * @param {?} url\n     * @return {?}\n     */\n    function (baseUrl, url) {\n        var /** @type {?} */ resolvedUrl = url;\n        if (baseUrl != null && baseUrl.length > 0) {\n            resolvedUrl = _resolveUrl(baseUrl, resolvedUrl);\n        }\n        var /** @type {?} */ resolvedParts = _split(resolvedUrl);\n        var /** @type {?} */ prefix = this._packagePrefix;\n        if (prefix != null && resolvedParts != null &&\n            resolvedParts[_ComponentIndex.Scheme] == 'package') {\n            var /** @type {?} */ path = resolvedParts[_ComponentIndex.Path];\n            prefix = prefix.replace(/\\/+$/, '');\n            path = path.replace(/^\\/+/, '');\n            return prefix + \"/\" + path;\n        }\n        return resolvedUrl;\n    };\n    return UrlResolverImpl;\n}());\n/**\n * Extract the scheme of a URL.\n * @param {?} url\n * @return {?}\n */\nfunction getUrlScheme(url) {\n    var /** @type {?} */ match = _split(url);\n    return (match && match[_ComponentIndex.Scheme]) || '';\n}\n/**\n * Builds a URI string from already-encoded parts.\n *\n * No encoding is performed.  Any component may be omitted as either null or\n * undefined.\n *\n * @param {?=} opt_scheme The scheme such as 'http'.\n * @param {?=} opt_userInfo The user name before the '\\@'.\n * @param {?=} opt_domain The domain such as 'www.google.com', already\n *     URI-encoded.\n * @param {?=} opt_port The port number.\n * @param {?=} opt_path The path, already URI-encoded.  If it is not\n *     empty, it must begin with a slash.\n * @param {?=} opt_queryData The URI-encoded query data.\n * @param {?=} opt_fragment The URI-encoded fragment identifier.\n * @return {?} The fully combined URI.\n */\nfunction _buildFromEncodedParts(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) {\n    var /** @type {?} */ out = [];\n    if (opt_scheme != null) {\n        out.push(opt_scheme + ':');\n    }\n    if (opt_domain != null) {\n        out.push('//');\n        if (opt_userInfo != null) {\n            out.push(opt_userInfo + '@');\n        }\n        out.push(opt_domain);\n        if (opt_port != null) {\n            out.push(':' + opt_port);\n        }\n    }\n    if (opt_path != null) {\n        out.push(opt_path);\n    }\n    if (opt_queryData != null) {\n        out.push('?' + opt_queryData);\n    }\n    if (opt_fragment != null) {\n        out.push('#' + opt_fragment);\n    }\n    return out.join('');\n}\n/**\n * A regular expression for breaking a URI into its component parts.\n *\n * {\\@link http://www.gbiv.com/protocols/uri/rfc/rfc3986.html#RFC2234} says\n * As the \"first-match-wins\" algorithm is identical to the \"greedy\"\n * disambiguation method used by POSIX regular expressions, it is natural and\n * commonplace to use a regular expression for parsing the potential five\n * components of a URI reference.\n *\n * The following line is the regular expression for breaking-down a\n * well-formed URI reference into its components.\n *\n * <pre>\n * ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?\n *  12            3  4          5       6  7        8 9\n * </pre>\n *\n * The numbers in the second line above are only to assist readability; they\n * indicate the reference points for each subexpression (i.e., each paired\n * parenthesis). We refer to the value matched for subexpression <n> as $<n>.\n * For example, matching the above expression to\n * <pre>\n *     http://www.ics.uci.edu/pub/ietf/uri/#Related\n * </pre>\n * results in the following subexpression matches:\n * <pre>\n *    $1 = http:\n *    $2 = http\n *    $3 = //www.ics.uci.edu\n *    $4 = www.ics.uci.edu\n *    $5 = /pub/ietf/uri/\n *    $6 = <undefined>\n *    $7 = <undefined>\n *    $8 = #Related\n *    $9 = Related\n * </pre>\n * where <undefined> indicates that the component is not present, as is the\n * case for the query component in the above example. Therefore, we can\n * determine the value of the five components as\n * <pre>\n *    scheme    = $2\n *    authority = $4\n *    path      = $5\n *    query     = $7\n *    fragment  = $9\n * </pre>\n *\n * The regular expression has been modified slightly to expose the\n * userInfo, domain, and port separately from the authority.\n * The modified version yields\n * <pre>\n *    $1 = http              scheme\n *    $2 = <undefined>       userInfo -\\\n *    $3 = www.ics.uci.edu   domain     | authority\n *    $4 = <undefined>       port     -/\n *    $5 = /pub/ietf/uri/    path\n *    $6 = <undefined>       query without ?\n *    $7 = Related           fragment without #\n * </pre>\n * \\@internal\n */\nvar _splitRe = new RegExp('^' +\n    '(?:' +\n    '([^:/?#.]+)' + // scheme - ignore special characters\n    ':)?' +\n    '(?://' +\n    '(?:([^/?#]*)@)?' + // userInfo\n    '([\\\\w\\\\d\\\\-\\\\u0100-\\\\uffff.%]*)' + // domain - restrict to letters,\n    '(?::([0-9]+))?' + // port\n    ')?' +\n    '([^?#]+)?' + // path\n    '(?:\\\\?([^#]*))?' + // query\n    '(?:#(.*))?' + // fragment\n    '$');\n/** @enum {number} */\nvar _ComponentIndex = {\n    Scheme: 1,\n    UserInfo: 2,\n    Domain: 3,\n    Port: 4,\n    Path: 5,\n    QueryData: 6,\n    Fragment: 7,\n};\n_ComponentIndex[_ComponentIndex.Scheme] = \"Scheme\";\n_ComponentIndex[_ComponentIndex.UserInfo] = \"UserInfo\";\n_ComponentIndex[_ComponentIndex.Domain] = \"Domain\";\n_ComponentIndex[_ComponentIndex.Port] = \"Port\";\n_ComponentIndex[_ComponentIndex.Path] = \"Path\";\n_ComponentIndex[_ComponentIndex.QueryData] = \"QueryData\";\n_ComponentIndex[_ComponentIndex.Fragment] = \"Fragment\";\n/**\n * Splits a URI into its component parts.\n *\n * Each component can be accessed via the component indices; for example:\n * <pre>\n * goog.uri.utils.split(someStr)[goog.uri.utils.CompontentIndex.QUERY_DATA];\n * </pre>\n *\n * @param {?} uri The URI string to examine.\n * @return {?} Each component still URI-encoded.\n *     Each component that is present will contain the encoded value, whereas\n *     components that are not present will be undefined or empty, depending\n *     on the browser's regular expression implementation.  Never null, since\n *     arbitrary strings may still look like path names.\n */\nfunction _split(uri) {\n    return /** @type {?} */ ((uri.match(_splitRe)));\n}\n/**\n * Removes dot segments in given path component, as described in\n * RFC 3986, section 5.2.4.\n *\n * @param {?} path A non-empty path component.\n * @return {?} Path component with removed dot segments.\n */\nfunction _removeDotSegments(path) {\n    if (path == '/')\n        return '/';\n    var /** @type {?} */ leadingSlash = path[0] == '/' ? '/' : '';\n    var /** @type {?} */ trailingSlash = path[path.length - 1] === '/' ? '/' : '';\n    var /** @type {?} */ segments = path.split('/');\n    var /** @type {?} */ out = [];\n    var /** @type {?} */ up = 0;\n    for (var /** @type {?} */ pos = 0; pos < segments.length; pos++) {\n        var /** @type {?} */ segment = segments[pos];\n        switch (segment) {\n            case '':\n            case '.':\n                break;\n            case '..':\n                if (out.length > 0) {\n                    out.pop();\n                }\n                else {\n                    up++;\n                }\n                break;\n            default:\n                out.push(segment);\n        }\n    }\n    if (leadingSlash == '') {\n        while (up-- > 0) {\n            out.unshift('..');\n        }\n        if (out.length === 0)\n            out.push('.');\n    }\n    return leadingSlash + out.join('/') + trailingSlash;\n}\n/**\n * Takes an array of the parts from split and canonicalizes the path part\n * and then joins all the parts.\n * @param {?} parts\n * @return {?}\n */\nfunction _joinAndCanonicalizePath(parts) {\n    var /** @type {?} */ path = parts[_ComponentIndex.Path];\n    path = path == null ? '' : _removeDotSegments(path);\n    parts[_ComponentIndex.Path] = path;\n    return _buildFromEncodedParts(parts[_ComponentIndex.Scheme], parts[_ComponentIndex.UserInfo], parts[_ComponentIndex.Domain], parts[_ComponentIndex.Port], path, parts[_ComponentIndex.QueryData], parts[_ComponentIndex.Fragment]);\n}\n/**\n * Resolves a URL.\n * @param {?} base The URL acting as the base URL.\n * @param {?} url\n * @return {?}\n */\nfunction _resolveUrl(base, url) {\n    var /** @type {?} */ parts = _split(encodeURI(url));\n    var /** @type {?} */ baseParts = _split(base);\n    if (parts[_ComponentIndex.Scheme] != null) {\n        return _joinAndCanonicalizePath(parts);\n    }\n    else {\n        parts[_ComponentIndex.Scheme] = baseParts[_ComponentIndex.Scheme];\n    }\n    for (var /** @type {?} */ i = _ComponentIndex.Scheme; i <= _ComponentIndex.Port; i++) {\n        if (parts[i] == null) {\n            parts[i] = baseParts[i];\n        }\n    }\n    if (parts[_ComponentIndex.Path][0] == '/') {\n        return _joinAndCanonicalizePath(parts);\n    }\n    var /** @type {?} */ path = baseParts[_ComponentIndex.Path];\n    if (path == null)\n        path = '/';\n    var /** @type {?} */ index = path.lastIndexOf('/');\n    path = path.substring(0, index + 1) + parts[_ComponentIndex.Path];\n    parts[_ComponentIndex.Path] = path;\n    return _joinAndCanonicalizePath(parts);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * An interface for retrieving documents by URL that the compiler uses\n * to load templates.\n */\nvar ResourceLoader = /** @class */ (function () {\n    function ResourceLoader() {\n    }\n    /**\n     * @param {?} url\n     * @return {?}\n     */\n    ResourceLoader.prototype.get = /**\n     * @param {?} url\n     * @return {?}\n     */\n    function (url) { return ''; };\n    return ResourceLoader;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes} checked by tsc\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * The host of the Extractor disconnects the implementation from TypeScript / other language\n * services and from underlying file systems.\n * @record\n */\n\nvar Extractor = /** @class */ (function () {\n    function Extractor(host, staticSymbolResolver, messageBundle, metadataResolver) {\n        this.host = host;\n        this.staticSymbolResolver = staticSymbolResolver;\n        this.messageBundle = messageBundle;\n        this.metadataResolver = metadataResolver;\n    }\n    /**\n     * @param {?} rootFiles\n     * @return {?}\n     */\n    Extractor.prototype.extract = /**\n     * @param {?} rootFiles\n     * @return {?}\n     */\n    function (rootFiles) {\n        var _this = this;\n        var _a = analyzeAndValidateNgModules(rootFiles, this.host, this.staticSymbolResolver, this.metadataResolver), files = _a.files, ngModules = _a.ngModules;\n        return Promise\n            .all(ngModules.map(function (ngModule) {\n            return _this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, false);\n        }))\n            .then(function () {\n            var /** @type {?} */ errors = [];\n            files.forEach(function (file) {\n                var /** @type {?} */ compMetas = [];\n                file.directives.forEach(function (directiveType) {\n                    var /** @type {?} */ dirMeta = _this.metadataResolver.getDirectiveMetadata(directiveType);\n                    if (dirMeta && dirMeta.isComponent) {\n                        compMetas.push(dirMeta);\n                    }\n                });\n                compMetas.forEach(function (compMeta) {\n                    var /** @type {?} */ html = /** @type {?} */ ((/** @type {?} */ ((compMeta.template)).template));\n                    var /** @type {?} */ interpolationConfig = InterpolationConfig.fromArray(/** @type {?} */ ((compMeta.template)).interpolation);\n                    errors.push.apply(errors, /** @type {?} */ ((_this.messageBundle.updateFromTemplate(html, file.fileName, interpolationConfig))));\n                });\n            });\n            if (errors.length) {\n                throw new Error(errors.map(function (e) { return e.toString(); }).join('\\n'));\n            }\n            return _this.messageBundle;\n        });\n    };\n    /**\n     * @param {?} host\n     * @param {?} locale\n     * @return {?}\n     */\n    Extractor.create = /**\n     * @param {?} host\n     * @param {?} locale\n     * @return {?}\n     */\n    function (host, locale) {\n        var /** @type {?} */ htmlParser = new HtmlParser();\n        var /** @type {?} */ urlResolver = createAotUrlResolver(host);\n        var /** @type {?} */ symbolCache = new StaticSymbolCache();\n        var /** @type {?} */ summaryResolver = new AotSummaryResolver(host, symbolCache);\n        var /** @type {?} */ staticSymbolResolver = new StaticSymbolResolver(host, symbolCache, summaryResolver);\n        var /** @type {?} */ staticReflector = new StaticReflector(summaryResolver, staticSymbolResolver);\n        var /** @type {?} */ config = new CompilerConfig({ defaultEncapsulation: ViewEncapsulation.Emulated, useJit: false });\n        var /** @type {?} */ normalizer = new DirectiveNormalizer({ get: function (url) { return host.loadResource(url); } }, urlResolver, htmlParser, config);\n        var /** @type {?} */ elementSchemaRegistry = new DomElementSchemaRegistry();\n        var /** @type {?} */ resolver = new CompileMetadataResolver(config, htmlParser, new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector), new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer, console, symbolCache, staticReflector);\n        // TODO(vicb): implicit tags & attributes\n        var /** @type {?} */ messageBundle = new MessageBundle(htmlParser, [], {}, locale);\n        var /** @type {?} */ extractor = new Extractor(host, staticSymbolResolver, messageBundle, resolver);\n        return { extractor: extractor, staticReflector: staticReflector };\n    };\n    return Extractor;\n}());\n\nexports.core = core;\nexports.CompilerConfig = CompilerConfig;\nexports.preserveWhitespacesDefault = preserveWhitespacesDefault;\nexports.isLoweredSymbol = isLoweredSymbol;\nexports.createLoweredSymbol = createLoweredSymbol;\nexports.Identifiers = Identifiers;\nexports.JitCompiler = JitCompiler;\nexports.DirectiveResolver = DirectiveResolver;\nexports.PipeResolver = PipeResolver;\nexports.NgModuleResolver = NgModuleResolver;\nexports.DEFAULT_INTERPOLATION_CONFIG = DEFAULT_INTERPOLATION_CONFIG;\nexports.InterpolationConfig = InterpolationConfig;\nexports.NgModuleCompiler = NgModuleCompiler;\nexports.AssertNotNull = AssertNotNull;\nexports.BinaryOperator = BinaryOperator;\nexports.BinaryOperatorExpr = BinaryOperatorExpr;\nexports.BuiltinMethod = BuiltinMethod;\nexports.BuiltinVar = BuiltinVar;\nexports.CastExpr = CastExpr;\nexports.ClassStmt = ClassStmt;\nexports.CommaExpr = CommaExpr;\nexports.CommentStmt = CommentStmt;\nexports.ConditionalExpr = ConditionalExpr;\nexports.DeclareFunctionStmt = DeclareFunctionStmt;\nexports.DeclareVarStmt = DeclareVarStmt;\nexports.ExpressionStatement = ExpressionStatement;\nexports.ExternalExpr = ExternalExpr;\nexports.ExternalReference = ExternalReference;\nexports.FunctionExpr = FunctionExpr;\nexports.IfStmt = IfStmt;\nexports.InstantiateExpr = InstantiateExpr;\nexports.InvokeFunctionExpr = InvokeFunctionExpr;\nexports.InvokeMethodExpr = InvokeMethodExpr;\nexports.LiteralArrayExpr = LiteralArrayExpr;\nexports.LiteralExpr = LiteralExpr;\nexports.LiteralMapExpr = LiteralMapExpr;\nexports.NotExpr = NotExpr;\nexports.ReadKeyExpr = ReadKeyExpr;\nexports.ReadPropExpr = ReadPropExpr;\nexports.ReadVarExpr = ReadVarExpr;\nexports.ReturnStatement = ReturnStatement;\nexports.ThrowStmt = ThrowStmt;\nexports.TryCatchStmt = TryCatchStmt;\nexports.WriteKeyExpr = WriteKeyExpr;\nexports.WritePropExpr = WritePropExpr;\nexports.WriteVarExpr = WriteVarExpr;\nexports.StmtModifier = StmtModifier;\nexports.Statement = Statement;\nexports.collectExternalReferences = collectExternalReferences;\nexports.EmitterVisitorContext = EmitterVisitorContext;\nexports.ViewCompiler = ViewCompiler;\nexports.getParseErrors = getParseErrors;\nexports.isSyntaxError = isSyntaxError;\nexports.syntaxError = syntaxError;\nexports.Version = Version;\nexports.VERSION = VERSION;\nexports.TextAst = TextAst;\nexports.BoundTextAst = BoundTextAst;\nexports.AttrAst = AttrAst;\nexports.BoundElementPropertyAst = BoundElementPropertyAst;\nexports.BoundEventAst = BoundEventAst;\nexports.ReferenceAst = ReferenceAst;\nexports.VariableAst = VariableAst;\nexports.ElementAst = ElementAst;\nexports.EmbeddedTemplateAst = EmbeddedTemplateAst;\nexports.BoundDirectivePropertyAst = BoundDirectivePropertyAst;\nexports.DirectiveAst = DirectiveAst;\nexports.ProviderAst = ProviderAst;\nexports.ProviderAstType = ProviderAstType;\nexports.NgContentAst = NgContentAst;\nexports.PropertyBindingType = PropertyBindingType;\nexports.NullTemplateVisitor = NullTemplateVisitor;\nexports.RecursiveTemplateAstVisitor = RecursiveTemplateAstVisitor;\nexports.templateVisitAll = templateVisitAll;\nexports.identifierName = identifierName;\nexports.identifierModuleUrl = identifierModuleUrl;\nexports.viewClassName = viewClassName;\nexports.rendererTypeName = rendererTypeName;\nexports.hostViewClassName = hostViewClassName;\nexports.componentFactoryName = componentFactoryName;\nexports.CompileSummaryKind = CompileSummaryKind;\nexports.tokenName = tokenName;\nexports.tokenReference = tokenReference;\nexports.CompileStylesheetMetadata = CompileStylesheetMetadata;\nexports.CompileTemplateMetadata = CompileTemplateMetadata;\nexports.CompileDirectiveMetadata = CompileDirectiveMetadata;\nexports.CompilePipeMetadata = CompilePipeMetadata;\nexports.CompileNgModuleMetadata = CompileNgModuleMetadata;\nexports.TransitiveCompileNgModuleMetadata = TransitiveCompileNgModuleMetadata;\nexports.ProviderMeta = ProviderMeta;\nexports.flatten = flatten;\nexports.templateSourceUrl = templateSourceUrl;\nexports.sharedStylesheetJitUrl = sharedStylesheetJitUrl;\nexports.ngModuleJitUrl = ngModuleJitUrl;\nexports.templateJitUrl = templateJitUrl;\nexports.createAotUrlResolver = createAotUrlResolver;\nexports.createAotCompiler = createAotCompiler;\nexports.AotCompiler = AotCompiler;\nexports.analyzeNgModules = analyzeNgModules;\nexports.analyzeAndValidateNgModules = analyzeAndValidateNgModules;\nexports.analyzeFile = analyzeFile;\nexports.mergeAnalyzedFiles = mergeAnalyzedFiles;\nexports.GeneratedFile = GeneratedFile;\nexports.toTypeScript = toTypeScript;\nexports.formattedError = formattedError;\nexports.isFormattedError = isFormattedError;\nexports.StaticReflector = StaticReflector;\nexports.StaticSymbol = StaticSymbol;\nexports.StaticSymbolCache = StaticSymbolCache;\nexports.ResolvedStaticSymbol = ResolvedStaticSymbol;\nexports.StaticSymbolResolver = StaticSymbolResolver;\nexports.unescapeIdentifier = unescapeIdentifier;\nexports.unwrapResolvedMetadata = unwrapResolvedMetadata;\nexports.AotSummaryResolver = AotSummaryResolver;\nexports.AstPath = AstPath;\nexports.SummaryResolver = SummaryResolver;\nexports.JitSummaryResolver = JitSummaryResolver;\nexports.CompileReflector = CompileReflector;\nexports.createUrlResolverWithoutPackagePrefix = createUrlResolverWithoutPackagePrefix;\nexports.createOfflineCompileUrlResolver = createOfflineCompileUrlResolver;\nexports.UrlResolver = UrlResolver;\nexports.getUrlScheme = getUrlScheme;\nexports.ResourceLoader = ResourceLoader;\nexports.ElementSchemaRegistry = ElementSchemaRegistry;\nexports.Extractor = Extractor;\nexports.I18NHtmlParser = I18NHtmlParser;\nexports.MessageBundle = MessageBundle;\nexports.Serializer = Serializer;\nexports.Xliff = Xliff;\nexports.Xliff2 = Xliff2;\nexports.Xmb = Xmb;\nexports.Xtb = Xtb;\nexports.DirectiveNormalizer = DirectiveNormalizer;\nexports.ParserError = ParserError;\nexports.ParseSpan = ParseSpan;\nexports.AST = AST;\nexports.Quote = Quote;\nexports.EmptyExpr = EmptyExpr;\nexports.ImplicitReceiver = ImplicitReceiver;\nexports.Chain = Chain;\nexports.Conditional = Conditional;\nexports.PropertyRead = PropertyRead;\nexports.PropertyWrite = PropertyWrite;\nexports.SafePropertyRead = SafePropertyRead;\nexports.KeyedRead = KeyedRead;\nexports.KeyedWrite = KeyedWrite;\nexports.BindingPipe = BindingPipe;\nexports.LiteralPrimitive = LiteralPrimitive;\nexports.LiteralArray = LiteralArray;\nexports.LiteralMap = LiteralMap;\nexports.Interpolation = Interpolation;\nexports.Binary = Binary;\nexports.PrefixNot = PrefixNot;\nexports.NonNullAssert = NonNullAssert;\nexports.MethodCall = MethodCall;\nexports.SafeMethodCall = SafeMethodCall;\nexports.FunctionCall = FunctionCall;\nexports.ASTWithSource = ASTWithSource;\nexports.TemplateBinding = TemplateBinding;\nexports.NullAstVisitor = NullAstVisitor;\nexports.RecursiveAstVisitor = RecursiveAstVisitor;\nexports.AstTransformer = AstTransformer;\nexports.visitAstChildren = visitAstChildren;\nexports.TokenType = TokenType;\nexports.Lexer = Lexer;\nexports.Token = Token;\nexports.EOF = EOF;\nexports.isIdentifier = isIdentifier;\nexports.isQuote = isQuote;\nexports.SplitInterpolation = SplitInterpolation;\nexports.TemplateBindingParseResult = TemplateBindingParseResult;\nexports.Parser = Parser;\nexports._ParseAST = _ParseAST;\nexports.ERROR_COMPONENT_TYPE = ERROR_COMPONENT_TYPE;\nexports.CompileMetadataResolver = CompileMetadataResolver;\nexports.Text = Text;\nexports.Expansion = Expansion;\nexports.ExpansionCase = ExpansionCase;\nexports.Attribute = Attribute$1;\nexports.Element = Element;\nexports.Comment = Comment;\nexports.visitAll = visitAll;\nexports.RecursiveVisitor = RecursiveVisitor;\nexports.findNode = findNode;\nexports.ParseTreeResult = ParseTreeResult;\nexports.TreeError = TreeError;\nexports.HtmlParser = HtmlParser;\nexports.HtmlTagDefinition = HtmlTagDefinition;\nexports.getHtmlTagDefinition = getHtmlTagDefinition;\nexports.TagContentType = TagContentType;\nexports.splitNsName = splitNsName;\nexports.isNgContainer = isNgContainer;\nexports.isNgContent = isNgContent;\nexports.isNgTemplate = isNgTemplate;\nexports.getNsPrefix = getNsPrefix;\nexports.mergeNsAndName = mergeNsAndName;\nexports.NAMED_ENTITIES = NAMED_ENTITIES;\nexports.NGSP_UNICODE = NGSP_UNICODE;\nexports.debugOutputAstAsTypeScript = debugOutputAstAsTypeScript;\nexports.TypeScriptEmitter = TypeScriptEmitter;\nexports.ParseLocation = ParseLocation;\nexports.ParseSourceFile = ParseSourceFile;\nexports.ParseSourceSpan = ParseSourceSpan;\nexports.ParseErrorLevel = ParseErrorLevel;\nexports.ParseError = ParseError;\nexports.typeSourceSpan = typeSourceSpan;\nexports.DomElementSchemaRegistry = DomElementSchemaRegistry;\nexports.CssSelector = CssSelector;\nexports.SelectorMatcher = SelectorMatcher;\nexports.SelectorListContext = SelectorListContext;\nexports.SelectorContext = SelectorContext;\nexports.StylesCompileDependency = StylesCompileDependency;\nexports.CompiledStylesheet = CompiledStylesheet;\nexports.StyleCompiler = StyleCompiler;\nexports.TemplateParseError = TemplateParseError;\nexports.TemplateParseResult = TemplateParseResult;\nexports.TemplateParser = TemplateParser;\nexports.splitClasses = splitClasses;\nexports.createElementCssSelector = createElementCssSelector;\nexports.removeSummaryDuplicates = removeSummaryDuplicates;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=compiler.umd.js.map\n"]}